How AI Changes the Idea-to-Market Value Stream

How building software shifts from a chain of hand-offs to an AI-built flow with a person signing off and what the evidence shows.

Sebastian Bitter

3.8.2026

Idea-to-Market turns a product idea into working software your customers use. Today it runs as a chain of hand-offs from one person to the next, and that is where the time gets lost. As AI takes on more, the steps merge and the person moves from writing every line to setting the direction and approving the result. We walk the stream one level at a time and show each change with a real example: GitHub Copilot, Amazon Q and Devin. For most teams the realistic target is an AI that does the work with a person approving it. Letting AI run fully on its own is not dependable yet. A faster single step is not the same as faster delivery. In one controlled study, experienced developers were about 19% slower on large existing code, so the gain depends on the context.

The stream today, and where AI takes it

Idea-to-Market is the value stream that turns a product idea into working software your customers actually use. It starts when someone writes down what is needed and ends with live software running and watched in production. Almost every software and product team lives in this stream, and it is where today's AI coding tools show up first.

In its classical form the work runs as six steps, each passed from one person to the next. The product owner and the business write down what is needed. An architect designs the solution. Developers write the code by hand. Testing happens separately, at the end. A colleague checks the change, and then it is added to the shared code. Finally the release goes out by hand, and if something breaks, undoing it is slow.

The shape of this is a straight line. A person does every step, quality is only checked at the end, and reactions are slow. As in any value stream, most of the delay and rework hides in the hand-offs between the steps, where one person waits on another or picks up work without the full picture. A faster code editor does not fix that, because the hold-up sits between the steps, not inside them.

This is what AI changes. Across the levels the six steps do not just run faster, they change shape. Design and coding merge. Writing the requirement and defining its test move together. Quality checking moves out of the final gate and into every step. And the person moves from writing every line to setting the direction and approving the result. The rest of this post walks that path one level at a time and shows each change with a real example.

Figure 1: The same stream at each level. From assistive to agentic the six classical steps collapse to five, as design and coding merge and testing becomes continuous.

Level by level, shown by real cases

Each level below comes with a real example, its headline number, and the point where that number stops holding. The classical level is the starting point above, with no AI in the flow, so we begin at assistive.

Assistive: AI suggests, the person stays in every step

At the assistive level the six classical steps stay as they are, and AI helps inside each one. A coding assistant suggests code, tests and documentation while the developer keeps every decision. The stream keeps its shape, each step gets a little faster, and the person is still in the middle of all of it.

The example is GitHub Copilot. In a controlled experiment with 95 developers building something from scratch, a small web server, the group using Copilot finished about 55% faster, and more of them finished at all. This is a solid, independently designed result, which is why it belongs at the assistive level.

A fast single step is not the same as a faster whole. A 2025 experiment by the research group METR gave experienced developers AI tools on large, long-lived code and found them about 19% slower, even though they felt faster. A 2024 industry report (DORA) saw the same pattern at scale: teams using more AI wrote better-documented code, but shipped a little less and broke things a little more often. The assistive gain is real on fresh, self-contained work. It thins out on big existing systems.

Figure 2: The task, the AI suggestion, the person's decision and the result, with the limits shown alongside. The 55% comes from a from-scratch task and does not carry over to large existing code.

Agentic: the AI does the work, a person signs off

At the agentic level the work is rebuilt around an AI agent, an assistant that can carry a whole task on its own, and the six steps collapse to five. The person sets the intent, giving the goal and the guardrails, and the requirement and its test take shape in a back-and-forth with the AI. The agent then builds the solution from that description, so design and coding become one step. Testing runs continuously, on every change, so quality moves to the front instead of the end. The person becomes a reviewer and approver: checking, approving and deciding the exceptions. The release follows once the change is signed off.

The example is Amazon Q Code Transformation. Amazon had an AI agent update about 30,000 Java applications from an old version to a newer one, and reported saving the equivalent of roughly 4,500 developer-years of work, plus a separate estimate of about 260 million dollars a year in running costs. It also reported that about 79% of the AI-written code shipped with no further changes, and a developer reviewed and approved every change. That approval is the whole point. This is an AI doing the heavy lifting with a person signing off, which is exactly the setup a careful or regulated team can trust.

The gain is narrower than the headline. An outside test reached only about 36% success on its own, without Amazon's internal tools and libraries. It is weaker on tangled old code. And the headline numbers come from Amazon itself, not an independent audit. A project this size only pays off when the same update repeats across thousands of similar applications.

Figure 3: An old application goes in, the agent updates it, a developer reviews and approves, and the new version ships. The limit, about 36% success without Amazon's own tools, sits alongside.

Autonomous: the system runs the loop, the person sets the rules

At the autonomous level the loop closes further. The system sets its own sub-goals, runs its own build-and-check loop, and even releases with a safety net: it rolls the change out to a small share of users first, watches the live numbers, and pulls it back on its own if something looks wrong. The person no longer approves each result. They set the goals and the guardrails and keep watch over the whole thing.

The example here is a warning, and we show it as one. When Answer.AI, an independent team, ran a structured test of the autonomous agent Devin across 20 real tasks, 14 failed, 3 worked and 3 were unclear. Running fully on its own is not dependable yet, which is why the autonomous level in this stream is a direction to watch and not a recommendation.

Figure 4: The autonomous loop as tested, with the result that most tasks failed. This case marks the ceiling of the stream today: the autonomous level is where the evidence runs out, not where it is strongest.

What is realistic

Put the levels together and the advice is clear. For most software teams the realistic target in Idea-to-Market is the agentic setup with a person at the gate: the AI does the bounded work, the checks run alongside it, and a developer approves before anything counts. That is the Amazon Q pattern, and it is where the real gains and real control meet.

Getting there takes a few things, and they are concrete. The AI needs code it can find its way around. It needs enough automated tests to check its own work. It needs the access to act, not only to suggest. And it needs a clear approval step with a named owner. The cleaner and more modular the code, the further the AI carries, which is the flip side of the Amazon Q limit. It also takes a change in what you measure. The number that counts is the time from idea to running software, not the speed of any single step, because that is the one number a faster editor cannot fake.

The second cost is easy to miss in this stream: the material you hand the AI is your source code, often the company's crown jewels. The deeper the agent works, the more of that code it needs to see, so how you run the tool matters as much as what it does. On public consumer tools your code can end up training the provider's model. On business or private setups that keep your data to themselves, it stays on your side and is not used for training. For a regulated company that choice belongs in the plan from day one, right next to the business case.

More autonomy buys speed at the cost of more work in control and setup. Someone still has to define what good looks like, keep the guardrails current and handle the exceptions. The strength of an agentic Idea-to-Market is throughput on repetitive, well-defined work, and the opportunity is freeing your senior people for design and judgment. The weakness is that the gain depends heavily on context and is easy to oversell. The risk is measuring the wrong thing, counting a fast keystroke or an accepted suggestion as delivered value.

Autonomy has a ceiling here. Part of it is technical, as the Devin test shows. Part of it is accountability: someone has to answer for what goes live, so the approval step stays even when the tooling could skip it. In regulated settings that step is not optional. For Idea-to-Market the dependable end state, for now, is agentic with a person at the gate, with full autonomy only in the narrowest and best-fenced corners where a wrong result is cheap to catch.

The practical first move is not a big bang. Start where the agentic pattern already pays off: a small, repetitive, well-defined job where checking the result is cheap and easy, like updating a framework or a well-tested service. Keep the person at the gate. Measure the whole stream, from idea to running software. Widen the scope only once that end-to-end number holds. That way the first project earns the trust the next one needs.

Figure 5: Each level brings a gain and asks a price, drawn from our cases. Agentic is the realistic target state, autonomous the warning case.

What comes next

Idea-to-Market shows the pattern of the whole series in one concrete stream: steps merge, quality moves forward, the person moves to the gate, and the real gain depends on the context. The next post takes the same view to Issue-to-Resolution, the customer-service and incident stream, where the wins and the walk-backs sit unusually close together.