đ 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.
My agenda
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:
The end of the bottom-up apprenticeship (and what we need to teach now)
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.
Links that caught my eye this week
Inkling-Small: the open MoE from Thinking Machines Lab
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.
Claude 5: fewer rules, more judgment
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.
GPT-5.6: the frontier gets cheaper
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.
DeepSeek V4-Flash: the penny open weight
$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.
Gemini Robotics ER 2: AI leaves the screen
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.
The harness analogy is the sharpest framing I've seen for this - juniors needing a deliberate training harness the same way agents need an execution harness to stay on track. It connects directly to what I found looking at AI-first codebases: systems nobody fully understands because the people who'd normally build that understanding through review are the ones being skipped. Does the ADR-as-training-discipline approach hold up when the junior isn't writing the code at all - can architectural judgment form purely through review and decision records, or is there a floor of hands-on implementation below which it doesn't stick? Happy to connect, let's talk more about it.
The shift from implicit to explicit is the right diagnosis, and the ADR discipline is a genuine part of the fix. But architecture and patterns are the wrong things to put first if the goal is someone who can actually save a system when it breaks.
Reusable code, the right architecture model, security by design â none of my generation learned those as rules from a book. They were built by writing the bad version first, watching it fail, and doing the work of understanding why. That's the same judgement an AI model doesn't have. It can generate the pattern-correct answer without ever having lived with the consequence of getting it wrong, which is exactly why it doesn't know good from bad â it's never had to.
Teaching the WHAT top-down closes half the gap. It gives a junior the vocabulary to describe a decision and reference the pattern that justifies it. It doesn't give them the ability to open a system that's already broken, work out why, and fix it â because that skill only comes from having built and broken things by hand, not from reading the architecture that explains how they were supposed to work.
Which is the actual test this doesn't have an answer for yet: not the design review, but the outage â when the thing that failed can't explain itself, and the only useful skill left in the room is someone who can read the code directly and knows what wrong looks like.