Bill Staples, CEO of GitLab, published When code is abundant this week. It’s the sharpest thing written so far about what happens after Anthropic’s AI-Native SDLC playbook declared that code is no longer the bottleneck.

His thesis is one sentence: when implementation becomes abundant, trust becomes scarce. Models can generate implementation far faster than humans can, and that says nothing about whether the result is correct, secure, performant, compliant, maintainable, or what the business actually asked for. The hard problem stops being production and starts being verification.

Buried in the middle of the piece is a claim we think is the most actionable thing in it, and the one most likely to be nodded at and skipped.

A useful software change includes generation, environment setup, context, verification, review, remediation, and governance. AI is collapsing the generation term. Everything else becomes proportionally more important. An organization that makes generation ten times faster while leaving CI, review, and validation untouched does not become ten times faster. It moves the queue.

That is a measurement claim. And it is the one nobody is set up to answer.

What the decomposition actually looks like

Staples’ first recommendation for the next ninety days is to track elapsed time from generated change to accepted change, then decompose it across environment, CI, review, remediation, and governance. His prediction is that most teams will find generation is already a small part of the total.

He’s right. Here is what that shift looks like when you draw it:

Notice what that picture demands. To draw your own version, you need timestamps for when a change was generated, when the environment was ready, when CI ran and how long it took, when review started and finished, how many remediation cycles happened before acceptance, and how long the change waited at each approval gate. Correlated per change. Segmented by team and repository. Compared against a baseline.

That data exists. It lives in git history, PR metadata, CI events, and your incident tracker, exactly as Staples describes. What almost nobody has is the layer that pulls it together into a single number and then decomposes it back down.

Three modes is a data question, not a maturity survey

The most useful framework in the piece is the argument that AI adoption is not one journey. Human-controlled legacy, agentically accelerated development, and autonomous development will coexist for years, and forcing every workload into full autonomy too early is one of the more expensive mistakes available right now.

Staples offers three diagnostic questions for placing a workload. Read them again as an engineering leader, and notice that each one is answerable with evidence you already generate:

Which mode a given system belongs in is not a judgment call you make once in a workshop. It’s a reading you take per repository, and it moves. A service that was firmly Mode 1 last quarter may be a candidate for Mode 2 after someone fixes the test coverage. Without measurement you are guessing, and guessing in this direction is expensive in both possible ways: too cautious and you leave the value unrealized, too aggressive and you find out in production.

Trust is an evidence problem, and evidence is a measurement problem

Staples argues that trust requires more than a model producing a plausible answer. It requires evidence that the software was produced under the right constraints and behaved the way the organization intended.

He also makes a point about compounding that deserves more attention than it will get. Every time an agent acts, the organization produces evidence about what worked and what did not. Which changes were accepted. Which were rejected. Where a human intervened. What failed in production. Which constraints caught the problem. Preserved over time, that becomes an internal evaluation set grounded in your own codebase rather than a public benchmark.

That is a description of an engineering intelligence dataset. It is the exact thing Waydev has been building since 2016, and the reason our foundation is a USPTO-patented Git analytics engine rather than a survey tool: the record of what your organization actually accepted, rejected, and had to fix lives in the work itself.

One of the commenters on the piece, an engineering leader at Airbus, asked what the equivalent of git blame becomes in a repository full of automated pull requests, and noted that in regulated industries the audit may cost more than generating the code did. That’s the right question. The answer is not a better prompt. It’s an evidence layer that survives the agent, the model, and the vendor.

Where Waydev fits

Staples is explicit that the durable layer has to be model- and cloud-neutral, that context and controls should not become captive to whichever vendor is in favor this year, and that an organization’s accumulated knowledge should stay portable. We agree, and we’d extend the same principle one layer further: your measurement should be neutral too.

If your metrics only exist inside one agent platform, you cannot compare across the agents you build, the agents you buy, and the engineers who are still doing the work by hand. That comparison is the whole point.

Through Waydev MCP, that intelligence is queryable inside the loop rather than parked in a dashboard. The agent diagnosing a production anomaly can reach the real baseline. The governance layer deciding whether a change qualifies for automatic merge can consult the actual historical distribution for that class of change. And the board slide answers itself.

The line worth keeping

Staples closes by saying software engineering spent sixty years protecting a scarce resource and will spend the next decade governing an abundant one, and that this is a better problem.

It is. But governing something requires seeing it. The organizations that will do this well over the next two years are not the ones with the most agents running. They’re the ones who instrumented the loop before they scaled it, and can say with a straight face what a change actually costs them now versus a year ago.

Start with the number. Everything else in the transition is downstream of it.

Sources: Bill Staples, When code is abundant, GitLab, August 24, 2026, and The AI-Native SDLC Playbook, Anthropic, August 21, 2026. Waydev is an AI-native engineering intelligence platform measuring AI adoption, impact, and ROI across engineering organizations, trusted by Fortune 500 companies including American Express, Dropbox, Caterpillar, and PwC.