Up to Seven Times the Code
In mid-January 2026, our development team at Teamscale went all in on Claude Code. Nine months later, all our developers use it on almost every ticket. When we measured what that did to our codebase, the answer was three to seven times as much code from the same people. Over those nine months, it was about three times as much as over an equally long stretch before, and in the last two months about seven times as much. That counts only the code we added. Changed code has probably grown similarly, but we have not measured it.
Chart: Source lines of code in our codebase, April 2025 to October 2026. The dashed line marks the switch to agents.
Most of that code comes from real extra work. We close about 30% more tickets than before, and maintenance grew most, from about 40 tickets a month early in the year to about 95 in August. Developers now take on refactorings they had put off for years, some of them across 250 files. Features arrive more complete, and a user interface gets more rounds of polish in the same time. Even colleagues outside the development team now ship changes of their own.
All that code needs a review, though. Code nobody understands is a liability however fast it arrives, and review is where we come to trust a change before it ships. So we had to learn to scale review with the amount of code. This post shares what agentic review does for us and how we approach making changes cheaper to understand.
Reviewing Is the Job Now
Review used to take 20% to 30% of the time our developers worked on tickets. Now review has become their main job. Thomas Kinnen, our head of development, summed it up: »Coding has turned into 80% code review. First review code that Claude is writing for my current ticket, then review someone else's code (also written by Claude).«
The developer is now the first reviewer of the code the agent writes, taking responsibility for the outcome. This starts before any code exists. They tell Claude to draft a plan for the ticket and iterate on it first. A wrong assumption caught there costs a paragraph, while one caught later costs the code built on it, the review of that code and the rework. The developer then reviews what the agent implemented and has it fix what is off, before anyone else sees the change. These early rounds spread the review work across the whole team and take load off the senior developers, who would otherwise have to catch everything at the end.
Still, every change gets a second reviewer, because their independence matters as much as it always did. The developer chose the approach, steered the agent and decided when the work was done. They are badly placed to audit the outcome. Agent-written code also reads clean and convincing, which hides the agent's habit of tacking code on and patching symptoms where the cause needs fixing. Catching that takes someone who comes to the change fresh and has to understand it on their own.
»It is exhausting doing code review all day,« Thomas adds, and our team nods in agreement. Working with the agents' 30-to-60-second bursts, too short to turn to something else and too long to simply wait, makes this even worse. How can we help our people fight review overload?
One obvious answer is to let an AI take on part of the review. Since we were building agentic reviews into Teamscale already, we put them to work on our own changes.
Teamscale's agentic reviews run in three phases:
First, review agents examine the change. In our setup, one agent does a general review and four others focus on functional correctness, performance, security and test quality.
Second, every agent's comments pass through a verification step, in which a separate agent tries to refute each comment, so that wrong ones are dropped before anyone reads them.
Third, a consolidation step merges comments that different agents raised about the same problem before the rest lands in the merge request.
In our team, the agentic review is the developer's job, and it is mandatory. After pushing a change, the developer triggers the review, works through the comments, and only then hands the ticket to a colleague for the second review. A common way to work review comments is to paste them into Claude and ask for a plan that sorts them by usefulness. The developer rates every comment, which lets us measure how good the reviews are.
Over the last months, we learned that agentic reviews find real bugs, including ones a colleague would probably have missed. They overlap less with the human review than we expected, because the agents flag different things than a person does.
Working through those comments takes time, though. A wrong comment usually sounds plausible and is often elaborate, for example tracing a code path to a possible null pointer, so refuting it takes real effort. The review agents nearly always find something to say, so the comments get weaker the cleaner the change is. Running the review again only produces new comments of the same quality.
Agentic reviews cost real money, billed at API prices. Across our team, they add up to about $2,500 a month. That is roughly a third of what we pay for a developer. A single review costs less than $10 on average, so the large number of reviews is driving the bill.
Early on, we made benchmarking an integral part of agentic reviews in Teamscale. Our CTO Benjamin Hummel started this from a simple observation: »Opus is thorough, but quite slow.« When we benchmark, we run two models side by side on the same changes and let the developers' ratings decide. Our latest findings:
Opus 5.5 comes close to Opus 5 while costing about 40% less and finishing in under four minutes instead of five. It writes fewer comments, a slightly larger share of them useful, but each model finds useful comments the other misses.
Cheaper models do markedly worse. Sonnet 5.5 falls well short of Opus, and Sonnet 5 and two GPT 5.6 models together do worse than Opus 5 alone.
We recommend that every team benchmark its own agentic reviews, because results like ours likely depend on the setup and codebase. A benchmark run adds to the monthly bill, but it is how to choose the model and tune its prompts and settings, such as the thinking level.
Screenshot: Teamscale's benchmark of two models reviewing the same 126 changes, rated by our developers. Costs are dollars per review at API prices. Recall counts against all useful comments either model found, so a lower recall means missing comments the other model caught.
Our judgment is that agentic reviews are worth the money. Almost every review yields at least one comment worth acting on, and Thomas concludes: »If it can save us one relevant bug per day, it's a no-brainer.«
But agentic reviews do not scale review. Even a much better AI reviewer would not replace the human one. Anthropic reports that its engineers mark less than 1% of its automated reviewer's findings as incorrect, and still a person approves every merge, with criticality deciding how deep their review goes.1 Someone has to understand the change and answer for it, and that person has to read the whole change. So far, agentic reviews have not saved us any of that time.
Understanding the change was the hard part of review long before agents. In 2013, a Microsoft Research study found it to be the main challenge reviewers named. Since tools offered little more than a highlighted diff, reviewers read the description, ran the code, or, in 20% to 40% of cases, walked over to ask the author in person.2 That was not enough then. At several times the code, it clearly is not enough now.
Our developers have already moved away from traditional tools. Some have not opened a debugger in months. For many tickets, the agent session has become their main view. One colleague finds that most of the IDE's features have stopped mattering, and a development environment built from scratch today would look very different.
We believe such an environment would be built around explaining changes, so a reviewer gets to the central and riskiest pieces first. Because, quoting Addy Osmani, the team that »knows what's worth reading« will be the team that wins.1
Our first line of experiments pushes the limits of tools we have, with Claude doing the chores. Cutting and regrouping a change used to be a nightmare by hand, but an agent does it in seconds. For example, we ask Claude to regroup a merge request into commits for backend, frontend, tooling and build, or into a stack of merge requests that build on each other, so each can be reviewed on its own. This makes the change much easier to understand.
Screenshot: One feature as a stack of three merge requests in GitLab, each reviewed on its own. The bottom of the stack merges first.
Our second line of experiments is new tooling, which some of our developers build to try out ideas on our own reviews. One prototype lays out the files of a change as a graph in layers, ordered by their dependencies, so reviewers can work through the change systematically from one end to the other. Next to the graph, it shows the ticket's acceptance criteria and where each one is implemented and tested. And a co-reviewing agent adds its comments while the reviewer works. Working with such prototypes helps us find out what works and decide which ideas move into Teamscale.
Screenshot: A prototype review tool from our team orders the files of a change by their dependencies, so a reviewer can work through it level by level next to the diff.
The pressure keeps rising. At the pace of the last two months, our codebase of about 2.3 million lines would double in about 26 months. How to handle that much new code at this speed is an open question. We are convinced that helping developers and reviewers understand changes quickly is a crucial part of the answer, because understanding changes is how we come to trust them. That is why we keep working on making review scale.
Tests are another way to trust changes. Our test suite gave us a head start when we went all in on agents, and since then it has become the fastest-growing part of our codebase. Our next post is about what agents do to tests. Sign up for our newsletter below to get it when it appears.
1 Addy Osmani, Elevate: »The Code Nobody Reads«
2 Alberto Bacchelli and Christian Bird, Microsoft Research: »Expectations, Outcomes, and Challenges of Modern Code Review«, ICSE 2013