Coding agents in a development team: verify, measure, train.
Coding agents make it possible to produce more code. For those who lead a development team, the question becomes a different one: can the team understand it, verify it and maintain it? Measure the benefit through useful, maintainable software that reaches production.
What I can do, and what I have not done yet
Training and mentoring junior developers has always been part of my work as a senior developer and team lead.
I can do the same with coding agents: train individual developers to use them methodically, each on their own work (written specifications, a personal harness, checks), and support them during the project. It is the way I use them myself, described in Coding agents.
Having a whole team work on a single shared harness is a different and much more complex step, which I have not yet tackled on a project. The sections that follow bring together the criteria I consider necessary in a team: they are methodological proposals, not the account of an adoption I have already led.
Why a shared harness is difficult
I have not done this on a project yet. These are the problems I see.
- Who changes it. If everyone can edit it, it degrades and loses precision: it needs an owner and a review, as code does.
- How it grows. The information grows and the agent must keep finding the right pieces: it has to be maintained and optimised over time.
- What it contains. Beyond a basic structure, every project has its own needs: there is no ready-made template to copy.
- Seniors and juniors. As I see it, the seniors would have to build into the harness the workflows, the domain documentation and the checks that make it possible to assign tasks and validate the work; the juniors would receive the tasks and work on them until the review clears the pull request. In theory that is how it works; in practice it looks complex to me. And the agent, on its own, does not make a junior grow: training and mentoring them during the project remains the seniors' job.
- What it costs. It is extra work, to be counted in the cost of adoption.
Verification can become the bottleneck
If an agent changes more code than a team can understand and verify, the initial speed can become review and maintenance work. This is the risk I consider central.
My proposal is to separate production from validation: acceptance criteria and reference results should also be checked outside the process that generated the change. A second agent can help, but may share the first agent's mistakes.
- Behaviour, integration, contract and regression tests proportionate to risk.
- Static analysis, security checks and dependency checks.
- Reviews with explicit criteria and comparison against domain requirements and constraints.
- Changes small enough to make mistakes and consequences visible.
Not every line needs the same human scrutiny. There must, however, be a person responsible for the decision, with stronger checks where an error has greater consequences.
Tools and responsibilities in a team
As a freelancer, the assessment is direct: I set myself a budget and check whether the result justifies the cost; where needed, the client approves the use. In a company the return varies from person to person, and without tools to measure it, approving the use of coding agents becomes difficult.
Not evaluating them has a cost, though. In my experience, small teams and professional practices often have, in specific areas, greater technical capability than teams put together by larger companies, which is partly why they are sometimes given delegated work. With coding agents, perhaps not straight away, a small team with skills and method can offer a client a better and cheaper solution. If it then keeps its promises, continuity of service included, whoever loses the contract also loses face. This is a scenario to assess, not a prediction.
For a team, I would select tools and access levels according to activities, rather than automatically assigning everyone the same licence. Purchasing should come with training, shared practices and clear responsibility for context and documentation.
A case made public in October 2026 points the same way: according to 404 Media, since 1 October Accenture has paid $29 a month per employee for Claude and asks for any further spending to be charged to the project or team. One employee, who used Claude Code to build and test software for several clients, typically spent between $500 and $1,000 a month. With a coding agent used intensively, spending depends on use, not on the licence: that is why the cost should be compared with the work it produces, not with the price list.
Preparing the work before assigning it also reduces consumption: with precise requests the agent explores less of the code.
I would measure completion and review times, defects and rework alongside costs. Tokens, generated lines and pull request counts are insufficient measures of benefit or an individual's contribution: this is a methodological proposal, not a universal ROI formula.
Measure work the team can maintain
The total cost of AI applications
Training junior developers
Coding agents can improve productivity, depending on the task and context. They do not replace an understanding of the system, and that is where the distinction remains.
It also changes how junior developers are trained. The risk is someone who doesn't grow and just keeps prompting the AI until something works. That is why I ask the juniors I mentor to build their own direct understanding of the product, and I always discuss their assigned items with them. It is the same principle I follow as a team lead.
Maintain an understanding of the system
I use “cognitive debt” to describe a risk: the software still works, but fewer people understand why it was built that way. This is a useful concept, not an established standard metric.
Documented decisions, domain discussions and checks with the team help retain that knowledge. A developer's role includes requirements, architecture, context and judgement about changes; delegating execution still requires these skills.
The harness must make errors visible
A harness contains context, rules, tools and procedures. Improving it can make an agent more effective; it can also propagate a mistaken interpretation faster.
I therefore include action limits and stopping conditions in the harness: failed tests, ambiguous requirements, unexpected differences or missing checks. Detecting an incorrect change before it reaches the product matters.
Coding agents on legacy applications
A coding agent can work more independently when it has a verification loop: it changes the code, runs checks, reads errors and corrects them. Automated tests are central to this loop, alongside compilation and other relevant checks. A strict TDD process is not necessarily required; what matters is repeatable feedback on the required behaviour.
In some legacy applications, checking a change requires starting the entire system, a database with suitable data, external services and configurations that are difficult to recreate. When the logic is tightly coupled to these dependencies and automated tests are missing, setting up a verification loop takes additional work. A recent application can have the same constraints.
A database does not prevent automation: test environments and resettable data can be prepared. It may nevertheless be necessary to document startup, introduce tests describing existing behaviour and gradually separate some dependencies. This work belongs in the initial adoption assessment. Where verification remains mainly manual, I would allow the agent less autonomy and keep changes small, with explicit human checks.
Measure work the team can maintain
AI-generated code percentage, tokens, prompts or pull request counts are insufficient measures of benefit. I compare completion and review times, defects, regressions, rework and the ability to evolve the product.
The SPACE framework treats productivity as multidimensional. In that spirit, I propose assessing outcomes, collaboration and sustainable working practices together, without turning a single measure into a ranking of individual developers.
The objective I would choose is correct, useful and maintainable software at a sustainable cost.
What the studies say
Productivity and quality do not have an automatic relationship.
Borg and colleagues' experiment, published in 2026 with 151 participants, finds no significant differences in subsequent maintainability of code developed with AI assistants. The tasks took place in late 2024, before today's coding agents.
Liu and colleagues instead analyse around 302,600 AI-attributed commits in 6,299 repositories. They identify issues through static analysis, of which 22.7% remain at the latest observed revision. This is evidence of persistent issues in the sample, not a measure of every defect or a comparison with every human developer.
GitClear observes more duplication and less refactoring during the spread of AI. These are signals to monitor; alone, they do not establish a single cause.
The 2025 DORA report, based on nearly 5,000 responses, observes that AI use is associated with more deliveries but also with less stable releases, and that 30% of participants have little or no trust in generated code. For the authors, AI amplifies what is already there: it strengthens solid teams and exposes the problems of the others. It is a survey of participants' responses, not a direct measurement of the code.
Reading these studies together suggests measuring effects within your own process.
A case: Shopify
In September 2026, Shopify describes moving from React Native to Swift and Kotlin: coding agents changed the cost of maintaining two native implementations. The Shop app was rebuilt and released in about 12 weeks; migration of the Shopify app, with more than 300 screens, is described as ongoing. For the migration it uses small steps with tests, visual comparison and two independent reviews; engineer approval is the default. This is one company's experience, not an estimate transferable to other applications.
From this I draw a broader proposal: clear responsibilities, explicit contracts, fast tests and understandable observability make a system easier for both people and agents to work on.
Supporting sources
The studies use different methods and cover different settings. The proposals on validation and the developer’s role are working principles drawn from this evidence, rather than promises of a universal outcome.
- Borg et al. — Echoes of AI (opens in a new tab): experiment on subsequent maintenance; data collected in late 2024.
- Liu et al. — Debt Behind the AI Boom, version 2 (opens in a new tab): AI-attributed commits and issues detected through static analysis.
- GitClear — Maintainability Gap (opens in a new tab): observational signals on duplication, reuse and maintenance.
- Shopify — choosing native development (opens in a new tab): reasons for the change and agent-addressable architecture.
- Shopify — Shop app migration (opens in a new tab): experience and timings of that particular project.
- Shopify — Helix (opens in a new tab): checkpoints and verification for the Shopify app migration.
- Forsgren et al. — SPACE (opens in a new tab): complementary dimensions of developer productivity.
- Claude Code — Best practices (opens in a new tab): criteria and checks the agent can execute.
- Martin Fowler — Legacy Seam (opens in a new tab): separating dependencies to test existing code.
- Microsoft — Choosing a testing strategy (opens in a new tab): real-database tests, isolation and the limits of test doubles in EF Core projects.
- DORA — State of AI-assisted Software Development 2025 (opens in a new tab): survey of nearly 5,000 professionals; relationship between AI use, delivery throughput and release stability.
- 404 Media — Accenture limits employees' Claude spending to $29 a month (opens in a new tab): a report based on a non-public internal communication; a single case, without the company's reasons. Part of the article is for subscribers only.
- The Next Web — summary of the 404 Media report (opens in a new tab): details of the internal communication and employees' reactions; a secondary source, readable in full.