Training juniors in the AI era: the bottom-up apprenticeship is over

🔗 Learn more about me, my work and how to stay in touch: maeste.it: personal bio, projects and social links.

This week I’m talking about something close to home: training junior developers in the age of AI. If coding assistants have eroded the code juniors write, and code review is becoming a bottleneck that AI itself is absorbing, what’s left of the traditional apprenticeship? My thesis is that training must shift from implicit bottom-up to explicit top-down, and that books that seemed outdated like Fowler’s are becoming central again, while agentic patterns like Gullí’s are the new body of knowledge to study. It’s a theme I also touched on in Saturday’s podcast: if AGI is an asymptote, and for almost all real work AI doesn’t need to be perfect, then the point isn’t how smart the model is, but how solid the scaffolding of context, architecture and judgment you build on top of it is. It holds for agents, it holds for people. Enjoy the read.

Podcast:

• Saturday saw the release of episode 65 of Risorse Artificiali, “AGI is an asymptote”: why AI will never be perfect, and why for almost all real work it doesn’t need to be. Also covers Laguna S2.1, model density and quantization. Listen:

I started programming by writing code, like everyone else. I’d bang out lines, get them corrected in review, make mistakes, redo them. It was a bottom-up apprenticeship: you learned patterns by getting them wrong, trade-offs by suffering through them, architecture by discovering it one production incident at a time. It wasn’t elegant, but it worked, and it’s how two generations of engineers were trained.

That path is closing, and it’s not an opinion. The Stanford Digital Economy Lab, analyzing millions of ADP records, finds that workers aged 22-25 in occupations most exposed to AI have lost 16% of relative employment since late 2022. The SignalFire report is blunt: new graduate hires at Big Tech have dropped to 7%, half of 2019, and 37% of managers prefer using AI over hiring someone under 30. Add to this what Gergely Orosz put in black and white talking to engineering leaders across half the world: since models started generating more code, the bottleneck has shifted from writing to review. PRs multiply, reviewers burn out, and when AI code review finds no comments, the human reviewer approves without reading. It’s the comprehension debt I’ve been talking about for weeks, but now it has an operational face.

The point I care about is the junior developer. If you learned bottom-up, by writing and getting corrected, what do you learn when you no longer write code and soon won’t even review it? AI has eroded both legs of the traditional apprenticeship. Nazar Boyko puts it well: the work AI automated away was never waste, it was the apprenticeship. AI didn’t prune inefficiencies, it canceled the curriculum and kept the exam.

My hypothesis is that training must explicitly shift from bottom-up to top-down. Companies need to invest in a structured path that teaches architecture, design patterns and system design as a discipline, not as a byproduct of repeated mistakes. Martin Fowler‘s books, Refactoring and Patterns of Enterprise Application Architecture, which looked like dinosaurs in a Copilot world, are central again. Fowler himself, in an August 2025 writeup on the impact of LLMs on software development, is explicit: refactoring is more important than ever, because generated code needs constant reorganization to stay healthy. And he has an observation that struck me: you often hear LLMs compared to a junior colleague, but an LLM is happy to say “all tests green” when tests are failing. If that were a junior engineer’s behavior, how long before HR got involved? The comparison works only if the junior has the judgment the LLM lacks, and that judgment must be trained.

Architecture Decision Records become the discipline with which you teach a junior to think in terms of constrained choices, not code that works. An ADR captures a decision and its rationale, including trade-offs and consequences, and it’s exactly the skill that separates someone who can evaluate AI-generated code from someone who accepts it passively.

And here comes the book that, in my opinion, bridges the classic with the new better than any other: Antonio Gullí, Agentic Design Patterns (Springer, 2025). Gullí, a Distinguished Engineer in Google’s CTO Office, explicates reusable patterns for orchestrating agents, managing memory, evaluations and human control. It’s the natural extension of classic design patterns to the agentic world: the GoF for the AI era. And it’s exactly the case where top-down teaching is not only possible but inevitable, because agentic patterns are too new and too specific to be discovered through trial and error on a production codebase.

There’s a parallel that convinces me and ties back to my hobby horse about harnesses. Birgitta Böckeler of Thoughtworks, commenting on OpenAI’s work on what they call “harness engineering”, defines the harness as the set of practices and tooling that keep AI agents on track: context engineering, architectural constraints, code garbage collection. OpenAI built a product of over one million lines with no code typed manually, but only because they had a solid harness. The analogy is powerful and symmetric: just as AI agents need a well-designed harness to be effective, juniors need a training harness that teaches them the WHAT (architecture, patterns, trade-offs) before or alongside the HOW (writing code).

This isn’t an obvious observation, and some argue that the apprenticeship doesn’t disappear, it shifts. They’re right, in part. The point is to carefully choose which tickets stay human because they’re training, not throughput: end-to-end understanding of a flow, shadow on-call, writing postmortems. Assign understanding, not just output. But this requires awareness and deliberate investment, it doesn’t happen on its own.

The conclusion is simple and uncomfortable. If the bottom-up apprenticeship dies, and it’s dying, whoever doesn’t invest in structured architecture and patterns training will end up with orchestrators who don’t understand what they orchestrate. And the right books, the right patterns, ADRs as a discipline, these aren’t old school: they’re the only school left. The seniors of 2030 are the juniors someone is training today. If nobody trains them, by 2030 there will only be irreproducible seniors and no one to take their place.

MoE 276B/12B, native multimodal, controllable reasoning effort, one million token context.

Thinking Machines Lab never stops surprising me. After the manifesto on decentralized AI and July’s open weight release, here comes Inkling-Small with numbers that speak clearly: 276 billion total parameters, 12 billion active, 4.4% sparsity. It’s the kind of model that confirms the trend I’ve been tracking for weeks: active parameters have been flat for two years between 12 and 49 billion, while totals grow. Sparsity costs storage, which is cheap, not compute. And controllable reasoning effort means you can dose how much thinking happens before answering, which in my world of harnesses and agentic loops is gold. For the European insurance policy, every open model at this level is ammunition.

Anthropic removed 80% of Claude Code’s system prompt for Opus 5 with no loss on evals. The shift: from rules to judgment, from manual memory to auto-memory.

I felt this connection with today’s deep dive immediately. If 80% of the system prompt is redundant, it means mature models need less HOW (operational instructions) and more WHAT (context and intent). It’s the same rule I defend for training juniors: the HOW can be delegated or automated, the WHAT must be taught. The fact that Claude Code improves by removing rules is the empirical proof of a principle that holds for agents and holds for people. Progressive disclosure, auto-memory, judgment instead of checklists: it’s the future of harnesses and training.

Luna -80%, Terra -20%, Sol Fast mode. Sol auto-optimizes its own inference kernels.

OpenAI is aggressively cutting GPT-5.6 prices, and the most interesting technical detail seems to be Sol’s kernel auto-optimization. It’s recursive self-improvement applied to inference, not the model, and it confirms what Lilian Weng says and I’ve been repeating for weeks: the real lever is the harness, not the weights. On the pricing front, collapsing costs make multi-model systems increasingly practical: when each call costs little, you can afford to combine ten. It’s the ground I’m betting on, and crashing prices accelerate the curve.

$0.14/$0.28 per million tokens, 1M context, 384K output, thinking + non-thinking modes.

DeepSeek continues to be the best value-for-money open weight, and V4-Flash confirms it. Fourteen cents per million input tokens, twenty-eight for output, one million context: these are numbers that three months ago seemed impossible. The thinking + non-thinking mode is exactly what you need in multi-agent systems: the same model serves as a fast worker for simple tasks and a reasoner for complex ones, without changing vendor. For those building on top of open models like me, DeepSeek has become the default worker.

Embodied reasoning, temporal intelligence, multi-robot collaboration.

It’s outside my usual perimeter, but I can’t ignore it. Gemini Robotics ER 2 focuses on embodied reasoning and temporal intelligence, and the detail that strikes me is multi-robot collaboration: physical agents that coordinate. It’s the extension of the agentic paradigm from software to the real world, and the orchestration patterns I talked about in the deep dive, Gullí’s, apply here too. The harness of a collaborative robot is much more constrained than a coding agent’s, but the principle is the same: how much autonomy you can delegate depends on how much you can verify.