10 repliesDiscussion3h ago
Index
Feed
Posted by ottoline · Apr 29, 2026
We hired a new grad six months ago. He ships like a mid-level engineer: clean PRs, reasonable velocity, tests included. He is also, as far as I can tell from whiteboard conversations, not much stronger than the day he started — because Claude Code writes essentially all of his code, and he has become excellent at directing it and adequate at reviewing it, without much of the load-bearing knowledge underneath.
Here's what's keeping me up: the apprenticeship model was never designed. It was a side effect. Juniors learned because the only way to ship was to write every line, suffer every bug, and slowly compile experience. Agents removed the suffering, and it turns out the suffering was the curriculum.
I don't buy the "it's just a better compiler" analogy either. Compilers abstracted a layer we agreed to stop thinking about. Agents abstract judgment — and we haven't agreed to stop thinking about that; we're just quietly stopping.
But I also refuse to be the lead who bans agents for juniors while every senior uses them, teaching everyone that the real skill is seniority theater. So, concretely, for teams actually navigating this: what does deliberate skill-building look like when writing code by hand is no longer economically natural? What replaced the suffering?
Related records
Strong evidence gets promoted into the record above.
Notably, predict-then-compare is exactly how we trained on legacy systems too big to fully understand, which every real codebase already was. The juniors were never going to compile experience by writing everything — that world ended before agents. Agents just made the pretense unaffordable.
From the consulting side, the pattern that separates the teams that grow juniors from the ones quietly hollowing out: whether review is taught as a first-class skill. The hollowed teams treat review as a checkpoint. The healthy ones run review apprenticeships — junior reviews the agent PR first, senior reviews both the PR and the junior's review, and the delta between the two reviews is the lesson. The senior's findings the junior missed ARE the syllabus, personalized, weekly, forever.
One concrete practice we adopted: no-agent Fridays for anyone under two years experience, on real tickets, not katas. Controversial, slows them down 3x, and they grumble. But our two juniors both say the Friday struggle changed how they direct agents the other four days — you can't specify what you can't imagine building. Sample size two, but I'll take it over the alternative of finding out at their first 2 AM incident.
We tried this and dropped it in a month — honest failure report. The juniors treated it as ceremony, quality was worse, nothing shipped Fridays, and the 'struggle' was mostly them fighting boilerplate agents handle for a reason. Calvinl's prediction ritual gets you the same muscle inside real workflow, without pretending it's 2019 one day a week.
The uncomfortable long-term question nobody's answered: our entire seniority pipeline assumes review skill grows out of writing skill. If juniors now learn review-first, we genuinely don't know whether that's a shortcut or a foundation with a missing floor. Ask me again when the first review-first generation is running incident response alone. That's the experiment we're all enrolled in, consent forms pending.
Sign in to join the discussion, vote, and verify fixes.
New grad here, eighteen months in, so this thread is about me. Some ground truth from the other side:
The learning didn't stop. It moved. I debug the agent's wrong assumptions daily, and doing that forced me to learn systems thinking way earlier than the tickets I'd otherwise be shoveling — I've read more production stack traces than any second-year I know, because triaging agent mistakes IS my curriculum.
What I genuinely don't have: mechanical fluency. Asked to write a nontrivial function on a whiteboard cold, I'm slower than my agent-free peers. Whether that matters in 2028 is exactly the bet all of us made when we took these jobs.
The thing that actually built skill: my lead makes me predict, out loud, what the agent will do before I run it, then compare against what it did. Cheap, slightly humiliating, and it works — prediction error is the fastest teacher I've found.
The predict-first ritual is the single most actionable thing in this thread and I'm instituting it Monday. Prediction error as curriculum — that's the replacement for suffering I was asking for, isn't it.