You hear it at every meetup and under every thinkpiece: AI is coming for the junior developers first. The logic is always the same. Juniors do the simple work, agents do the simple work now, so there's no room left for juniors.
I'm a junior developer, and I run coding agents every working day on real tickets. I think that logic has the facts right and the conclusion wrong.
Here's the part that's true. If you treat the agent as a faster typist and compete with it on typing, you lose. It is faster than you, and that isn't close. The old junior job, the one that was mostly typing with a learning problem attached, really is shrinking.
Here's the part people miss. The moment you stop competing with the agent and start driving it, the job turns into judgment, verification, and taste. Those are learnable, and a junior who practises them on real work builds them fast, because every task the agent does can come with its reasoning attached if you insist on it. You get a running explanation of the codebase, all day, at whatever pace you can absorb.
Two concrete things that moved the needle for me.
1. Give the agent a file about your world
A fresh session starts from zero. It doesn't know your stack, your conventions, or that you're still learning and want the reasoning spelled out. So I stopped re-typing that every morning and put it in one file the agent reads before every session:
## How I work
- I'm still leveling up. When you explain something, show
the reasoning, not just the answer, I want the why.
- Capture fast, sort later. New notes hit an inbox folder.
- This is work only. Personal stuff lives in a separate place.
That's a trimmed piece of mine. The rule I use to decide what goes in it: if I type the same instruction into a chat twice, it moves into the file. Once might be a fluke. Twice means I'll be typing it forever otherwise.
2. Assume it's confidently wrong, and check
My favourite cautionary tale from my own notes. I had an agent generating summaries of some numbers. One line read, roughly, "180 plus 95 plus 60 across the three categories, 310 total." Read that again. It's 335. The agent wrote it with complete confidence, and I pasted it into my own notes without checking, because it looked right.
That's the trap. Agent output always looks right, whether it is or not. Well written and correct used to travel together. With an agent they don't, so if you don't check the numbers, nobody has. The skill nobody warned me would become the core of the job is reading work you didn't write, sceptically.
Neither of these is clever. That's sort of the point. The junior who gets good at the unclever, unglamorous parts (feeding the agent context, checking its output, writing down what you learn) ends up in a strong spot, not a threatened one.
I wrote a short book about the whole setup: the instruction file, a plain-markdown "second brain" the agent maintains, durable memory, hooks, multi-agent audits, and the guardrails that stop it doing something you can't undo. It's called The Agentic Junior, written from the junior's side, with the failures left in. Link in my profile / below if you want it. Either way, the two habits above cost nothing to try this week.
The Agentic Junior
Almost everything written about AI and coding comes from senior engineers, founders, or someone with a course to sell. This is written from the other seat: a junior developer on a small team, maintaining legacy code by day and running coding agents every working day. There's no hype here, and no "just prompt harder and you'll be fine." What you get is the actual system I use day to day: the files, the habits, the workflows, and the failures I ran into building it. That includes the time an agent wrote a chart caption whose arithmetic was flat wrong, presented it with total confidence, and I shipped it straight into my own notes before I caught it. If you're early in your career and the AI conversation makes you nervous about where you fit, this book argues the opposite case, and shows the working. ### What's inside - Writing a project instruction file your agent reads before every session, so you stop repeating the same context every morning - Building a "second brain" in plain markdown that the agent reads from and keeps current - Durable memory: giving an agent that forgets everything between sessions a way to remember your world - Automating the dull parts with hooks that don't rot a week after you set them up - Running several agents at once for audits and reviews, plus when that genuinely helps and when it's just noise - The team hive-mind: how a small team shares agent knowledge without overwriting each other - Guardrails: the small set of rules that stop an agent doing something you can't undo - A full week in the life, with real prompts and the mistakes left in ### Who it's for Junior and self-taught developers who already use agents on real work, or want to start. Anyone who suspects the way they're using AI makes them quicker this month and weaker this year, and wants to flip that. ### Who it's not for If you want a pack of magic prompts, or you want to be told AI changes nothing, this isn't your book. ### What you get A PDF (around 115 pages) and an EPUB, cover included, readable on anything. Everything in it comes from real practice. Names and client details are stripped out, but nothing is invented. ### An honest note I'm still leveling up myself, and that's the whole point of the book. Every technique in here is one I actually run, and every warning comes from something that bit me first. You're not buying advice from above. You're getting the notes of someone about one step ahead, written down while it's still fresh.
demeulenaere.gumroad.com
Top comments (0)