AI coding assistants make some teams slower. Here is how we keep them fast.
The evidence says assistants amplify whatever discipline a team already has. The practices, the measurements and the operating agreement we use so they amplify the right things.

Praveen Kumar
Founder & Technology Leader

On this page
Every engineering leader I talk to has the same two data points. Their developers say the assistants make them faster, and the delivery numbers have not moved. Sometimes the numbers have moved the wrong way. Both things are true at once, and the research explains why.
This article is about what we have learned running AI-assisted delivery on client work: where the time actually goes, the practices that keep it from going there, and how to measure whether an assistant is helping a team or just helping it feel busy. The templates we use, including the one-page team agreement and a script that measures the effects on your own repositories, are in our engineering notes repository.
What the evidence actually says
Read the studies rather than the headlines and a consistent picture appears. Assistants produce more code, faster. Whether the team gets faster depends on everything around the code.
- METR, July 2025. The only independent randomised trial on experienced developers in real repositories: 16 maintainers, 246 tasks, codebases they knew well. With AI allowed, tasks took 19% longer. The developers had predicted a 24% speedup and, after the study, still believed they had been 20% faster. Small sample, early-2025 tools, and the authors list the caveats themselves. Their 2026 follow-up with 57 developers produced only weak evidence either way, because a third to a half of participants withheld tasks they did not want to do without AI. (study, follow-up)
- DORA, 2024 and 2025. Nearly 3,000 respondents in 2024: for every 25% increase in AI adoption, delivery throughput fell 1.5% and delivery stability fell 7.2%, while documentation and code quality improved. In 2025, with nearly 5,000 respondents, throughput turned positive but instability still rose. DORA's own framing: AI is an amplifier of what a team already does. (2024, 2025)
- Field experiments inside companies. A randomised trial across 4,867 developers at Microsoft, Accenture and a Fortune 100 company found 26% more completed tasks, with the largest gains for less experienced developers. A Google trial of 96 engineers on one enterprise task measured about 21% faster, which was not statistically significant once covariates were included. Volume went up; nobody measured whether the extra volume was worth shipping. (Cui et al., Paradis et al.)
- What happens to the pull requests. Faros AI's telemetry across 10,000 developers: teams with high adoption merged 98% more pull requests, with 154% larger PRs, 91% longer review time and 9% more bugs per developer, and no significant productivity correlation at company level. Uplevel's comparison of 785 developers found cycle time unchanged and the bug rate up 41% for the group with assistant access. Both are observational and vendor-published, and both point the same way. (Faros, Uplevel)
- What developers report. In the 2025 Stack Overflow survey of 49,009 developers, 84% use or plan to use AI tools, 33% trust the output's accuracy, 66% name "solutions that are almost right, but not quite" as their top frustration, and 45% say debugging AI-generated code takes longer than expected. (survey)
- Security and skills. Veracode's 2025 and 2026 tests of more than 100 models found that roughly 44 to 45% of generated solutions introduced a known vulnerability class, a rate that did not improve between the two years. A 2026 randomised study of people learning a new library found the AI-assisted group scored about 17% lower on a comprehension test with no significant time saving. (Veracode 2026, Shen and Tamkin)
None of this says assistants are not worth using. We use them every day. It says that the gain is not in the tool. It is in the discipline around it, and a team without that discipline gets more code, bigger reviews, more rework and the same lead time.
Where the time goes
Watch a team that is slower with assistants and the same patterns show up.
Context-free prompting. The engineer describes the task in a sentence, accepts a plausible answer, and spends the next hour discovering which conventions it ignored: the error type the codebase uses, the logging shape, the tenant scoping rule, the test fixtures that already exist. The assistant did not know, because nobody told it, and nothing in the repository told it either.
The review tax moves to the senior engineer. Generated code arrives in larger pull requests written faster than anyone can read them. The author did not fully read the diff either, so review becomes the first time a human thinks about the design. Faros's 91% longer review time is this, measured.
Tests that assert the bug. Asked to "add tests", an assistant writes tests that pass against the current implementation. If the implementation is wrong, the tests lock the wrong behaviour in, and the suite goes green.
Prompt-and-pray debugging. When generated code fails, the fastest-feeling move is to paste the error back and accept the next attempt. Three rounds later the engineer has a patch they cannot explain and a bug they never understood.
Ownership drift. "The assistant wrote it" starts appearing in standups. Nobody can explain the retry logic in the payment client. The next incident takes twice as long because the people on call did not write the code and the people who prompted it do not remember it.
Data in prompts. A production log pasted into a chat window to ask what went wrong, with a customer's email address and a bearer token in it. Not malice; the absence of a rule.
Every one of these is a process gap the assistant exposed, not one it created. That is also why they are fixable.
The operating model
Your agent is only as good as the context and the contract you give it, and so is a coding assistant. These are the practices that make the difference on our client teams. All of them are written into a one-page team agreement that every engineer signs before an assistant touches production code.
Spec before prompt. The task is written down first: behaviour, edge cases, non-goals. The assistant gets the spec. "Make the export faster" produces a different week of work than "the monthly export of invoices for one tenant must complete under 30 seconds for 200,000 rows; it currently takes 4 minutes because of an N+1 on customer lookups; the API contract may not change."
A repository context file that encodes the conventions. One file at the root, read by every assistant on every task and by every new engineer: how to run and test, the layering rules, the one way errors are returned, how tenant scoping is enforced, the things that look wrong but are intentional, the files that are off limits. It is part of the definition of done for any change to a convention. A team that keeps this file current gets dramatically better output from the same tool, because the assistant stops guessing.
Small diffs. A pull request an engineer cannot read in twenty minutes is split. This single rule reverses most of the review-time problem. Assistants make it easy to produce a 1,500-line change in an afternoon; the agreement makes it unacceptable to submit one.
Tests are the contract, and the engineer writes the assertions. The assistant can draft a test file. The engineer decides what must be true, reads every assertion, and deletes the ones that merely mirror the implementation. A test the author cannot defend does not merge.
The author owns the diff. Whoever opens the pull request can explain every line without the tool. Reviewers are entitled to ask, and "the assistant generated it" ends the conversation in the wrong direction.
A reviewer budget. Reviewers spend the time the change deserves, not the time the author saved. If review load rises for a month, the process changes, not the reviewer's evenings.
Scanners do not care who wrote the code. Static analysis, dependency scanning and secret detection run on everything. Given the Veracode numbers, generated code touching authentication, cryptography, access control or payments gets a second human review, flagged in the pull request.
Data boundaries. An approved tool list, under accounts the company controls, with the data classes allowed for each. Client data, secrets and personal data never enter a prompt. This is a contractual matter with every client we work for, and it is a rule in the agreement, not a hope.
Where it clearly pays
With those rules in place, the assistant earns its seat quickly, and in predictable places:
- Mechanical migrations and refactors across many files, where the spec is precise and the tests already exist.
- Boilerplate: handlers, data-transfer objects, client wrappers, configuration.
- Tests for legacy code that has none, with the engineer choosing the cases.
- Exploring an unfamiliar codebase, API or error message as a starting point for verification.
- Documentation drafts, commit messages, runbook skeletons.
- One-off scripts and data fixes that would otherwise not get written at all.
The common thread is a verifiable output and a clear specification. The further a task is from both, the more the assistant's speed becomes your rework.
Measuring it
Do not measure acceptance rate; accepted code is often rewritten or deleted before it ships. Do not celebrate merged pull request counts on their own; Microsoft's 2026 rollout study found adopters merged about 24% more PRs and the authors were careful to say a merged PR is not the same as delivered value. Measure what happens to delivery when the volume goes up.
Four numbers, monthly, per team:
| Metric | Why | What a problem looks like |
|---|---|---|
| Median PR size, and the share over 400 lines | Review quality collapses with size | Size climbing month on month |
| Time to first review and time to merge | Where the queue forms | Time to merge rising while PR count rises |
| Rework rate: merged PRs followed by a fix to the same files within 14 days | The cost of "almost right" | Rework above your pre-assistant baseline |
| Revert rate and change failure rate | Stability, which DORA says is the first casualty | Any sustained increase |
Plus one question to engineers once a month, on a scale, about friction. The script in the repository pulls the first four from GitHub for any repository. Here it is run against a public SDK repository whose pull requests are largely generated code, which is why the numbers are extreme and a good illustration of what the metrics catch:
anthropics/anthropic-sdk-python · 22 merged PRs since 2026-08-01
PR size (lines changed): median 3154, p90 14912, over 400: 77%
Time to first review: median 6.4 h (22/22 PRs had a review)
Time to merge: median 6.4 h, p90 143.3 h
Rework rate (14-day, same files): 95%
Revert rate: 0%
Read together, not alone. A rising PR count with flat time to merge and flat rework is a team getting faster. A rising PR count with rising review time and rising rework is a team getting busier.
How we run it for clients
On client engagements the agreement has three additions. Tools are used only from the approved list, under accounts the client or NexifyPro controls, so prompts and context stay inside an agreed data boundary. Generated changes to security-sensitive code get a named second reviewer. And the metrics above are reported to the client monthly, because a client paying for delivery is entitled to know whether the tooling is improving it.
When this is wrong
A prototype that will be thrown away does not need the agreement; it needs speed, and the assistant provides it. A solo expert in a codebase they know cold can skip most of the ceremony, because the context lives in their head and the review is theirs anyway. And a task with no verifiable output, such as exploring whether an idea is feasible, is better served by treating the assistant as a conversation partner than as a code generator.
Everything else, which is most professional software work, is faster with the discipline and slower without it.
The checklist
Before an assistant is allowed on a production codebase:
- The team has signed the one-page operating agreement.
- The repository has a current context file with run, test and convention rules.
- Pull requests carry the AI-assisted checklist, including what was generated and what was verified by hand.
- A PR size limit is agreed and enforced in review.
- Scanners run on every change; security-sensitive generated code gets a second reviewer.
- The approved tool list and data boundary are written down.
- The four metrics have a baseline from before adoption and are reviewed monthly.
The templates are in the engineering notes repository: the team operating agreement, the context-file template, the pull request checklist and the metrics script.

Written by
Praveen Kumar
Use this article