Your Definition of a Junior Is Out of Date

The bar moved up. Most hiring is still aimed at the wrong version of it.

When I graduated, the expectations for a junior engineer were absurd. You were supposed to know sorting algorithms cold, with the tradeoffs between merge sort and quicksort ready in case the interviewer wanted to dig. You were supposed to have a GitHub profile, ideally with regular contributions to projects with stars. You were supposed to be active in some open source community. You were supposed to know operating systems internals well enough to discuss memory allocation on a whiteboard. The job ad said "junior" and the real expectation was fluent from the first day.

I felt this was unfair at the time. Looking back I still think it was unfair, but it was also exactly what every generation of new engineers has felt about their entry into the field. And it's exactly what the next generation will feel about whatever comes after this.

Every generation thinks the next one has it easier and is therefore weaker. The seniors who learned in vi thought the IDE generation was soft. The seniors who debugged with print statements thought the Stack Overflow generation didn't really know how anything worked. They were partially right and mostly wrong. The IDE generation grew up to be perfectly competent engineers running systems the vi generation couldn't have imagined. The Stack Overflow generation became the senior generation that's now panicking about AI.

When I see leadership panic about what AI is doing to junior engineers, my reflex is to ask which generation of seniors is doing the panicking, and what they had to defend when they were the new ones being looked at sideways.

It's the same bar, just the units have changed

Knowing sorting algorithms cold mattered when you might have to implement one. You almost never have to implement one anymore. What you have to do is judge whether the implementation in front of you, written by someone else or generated by a tool or pulled from a library, is correct, performant, and appropriate for the case in front of you. That's a higher-level skill, and it's what entry-level work tests for now, even when the job ad still says "must know data structures."

The new junior is expected to compose tools, orchestrate agents, and judge outputs from systems they didn't design and couldn't debug if you held a knife to them. Read code they would never have written. Ask the right question to the right tool, which is what we used to call "knowing how to Google" except now the search space is six different agents and a knowledge base. Own the debugging loop end-to-end when the first three things they tried were AI suggestions and none of them worked.

These are not easier skills. The failure modes are subtler, and the confidently-wrong answer is more convincing than a syntax error ever was. The bar moved up a complexity layer.

The three pressures

Start with what's getting locked out.

A generation of people would have made fine engineers under the old rules. If your way into the field was raw determination plus the willingness to spend two years getting from "okay" to "good," the new bar is even harder than the old one.

The kid who couldn't have written quicksort cold but had grit and pattern-recognition could grow into a senior. The kid who can't fluently compose AI tools today might not have a secure place to grow from is where the real cost is. Nobody's pricing it in because "we have plenty of applicants" is technically true, and also missing the point.

Then there's the hiring side.

The job ad still says "junior software engineer," the requirements list data structures and algorithms, the interview is a whiteboard problem and a system design question that assumes ten years of experience. The candidates who pass the interview don't end up doing most of what was tested for, and the candidates who would have actually been useful in the real job were filtered out at step one.

Hiring managers I talk to complain they can't find good juniors. They can. They're filtering for the wrong signals.

This will last three to five years before the interview process catches up to the work. In the meantime both sides are frustrated. Candidates feel the bar is impossibly high. Managers feel the talent pool is thin.

And this is coming for industries other than tech.

Tech moves first because tech rewrites its own definitions faster than any other field. Junior accountants, junior lawyers, junior doctors are all heading into the same redefinition, except the institutions around them (partner tracks, residency programmes, professional certifications) are designed to move slowly. A junior associate at a law firm is still expected to demonstrate skills the firm's billable model is built around, even when AI is quietly doing most of that work in the background.

The redefinition will arrive there too. The institutions will resist longer, and the gap between what entry-level credentials certify and what entry-level work actually requires will be wider than it currently is in tech. The panic will be louder there too. Watch for the drama.

The gap between juniors and seniors hasn't gone anywhere

What hasn't changed is the value of experience. A senior with fifteen years in the field knows things a junior doesn't, and those things still matter. It's just the content that has shifted, and that experience gap remains intact.

The senior knows when the AI's confident answer is wrong. The senior knows which orchestration patterns will collapse under load and which ones will scale. The senior has watched four versions of the same architectural debate play out and remembers which one ended badly. None of that is replicated by a junior with better tools.

The mistake is thinking either that AI has erased the gap or that it's widening it with no path across. Neither is what's happening. The gap is the same shape it always was. It just lives at a different complexity layer.

The new junior is doing different work, expected to know different things, and being interviewed for skills that are mostly stale. The new senior is operating one level up the abstraction ladder. The calls are about which tool to trust and how to compose them. Sorting tree balancing still happens; it just stopped being where senior judgement compounds.

Same thing, different complexity layer.