2026-07-26 · 6 min read

Junior developers should learn code review before anyone pays them to write code

The numbers on entry-level developer jobs stopped being ambiguous this year, and they're not fun to look at if you're 23 and just finished a CS degree. Stanford's AI Index, drawing on ADP payroll data analyzed by Erik Brynjolfsson's team, shows employment for software developers aged 22 to 25 down nearly 20% from the late-2022 peak, while every cohort over 30 held flat or grew, which means the industry didn't shrink, it just stopped letting new people in. Stack Overflow's look at the same problem fills in the pipeline: entry-level tech hiring down 25% year over year, tech internship postings down 30% since 2023, and computer science graduates now facing 6.1% unemployment, which is worse than the average across all majors, including the ones your relatives kept telling you wouldn't lead to a job. The career ladder didn't get shorter. Its bottom rung got pulled out.

What exactly disappeared, and why it matters that it was specifically the junior work

Here's the thing people miss about entry-level developer jobs: they were never really about the output. The boilerplate endpoints, the small bug fixes, the test scaffolding, the CRUD controllers, the glue code between two services that someone more senior designed, all of that work was modestly valuable on its own, but the real reason companies hired juniors to do it was that doing it is how someone becomes a mid-level engineer. You learn how the codebase works by touching every boring corner of it. You learn what breaks by breaking things and getting your PRs torn apart. The company got cheap labor; the junior got an education. That was the bargain, and AI broke it. The routine tasks went first, exactly the ones Anthropic's CEO Dario Amodei was describing when he warned that AI could eliminate half of entry-level knowledge work, and what's left is a genuinely circular problem: the tasks that used to teach fundamentals are now automated, which means a junior can't get hired without skills they were supposed to acquire on the job that no longer exists for them to acquire those skills on.

Read the fine print on the jobs that are supposedly coming back

The loudest counter-signal came from IBM earlier this year: the company is tripling its entry-level hiring in the US, and Chief HR officer Nickle LaMoreaux said it with the kind of confidence that makes headlines: "And yes, it's for all these jobs that we're being told AI can do." But the interesting part isn't the headcount, it's what IBM did before they opened the roles. They rewrote the job descriptions from scratch, because the entry-level job of three years ago, the one where you write boilerplate and learn by doing, can now largely be done by a model that doesn't need health insurance. The redefined junior developer role centers on AI oversight: working with generated code, judging whether it's correct, catching what's wrong with it, and knowing when to trust it and when to push back.

That's worth sitting with for a minute, because the implication is a genuine shift in what "junior developer" means. The job that's disappearing is "write routine code." The job that's being created to replace it is "supervise the thing that writes routine code." And supervising code you didn't write, reading a diff you've never seen before and deciding whether it should ship or whether it has a bug hiding behind its confident formatting, has a name that used to be reserved for senior engineers: code review. The skill that marked you as experienced enough to gate other people's work is quietly becoming the entry requirement, and nobody updated the curriculum to reflect that.

Nobody teaches it, and now there's no job to absorb it on either

Review judgment used to be something you picked up through years of writing code and watching your own PRs get torn apart by people who knew more than you did. You'd submit something you were proud of, a senior would leave four comments about edge cases you never considered, and over time you internalized the habit of asking those questions yourself before clicking "create pull request." Juniors can't take that path anymore, because the years of routine writing are exactly the part that got automated. And meanwhile the interview process is drifting in the same direction as the job itself: more take-homes that hand you an AI-generated codebase and ask what's wrong with it, more review rounds where the question isn't "can you invert a binary tree" but "would you have approved this PR, and can you explain why."

The good news, and there is genuine good news here, is that review is trainable deliberately, without anyone hiring you first. The core skill is building a mental model of intent from a diff, reading code you've never seen and understanding what it's trying to do well enough to notice where it fails, and that only develops against code you didn't write, which means reading your own projects over and over doesn't help. What does help is picking an open-source project you actually use, opening its PR queue, reading an incoming pull request, writing down what you'd flag, and then comparing your notes against what the maintainer actually said. It's free, the code is real, and the maintainer's review is your answer key, though the feedback is slow because you have to wait for someone to review the PR, and on quiet projects that review might never come. The faster version of that loop is practicing against diffs with known, planted defects, where every review ends with the full answer and you find out immediately what you caught and what walked right past you, because the problem with learning from real repos is that you never learn what you missed.

When your resume is empty, proof of judgment is worth more than another side project

There's a second, colder reason this matters for juniors specifically, and it's about the job application itself. With no work history, you have no way to demonstrate judgment. Everyone's resume says "attentive to detail" and everyone's GitHub has a todo app and a portfolio site. What you don't have is evidence that you can read someone else's code and make a good call about whether it should ship. On DiffDojo the library is full of AI-written PRs with planted bugs, and your profile accumulates the measurement over time: catch rate per bug category, verdict accuracy, false-flag precision, and the specific blind spots you still have. "I catch 4 of 6 defect classes, and here's the breakdown" is a claim a hiring manager can actually verify by looking at your profile, which puts it in a completely different category from anything else on an entry-level resume. Today's PR is free, no signup.

The bottom rung didn't come back, and it probably isn't going to. But the wall it used to lead to now has a different handhold on it, and unlike the old one, this handhold can be trained from a laptop before anyone gives you a badge or a salary or even an interview.