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 (9)

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.

Collapse
 
rimonnassory profile image
Rimon Nassory •

Great article! The apprenticeship problem really stood out to me. I've been thinking about whether junior developers should initially work without AI to build their fundamentals. Have you seen teams successfully introduce AI from day one while still ensuring juniors develop independent problem-solving skills?

Collapse
 
anne_jacobs_ac166227aa92b profile image
AJ •

The connection between the review bottleneck and the apprenticeship problem is the strongest part of this piece. They’re not separate problems: the people whose time we’re consuming with today’s review queue are also the people we need to develop tomorrow’s reviewers. Optimizing only for code generation risks spending that same scarce attention twice.

One distinction I’d add: we shouldn’t preserve routine work simply because it used to be how people learned. We should preserve the responsibility and feedback that made the work educational. A junior engineer manually writing an endpoint without understanding its failure modes isn’t necessarily learning more than one using AI who must explain the authorization boundary, test concurrent requests, and investigate what happens after deployment. The apprenticeship worth protecting is the loop from prediction to consequence—not typing every line.

That also suggests a higher bar for what counts as “ready for review.” Rather than handing a reviewer a polished diff and implicitly asking them to reconstruct the reasoning, the author could include a short verification brief:

  • What behavior is supposed to change?
  • Which assumptions does the implementation depend on?
  • What evidence supports its correctness?
  • What failure cases were checked, and what remains uncertain?
  • How would we detect and recover from a bad deployment?

The point isn’t more paperwork. It’s making the author do the first layer of judgment instead of outsourcing it to the reviewer. “CI passed” and “I can explain why this is safe to ship” should remain different claims.

I’d also qualify “none of this is slow.” Deliberate learning sometimes is slower in the short term, and mentorship consumes real capacity. Teams need to budget for that explicitly; otherwise, juniors hear “build judgment” while being rewarded for shipping faster, and seniors hear “mentor more” without anything coming off their workload.

For hiring, your flawed-code exercise seems especially promising if candidates can ask questions and receive new information. I’d care less about how many planted bugs someone spots than whether they identify consequential uncertainties, choose useful checks, and revise their conclusions when evidence changes.

Ultimately, “a human reviewed it” is not a sufficient safety model if that human has neither the time nor the context to challenge it. The goal shouldn’t be to keep a person ceremonially in the loop. It should be to keep understanding, accountability, and learning in the loop.

Collapse
 
dpietro profile image
Denise Pietro •

This is an exceptionally important discussion about the future of software engineering. I particularly appreciate the distinction between generating code and developing the judgment required to trust it. AI can accelerate implementation, but it cannot automatically replace the hard-earned understanding that comes from debugging production failures, questioning assumptions, evaluating trade-offs, and taking responsibility for decisions. The apprenticeship issue is especially concerning: if junior developers lose the opportunities to make mistakes, solve smaller problems, and learn through experience, we risk creating a generation that can produce code without fully understanding its consequences. I also love the practical emphasis on using AI as a learning partner rather than a substitute for thinking. Ultimately, the strongest engineers won't necessarily be those who generate the most code, but those who know what questions to ask, what risks to recognize, and when not to trust an apparently perfect solution. Thank you for such a thoughtful and timely contribution to this conversation. Code generation may be becoming automated, but engineering judgment remains a human responsibility worth cultivating.

Collapse
 
dgold profile image
D. Goldberg •

This is an important conversation, and I think the most significant point is that AI is changing not just how we write software, but how we develop software engineers.

The distinction between generating code and understanding code is becoming increasingly important. AI can produce a technically plausible implementation in seconds, but it cannot automatically provide the context, accountability, and experience required to determine whether that implementation is actually the right solution.

I particularly agree with the argument about the apprenticeship problem. Some of the most valuable engineering lessons rarely come from building something successfully the first time. They come from debugging an unexpected failure, investigating a poorly performing query, understanding why an apparently reasonable design doesn't scale, or realizing that a seemingly harmless change has broken another part of the system. These experiences gradually develop the intuition that experienced engineers rely on when reviewing unfamiliar code.

There is also a deeper organizational risk here: if companies optimize away the work through which junior engineers develop expertise, they may also be optimizing away their future senior engineering talent. Senior engineers don't simply appear because someone has accumulated years on a résumé. They emerge through years of progressively more complex decisions, mistakes, feedback, ownership, and exposure to real-world consequences.

I would add another dimension to this discussion: the review bottleneck is not exclusively a question of review capacity. It is also a question of cognitive ownership.

When developers generate code they don't fully understand, they transfer the intellectual burden of understanding that code to someone else. The reviewer must reconstruct the reasoning, identify hidden assumptions, examine edge cases, and assess risks. In that situation, AI hasn't necessarily eliminated engineering work; it has redistributed it, often toward the most experienced and already overloaded people.

I also believe we need to rethink what productivity means in this environment. Lines of code, pull requests, and completed tickets are increasingly weak indicators of engineering value. A developer who prevents a production incident, simplifies a complicated system, rejects an inappropriate abstraction, or identifies a security flaw may produce very little code while delivering enormous value.

One additional practice I'd encourage is making technical reasoning an explicit deliverable alongside the code. Every meaningful AI-assisted pull request should explain:

What problem is being solved and why this approach was selected.
What assumptions the implementation makes.
Which edge cases and failure scenarios were considered.
What alternatives were rejected and why.
How the developer independently verified the generated solution.

This would make code reviews more meaningful while forcing developers to retain ownership of their decisions rather than treating generated output as inherently trustworthy.

Ultimately, I don't think the future belongs simply to engineers who know how to use AI most efficiently. It belongs to engineers who can combine AI's speed with independent reasoning, healthy skepticism, systems thinking, and the ability to take responsibility for production outcomes.

The biggest danger isn't that AI will make junior developers less productive. It's that organizations might mistake faster code production for engineering competence and stop investing in the experiences that create competence in the first place.

AI should accelerate the learning process, not eliminate the learning process. We need to automate repetitive work without automating away the opportunities to develop judgment.

The question organizations should be asking isn't just how many engineering hours AI can save today, but whether they are still developing the engineers capable of making sound decisions tomorrow.

That's the real long-term productivity challenge.

Collapse
 
usernamevalid profile image
Shirley •

Very informative read Mirella appreciate you sharing with us, cheers!

Collapse
 
n_c_e4a8149b59e51d8be77 profile image
N. C. •

Very informative piece thank you so much for sharing this gem!