← The Forge Brief
Contrarian · 4 min read

Everyone's worried AI tutors make learners lazy. The real damage already happened upstream.

AI didn't make your juniors stop thinking — it quietly deleted the work that used to teach them how.

By Hendrik Lojek
Key Takeaways
  • AI tutors making learners lazy is the wrong worry — AI already deleted the execution reps that used to build judgment (the “missing junior loop”).
  • Learning comes from generating answers, not receiving them — so the fix isn't less AI, it's an AI tutor engineered to withhold and build judgment.
  • Stop measuring ramp speed with the tool present; measure time-to-validate with it absent — the only apprenticeship metric that survives automation.

You inverted the junior role without noticing. The process tech you hired to pull the OEE numbers, chase the sensor data, and run the standard fix now supervises an agent that does all three faster than she can. On paper she's more productive. But six months in, when the agent returns a fault code that's confidently wrong, she approves it — because she never spent the year of pulling those numbers by hand that would have taught her what a wrong one looks like. You didn't hire a supervisor. You hired someone to rubber-stamp a machine.

This is the part of "AI in education" that the classroom debate keeps missing. The anxious conversation is about students offloading their thinking to a chatbot — the "cognitive debt" a 2025 MIT Media Lab study measured as the weakest brain connectivity in people who wrote with an LLM. That effect is real. It is also not your biggest problem.

The reps were the curriculum, and AI already deleted them

Manufacturing always ran an implicit apprenticeship: a junior did execution-level work for three to five years, and the tacit judgment — which reading is drifting, which fix won't hold in summer humidity — accumulated as a free byproduct of the labor. Nobody designed it. The work was the lesson.

Automate first-pass analysis, routine reporting, and standard troubleshooting, and the byproduct disappears. The organizational-AI literature calls this the missing junior loop (Salim Ismail et al., The Organizational Singularity) — automate the entry rungs and you don't just displace juniors, you starve the firm of the senior operators it will need in a decade. The role doesn't vanish; it inverts into supervision, which demands exactly the judgment the old execution path used to build. You've created a job that requires senior pattern-recognition from someone you never let develop it. That's a judgment-development gap, and no amount of content fixes it, because it was never a knowledge gap.

Why the tutor is the fix, not the threat

Here the learning science stops being a warning and becomes a blueprint.

In 1984 Benjamin Bloom documented the "2 Sigma Problem": one-on-one tutoring moved an average student to roughly the 98th percentile. The finding was never disputed — the obstacle was that you can't put a human tutor next to every apprentice. AI is the first thing that plausibly can. A Harvard study (Kestin et al., published in Scientific Reports, 2025) ran physics students through a purpose-built AI tutor versus an active-learning classroom; the AI group learned more than twice as much in less time, and reported higher engagement. Tutoring works, and AI finally makes it scalable.

But the same literature is exact about why it works, and it isn't speed. Robert Bjork's "desirable difficulties" established that the struggle is the mechanism — retrieval, spacing, the effort of generating an answer from memory is what converts exposure into durable skill. Freeman's 2014 PNAS meta-analysis found the mirror image: students who sat and received lectures failed 55% more often than those made to do the work. An AI that instantly hands over the answer is just a very fast lecture. The tutor that teaches is the one that withholds.

So the design question inverts too. Not "how quickly can the tutor answer," but "how reliably can it make the learner produce the answer." A tutor built for judgment asks the diagnostic question back before it gives the fault code. It makes the apprentice state a hypothesis before it confirms one. It climbs her deliberately up the rungs — from executing the task, to reading the output, to the rung that matters: validating it, detecting when the agent is wrong and why. That rung — call it getting above the loop — is the entire job of an experienced operator: you don't run every gauge yourself, you know which reading is lying. It used to take years of accidental accumulation. Engineered, it takes months.

What to do Monday

Two changes, both cheap. First, put any training-mode AI in Socratic mode — questions before answers, hypotheses before confirmations — and reserve answer-completion for production work, not for people still learning the machine. Second, change your scorecard. Stop grading ramp speed with the tool present; that number flatters everyone. Grade time-to-validate: how long until the technician catches a wrong agent output on her own, with the copilot switched off. That single number is the difference between having trained a person and having rented one — and it's the only apprenticeship metric that survives the arrival of the machine that did the homework.

Sources
Ismail, S. et al. — The Organizational Singularity (OpenExO)Bloom, B. (1984) — The 2 Sigma Problem, Educational ResearcherKestin et al. (2025) — AI Tutoring Outperforms Active Learning, Scientific ReportsFreeman et al. (2014) — Active learning meta-analysis, PNASBjork & Bjork (2011) — Making Things Hard on Yourself, But in a Good WayMIT Media Lab (2025) — Your Brain on ChatGPT