A small change to a product can still take weeks to reach customers. A lot of that time goes into product handoffs: the moments when work passes from one person to the next, and the next person has to catch up, ask questions and wait for answers.
This post follows one small fix through those handoffs. For each one, you’ll see where it gets stuck and what changes when every step can see your codebase. At the end, there are four questions to ask about the last feature your team shipped.
Four jobs, four handoffs
A typical change passes through four jobs. An analyst works out what’s causing the problem. A product manager decides what to change. A designer works out how it should look. An engineer builds it, and another engineer reviews it. At a startup, one person might do all of them. At a bigger company, each job often belongs to a different person with a different tool.
Our CTO, Tammuz Dubnov, on the four jobs behind a single feature.
Here’s the fix we’ll follow. Users sign up, then stop using the product after their first week. Say the research points to a confusing first session, and the fix is a clearer getting-started checklist.
Following one fix through the four handoffs
AutonomyAI runs all four steps as one system, called Autonomous Product Delivery. It works on a Product Harness built inside your codebase, which learns your components, your design system and how your engineers write code. A PM or designer drives each step, and an engineer reviews and approves the pull request at the end. Here’s what each handoff looks like.
1. Analyst → product manager
Where it gets stuck: The analyst compares what users who stayed did in their first session with what users who left did, reads support tickets from people who stopped using the product, and checks whether anything changed around the time the numbers dropped. That work spans several tools before anyone has an opinion, and the PM then gets a summary they have to take on trust.
What changes: Discover Mode researches the same question across your analytics, support tickets, customer calls and the codebase itself. It returns a Discovery Brief: findings with the sources cited, gaps in the evidence, and suggested next steps. The PM reads the evidence directly.
2. Product manager → designer
Where it gets stuck: The PM writes a spec for the checklist, and the questions start. Does this screen already have that state? Is this a new component or a version of one we already have? Does the API return that field? They come up because the person writing the spec usually can’t see the code.
What changes: Plan Mode turns the brief into a spec mapped to how your product is actually built, and carries the brief’s context with it, so nothing gets explained twice. Duplicate components and requests the code can’t support get caught here, so the designer starts from components the product already has.
3. Designer → engineer
Where it gets stuck: The designer hands over a mockup. If it uses a component the product doesn’t have, or spacing that isn’t in the design system, the engineer finds out while building it, and it goes back for another round.
What changes: Build Mode writes the checklist with your own components and conventions. It starts your actual app, shows the real screen, and checks every state before anyone reviews it. Designers can point at the screen and adjust it visually in Design Mode.
4. Engineer → reviewer
Where it gets stuck: An engineer opens a pull request and another engineer reviews it. Comments about which component to use, or how the team names things, can send it back for another pass.
What changes: The change arrives as a ready-to-review pull request in the queue your engineers already use, written with their own components and conventions. Engineers decide what merges, and nothing goes live without their approval.
The PM, designer and engineers make every call, and each of them starts from work that’s already been checked against the codebase.
After the fix ships
After the checklist ships, ask how it’s doing, and you get a post-release snapshot: who’s using it, what the feedback says, and whether it needs a follow-up. Any follow-up becomes the next question for step 1, one click back into the loop.
Every merged pull request teaches the system more about your product and how your engineers write code, so each round starts with more context than the last. That’s the idea behind a software factory for product teams: specialist agents for research, planning, building and checking, working as one line, with product making the decisions and engineers owning the merge.
Check your own handoffs
Take the last small feature your team shipped and ask:
- How many days passed between noticing the problem and having an answer backed by evidence?
- How many questions came back on the spec, and how many days did the answers take?
- Did the design use any component or spacing the product didn’t already have? How long did that take to sort out?
- How many review rounds did the pull request go through, and how many days did it sit between rounds?
Add up the days spent waiting. That’s what the handoffs cost on that feature.


