A while back I wrote that the industry is eating its own seed corn: engineering hiring held up, junior hiring collapsed, and the profession quietly stopped funding the process that makes seniors.
I ended that post with one line of advice for anyone early in their career: the on-ramp is still there, it just got a lot narrower. Then I moved on, which was easy for me, because I am not the one standing on the narrow bit.
So this is the part I owe. If I were twenty-two today, with the agent already on my desk and the graduate job market looking the way it does, what would I actually learn first?
The numbers are not subtle. Computer science graduates are sitting at 6.1% unemployment, nearly double the rate for philosophy majors. Entry-level software engineering postings dropped about 30% year on year. And the line that should worry everyone: 57% of surveyed managers say they trust the AI's work more than an intern's or a recent graduate's.
That last one describes what you are being compared against.
The advice everyone gives you is worth two weeks
Search "junior developer skills 2026" and you get the same list every time. Learn prompt engineering. Learn agent orchestration. Get fluent in Copilot, Cursor, Claude Code. Be "bilingual" in coding and directing.
The tools genuinely matter. Turning up in 2026 unable to drive an agent is like turning up in 2010 unable to use git, and I would not hire that person either. Learn them. It takes a fortnight.
Then what? Everyone else also spent that fortnight. Tool fluency has no scarcity and a brutal half-life: half the specific advice written about prompting in 2023 is now wrong, because the models changed underneath it. You cannot build a career on the thing that is easiest for the next cohort to copy and most likely to be obsoleted by a release note.
The skills worth your first two years are the ones with the opposite shape: slow to acquire, hard to fake, and more valuable every time the volume of generated code goes up. There are four of them.
1. Debugging, because it cannot be prompted
Generation is now the cheap half of the job. Figuring out why the generated thing does not work is the expensive half, and it stayed expensive.
Debugging resists automation for a specific reason: it needs a model of a running system, this deployment, this data, this ugly interaction between a cache and a timezone at 3am. The model has read a million bug reports and can suggest the five most statistically likely causes. It cannot watch your staging environment misbehave and get a hunch.
That hunch is the thing. It comes from having been wrong, repeatedly, with a stack trace in front of you. Every hour you spend bisecting a problem by hand is an hour of deposits into an account nobody can transfer to you.
Practical version: pick one bug a week and refuse to paste it anywhere. Read the trace top to bottom. Form a hypothesis, write it down, then test it. Being wrong on paper is how the instinct gets built.
2. Reading code, because you will do ten times more of it
Robert Martin put the ratio of reading to writing at about ten to one, and that was decades before a machine could produce a thousand plausible lines while you make coffee. Now most of the code you read is code you did not write, which is the hardest kind, and it arrives faster than ever.
Meanwhile the writing that used to build your reading instinct is the exact part you handed off.
I wrote the training routine for this yesterday, so I will not repeat it here: how to get better at reading code has the actual drills, a merged PR a day, predict before you run, explain it back with the AI closed. Do them. Twenty minutes.
If you only take one habit from this whole post, take that one. It is the skill that decides whether you can spot the bug in code you did not write, which is now most of your professional life.
3. Data modelling, because the agent cannot unmake it
This is the one missing from every listicle, and it is the one I would push hardest.
Ask an agent for a function you dislike and you delete it. Ask an agent for a schema you dislike, ship it, and put eighteen months of production data in it, and you own that decision for years. Migrations are expensive, backfills are risky, and every downstream service has already grown around the shape you chose.
Code is now cheap enough to throw away. Data never was.
So learn what normalisation is actually for. Learn why every nullable column is a decision someone will have to live with. Learn what a foreign key buys you and what an index costs on write. Learn to spot the moment a "flexible" JSON blob is really an admission that nobody knew what the entity was.
Agents are good at this in the small and thoughtless about it in the large, because they optimise for the request in front of them, while the shape you choose is the one you will still be living in when someone asks for a report across three years. Being the person in the room who thinks about that is disproportionately valuable, and it is learnable from books that were already old when I started.
4. One language deep, not five shallow
The temptation right now is enormous. The agent writes competent Go, and you do not know Go, so you ship Go. Repeat across four stacks and you have a CV that looks broad and a brain that owns nothing.
Depth is what makes reading fast, and reading fast is what makes review possible. Once you know one language properly you stop parsing it line by line and start seeing shapes: that is a retry loop, that is a leak, that is a race waiting to happen. Reviewers who see shapes catch things. Reviewers who translate every line into English in their head run out of patience and approve.
That pattern library also transfers. Learn concurrency properly once and you will recognise it everywhere. Learn it shallowly four times and you will recognise it nowhere.
Pick the language your ecosystem actually uses, go deeper than the tutorial layer, and know how it works underneath: memory, the type system, the standard library, what the runtime is really doing.
What I would skip
Framework tourism. A weekend project in every new thing that trends is fun and produces nothing that compounds. One real system carried from idea to production teaches more than a dozen starter templates, because only the real one comes with users, an incident and a migration.
I would also skip the prompt engineering course. Prompting matters, but a fortnight of learning is being sold to you as a career, and the version you buy today expires with the next model release.
The reps do not arrive by accident any more
This is the uncomfortable structural bit, and it applies whether you are three months in or fifteen years in.
The old apprenticeship worked because the work itself forced the practice. You had to read the codebase to change it. You had to sit with the bug, because there was nobody to ask at 2am.
Nobody planned that curriculum. The job supplied it by accident.
The agent removed the accident. Now there is always something to ask, always an instant plausible answer, and the path of least resistance skips every rep that used to build judgement. You can now go a full year shipping features and learning almost nothing, which was genuinely hard to do before.
So the reps have to be deliberate. Set your own rules and hold them: solve it yourself first for twenty minutes, then ask. Read the diff before you accept it. And never ship code you cannot explain, which stops being a slogan the first time someone asks you in a postmortem why the retry logic did that.
Use the agent as a tutor rather than a vending machine. Ask it why the code it wrote is shaped that way. Make it defend a design. Argue back. That is the same tool, pointed at your understanding instead of your ticket.
The good news the numbers hide
Everything above is harder than it was in 2019. It is also more concentrated, because most people will not do it. The competition is not the model. The competition is a cohort being told that fluency with the tools is the whole job, and mostly believing it.
Debugging, reading, data modelling and real depth in one language were valuable before any of this. What changed is that the market got shorter of them at the exact moment it started paying a premium for judgement. That is an unpleasant thing to say about how the industry treats new people, and a genuinely good thing to know if you are one of them.
The ladder lost its bottom rung. Nobody is putting it back this year, so climb the wall next to it, where the handholds are the things nobody can generate for you.