A guide for leaders and teams: the stages a team goes through, how to identify where you are now, and what to do next.
What changes
In a conventional team, work moves along a chain. The product manager writes requirements, the designer creates screens, developers write code, and QA checks the result. Each person hands their output to the next, and weeks or months pass between an idea and a working version.
Coding agents shorten this path. A prototype can be built in hours or days, and one person can build it. The boundaries between roles begin to blur: product managers and designers create working versions, while developers spend more time on architecture, assigning work to agents, and reviewing their code. A person who takes a task from idea to release is often called a Product Engineer.
Teams reach this model gradually. Below are four stages.
Stage 0. Feature factory
Signs:
- requirements are handed over as specifications;
- each role owns a separate area: the product manager owns requirements, the designer owns screens, and developers own code;
- the first working version appears after weeks or months;
- quality is checked manually after development.
What gets in the way: AI tools are unavailable or their use is prohibited.
How to move forward:
- give employees access to an AI assistant approved by the security team;
- document which data may be shared with AI and which data must not be shared.
Stage 1. AI for everyone
Signs:
- employees use AI in their own work: writing text, analyzing data, and generating parts of the code;
- roles and processes remain unchanged, and work moves through the same chain;
- each person works faster, but overall project timelines barely change.
What gets in the way: everyone has accelerated their own part, but handoffs remain. Time is still lost to waiting and coordination.
How to move forward:
- choose one task and let a product manager or designer build a prototype with a coding agent;
- assign a developer to help with the environment and review the prototype’s code;
- show the prototype to users before full development begins.
Stage 2. The product manager builds the prototype
Signs:
- a product manager or designer builds a working prototype in a few days;
- the requirement is handed over as a prototype and a set of examples;
- hypotheses are tested with users before development;
- developers move the validated solution into the product.
What gets in the way: the prototype and the product live separately, so the prototype is rewritten from scratch. The product manager lacks the engineering skills needed to take it to release.
How to move forward:
- agree on a technology stack and repository rules so the prototype can continue to evolve;
- document context for agents in the repository: architecture, coding rules, and build and run commands;
- teach product managers and designers basic engineering skills: git, running the project, reading logs, and reviewing agent-written code;
- for AI features, collect real requests with expected answers and evaluate every change against them.
Stage 3. Product Engineer
Signs:
- one person takes a task from idea to release;
- agents write most of the code, while the person defines tasks, reviews the work, and accepts the result;
- requirements, rules, and examples live in the repository alongside the code;
- the team is small, and each person owns a complete area of the product.
What must remain in focus: building a feature becomes cheap, so the team can easily build unnecessary things. People must still decide what to build and how to verify its impact.
What changes for each role
Product manager. Previously wrote specifications; now builds prototypes and tests hypotheses with users. New skills: working with coding agents, basic engineering, and usage metrics.
Designer. Previously designed static screens; now builds working interfaces. New skills: implementing layouts with an agent and maintaining a design system in code.
Developer. Writes less code by hand and takes greater responsibility for architecture, task definition for agents, and code review. Ensures that prototypes can grow into production products.
QA engineer. Moves from manual checks to automated tests and example sets for AI features.
Team leader. Builds small teams in which each person owns a complete area. Measures the time from idea to user validation.
Where to start
- Identify the team’s current stage using the signs above.
- Choose one real task on which the team will move to the next stage.
- Assign two people: the person learning the new role and a developer who will support them.
- After two or three weeks, compare the timeline and outcome with the conventional process.
- Record what got in the way and update the rules for the next task.
Checklist
- I know which stage the team is at.
- Employees have access to AI tools and clear rules for working with data.
- A product manager or designer has built at least one prototype independently.
- The prototype was shown to users before full development.
- The repository contains documented context for agents.
- AI features have example requests with expected answers.
- The time from idea to user validation is measured.