Who Signs Off on the Code Your AI Writes?
Anthropic says engineers delegate only 20% to AI. The other 80% is your liability.
The report landed at 4:47 in the morning. One of my research agents, the one Alessandro and I built to scan every night for new academic and industrial publications, had flagged it as high priority. Anthropic’s 2026 Agentic Coding Trends Report. I opened it on my phone while the coffee was still brewing, scrolled past the executive summary, and stopped at one number.
Engineers can fullydelegate only 0 - 20% of their tasks to AI.
I read it again. Zero to twenty percent. Despite using AI in sixty percent of their work. Despite the orchestration era that Gartner, Hassan, and every serious researcher has been describing for over a year. Despite the fact that companies like Rakuten are running agents autonomously for seven hours across twelve and a half million lines of code with 99.9% accuracy. Despite Augment Code compressing a four to eight month project into two weeks.
Twenty percent.
I put the phone down and started my morning routine. Somewhere around the two hundredth burpee, a smile crept across my face. Not because the number was wrong. It was probably accurate for most organizations. The smile was because I knew why the number was so low. And the reason was something that neither Anthropic, nor Gartner, nor any of the academic frameworks had fully named.
They were describing a single layer of a three layer shift. And most engineering organizations were stuck on layer one.
Three weeks earlier, in our pre-podcast call, Thiago Maior had shown us what the terrain looks like from the CEO’s chair. Two hundred hours of work compressed to twenty. Same developer, same client. The seven year window that DevOps gave us to catch up had closed; AI compressed it into months. And the week before that, Dave Farley had sat with nWave and said it felt like it was reading his mind. Two witnesses, two completely different vantage points, the same structural truth underneath:
the human stays in the loop, but the nature of the loop just changed.
So here is the question that three different CTOs asked me in the past weeks: the terrain compressed, the human matters more than ever, but what exactly should my engineers be doing differently when they open their laptops on Monday morning?
The Anthropic report tries to answer this. It maps eight trends reshaping software development and names the central shift clearly: engineers are moving from writing code to orchestrating agents that write code. Their value shifts to architecture, system design, strategic direction, quality evaluation. The report is honest about the collaboration paradox. Engineers develop intuitions for delegation over time, but the more conceptually difficult or design dependent a task, the more likely they keep it for themselves.
This is real. This is measured. And it is only the first layer.
Here is what I see from the inside of building nWave with Alessandro Di Gioia, and what became clear to me somewhere between the burpees and the cold shower that morning.
Anthropic describes the shift as engineer directs agents. One layer. Human tells the machine what to do. But that is not what actually happens in production. What happens is a double loop. The human provides intent, judgment, the north star. The LLM, the orchestrator itself, translates that intent into structured agent coordination, managing context, applying behavioral patterns, invoking specialized agents for implementation, testing, documentation. Then those agents execute.
You do not orchestrate agents. You orchestrate the LLM that orchestrates agents. And that requires something entirely different from what the current literature describes. It requires behavioral science applied to the machine itself, shaping the orchestrator so it can translate human expectations into deterministic, predictable agent behavior. What we call DES, Deterministic Execution System.
This is what Alessandro and I built with nWave. Behavioral Science, Contract testing, and something more, applied to how agents get invoked. As I explained on the Product Engineers podcast with Peppe Silletti, “we are applying contract testing in how we invoke and summon the agents. We know that the input has to be compliant to a prompt that is a contract. Then the work is framed by behavioral guardrails, and the output needs to be compliant with a document that is the memory of what the agent did.“ Normalized input, constrained behavior, verified output, single responsibility agents. A deterministic execution system that prevents context drift, stores detailed AI-centric memories, and keeps the stochastic nature of AI within a variance that is acceptable. The same variance we expect from a senior engineer.
People are still constraining themselves with the belief that AI is inherently stochastic, that you cannot trust it with more than twenty percent of your work. With the proper guardrails on behaviors and orchestrators, you can make it dramatically more deterministic. You can delegate far more than twenty percent. But only if you understand the double loop.
And that double loop demands a role that does not exist yet in most organizations.
On the Product Engineers podcast, Alessandro said something that I have not been able to stop thinking about: “It does not matter how good you are implementing something if it is useless. Understanding what matters and why it matters is crucial.“
I added the part that had been forming in my head for months: “We cannot do something just for code. We need to do something that helps the entire software development lifecycle, because if you do not resolve the bottleneck upstream, it does not matter that the AI is a crafter. If you give it bad requirements, it is a bad product with amazing code.“
Since the early days of SCRUM vs Extreme Programming, we knew that having a product owner as a filter between the customer and the team was suboptimal. You lose fidelity at every handoff. Product Owner interprets the customer. Refinement simplifies the interpretation. The backlog captures a fraction of the simplification. The developer implements a version of the fraction. And now AI generates code from whatever survived that chain of telephone.
The LLM needs something fundamentally better. It needs expectations written at a level of detail that most organizations have never produced, because no human downstream ever required it. The acceptance tests that nWave writes before a single line of implementation code exists are not just quality gates. They are the translation layer between human intent and machine execution.
This is the role we have been calling the product engineer. Not a product owner. Not a developer. A software crafter who understands architecture deeply enough to set the north star for agents and orchestrators, who knows what well crafted software looks like at the level of detail an LLM requires, and who simultaneously understands the product deeply enough to bridge from user needs to machine readable expectations.
As Alessandro put it:
“We are not spec driven. We are beyond that. We are expectation driven.”
This is the role that closes Anthropic’s delegation gap. The reason most engineers can only delegate zero to twenty percent is not a model limitation. It is a human role limitation. There is nobody in most org charts whose job is to write expectations at the precision agents require while maintaining the product judgment that ensures the right thing gets built.
And this is not a theoretical concern. Stanford researchers, analyzing payroll data from millions of workers, found that employment for software developers aged twenty two to twenty five has declined nearly twenty percent since late 2022. The pipeline that used to feed the old refinement chain is thinning. The product engineer is not just a new role. It is the evolutionary response to a pipeline that is disappearing.
But there is a third layer that nobody in the Anthropic report, or any report I have read this year, addresses directly.
When an agent produces code that reaches production and something breaks, someone stands before the board. Under the EU AI Act, the high-risk compliance deadline just shifted from August 2026 to December 2027. Most organizations will exhale. The smart ones will use those sixteen months to build the traceability they should have started with. Because the institutions made it clear: there will not be a third postponement. The penalties reach thirty five million euros or seven percent of global turnover.
“I do not know how the code arrived in production” is not a defense.
Alessandro built the perfect metaphor during our conversation with Pepe: “I am not building guardrails. I am building railways. A train without railways is only digging holes faster.”
Full traceability means every link in the chain is auditable. The product engineer’s expectations. The LLM orchestrator’s reasoning and contract tested invocations. The agent outputs and their verification through double loop test driven development and mutation testing. The human review decisions at every wave. The production deployment authorization.
This is not only about the EU AI Act. This is AI governance as the operating model for a modern software industry. Enterprise leaders at companies I am working with are already setting objectives to build agentic software factories where humans are in the loop by design, not by accident. The vision is an organization that knows what is running inside its workforce and has a dashboard to observe every decision, every agent invocation, every line of reasoning that led to code reaching a customer.
The product engineer does not just bridge intent to execution. They become the accountable human in the governance chain. The person who can explain, under audit, why a particular expectation led to a particular agent output that reached production.
I finished my burpees that morning and sat with the coffee, still warm. The Anthropic report was still open on my phone. A good report. An honest map of layer one. But the smile stayed because I knew that the other two layers, the double orchestration loop and the product engineer and the full governance chain, were not theoretical for us. We had built them. We had tested them across months of alpha with early adopters who pushed the system harder than we ever could ourselves.
The idea that formed during that morning routine was not just an article. It was the recognition that the shift the industry is measuring at twenty percent delegation is actually a shift toward something much larger. From teams of developers to teams of product engineers who orchestrate AI through behavioral guardrails. Who bridge user vision to machine execution. Who produce code cleaner than what even a craftsman could write by hand. And who can trace every decision from intent to production.
We made it. And we called it nWave Enterprise.
When you are ready to see where your organization stands on this shift, the AI Readiness Assessment maps your four dimensions against the orchestration era. A few minutes, no strings, just clarity on the path ahead.
Your timeline. Your choice. I am beside you.
Next week: we map the agentic framework landscape and why the framework your team chooses is actually a governance decision, not a features decision.
Listen to the full conversation on The Product Engineers Podcast with Pepe.
Take the free AI Readiness Assessment: nwave.ai/go/discipline**