---
title: "For New Grads, the Path to Senior SWE Is Broken"
url: https://www.insulin.dev/blog/new-grad-path-to-senior-engineer/
canonical: https://www.insulin.dev/blog/new-grad-path-to-senior-engineer/
type: Blog
description: "AI agents now do the work that trained junior engineers, seniors no longer need their help, and employers won't pay to train them. Why the path breaks."
---

# For New Grads, the Path to Senior SWE Is Broken

> Canonical HTML version: https://www.insulin.dev/blog/new-grad-path-to-senior-engineer/

1.  [Home](/)
2.  [Blog](/blog/)
3.  For New Graduates, the Path to Senior SWE Is Broken

# For New Graduates, the Path to Senior SWE Is Broken

AI coding agents now do the work that used to train junior engineers. Senior engineers no longer need their help, and companies would rather hire seniors than pay for the years it takes to grow one.

![Chengjun Yuan](/leadership/chengjun.jpeg)

Chengjun Yuan

Co-founder & CTO · Nov 21, 2026

 ![For New Graduates, the Path to Senior SWE Is Broken](/images/blog/new-grad-path-to-senior-engineer/hero.png)

I think a computer science graduate in 2026 faces a much harder path to senior engineer than the class before them. There are fewer jobs, but that is not my main concern. AI coding agents now do much of the work that junior engineers used to learn from.

The pressure comes from three directions: the new engineer, the senior engineer, and the company employing them. Each is making a rational choice. Together, those choices make it very hard to keep training senior engineers in any systematic way.

TL;DR

Juniors used to become seniors through years of practice, with a senior checking their work. Now agents do much of that work, seniors can finish large projects without juniors, and companies would rather hire a senior than train one.

## What does it take to become a senior engineer?

**A senior engineer gets there by doing the full job repeatedly, with feedback from someone more experienced.** You cannot get the same judgment from reading about it. You need to make decisions, get some wrong, and see the consequences.

The work starts small and grows:

-   **Design**, from a function to a service and then a system, and seeing what happens when the design does not hold up.
-   **Writing code**, a lot of it.
-   **Reviewing other people’s code**, with specific comments about what should change and why.
-   **Being reviewed by a senior engineer**, then thinking critically about the feedback instead of applying every comment blindly.
-   **Writing tests** that catch the failure that actually happens.
-   **Debugging**, where you form a theory, read logs, get it wrong, and narrow the problem down.
-   **Deploying, monitoring and being on call**, including the night something you shipped breaks.

Every part takes repetition. That is how you learn which design will still be simple to run in two years, which test is worth writing, and which review comment is mistaken. That judgment is what companies pay senior engineers for. Even with the practice, not every junior becomes a senior.

 ![Seven reps that make a senior engineer, before and with AI coding agents. Design, writing code, reviewing others' code, being reviewed, writing tests, debugging, and deploying and on-call. Before agents, the junior does each one and a senior checks it. With agents, the agent does each one and the junior clicks Approve.](/images/blog/new-grad-path-to-senior-engineer/reps.png)

## Reason one: the agent does the reps

**Claude Code and Codex can take over much of the work a junior engineer learns from.** They propose a design, write code and tests, run them, fix failures, and draft the pull request description. The junior can read a summary and click Approve a few times.

The task ships, and the junior may look productive from the outside. But the agent did the reps. The junior did not have to weigh the design, chase the bug, or defend a decision in review. That is the work that develops judgment.

I do not see this as laziness. If an agent can finish a task in ten minutes, doing it yourself for a day can look like wasting the company’s time. Often the manager sees it the same way.

There is early evidence of the cost. In a randomized trial [Anthropic published in January 2026](https://www.anthropic.com/research/AI-assistance-coding-skills), 52 mostly junior engineers learned a Python library they had not used before. The group with an AI assistant averaged 50% on the quiz that followed; the group that coded by hand averaged 67%. The AI group finished about two minutes sooner, a difference that was not statistically significant. The largest gap was on debugging questions. How people used the assistant mattered: those who asked it only conceptual questions scored 65% or higher, and those who handed it the whole task scored under 40%. The study used a chat assistant in a sidebar, and its authors expect agentic tools like Claude Code to affect skill development more.

The tool itself is not the problem. The default use is. If it skips the part where you have to think through the work, you lose the training.

## Reason two: senior engineers no longer need help

**Agents let senior engineers complete large projects alone, so fewer large projects need junior engineers.** That removes one of the main places juniors used to get serious work and feedback.

The old arrangement made sense. A senior designed the system, split it into pieces, handed work to juniors, and reviewed what came back. Juniors had real problems, deadlines, and someone who understood the system well enough to challenge their decisions.

Now the senior can split the work across agents instead. An agent needs no onboarding, works through the night, and does not mind if its code is thrown away. Bringing in a junior costs the senior time and can hurt quality, because the work needs careful review and sometimes has to be redone. Many senior engineers do not have much reason to take that on.

We see this at Fours. When we [replaced ClickUp with GitHub Issues](/blog/replace-clickup-with-github-issues/), the first version merged after one week of engineering, run as a side project. A project that size used to be how a junior engineer got a first real system to build.

In many cases, I believe a senior engineer with enough tokens can produce 1,000 times what they could a few years ago, sometimes 10,000 times. That is my estimate, not a measurement. The exact number is less important than the change underneath it: a senior no longer needs a team of juniors to finish a large project on time.

## Reason three: companies stop paying to train juniors

**Training a junior takes years, costs real money, and may not work, so companies will hire senior engineers instead.** From an employer’s view, that is the safer bet.

The case against hiring juniors is straightforward:

-   **The cycle is long.** It takes years before a junior can own a system alone.
-   **It is expensive.** Juniors make basic mistakes, and AI does not give them taste. A junior with an agent can produce complicated, fragile code very quickly without knowing when the agent has overbuilt something.
-   **It may not work.** Some juniors will not become seniors because of gaps in fundamentals or temperament. The company carries that risk.

A senior engineer with agents looks like the safer hire, and that is where the money goes.

The hiring data points in the same direction. In [August 2026, the Stanford Digital Economy Lab](https://digitaleconomy.stanford.edu/news/canariesaug26/) reported that employment among workers aged 22 to 25 in highly AI-exposed occupations is about 19% below where it would be had it kept pace with workers the same age in less exposed jobs. The gap comes mainly from fewer young people being hired, not from more being let go. The lab’s [Canaries dashboard](https://digitaleconomy.stanford.edu/project/indicators/canaries/) puts software developers in the most exposed group, with large declines for early-career workers and growth for older ones. The authors call these descriptive patterns, not proof that AI caused them.

## Three sensible choices, one bad result

**The junior, senior engineer, and company are each responding sensibly to their incentives. Together, they break the system that produces senior engineers.**

 ![Three sides, one result. The new graduate lets the agent do the work, so the reps never happen. The senior engineer finishes big projects alone with agents, so there's no room or time to mentor. The company hires proven seniors instead of training juniors, which costs it nothing this year. All three lead to the same result: nobody is training the next senior engineers, and it shows in ten years, when today's seniors move on and someone still has to judge what the agents build.](/images/blog/new-grad-path-to-senior-engineer/three-sides.png)

Senior engineers are made over time. Every senior working today was once a junior whose mistakes someone else paid for. We are drawing down that stock without replacing it. The effect will take years to show, until today’s seniors move on or retire.

As agents write more code, the need for people who can judge that code rises. Someone still has to tell a sound design from a plausible one, decide what to check before shipping, and take responsibility when it breaks. That is senior engineering, and it is the skill we are no longer teaching at scale.

AWS CEO Matt Garman called replacing junior staff with AI “the dumbest thing I’ve ever heard” in [an August 2025 interview](https://www.theregister.com/2025/08/21/aws_ceo_entry_level_jobs_opinion/). “How’s that going to work when ten years in the future you have no one that has learned anything?” he asked.

## What could keep the path open?

**The old apprenticeship will not return unchanged, but we can still preserve a path if juniors, seniors, and companies change their defaults.** These are the changes I would make. I do not think anyone has proved the answer yet.

-   **New graduates: use the agent to learn, not only to finish.** Write the first version yourself before you ask. When the agent writes code, read every line and be able to explain it before you approve. Spend the first hour on a bug without it. Ask why, and ask what else it considered. In Anthropic’s study, the people who asked conceptual questions kept their scores.
-   **Senior engineers: review the reasoning, not just the diff.** Before approving a junior’s agent-written change, ask why it was built that way and what they rejected. Give juniors a small system to own end to end, pager included.
-   **Companies: hire fewer juniors if you have to, but do it on purpose, and budget their training as an investment.** Measure what they understand, not how many pull requests they merge. Garman’s advice was to keep “teaching them the right ways to go build software and decompose problems and think about it.”

## What we don’t know yet

**I do not know whether a new path will build the same judgment, or whether agents will reduce the need for senior engineers.**

-   Engineers who start their careers with agents may build judgment another way, by directing and reviewing agents from day one. Nobody knows whether that produces the same judgment as years of doing the work by hand.
-   Agents may improve fast enough that companies need fewer senior engineers. Even then, someone has to decide what to build and answer for it when it breaks.
-   The hiring data is noisy. Other forces, interest rates among them, hit young workers too, which is why Stanford’s authors do not claim cause.

## Takeaways

-   Senior engineers are made through years of reps in design, code, review, tests, debugging and on-call, with someone more experienced checking the work.
-   AI coding agents now do many of those reps, so a junior can ship without learning much. In Anthropic’s trial, the people who handed the whole task to the assistant scored under 40%.
-   With agents, a senior can finish a large project alone, and companies would rather hire that senior than train a junior.
-   Each choice makes sense on its own. Together they leave nobody training the next senior engineers, and the gap will show in about ten years.

What I am sure of is that senior engineers do not appear on their own. If nobody trains them now, we will be short of them in ten years, right when we need people who can check what the agents build.
