Luca Morelli
Software engineer and analyst
Team lead

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.

AI pull request review and the growth of junior developers

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

Assess the choice to wait, too

Preparing the work: clearer pull requests and lower spend

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.

My method: specifications and the project harness

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.

Content last updated

Would you like your developers to learn to use them methodically?

Detailed CV and references available on request.