The weekly letter from Systems Thinking Lab: systems thinking insights for junior engineers, framed through the seven building blocks.
You have probably seen the claim by now: AI is coming for the junior engineer first, so if you are early in your career, or trying to become one, the timing looks bad. If you are a senior who has repeated that line to someone below you, this is worth a second look too.
I wrote a longer essay taking the other side of that argument this week, and I want to give you the short version here.
Look closely at what those predictions actually describe. Not a junior engineer. A person whose entire job is turning a finished spec into working code. That role is real and it is shrinking fast. But it was never the same thing as "junior engineer." We welded the two together for forty years because, until recently, spec-to-code translation was the main thing a junior had the skill to do. AI is eating that task. It does not follow that it eats the title too, unless we insist on keeping them tied together.
So the real question is not whether the junior engineer survives. It is what we train a junior engineer to do now that translation work is cheap.
I think a lot of people land on "they are doomed" for a reason that has nothing to do with whether it is true. It is the easy conclusion. It asks nothing of us. Figuring out how to train a junior into a senior without the years of tickets we used to lean on is genuinely hard. "They are doomed" lets everyone off the hook. "How do we train juniors into seniors now" does not, but it is the question with a future in it.
Here is what is actually disappearing. For as long as I have been in this field, the plan was the same: hire someone who can code, hand them small well specified tickets, and let them grind through years of execution until judgment showed up. Bugs, edge cases, code review, the slow accumulation of pattern recognition. Somewhere around year four or five, if it worked, they started asking "should we build this" instead of just "how do I build this."
That path is closing, and not because anyone designed it to close. The years that used to build judgment were built entirely out of execution work, and execution work is exactly what agentic coding now absorbs. Take away the tickets and there is nothing left for the apprentice to practice on. The casualty is not the junior engineer. It is the apprenticeship.
Somebody still has to build senior judgment. It just cannot happen the old way anymore, which means it has to be built somewhere else, on purpose, before the first job starts. That is school. That is workshops and bootcamps. That is the courses people take on their own time. Each of those has mostly taught something other than judgment: theory in school, syntax and tooling in bootcamps and workshops. That is what has to change. I believe this enough to grade on it: the course I am teaching at UC Berkeley this fall has students build real applications with agentic coding, then grades them on defending the design decisions.
None of this waits on a school's calendar, either. If you are already working, or already past whatever program you paid for, you can start this week on any real project you have open right now: make the agent produce a plan before it writes a line of code, question every decision in that plan, then let what actually happens grade whether you questioned the right things. No enrollment required.
The full essay goes further into the mechanism I think replaces the old apprenticeship. People are calling the discipline of directing an agent well "loop engineering," and most of its value in a company comes from designing the human out of the loop. I think the training version runs the opposite direction: the junior stays in the loop on purpose, pushing back on the agent's plan until an area is genuinely understood, and only then earns the right to step out of it, one area at a time. That part, the graduation mechanism, is the piece worth the full read: https://systemthinkinglab.ai/newsletters/the-junior-engineer-is-not-disappearing/
For now, the short version is this.
You do not train a junior by handing them a shrinking task and hoping judgment shows up on its own. You train them by building the judgment on purpose, before the tickets that used to build it are gone.
P.S. If this is the first thing you have read from me, the free course is where the building blocks lens starts: https://systemthinkinglab.ai/learn