We Stopped Hiring Juniors

We recently restructured our entire engineering team because of AI code generation. Not in a "we're exploring new workflows" way. In a "the old structure is broken and we need to fix it now" way.

For the past couple years, everyone on the team has been using code generation tools. Claude, Cursor, the usual. It made everyone faster, but it didn't change how we worked. Same team structure. Same review process. Same roles.

That changed around Codex 5.3, and it really changed when we started using Devin.

The engineering team started shipping so much code that the bottleneck flipped. The constraint was no longer writing code. The constraint was reviewing it.

Our CTO, Alex Goldstein, reviews a lot of the code at Structify. He's a small-startup CTO. Hands on everything. Deeply technical. Deeply invested in the quality of what we ship. He was getting destroyed. PRs piling up. His entire day was consumed by review instead of building. For a 10-person startup, a bottleneck is debilitating.

But the volume wasn't even the worst part. Two things broke at once.

First, the obvious one. Reviews became a chokepoint. More code was coming in than could be responsibly approved. Goldstein went from building and reviewing to just reviewing. That's a terrible trade when you're trying to survive.

Second, and this is the one that actually stung. Reviews lost their purpose. Goldstein loves teaching. A huge part of code review has always been pedagogical. You read a junior's PR, leave thoughtful comments, they internalize the feedback, they get better. That loop was half the reason the review process existed in the first place. But now the reviewer isn't improving a person. They're leaving comments for a faceless AI that will never learn from them. You're teaching into a void. The educational purpose of review just evaporated.

...

That's a joke. We built software we're proud of and we have no interest in breaking it. AI is nowhere near reliably shipping unreviewed code. But we did need to fundamentally change the structure.

We started treating every person on the team as a senior engineer. Not as a feel-good title bump. As a responsibility shift. To be useful here right now, you need to be capable of approving a PR to production without another set of eyes on it. The job isn't "write code and get it reviewed" anymore. It's "review AI-generated code and decide whether it ships."

For complicated PRs (as judged by either the reviewer or the writer), we now require a second reviewer. Both reviews are aimed at making the code better. But the second review is also aimed at making the first reviewer better. If the core skill of an engineer right now is catching what the AI missed, we need our team to be exceptional at that. Double reviews on hard PRs are how we sharpen that skill.

This also means we are no longer going to hire juniors or interns.

I want to be honest about something before I go further. I went to Yale for computer science. I had an on-ramp into this industry that most people don't get. I got to be an early engineer at a robotics startup, learn from brilliant people, make mistakes in environments that were forgiving enough to let me grow. The ladder I climbed to get here existed for me. I recognize that.

And what I'm telling you is that we are pulling it up behind us.

I'm not alone in this. Salesforce froze junior engineering hiring. Entry-level tech postings dropped 67% between 2023 and 2024. A Harvard study of 62 million workers found that junior developer employment drops about 10% within six quarters of a company adopting generative AI. Stanford data shows employment for software developers aged 22-25 has declined nearly 20% from its 2022 peak.

This isn't a blip. It's a structural shift. I view us, as an early agile startup, as a harbinger of what’s to come in the field. And more companies are going to land where we did, because the math is the same for everyone. If a senior engineer with AI tools can do the work that used to require a senior and two juniors, the juniors don't get hired. No one needs to be callous or shortsighted for this to happen. The incentives just point that way.

AWS CEO Matt Garman called this trend "one of the dumbest things I've ever heard." His argument is straightforward. If nobody trains juniors today, there are no seniors in ten years. The pipeline that produces the people everyone still desperately needs just breaks.

He's right. And yet I'm still not hiring juniors. Because no individual startup can absorb the cost of solving a collective action problem. We raised a seed round. Our competitors won't think twice about this. The market doesn't reward altruism. I need every person on my 10-person team making us better right now, not in eighteen months.

So that leaves the real question. If not us, then who? And how?

I think the optimistic version of the future looks something like this. Software engineering becomes a trade. It reduces the number of code monkeys/grunt work, and increases people to thinking about the harder issues.

Not in a diminishing sense. In the way that electricians and machinists work. Formal apprenticeship. Credentialing tied to demonstrated competence. A clear path from apprentice to journeyman to master.

The old on-ramp into software was grunt work. Write the boilerplate, set up the API routes, style the buttons. A senior broke the work into small tickets, a junior translated them into code, and the act of doing that translation was how they learned. AI does all of that now. The on-ramp didn't get steeper. It disappeared.

But the skills that actually matter didn't go anywhere. Reading code critically. Understanding systems holistically. Exercising judgment about what's safe to ship and what isn't. These are more important than ever. And someone has to teach them.

Apprenticeship works because it separates training from simple task delegation. An apprentice electrician doesn't slow down a job site. They learn by watching, then doing under supervision, then doing independently. The master isn't sacrificing productivity to teach. The structure is designed so that teaching happens inside production, not instead of it.

I think something similar can work in software. An apprentice engineer's first job isn't writing code. It's reading AI-generated code and learning to assess whether it's correct. The feedback loop still exists, it just starts at a different point. Instead of "write this function and I'll tell you what's wrong," it's "review this PR and I'll tell you what you missed." That's actually closer to the real job anyway.

Universities have a role here too. CS programs are still largely training students to write code from scratch. That's increasingly not what the work looks like. The work is orchestrating AI, validating output, understanding systems, and making judgment calls under uncertainty. That's a fundamentally different curriculum. The schools that figure it out first will produce the most employable graduates.

There's also a version of this where AI itself becomes the patient teacher that most juniors never had. If you can paste confusing code into an agent at 2am and ask "explain this line by line" and get a thoughtful, non-judgmental answer, that's a better learning environment than most engineers have ever experienced. The ceiling on self-directed learning just got dramatically higher. Maybe the path into the profession doesn't run through a company's payroll at all.

I don't think any of this will be smooth. There's going to be a painful gap. Maybe we're already in it. Companies aren't hiring juniors and the new structures haven't materialized yet. Real people who would have been great engineers are going to get squeezed out. I know that, because I would have been one of them if the timing had been different and I hadn't had the advantages I had.

But the bull case isn't that things stay the same. It's that we rebuild the pipeline for a world where writing code is cheap and judgment is expensive. Where the entry-level question isn't "can you write a for loop" but "can you tell me whether this AI-generated system is going to fall over at 3am." Where the on-ramp is designed for the actual job, not a version of the job that no longer exists.

I think we can get there. I just know it's not my 10-person startup's job to build the bridge. And I think anyone who tells you otherwise is either running a company big enough to afford it, or isn't running a company at all.