The New Junior Profile

The question I get most in class stopped being “which framework should I learn?” and became “does it still make sense to get into this?”.

It does. But the entry-level job changed shape, and preparing for the 2019 version of it is the worst available bet.

What died

The tasks that historically trained a junior — CRUD number fourteen, the form with validations, the endpoint that mirrors the one next to it, the styling migration — are exactly the ones a model finishes in minutes. They’re not coming back, the same way hand-coding table layouts never came back.

This creates a structural problem the industry still hasn’t solved: if seniors were forged doing junior tasks, and junior tasks are now done by the machine, where do the seniors of 2032 come from? The ladder lost its bottom rungs and we’re all looking up, whistling.

What a junior can actually offer today

Reading code better than writing it. The team’s bottleneck is review. A junior who spots that the generated query does an N+1, or that the retry isn’t idempotent, contributes from month one. That skill is trained by reading real repositories, not tutorials.

Verifying instead of believing. Knowing how to build the test case that breaks the pretty solution. Reproducing a bug reliably. Preferring the command’s actual output over a description of the output.

Fundamentals that don’t expire. How HTTP works, what an index does in the database, why that function is O(n²), what happens to memory. Everything the model applies but can’t explain when you ask it “why is this slow?”.

Knowing when the machine is lying. This is the rarest and the most valuable. It’s built by having your own judgment, and your own judgment is built by having done things by hand at least once.

How to study without wrecking your training

My recommendation in class, which annoys some people: use the model, but after you’ve tried it yourself. Not because suffering is pedagogical, but because the failed attempt is what makes the solution mean something. If you never fought the problem, the right answer is just text that crossed your screen.

And one concrete practice that works: ask the model for the solution, then ask a different session to audit it. Watching two versions of the same tool contradict each other is the fastest vaccine against false confidence.

For whoever is hiring

Stop evaluating code production in interviews. It doesn’t discriminate anymore: everyone can produce code.

Evaluate what does discriminate: hand over a PR with three planted bugs and ask for a review. Give an ambiguous requirement and watch what questions they ask before writing. Show a solution that works and ask what happens when the input grows a hundredfold.

A junior who asks the right questions about a vague requirement is more useful than one who types fast. That was always true; what’s new is that it can no longer be disguised.

The summary you didn’t want

The floor went up. A junior today has to arrive with judgment, not just enthusiasm. The good news is that judgment can be trained deliberately and almost nobody is doing it, so the line for that job is shorter than it looks from the outside.