Collaborating with AI can significantly increase speed and precision in software development. The Prototyp AI Playbook is our practical guide to working with AI agents in agile teams – a living document rooted in experimentation, learning, and transparency.
Our agile software development process is at the heart of Prototyp, and has been continuously crafted and updated over the past 15 years. The goal of this process is the same as it’s always been: to deliver the highest possible business value as fast as possible, while maintaining quality over time.
AI can help us reach this goal faster, but it is our firm belief that great software is still built by cross-functional teams working closely together. AI agents are capable of some pretty amazing things, but they are far from perfect. When used without consideration, they risk doing more harm than good.
At Prototyp, we use AI agents to enhance our agile development teams to deliver value faster than ever before, while preserving or even increasing the quality of our output.
AI is a fast-moving field with new tools and models every week. By exploring this development as openly and transparently as possible, our aim is to accelerate the learning process while allowing others to benefit from what we are doing.
Vibe coding has been present in the past years’ discourse around software development. By coding primarily through prompting an AI agent, output can be created much faster than by exercising coding skills and critical thinking. The drawback of this speedy and frictionless practice is often a lack of deeper understanding of the code that has been created.
At Prototyp, our position on vibe coding is clear: creating and maintaining high-quality, secure applications requires an accountable team of professional developers.
"There’s definitely a case for vibe coding, for example prototyping and experiments – that’s where it really shines. I don’t really see a case for handcrafting experiments anymore. I think that’s a good thing, because it means we can experiment much more. But you also need some accountability. If there’s no human developer who understands the code, how are you going to be able to take responsibility as an organization?" - Erik Lindgren, co-founder at Prototyp
When we’re building a simple internal tool, a prototype or a proof-of-concept, we should consider having AI do more of the coding with less human oversight. If we’re not worried about security and maintainability, and when we don’t need perfection in functionality and details of the design, it can be a powerful way to produce working software in a very short amount of time.
At Prototyp, we use these tools to very quickly test hypotheses, create single-use tools or short-lived prototypes.
In the context of fast-paced AI development, we take a close look at the entire process to see where we can find the clearest wins. Where can we improve the process today – not eventually or tomorrow, but right now, with the tools that we have?
AI is already being used by most software developers in one way or another. But there have been few clear guidelines for how and when the software development process benefits the most from its application.
We have identified three areas where there are clear wins to using AI support: the planning phase, the coding phase and the review phase.
The planning phase is time-consuming and has traditionally relied heavily on big meetings, human memory and manual typing. Involving AI in this part of the process allows for more detailed and structured plans, while also encouraging new kinds of discussions.
Every development sprint starts with a sprint planning workshop. The team takes items from the top of the product backlog and breaks them down into smaller, more detailed tasks before moving them to the sprint backlog.
The team discusses how to best solve each task and make sure all information needed is present. We ensure that we’re always working on the most important things at any given time, by always taking the highest priority items from the product backlog.
This process is now supported by an AI agent that assists the team in writing tasks with all the context and information needed to complete it. Using an AI agent in this step of the process is especially beneficial for two reasons:
To facilitate sprint planning with AI greatly improves the efficiency and output of this workshop, and often eliminates the need to have separate backlog grooming sessions (which is common when doing manual planning without AI).
It also encourages deeper discussions and collaborative design within the team, as the more detailed tasks usually end up being more opinionated about the solution.
One finding is that it is beneficial to give the AI agent a lot of agency. Giving the AI a short prompt for what you would like to create, can generate details that encourage further discussion within the team.
Another key to success is to have detailed and well thought out base instructions for the AI. If we don’t give it anything, we’re going to get way too much information. And we want something that is just enough.
How do we like our tasks? What would we like to be included? By composing an instruction file, we only have to give it quite brief instructions for each task.
As a team we can then look at what tasks could be fully automated by an AI. Babysitting the agent every step of the way is just time-consuming. We rather treat it as a co-worker and hand it a full task.
For AI-assisted sprint planning to work, you need to have the proper tooling in place:
“It's very beneficial to use AI in the planning phase. If you have the proper tooling, and an AI agent that has access to your codebase and planning tool, it can quickly generate a much more detailed instruction or specification for the tasks than a team member would be capable of writing. The broader context and background also promotes discussion within the team. It could lift different perspectives and solutions that might otherwise have been left unnoticed.” - Erik Lindgren, co-founder
“When we introduced AI in the planning phase it was really beneficial. From short questions we could get really nice descriptions.” - Lucia Dabezies, developer
“Some time goes by from the planning and backlog refinement to the actual development phase, so you might forget some of the context. The AI doesn’t.” - Christina Sonebo, developer
Coding is one of the lowest hanging fruits when it comes to AI integration. But coding with AI requires a delicate balance between speed, accuracy and accountability.
The sprint backlog contains a prioritized list of tasks to be done. In sprint planning, we marked some tasks as suitable for full automation, so both AI coding agents and human members of the development team can pick the highest priority tasks from the backlog and start working on them. This usually involves coding, but can also be things like setting up infrastructure or conducting research.
Before considering a task completely done, we perform an AI pre-review of the code. Simply asking an AI agent for potential improvements has proven to be a valuable way to increase the quality of our output. By doing it before other code reviews, we catch things early instead of spending more time on those same improvements later in the process.
We need to be careful in using AI to create the initial project setup. AI will generally not generate code using the latest versions of frameworks and libraries. It will also likely not be up to date with the latest best practices and tools, and has a tendency to add a bunch of things we didn’t ask for.
Most (if not all) frameworks and languages have excellent scaffolding functions designed to get us up and running quickly with an up-to-date application setup. Also, spending a bit of time to get the initial setup just right will save us significant time on maintenance over the course of the application lifetime.
Successfully automating entire tasks with AI coding agents requires suitable tasks, as well as the proper tooling. We need a coding agent with access to both our agile planning tool and the code hosting platform.
One example of such a setup is using Cursor integrated with Linear and Github, but the options in this space will surely grow rapidly in the near future. This is the ideal workflow when using an integrated coding agent:
Identifying the appropriate tasks to automate is dependent on the project-specific context, but some general guidelines are:
We give our developers a high degree of autonomy when it comes to workflows and tools. What works for one person doesn’t necessarily work for another.
With that said, we do have a number of practices that we have found to be important to consider when working with AI-enhanced development:
One of the main challenges that come from using AI for code generation stems from the fact that it’s occasionally brilliant – but it’s also occasionally under-performing. As a developer, it’s really tempting to over-use AI in code generation. And it’s especially dangerous if you are an inexperienced developer.
Our philosophy is to give each developer quite a lot of freedom in how to set up their own development environment. But we encourage our developers to be mindful and not over-rely on AI code generation.
Most of our client projects are large, business critical applications embedded with legacy, compliance and specific tech stacks. This means that we need to have structural processes that get things right. We can’t just vibe away without caring about what’s under the hood.
Relying on AI could also hinder creativity, since it has a strong bias towards standard or common solutions. In some contexts, there might be a reason for solving a problem in an unorthodox way. Then the AI might push you towards more standardized solutions, which might limit the benefits from AI.
“Treat it as your own code. You need to own it in the same way as if you had typed it yourself. If it looks good but you don’t understand it, then you are on thin ice. You need to understand the code.” - Erik Lindgren, co-founder
“Try to set the style of your codebase before using AI, because it might branch out in a way that you’re not comfortable with. For largescale projects that already have an existing codebase, the patterns are most likely already set.” - Christina Sonebo, developer
“I’m a firm believer that the future is in giving the AI more autonomy. Babysitting AI is a real time-sink, and I think that is a big reason why don’t see as much improvement from generative AI as we should, because we’re sitting waiting for it to do the work that we would have done, instead of handing over work to it and do other things ourselves.” - Erik Lindgren, co-founder
“It’s easy to vibe code a prototype. It’s easy to get impressive results the first time. But it’s a whole different ballgame when you work on a project that needs longevity.” - Christina Sonebo, developer
Code reviews are a cornerstone of our development process. They help us maintain code quality, surface misunderstandings early, and spread knowledge within the team. AI can significantly enhance this phase − but only with deliberation and clear boundaries.
At Prototyp, we practice two types of code reviews: from AI and from peers. The AI review comes first: as soon as a developer is done with a task, they request a review from a specific code review agent.
This practice is treated as a complement to the later peer review. Since agents sometimes give false advice, everything the agent points out doesn’t necessarily need to be resolved. Still, the AI review usually does result in some improvements to the solution. The peer review is done by another developer on the team.
The code review promotes discussion about the code, and often leads to adjustments that need to be made. The original developer assigned to the task is responsible for making the adjustments and, if needed, show them to the reviewer again. Once everyone is happy, the task is marked as ready for test, and any related code is added to the common codebase.
Tasks resolved by coding agents are treated the exact same way. They also go through one or more rounds of AI and human review.
AI code reviews work best if the code review agent is available on the platform where you host and collaborate on your code (e.g. GitHub). It’s important that it’s easy to request a review, but also to ask for a re-review.
However, there are some pitfalls. AI has a couple of weaknesses that can become especially troublesome in a code review setting. You need to be aware of these so you can spot and handle them appropriately:
The code review is a crucial part of our process. It spreads knowledge in our team and adds quality to the project. We have never aspired to replace humans in this process, but we have discovered that AI is really good at reviewing code. It’s not perfect, but it’s easy and the cost is low.
Peer reviews are essential, but they do come with a cost in terms of efficiency. If AI can surface potential issues beforehand, it can reduce that cost. Even limited feedback can add meaningful value as a complement to the human reviewer.
In an agile context, we want to develop the application in small steps, with very specific tasks that we want to complete. But AI usually wants to do everything in a big chunk. There’s always a risk of scope creep, where features are added in a way that may not work with the rest of the application. If you step outside of the scope of your task, you’ll likely step into the scope of someone else’s task and create duplicate or conflicting functionality.
The best way is if the AI agent is implemented into the platform, like Github. But it’s still a challenge. With time and budget constraints, we might not always want additional functionality and increased maintenance.
We need to find the right level of polish for a specific task. If you let it, the AI will keep you reviewing forever. So you need to know when to stop.
AI can be a powerful collaborator in software development − from planning and coding to reviews − when used as part of a human–machine tandem.
Introduced without intent, AI risks being dismissed as ineffective or inefficient.
Opting out, however, is not an option. The real work lies in deliberate use, continuous learning, and improvement over time.
This is the Prototyp philosophy.
“AI is really useful before you create a pull request, to get the code cleaner and more readable for the next person that will review it. It might catch some things that you have missed. You are saving the peers some valuable time.” - Lucia Dabezies, developer
“The AI will keep re-reviewing forever. It takes some experience to know what parts of the review that are actually useful – and what you should or shouldn’t act on. So being a less experienced developer is a bit more challenging, because you don’t know what to act on and when you should be done.” - Erik Lindgren, co-founder
“AI can help us make our work cleaner and save some time when doing new tickets. But I still think we should not abuse AI. We should learn when to use it and always make our own decisions. And don’t rely on everything it says. We are the developers and we should always have the final word.” - Lucia Dabezies, developer
“My bottleneck has never been the typing of the code. As a developer, I deliver value in other aspects – like understanding requirements and putting it down into a specification, solving architectural and engineering problems. Translating a complex reality into a program is a difficult task. And the AI is never perfect.” - Christina Sonebo, developer
“AI isn’t a silver bullet. If you put it out mindlessly and tell everyone to use it, you might not see the benefits. We are looking at a time when AI is going to be hugely beneficial for the teams that apply it thoughtfully and learn how to use it to get better results. It’s going to be a multiplier for some people and cause a lot of trouble for others.” - Erik Lindgren, co-founder
Vi använder kakor (cookies) för att ge dig en bättre upplevelse av vår webbplats. Du väljer själv om du godkänner kakor. Läs mer om hur vi hanterar kakor