DEV Community

Cover image for Code Is Cheap Now. Judgment Isn't: The Review Bottleneck and the Vanishing Apprenticeship
Mirella
Mirella

Posted on

Code Is Cheap Now. Judgment Isn't: The Review Bottleneck and the Vanishing Apprenticeship

Writing code has become the cheapest part of software development. Understanding it hasn't.

Over the past year, AI assistants have changed the economics of producing code. A working endpoint, a migration script, or a set of unit tests can appear in seconds.

But software doesn't ship when code is written. It ships when someone is confident enough to put it in front of real users.

That gap between generated and trusted is where a lot of engineering teams are quietly struggling right now. And it raises a question that goes beyond tooling:

If AI absorbs the work that used to teach engineers judgment, where will the next generation of reviewers come from?

Let's look at the review bottleneck, the apprenticeship problem behind it, and what developers and teams can do about both.

1. Faster Generation Doesn't Mean Faster Delivery

Imagine a developer who opens six pull requests before lunch. Each one is clean, well-formatted, and passes CI.

Now imagine the people who have to review them.

A reviewer doesn't just read the diff. They have to understand the intent, reconstruct the context, and think about what the diff doesn't show:

The index that should exist but doesn't.

The race condition that only appears under concurrent writes.

The authorization check that is present, but applied to the wrong object.

The behavior change in a downstream service nobody mentioned.

Reviewing is slower than generating, and AI hasn't changed that nearly as much.

So when output volume goes up and review capacity stays flat, teams usually end up in one of three places:

Queues grow, and "fast" code sits waiting for days.

Reviews get shallower, and risk moves into production unnoticed.

Senior engineers become full-time reviewers and quietly burn out.

None of these show up as a productivity problem on a dashboard that counts pull requests opened.

2. Measure Outcomes, Not Output

If a team celebrates the number of tickets closed or lines generated, it will get more of both.

Whether the software is actually getting better is a different question, and it needs different signals:

Change failure rate: how often do deployments cause a problem?

Time to restore: how quickly can the team recover when something breaks?

Review time: how long does a change wait, and how deep is the review it receives?

Incident frequency: are we seeing fewer surprises, or more?

If an AI tool makes individuals feel faster while these numbers stay flat or worsen, the team isn't more productive. It may simply be borrowing against future incidents.

This doesn't mean the tools aren't useful. It means the claim "we're faster" should be tested against outcomes, not impressions.

3. The Apprenticeship Problem

Here is the part that worries me more than the review queue.

Many experienced engineers built their instincts the slow way. They wrote plenty of mediocre code early in their careers, debugged it at inconvenient hours, and gradually learned what wrong looks like.

They learned about performance by shipping a slow query. They learned about concurrency by causing a bug that only appeared on Fridays. They learned about failure modes by being the person on call when something fell over.

A lot of that learning happened through small, unglamorous tasks:

Fixing minor bugs.

Writing straightforward endpoints.

Adding tests to existing code.

Reading unfamiliar code and figuring out why it worked.

These tasks weren't just cheap labor. They were the training program.

If AI absorbs many of them, and companies respond by hiring fewer juniors, we risk a delayed problem. The people who would have become tomorrow's senior reviewers never get the experience that makes review possible.

That cost won't appear on this quarter's budget. It will show up years from now, when organizations discover they have plenty of generated code and not enough people who can judge it.

4. Judgment Is Built by Being Wrong

There's an uncomfortable idea here.

Engineering judgment is often presented as the durable advantage in the AI era. I believe that's largely true. But judgment isn't something you can read your way into.

It develops through a loop:

Make a decision.

See what happens.

Notice the gap between what you expected and what occurred.

Adjust your mental model.

Fluent, plausible AI output can weaken that loop. When code arrives looking polished and complete, a newer developer may not yet have the feel to recognize what's off. And if they never had to build it from scratch, they may have little to compare it against.

That doesn't mean juniors should avoid AI. It means the way they use it matters enormously.

5. Using AI to Learn Instead of Skip

There's a meaningful difference between using AI to understand something and using it to avoid understanding it.

A few habits that keep the learning loop intact:

Predict, then compare. Before asking for an implementation, write down how you think it should work and where it could fail. Then compare your prediction with the output. The gap between them is exactly what you need to study.

Keep a rejection log. Record AI suggestions you decided not to use, and why. "This query would have scanned the whole table" is a far better interview story than a polished repository with no history behind it.

Explain it back. If you can't explain why a generated solution works, in your own words and without looking at it, you don't own it yet.

Break it on purpose. Feed the code strange inputs, concurrent requests, and missing data. Learning what failure looks like is half of judgment.

Write the tests from the requirements. If the same tool writes both the function and the tests, the tests often just encode the function's assumptions. Derive test cases from what the code is supposed to do, then ask: what would have to be true for this test to fail?

None of this is slow. It's simply deliberate.

6. Portfolios That Show You've Operated Software

Earlier advice about building one substantial project still holds. But there's a refinement worth adding.

The most convincing projects aren't the ones that look the most polished. They're the ones where you can tell the author has actually operated the software.

That might mean:

A handful of real users, even a few friends or a small community.

A short incident write-up: what broke, how you found it, how you fixed it.

Notes on trade-offs you chose and what you'd do differently.

A changelog showing how the project evolved after real feedback.

A tutorial clone proves you can follow instructions. A small system with a postmortem proves you can debug, communicate, and learn from failure, which are exactly the skills teams struggle to find.

7. What Teams Can Do to Keep the Pipeline Alive

This can't only be an individual responsibility. Organizations that want experienced engineers in five years have to invest in producing them now.

Practical ways to do that:

Protect real learning work. Don't automate every small task away from juniors. Some of it is the curriculum.

Pair on purpose. Pairing and mentorship transfer the "why" behind decisions in a way documentation rarely does.

Make reviews teach. A review that explains the reasoning behind a comment is training. A review that just says "change this" isn't.

Give juniors real ownership. A small production service with real consequences, supported by a safety net, builds judgment faster than any exercise.

Plan for review capacity. If generation speeds up, review needs investment too: smaller changes, clearer descriptions, better automation, and protected time.

Preserve institutional knowledge. Document the systems, workarounds, and historical decisions that live only in a few people's heads, before those people are no longer around to explain them.

8. Can We Even Measure Judgment in Hiring?

There's a harder question underneath all of this.

If judgment is the valuable skill, how do hiring processes evaluate it?

Take-home projects can now be generated. Live coding interviews often measure performance under pressure more than long-term reasoning. Résumés list technologies, not decisions.

So the industry may be tempted to fall back on easy proxies: years of experience, brand-name employers, or credentials.

Better signals are possible, but they take more effort:

Ask candidates to walk through a past production issue and how it was reviewed afterward.

Give them a piece of flawed code (generated or not) and ask what concerns them.

Ask how they verify AI-assisted work, and what they've rejected.

Discuss a trade-off they made and what they'd change now.

Candidates can ask these questions too. A team's answer to "tell me about the last incident and how you learned from it" reveals a great deal about its culture, its ownership, and whether it's a place where you'd grow.

9. A Practical 30-Day Plan for Building Judgment

Judgment can't be rushed, but it can be practiced deliberately.

Week 1: Start a decision journal

For every meaningful task, note what you expected, what happened, and what surprised you. If you use AI, record your prediction before you see its answer.

Week 2: Review something you didn't write

Read an open-source pull request or a teammate's change. Write down what you would check, what you'd question, and what you can't judge yet. Those gaps are your study list.

Week 3: Break and fix something small

Take one of your own projects. Introduce a realistic failure (slow query, bad input, concurrent update), find it using logs and tests, then write a short postmortem.

Week 4: Share what you learned

Publish the postmortem, a rejection-log entry, or a short article. Teaching is one of the fastest ways to find out what you actually understand.

At the end of the month, you won't have mastered anything. But you'll have evidence of how you think, and that is what teams are increasingly trying to find.

Final Thoughts: Fast Code Still Needs Slow Learning

AI is making it easier than ever to produce code. That's genuinely useful, and ignoring it isn't a strategy.

But software engineering has never been only about producing code. It's about deciding what should exist, noticing what could go wrong, and taking responsibility for what reaches users.

Those abilities are built through experience: through being wrong, finding out why, and doing better next time.

If we let the tools replace the experiences that build judgment, we may end up with a profession that has plenty of output and fewer people qualified to trust it.

Developers can protect themselves by treating AI as a teacher rather than a shortcut. Teams can protect themselves by treating junior engineers as a long-term investment rather than a task queue that can be automated away.

Code will keep getting cheaper. Trust won't.

Let's discuss

I'd like to hear how this looks from where you work.

Review load: Has AI-assisted code changed how long reviews take, or how deep they go, on your team?

Learning: If you're early in your career, how do you make sure AI is teaching you rather than doing the thinking for you?

Mentorship: What has your team done to keep juniors learning when routine tasks get automated?

Hiring: How would you evaluate engineering judgment in an interview, now that take-homes can be generated?

Share your experiences in the comments. Practical lessons from people doing the work are more useful than another prediction about the future.

Editorial note: This article is an independent, developer-focused perspective and a follow-up to my earlier essay on 2026 technology layoffs. It reflects general engineering observations rather than measured data, and the practices described will fit some teams better than others.

Top comments (3)

Collapse
 
humanonmute401 profile image
Human On Mute 401 •

The apprenticeship point is the one teams will feel last and pay for first. If the work that used to teach judgement now arrives as a finished diff, the review queue only grows a cohort of approvers, not reviewers. A small habit helps: before anyone reads the generated change, the author writes two lines. What they checked by hand, and their own call on the open question. That keeps review from becoming a stamp on output volume.

Collapse
 
kira_m_b9e617f21ee9b4fbe profile image
Jane Jones •

Great piece. The framing of “generated vs. trusted” is the clearest way I’ve seen to describe what many teams are feeling right now. A few thoughts from the angle of someone who has watched this dynamic play out:

The review bottleneck is partly a context problem, not just a volume problem.
When a human writes a change, the reviewer can often infer intent from the author’s habits, the ticket history, and the shape of the diff. AI-generated changes strip away much of that signal. The code is uniformly polished, so nothing visually flags “this is the part I was unsure about.” Human authors leave tells (a hesitant comment, an oddly named variable, a TODO), and those tells direct reviewer attention. Generated code is confident everywhere, including where it shouldn’t be. One practical fix is to require PR descriptions that state what the author verified themselves versus what they accepted as-is, and where they’d look first if it broke. That restores some of the lost signal and forces the author to actually engage with the change.

“Measure outcomes, not output” is right, but watch the lag.
Change failure rate and incident frequency are lagging indicators, and the damage from shallow review often surfaces weeks or months later, long after the PR that caused it. Teams may want a leading indicator too, such as review depth (comments per change that touch behavior rather than style), or how often reviewers request tests. If approval times drop while comment substance drops with them, that’s an early warning.

On the apprenticeship problem: the small tasks were also a low-stakes feedback loop.
What you call the “training program” worked partly because mistakes were cheap and survivable. A junior who shipped a slow query to a low-traffic internal tool learned the lesson without a catastrophe. If AI takes those tasks, we lose the safe failures, and the remaining work skews toward high-stakes, high-ambiguity problems where juniors can’t afford to be wrong. Teams could deliberately create “safe-to-fail” environments: internal tools, staging-scale chaos exercises, or rotating juniors through on-call as shadows before they’re primaries.

A reframe on “predict, then compare.”
This is the most actionable habit in the article, and I’d extend it: the best version is predicting failure modes, not just implementation. “Where will this break under load? What input would I be afraid of?” Then check whether the generated code handles those cases. It trains exactly the adversarial instinct reviewers need, which is the skill most at risk of atrophy.

Seniors need to change too.
The article focuses on juniors and teams, but senior engineers are quietly facing a shift as well: from author to editor. Reviewing generated code at volume is a different cognitive skill than writing, and it’s rarely taught or recognized. Organizations should treat review as a first-class, credited contribution (in promotion criteria and workload planning) rather than overhead layered on top of “real” work. Otherwise the burnout scenario you describe becomes the default.

On hiring: I’d add one signal to your list: ask candidates to review a PR live, ideally one with a subtle flaw (a missing authorization check on the wrong object, as in your example). How someone prioritizes what to look at, what questions they ask about context before judging, and what they admit they can’t evaluate reveals more about judgment than almost any other format. Candidates who say “I’d want to know X before approving this” are showing precisely the skill you’re describing.

One counterpoint worth considering: AI may also accelerate learning for some people, because it lets a junior see ten approaches to a problem in an afternoon rather than one. The risk isn’t the tool itself but whether the learner stays in the loop of predicting, testing, and being wrong. So the differentiator may be less “juniors with AI vs. without” and more “juniors with mentorship and feedback vs. without.” That puts even more weight on your point about making reviews teach.

To answer your discussion questions briefly: on our side, reviews have gotten shallower on the easy-looking changes and deeper on the scary ones, which is precisely backwards from where the hidden risk tends to live. Smaller PRs and mandatory author-written “what could go wrong” notes have helped the most.

“Code will keep getting cheaper. Trust won’t.” is a great closing line. Thanks for writing this.

Collapse
 
busy_nikita profile image
Nikita •

Strong piece. The apprenticeship section stood out to me, and I’d add one angle on why review gets harder with AI-generated code, because it points to a fix.

The author used to be a free source of context. When a human writes a PR, the reviewer can infer a lot from how it was written: what the author was worried about, what they skipped, where they were unsure. AI-generated diffs are uniformly confident, so those signals disappear. The reviewer has to rebuild the intent from scratch, which is why review feels slower even when the code is clean.

Two things have helped on teams I’ve seen try this:

Make the author supply the missing context. A PR template that asks for intent, what you personally verified, and where you’re least sure. If the author can’t answer “where am I least sure?”, the PR isn’t ready for a human reviewer.
Move verification into executable artifacts. Property tests, invariants, and contract tests let the reviewer judge the spec instead of re-deriving correctness from the diff. This also fits your point about writing tests from requirements, not from the generated function.

On the pipeline problem, I’d suggest review itself can become part of the apprenticeship, if it’s structured. Seeded-bug exercises, replaying past incidents against the diff that caused them, and having juniors write the “what could go wrong” section on AI-assisted PRs all build the same pattern recognition that fixing small bugs used to. It isn’t a full replacement, though. Production feedback is the part AI doesn’t speed up, so getting juniors into on-call shadowing and postmortems earlier matters even more now.

To your hiring question: has anyone tried a “review this PR” interview with a seeded subtle bug? I’m curious whether it separates candidates better than take-homes do.