AI Workshop Recap

The workshop was held on Friday two weeks ago, and we had a few points on our agenda. We began by investigating projects which were heavily built by AI, to get a feeling of what can be done. We then shared our own experiences with AI in software development and had a cool discussion about the application areas as well as the pros and cons. Finally, we built our own project using an modern workflow, to see how much we can achieve in a small time window. Surprisingly, the end result was very good!

Our Experiences with AI

We looked at already completed projects that had been created entirely with AI and from there, we discussed the key-takeaways, which can make AI so powerful:

• Technology stack matters. AI-generated code strongly depends on the underlying stack. In the .NET ecosystem, for example, frequent breaking changes cause the AI to mix code snippets from different versions. The result often looks correct but fails at runtime.
• Fast-moving environments are difficult. In web development, even experienced developers struggle to keep up with changing frameworks. AI can only sometimes help with nightly features, but unless you specify the exact versions, it often produces outdated or incompatible code.
• Language choice. For scripting languages like JavaScript or Python, generated code often fails to execute. In contrast, for languages with strict and stable rules, such as Go, the results are far more reliable. Connecting the AI to a language server and letting it run code automatically improves accuracy significantly.
• Code quality. It is tempting to just repeatedly prompt our agent until the code works instead of looking at the generated code ourselves. However, reviewing and fixing small errors manually is often more efficient and avoids collecting technical debt. AI can easily introduce “dead code”, which is why generated code should always be checked and cleaned up afterwards.
• Scaffolding projects remains tricky. Setting up new projects directly with AI often results in dependency errors. A more reliable approach is to bootstrap the project first with tools like create-next-app, then use AI to generate code within the already existing project.

Building Our Own Project

After our discussion, we were eager to try out what we are able to do ourselves, so we created our own prototype: an Issue Management System.

• We experimented with the AI-first editor cursor, which includes unique features, like user rules and memory. While these features were interesting, the general experience felt quite similar to using our everyday editor vscode.
• We worked with a Project Requirements Document (PRD). This file describes the project in detail, allowing the AI to generate code according to specific requirements. Discussing the PRD with colleagues and the AI before finalizing it proved essential, since vague definitions easily lead to misinterpretations by the coding agent.
• We also tested rule files (e.g. .cursorrules), which inject specific prompts into the chat. For example, we added a rule that required git commit messages to consist of only emojis 😄. These rules can be configured in great detail to enforce some consistency in the development workflow.
• A key advantage of the PRD was the ability to mix business and technical language. For example, we could describe both database tables and business requirements in the same file, and the AI was able to understand both perspectives.
• After generation and a short debugging phase, we ended up with a functional frontend interface connected to a working backend database and an API. This result was better than what we expected.

Conclusion

The workshop showed us that AI tools can deliver surprisingly fast results, especially for prototyping. Within just a few hours, we were able to present a working interface that could already be shown to a client.

If applied carefully, by defining requirements clearly, reviewing generated code, and cleaning up after the AI, the benefits clearly outweigh the costs. For early-stage prototyping in particular, AI can significantly accelerate development and reduce manual effort.

The next step for us is to integrate AI agents into our existing projects, even into large codebases, in order to test their practical limits.