AWS is hiring 11,000 juniors. Anthropic says they won't be needed. Let me explain who's right.

OK, here's the story. Last week Matt Garman, AWS CEO, said in an interview, straight up: replacing juniors with AI is one of the dumbest ideas he's heard. Same day he confirmed AWS is hiring 11,000 interns in 2026. Same number as last year. And this is after Amazon let go thirty thousand people in twelve months.

Meanwhile Boris Cherny (the guy who built Claude Code at Anthropic) and Martin Casado at a16z have been pushing the same line for months. Software engineering is dying. AI writes code. We don't need programmers anymore. Pack it up.

So someone is lying.

Actually, nobody is lying. Casado and Cherny are looking into one hole, Garman is looking into another. Each sees their own truth. Let me unpack it.

What's actually dying

Casado and Cherny see one number — how many lines of code per day a live human writes. That number is collapsing. AI writes code faster and cheaper than a senior. Any junior with Cursor produces in a day what a senior took a week to do in 2022. Arguing with that is pointless.

But they take that ONE number and extrapolate it to the WHOLE profession. That's where the sleight of hand is.

Programming was never "writing code." That was one task of a programmer, and yes, for a long time it ate most of the workday. Simply because the tools sucked. We had vim, Stack Overflow, and Notepad++. "Figure out what the client needs," "design the architecture," "make sure it doesn't fall over in prod" — that got the scraps.

Now it's flipped. Code is an hour of work. Everything else — everything.

What's actually needed

Garman is looking at a different number. AWS doesn't have enough people who can actually understand a customer's problem, build an app for them, and make sure it stays up under load. Demand for those people is growing faster than headcount. Hence 11,000 interns — not charity, just trying to keep up.

And look at exactly what he said. Not "we need more Java developers." This:

"Narrow technical skills — like writing Java — are losing value. The focus is shifting to building full applications and solving customer problems."

That's a different profession. Not the one juniors got hired into in 2018. Back then it was: here's a five-page spec, implement it. Now it's: here's a live customer with their own pain, figure out what they need, ship something, make sure it holds up.

AI handles the first task. The second — not even close.

Three apps

That same week somebody brought me three projects to look at. All three built through Cursor with minimal human input. All three work. None of them sell.

A B2B landing page. Eight-field capture form. All eight fields fair — they need company, role, team size. Except the user closes the tab on the third one. Just gets tired.

An e-commerce checkout. Logic is clean, tests are green. The button reads "Confirm Order" instead of "Pay." Guess what happened. 28% of people at that step hit back. They figure clicking will take them to yet another page. Obviously.

A four-step onboarding. Technically flawless. On step two there's an empty state with "Nothing found." What to do next — not mentioned. Users close it.

Each of these apps technically works. And each one needed someone with the eye to walk through it as a customer would and say: folks, this doesn't sell. Good thing they showed me before launch. These founders genuinely thought they were good to go.

People with that eye — taste, product instinct, pattern recognition — are in catastrophic short supply. And that's exactly who Garman is hiring at AWS. He just calls them "junior software engineer."

Where the bottleneck moved

Used to be: idea — build — test — ship. The long part was building. Maybe 80% of the time. Seniors got paid well because they could build fast.

Now building takes an hour. Not "elegant distributed system architecture," just a normal feature. "Add a feedback form, post to Slack" — one hour, with tests.

The bottleneck moved to where there basically wasn't one before. The "let's first check if this is actually ready for the user" stage.

There's a real difference between two words.

"Works" — unit tests pass, page loads, form submits. AI handles this part itself.

"Ready" — that's something else. Does the user understand what to click. Do they see that something happened. Are we losing 40% of the funnel on step three. Does the email template break in Outlook (it always breaks in Outlook). What happens if the user has a VPN, slow 3G, and iOS 17.4. And does AI know that in Brazil checkout has to accept PIX, not Stripe. It doesn't.

About numbers, by the way. In April, Wiz found a vulnerability in Lovable (a $6.6 billion platform, mind you) that kept every user's source code and credentials publicly accessible for 48 days. 48 days. Their own audit of 1,645 Lovable projects: 10.3% had user data exposed before the project even had its first real customer. A tenth. Moltbook, a social network whose founder bragged on every corner that he didn't write a single line of code, leaked 1.5 million auth tokens three days after launch.

CodeRabbit ran 470 pull requests: AI code contains 2.74× more vulnerabilities than human code. In Q1 2026, 91.5% of vibe-coded apps had at least one hole AI simply "made up."

And my main point isn't "AI writes bad code." It writes well. Nobody looks at what it wrote THROUGH THE EYES OF THE USER.

Why Anthropic doesn't see this

Back to Anthropic. Casado and Cherny aren't stupid. They aren't villains either. They just look from their angle.

They sell a tool. They have a direct financial interest in this business model: the more expensive seniors and the cheaper AI, the more revenue. That doesn't make their words a lie. It does make their words heavily tilted in one direction.

Plus they look at the industry from a 20-person startup. And in a 20-person startup, one senior with Cursor really does close out the work of five 2018-era juniors. Just not because juniors are useless. Because in a 20-person startup the product decisions get made by the founder. The founder is the one walking through the app as a customer, cutting fields out of the form, vetoing features.

But at AWS, a founder doesn't scale to 11,000 interns. To move the product, AWS doesn't need "programmers" — they need thousands of small founders. They call them "junior software engineer" because the HR system doesn't have a better term.

What to do about it

If you're a junior now or studying — don't panic. The profession isn't dying, it's changing. If you've been studying "how to write Java" — drop it, it's a tool, and AI handles it better than you. You can't build a career on that.

What builds a career: being able to take a customer problem, break it down, figure out what to build, ship it, and check that it actually solves what was promised. A completely different job. Universities don't teach this. Learn through AI — but the goal isn't "write code," it's "understand what it wrote, and why."

If you're a founder — two pieces of news. Good: the person who can walk through your product as a customer and say "not ready" is probably already on your team. Bad: you probably don't realize how valuable they are. Don't let them leave. Give them veto on releases. Pay them like a senior engineer.

If you read Casado's tweet and thought "great, I won't hire juniors, I'll replace them with AI" — you have six months to change your mind. In six months you'll have a team of two seniors and Cursor. The seniors will burn out because all the unglamorous work is on them. Cursor doesn't burn out. But it also doesn't grow into someone who can run the product on their own in a year.

In short.

Programmers aren't going anywhere. What's going away is one very narrow type — the ones who wrote code to a spec. The ones who solve a customer's problem with an app — needed more than ever.

Garman gets it and is hiring. Anthropic doesn't see it and is selling seniors on the idea that juniors aren't needed.

I'm betting on Garman.