EveryDev.ai
Subscribe
Main Menu
  • Tools
  • Developers
  • Topics
  • Discussions
  • Communities
  • Users
  • News
  • Podcasts
  • Blogs
  • Builds
  • Contests
  • Compare
  • Arena
  • Polls
Rate toolsCreate
AI Tools by Topic
  • AI Coding Assistants
  • Agent Frameworks
  • MCP Servers
  • AI Prompt Tools
  • Vibe Coding Tools
  • AI Design Tools
  • AI Database Tools
  • AI Website Builders
  • AI Testing Tools
  • LLM Evaluations
Follow Us
  • X / Twitter
  • LinkedIn
  • Reddit
  • Discord
  • Threads
  • Bluesky
  • Mastodon
  • YouTube
  • GitHub
  • Instagram
Get Started
  • Users
  • Rate Tools
  • About
  • Editorial Standards
  • Corrections & Disclosures
  • Community Guidelines
  • Advertise
  • Contact Us
  • Newsletter
  • Submit a Tool
  • Start a Discussion
  • Write A Blog
  • Share A Build
  • Terms of Service
  • Privacy Policy
Explore with AI
  • ChatGPT
  • Gemini
  • Claude
  • Grok
  • Perplexity
Agent Experience
  • llms.txt
Theme
With AI, Everyone is a Dev. EveryDev.ai ©
    1. Home
    2. Blogs
    3. Code Inflation: AI Prints Code Faster Than Anyone Can Review It

    Code Inflation: AI Prints Code Faster Than Anyone Can Review It

    Joe Seifi's avatarJS
    Joe Seifi
    November 17, 2026·Founder at EveryDev.ai
    Discuss (4)
    AI is producing code far faster than engineers can review it, and little of it ships.

    A junior engineer told two Harvard researchers about a project where one senior engineer was the only person allowed to approve changes. He was so busy that he could review the junior's code about once a week. Then AI-generated commits caused some outages. The company responded with a new rule: AI-written code needs senior approval. The queue got longer.

    That story is from a 121-page working paper by Fiona Chen and James Stratton. They tracked 655 companies after engineers started using AI coding agents.

    Engineers wrote a lot more code. Companies shipped only a bit more software. The rest sat in review queues.

    A central bank might print money faster than the economy makes things to buy. AI now prints code faster than companies can check and ship it. That's code inflation.

    AI is printing code

    The data comes from Jellyfish, an analytics platform that companies connect to GitHub, Jira, and Google Calendar. The sample covers 445 million work events from 720,542 workers at 655 companies between January 2021 and August 2026.

    The researchers compared companies that adopted AI tools early with companies that adopted later. They ran the comparison once for coding assistants like GitHub Copilot and Cursor autocomplete. They ran it again for agents like Cursor Agent and Claude Code.

    Adoption was fast. Almost no company in the sample used an agent in October 2024. By July 2026, 98.3% did.

    More code in, less shipped out.

    Here is what changed 12 months after a company adopted each kind of tool.

    MeasureAssistantsAgents
    Lines of code added+30.4%+44.0%
    Commits+16.8%+36.0%
    Pull requests opened+20.9%+35.7%
    Jira issues resolved-1.5%+13.7%
    Jira epics resolved+3.4%+18.0%

    In this data, a Jira issue gets resolved when its code is deployed to production. That makes it the closest thing to "shipped work" the study has.

    That 13.7% is a rough cut. The real number could be anywhere from zero to 30%.

    Obvious objection: maybe tickets just got bigger. The researchers checked two ways and found no change. Bug reports per engineer stayed flat.

    Who printed the most

    • Biggest gains went to engineers who wrote the least code before. Seniors edged out juniors, but not by much.
    • Companies with more agent users saw bigger jumps. Fewest users: pull requests up 21%. Most users: up 67%.
    • Individual users outpaced company averages. A year in, only a third of engineers used agents, but those wrote up to 172% more code.

    Nobody reviews it fast enough.

    More code should mean more software. Mostly, it didn't. One senior nailed it: there's always one bottleneck. Speed up coding, and review becomes the slowest step.

    Coding: 74% faster. Shipped work: up 14%.

    The researchers built a simulation of a software team with two jobs, coding and review. It's a set of equations fitted to the measured results. It lets them estimate things nobody can observe directly. Three findings came out.

    Agents made coding 74% more productive. But pull requests only rose 36% because engineers spent less time coding.

    Engineers shifted from writing to reviewing. Before agents: two hours coding for every hour reviewing. After: one-to-one. The simulation says that's close to optimal. Adding more reviewers won't help much.

    A 74% coding gain turned into just 14% more shipped work. About 60% of the gain got stuck in review queues. The rest? Each shipped feature now takes 17% more pull requests. Two possible reasons: engineers split work into smaller chunks, or other slow steps like testing and sign-off are in the way.

    The interviews support the second reason. One senior engineer said they waited six months for legal approval on something that should have taken one.

    The next three sections show the evidence behind those numbers.

    The extra code is waiting in review.

    After agents, time from opening to merging a pull request jumped from 3.6 to 5.6 days.

    The delay has two parts. Both grew by almost the same amount.

    • Waiting for a reviewer to start: up 60%. Too much code, not enough reviewers.
    • Back-and-forth after review started: up 59%. Each pull request took more rounds.

    Reviewers left 39% more comments per pull request, even though PRs weren't bigger. The researchers call that a drop in code quality. Merge rate fell from 86% to 80%. None of this happened with autocomplete tools. They didn't add enough code to strain review.

    Joe Maddalone offers one possible reason in a recent video, drawing on an article by Rob West. A software factory needs a steady supply of specs. Teams end up writing requirements before they understand the problem. The agent fills the gaps with confident guesses.

    Why you can't just assign more reviewers

    First, reviewers need to know the code. Five out of six reviews came from someone who'd worked in that codebase. Second, seniors mostly review other seniors. Three out of four times, that's who did it. Hard to hand off reviews to someone new. Worse in big codebases: most repos, time to merge up 70%. Fewest repos, up 25%.

    AI reviewers are installed almost everywhere and do little of the reviewing.

    By July 2026, 79.1% of companies in the sample had used an AI code review tool such as CodeRabbit, Greptile, Graphite or Copilot's reviewer.

    Humans still did most of the work. AI wrote 1 in 4 review comments, but only 1 in 10 pull requests got any AI comment. Why? Shipping broken code is expensive. Companies keep people in the loop even when tools are there.

    Read next: AI Performance Metrics Explained Through How Printers Work
    Recommended

    Recommended

    AI Performance Metrics Explained Through How Printers Work

    AI Performance Metrics Explained Through How Printers Work

    A familiar office printer can explain a lot about AI performance, from latency and throughput to memory and scheduling. The Printer It's 1999. Somewhere in a university computer lab. Three computer science students are s…

    Read next

    What code inflation looks like

    Code is money; shipped features are what it buys. Agents are the printing press. Money supply jumped, output barely moved. Textbook inflation: too much money chasing too few goods. Here: too much code chasing too few reviewers.

    Review is the scarce good. Demand jumped, supply barely moved.

    The economyThe study
    The central bank prints moneyAgents make code cheap to produce
    Goods and servicesShipped work
    What the economy can really produceSenior reviewers who know the codebase
    Banks approving loansCode review. New code only reaches customers after someone signs off.
    Prices riseEach shipped item takes more pull requests
    Money sits idle in bank reservesCode sits in the review queue

    Nominal vs real: a 10% raise means nothing if prices rise 10%. Pull requests are nominal. Shipped work is real.

    Most printed code sits idle. After 2008, the Fed's balance sheet ballooned, but banks held the money as reserves. Inflation stayed low. Economists call this velocity. It dropped by a quarter from 2007 to 2017. Same with code: it moves slower, waiting in review, and buys less since each feature takes more pull requests.

    Lenders tightened up after 2008: first easy loans, then losses, then stricter rules. Same here: outages first, then a stricter approval rule.

    The analogy has limits.

    • Printed money creates nothing. Agents did raise shipped work, which is real.
    • Nobody's in charge. Central bank: one decision. Here: every engineer has a press.
    • More pull requests per feature isn't always a loss. Maybe engineers just split the same work into more PRs. That's swapping a $20 bill for twenty singles, so the total stays the same.

    The printing press hit the same problems.

    In 1470, the humanist Niccolò Perotti said the printed books in circulation were so inaccurate that it would have been better if they'd never been printed. When the printing press made text cheap to produce, checking it became the slow part. A scribe's mistake ruined one copy. A typesetter's mistake went into every copy in the print run.

    Printers answered with a new job called the corrector. This was a paid reviewer who read proofs in the print shop before the press ran. A 1683 printing manual said correctors should know Latin, Greek and Hebrew. Henri Estienne employed ten of them for his Greek editions.

    Review never fully caught up. Printers started shipping an errata page at the back of the book that listed the known mistakes. One 1650 title told readers to "correct as thou readest" and listed 32 errors.

    Today's version is harder in one way. The press sped up copying, but writing still took time. One corrector's pass covered every copy. Agents speed up writing. Every pull request is new text needing its own review.

    Where this leads

    Printing more code is the first of four steps. Here's how the rest could play out.

    1. AI prints more code. That's happening now.
    2. Cheap code means cheaper software. Build for less, charge less, sell more.
    3. Fewer engineers, more software. Forecast: 16% more software with 13% fewer engineers.
    4. The Fed prints more money. That's how a central bank eases falling prices and lost jobs.

    Only step one has happened. Steps two and three are from the simulation. The study stops before step four.

    Cheaper software

    Code is already cheap. The average engineer spent $178 a month on agents in July 2026, under 3% of entry-level pay.

    The study has no data on software prices. What happens next depends on how many more customers buy software when it gets cheaper. Economists measure that with a number called price elasticity. An elasticity of 2 means a 1% price cut brings 2% more sales. Older studies of mobile apps, retail software and console games average about 2.3.

    Fewer engineers

    So far, there has been no change in headcount or junior hiring. The measurement is rough, and a drop of up to 15% can't be ruled out.

    The forecast is different. The simulation says companies only hire more engineers if elasticity is above 3.7. At the 2.3 average, expect 16% more software from 13% fewer engineers. Human coding drops by a third. Review work grows by a quarter.

    By 2031, review is the deciding factor.

    ScenarioOutput by 2031Engineering jobs by 2031
    Review stays as slow as it is today+57.8%-10.3%
    AI speeds up review as fast as coding+341.4%-76.2%

    First scenario: output stops growing by late 2027. After that, faster coding just adds to the unreviewed pile. The second scenario is an upper bound. Real teams still have to pick features, test, and talk to customers.

    AI is improving faster in the lab than in companies. From assistants to agents, top AI models handled tasks 8.4 times longer (METR's measure). Inside companies, coding productivity grew only 1.7 times.

    The Fed

    The study stops at fewer engineers. The last step is an open question.

    Case for: if the forecast is right, software gets cheaper, and engineering jobs shrink. Falling prices and lost jobs are what central banks fight. Lower rates, then buying assets with new money. That's what the Fed did after 2008.

    Case against: one industry's prices and jobs are a small slice of the economy. A boom in chips and data centers could push rates up. The last two steps haven't happened yet.

    Nobody knows which way it goes.

    What to take away from all this

    For Engineers: Being able to review a codebase you know well is now gold. In the forecast, review work grows no matter what customers do.

    For Managers: Track metrics like time to merge, review queue size, and shipped work. More repos means longer queues.

    For PMs: AI review tools write a quarter of comments, but can't see the whole feature or its purpose.

    For Founders: this study mostly leaves you out. The companies here average 1,677 employees and are 19 years old. Results may differ for startups. If lower prices bring you more customers, your team grows.

    About the Author

    Joe Seifi's avatarJS
    Joe Seifi

    Founder at EveryDev.ai

    Apple, Disney, Adobe, Eventbrite, Zillow, Affirm. I've shipped frontend at all of them. Now I build and write about AI dev tools: what works, what's hype, and what's worth your time.

    Comments (4)

    Checking profile…

    Everson Tuffin's avatarET
    Everson Tuffin10 minutes ago

    If agents write most of the code and juniors mostly prompt, where does the next round of people who can actually review it come from? Like who becomes the reviewers of the future?

    Joe Seifi's avatarJS
    Joe Seifi7 minutes ago

    Reviewing is how a lot of us learned anyway. I learned more from reading other people's PRs than from my own early code. Being on the reading side of code forces you to understand it from a different angle and ask questions you wouldn't ask otherwise. So basically reviewing becomes training for the next gen.

    Sam Moore's avatarSM
    Sam Moore14 minutes ago

    Interesting note about Rob West's point about specifications. When I talk with teams using these tools, most review comments aren't really about the code at all. They amount to "this isn't what we meant." The agent faithfully implemented what the ticket said, and the ticket itself was the problem!

    So I'd be cautious about reading the 39% rise in comments per pull request purely as a decline in code quality. Some of it, I suspect, is a requirements problem that's simply surfacing later in the process, where it's more expensive to fix.

    Nolan Carrow's avatarNC
    Nolan Carrow18 minutes ago

    IMO the 17% more PRs per feature number might not all be bad news.

    On my team we started stacking smaller PRs on purpose once agents got involved, because a 1,200 line agent diff is basically unreviewable. More PRs, but each one gets a real look instead of a skim and an approve. How does it look if split by PR size?