If your team adopted AI coding tools this year, you have probably seen the curve: a sharp jump in the first weeks, then a plateau that no amount of prompt training moves. Our dashboards showed the same shape, with one added discomfort. The spread between individuals was large, stable, and not closing. Top movers were operating at multiples of the rest of the cohort on identical tooling, and the multiple persisted across months. This piece is an account of chasing that plateau through our delivery chain, and what we found at the end of it. The short version: AI-first development behaves like a production line. Remove one constraint and throughput rises until the next constraint binds. We have moved through three so far, and the third lives in the developer rather than the tooling.
The first constraint was code generation, and it fell almost immediately. Claude writes the implementation, the tests, and the scaffolding faster than anyone on the team. This is table stakes now; adoption is broad enough that generation speed no longer differentiates anyone. What it did instead was expose the next constraint within weeks, because everything downstream of generation was still built for human writing speed.
If code arrives ten times faster and review capacity stays fixed, the queue forms at review. We watched it happen, and our answer was to mechanize verification with the same seriousness we had mechanized generation. That machinery is the part of our stack we call the harness. The techniques were never secret. Property-based testing, fuzzing, metamorphic relations, mutation testing: all decades old, all well documented, and all skipped by most teams because building and maintaining them by hand costs more than anyone will pay. AI changed that economics twice over. Writing the tests became cheap, so we run every methodology on every change, because we can. And the AI does the tedious wiring itself: it works out how to mock each dependency for hermetic runs, then connects the same tests to live dev dependencies to prove the mocks told the truth.
The structure is five phase gates, each answering one question, with evidence accumulating on the pull request. P1 runs the full test gauntlet offline and fast. P2 proves the entire slice works in a sealed world of AI-built mocks and containerized infrastructure. P3 reruns against live dev dependencies to confirm the mocks were honest. P4 is adversarial: independent validation that runs and probes the change, with human approval on top; validate-review replaces read-review. P5 runs advisory checks in deployed dev and informs without blocking.
Across one product line, 550 PRs have merged end to end through this chain, with 4 confirmed regressions. Under one percent. Merging became a decision about evidence, and evidence can be checked mechanically.
With verification mechanized, we expected the velocity distribution to compress upward. It did the opposite of compressing. Individuals plateaued early in adoption and stayed put, and the gap between the top movers and the median stayed wide. The tooling was identical across the cohort, the gates were identical, the model was identical. Whatever was constraining throughput now varied by person.
My first hypothesis was trust. A developer who fears deploying works one change at a time no matter how strong the backstop: generate, verify, watch it land, exhale, repeat. Serial operation caps throughput regardless of how fast each step runs. So we worked on trust directly. We made the proof visible on every PR, publicized the saves when the net caught real defects, and gave people a clear adjudication path when they disagreed with a gate.
It helped, and it was not enough. Developers who trusted the net but kept working the way they always had gained a step and then flattened again. Trust removed a ceiling without supplying any lift.
The lift, it turned out, was visible in our own session transcripts. In one 15-hour session that closed out a 173-bug program, the human driver intervened 36 times, and we categorized every one. Zero were corrections of a wrong fact or a hallucination; the net caught the actual defects. The 36 were something else: steering scope toward where the risk was, pushing the model past its first adequate answer, forcing an honest tally of what was done versus assumed, and restarting a loop that had stalled even though it was authorized to continue.
The model was a reliable executor for that entire session. What it could not do was stay running on its own, choose where its effort mattered most, and hold its own honesty bar. Those came from the human, and they are the scarce input.
The clearest illustration of that input is small. A developer validating a data-heavy change used to sample a subset of the corpus, because checking everything by hand was never going to happen. With AI, running the entire corpus is trivial. The developers who did it found and fixed bugs nobody knew existed. The developers who kept sampling got their old results, faster.
We started calling the scarce input cognitive activation: the willingness to supply insight, widen scope beyond the assigned ticket, and run work in parallel. The earlier variable, the willingness to ship because the net will catch you, we call backstop trust.
Velocity in this regime behaves like the product of those two variables rather than their sum. High activation with low trust produces careful, serialized work: the developer thinks expansively and ships one change at a time. High trust with low activation produces marginal gains: the old workflow, faster. The step change requires both at once. Multiplication also explains the spread we measured, because modest differences in two multiplied inputs produce order-of-magnitude gaps in output, and raising either variable alone barely moves the product.
Trust responds to evidence and policy, and the harness manufactures both. Proof arrives with every PR. The saves are visible when the net catches a real defect. Disagreement with a gate has a route that does not require quietly working around it.
Activation responds to neither, because activation is behavior change, and behavior change does not come from a reading list. Study loses to feature work every day of the week: feature work rewards immediately and study pays off later. The interventions that moved it for us come straight from cognitive-behavioral practice. Graded exposure for deploy fear, meaning supervised low-stakes deploys with the net visibly active. Scheduled practice instead of willpower. Visible reinforcement when the backlog drains. Managers matter more here than tooling does; our clearest uptick came when a manager challenged the team directly on what failure modes they had never considered and what user paths they had never tested.
One measurement rule keeps all of this honest: watch landed throughput. Open branches measure enthusiasm. Docs read measure compliance. Merged, validated changes are the only number that survived contact with our data.
Four things, plainly. The loop does not yet stay running: the model stalls mid-session even when authorized and instructed to continue, and a stalled loop converts parallel work back into serial work until someone notices. The signed link in our evidence chain is designed and not built: we intend P4 to produce an independently verified, tamper-evident certification that a bot can merge on, and today merge is still a human act. Backfilling the full gauntlet onto an existing service is real work per service, and it is the first cost every adopting team hits. And comprehension debt is real: when humans stop reading every line, you need periodic audits confirming someone can still reason about the system. Ours currently pass, and we keep checking.
We do not know what binds after activation. Loop durability is the leading candidate, and there will be one after that. The pattern is the durable lesson. With AI, you hit what you shoot for: aim at automating typing and that is the win you get, modest and quickly plateaued. We shot for finding the current constraint, fixing it, and finding the next one, and each fix looked obvious a month later. Teams that treat AI adoption as tool collection will stack vanity metrics: model versions, agent counts, tokens burned around the clock. Teams that treat their delivery chain as a production line and walk it constraint by constraint will compound. The gap between those two groups is already visible inside a single cohort. It will not be less visible between companies.
The author works on AI-first engineering at Advisor360°, where the numbers in this piece come from: 550 merged PRs, a 4-regression record, and the session transcripts that finally explained the plateau.
The Constraint Always Moves was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.