Artificial intelligence is currently transforming the entire IT industry – and with it, the fundamental way in which software is developed. Terms such as agentic programming and prompt-driven development are appearing more and more frequently in developer communities and represent a new approach: code is no longer written exclusively line by line, but is created in interaction with large language models (LLMs) – faster, more iterative and more strongly controlled by requirements. This is relevant for companies for three main reasons: shorter time-to-market, higher productivity and a stronger focus on technical requirements.

We used this approach in one of our internal projects at Spirit in Projects – and gained two key insights into the use of AI in development projects: AI can significantly accelerate the development of applications, but requires additional effort in terms of precise control and consistent quality assurance through reviews and tests.

After Stefan Hiermann compared Power Apps and conventional development with AI support using the same project in another blog post (👉 click here for part 1), in this post we show how AI integration was implemented in our software development, what experiences we gained in the process – and why AI-supported programming is more than just a short-term trend for us.

Project context

The aim of this internal project was to develop a dashboard for employees and management as a central portal for:

Time recording
Resource management
Holiday management

Technically, the solution is based on Django (Python) and HTMX. We designed the software and data architecture (including structure, roles, rights, data model) ourselves in order to create a robust and long-term maintainable foundation.

Our approach: AI-supported development – without compromising on quality

The entire development process was based on clearly defined requirements. That is why we carried out a requirements engineering phase before implementation: Together with our stakeholders, we refined goals, roles, rights and processes, described user stories including use cases, and derived prioritised requirements with acceptance criteria – which served as a ‘single source of truth’. Learn more in our IREB/CPRE training courses.

Building on this, the code was generated on demand using an AI-native plugin (Kilo Code) directly in our development environment (Visual Studio Code). We used different models (including Gemini 3 Flash and Claude Sonnet 4.5). We have already described a comparison of these models in a separate article: 👉 Click here for the article

The AI-generated code was then regularly reviewed, adapted to our standards and manually supplemented as necessary, especially in cases of more complex logic or specific bugs. Through consistent testing, we were able to identify and fix errors early on. Combined with our technical expertise, this ensured that quality, maintainability and stability were guaranteed at all times.

The key challenges (and what we learned from them)

The use of AI in software development brings with it not only great opportunities but also legitimate challenges. Three points were particularly relevant for us – and are also the most important lessons we learned:

1) Formulating precisely what we really want

AI is particularly powerful when tasks are described in detail. In practice, however, it was sometimes surprisingly challenging to communicate the desired behaviour to the LLMs with sufficient precision to ensure that the right solution was actually produced.

Consequence: We did less ‘simple direct implementation’ and invested much more in refining requirements, concrete examples, and use and edge cases.

2) Paying more attention to side effects

A second, very practical lesson: when we changed something at point A in the code, something unexpected could break at point B. This is a well-known issue in software development, but it becomes even more relevant with AI-generated code and faster iterations.

Consequence: We invested noticeably more time in code reviews and tests to reliably ensure stability and maintainability.

3) Architecture remains the responsibility of the team

AI can be very helpful in implementation. However, we deliberately took responsibility for the architecture and data model ourselves and used AI primarily where it reliably speeds things up: in implementation, refactoring and detailed work.

Conclusion

Within a few weeks, we were able to launch a modern and clear dashboard that efficiently maps our processes and is tailored precisely to our requirements. What would probably have taken months using a traditional approach was achieved in a significantly shorter time.

For us, AI-supported software development is not a substitute for experience, but rather a tool that reinforces the experience we have already gained. We see the greatest benefit when AI is not ‘simply used’ but interacts with clear requirements, consistent quality assurance and architectural responsibility within the team. This significantly reduces development time while ensuring high code quality, stable, maintainable results and, most importantly, satisfied users.