The AI Access Ladder: a framework for responsible AI use in learning

Two failures kept landing on my desk, and they looked like opposites. One learner shipped a working feature in an afternoon and could not explain a single line of it when I asked. The code was real, the understanding was not. Another learner, who had sworn off AI entirely to “do it properly,” was three days behind on something the rest of the cohort had moved past, hand-rolling a date formatter the way we did in 2015. Copy-paste learns nothing. Abstinence falls behind. Both extremes were failing the same person.

So we did not ban AI, and we did not wave it through. We built a ladder. Each rung is a different level of access, from no AI at all to handing the whole task over, and the mentor’s job is to put each learner on the rung that matches what they are actually trying to learn right now. This is the framework we use, the reasoning behind it, and what happened when we put it into practice with real learners.

Five rungs, from no-AI to delegate

The ladder has five levels. They are not “beginner to advanced.” They are degrees of how much of the thinking you let the model do for this task. A senior engineer learning an unfamiliar domain belongs on a low rung; a beginner writing throwaway glue code can sit on a high one. The rung is a property of the task-and-learner pair, never of the person alone.

The shape matters. Climbing the ladder is not “getting better at coding.” It is transferring ownership of the thinking to the machine. That is fine when the thinking is no longer where the learning is. It is quietly corrosive when it is.

The science of desirable difficulty

The ladder is built on one idea from cognitive science: learning happens when your brain has to work, not when it watches work happen. In Make It Stick, Brown, Roediger, and McDaniel popularised the term desirable difficulties: the finding that effortful retrieval, spacing, and struggle produce more durable learning than smooth, easy review. The catch is in the word desirable: not all difficulty helps, and difficulty past a point becomes frustration.

Here is the danger nobody warns beginners about. Andrej Karpathy quipped that “the hottest new programming language is English,” and for a fluent practitioner that is right. But for a beginner, describing a problem well enough to get working code out requires the very mental model they have not built yet, and accepting the code back skips the retrieval that would have built it. The interface feels like learning. It is the opposite of learning. A Level 4 tool used at a Level 0 moment moves the learner to the flat left edge of that curve: productive on the screen, empty in the head.

This is also a growth-mindset argument. Carol Dweck’s Mindset makes the case that believing ability grows with effort changes what learners do when something is hard. AI offers a frictionless exit from “hard,” and a learner with a fragile mindset will take it every time. The ladder removes the exit at exactly the moments it would hurt most, and opens it once effort has done its job.

How mentors actually assign a rung

In a session this comes down to three quick reads: which skill, which learner, which task. The matrix below is the version I keep in my head. Read each row as a kind of work, and the highlighted cell as the rung it usually belongs on for someone still learning.

A few decision rules make this concrete:

• New fundamental, Level 0. First time writing a closure, reasoning about optionals, or laying out Auto Layout by hand. The struggle is the lesson. We ask people to close the AI panel.
• Known idea, unfamiliar syntax, Level 1. They understand a for loop but are new to Swift’s map/reduce. AI explains the syntax; they still write it.
• Their own draft, then a check, Level 2. They have a working solution and want feedback. Now AI is a reviewer, and a good one, but the first attempt was theirs, so the retrieval already happened.
• Refactoring code they understand, Level 3. They know what the function does and why; co-writing the cleanup is leverage, not a shortcut past learning.
• Glue, config, throwaway exploration, Level 3-4. Boilerplate, a one-off script, a spike they will delete. Low stakes, short life, no skill at risk. Delegate freely.

The hardest part of mentoring this is not the high rungs. It is holding learners on Level 0 when a single prompt would “solve” their problem in seconds. That is the moment the framework earns its keep.

What the levels trade off

What we observed, including the failures

I want to be honest here, because the framework is not magic and the failures taught us more than the wins.

What worked. Learners who spent their first two weeks at Level 0 on fundamentals (closures, optionals, the view-update cycle) debugged noticeably better for the rest of the program. When something broke, they had a model to reason from instead of pasting the error into a chat and hoping. The reviewer rung (Level 2) was the surprise favourite: it kept the first draft theirs while still giving fast feedback, and learners liked it.

Where it failed. Three honest failures:

1. Self-reported levels drift upward. Left to self-assess, learners quietly climbed to Level 3 because it was faster, then stalled when a project demanded a fundamental they had skipped. The ladder only works if a mentor periodically checks the rung, not just the output.
2. Level 0 bred resentment when we did not explain why. Early on we said “no AI for this” without the desirable-difficulty reasoning. It read as gatekeeping. Once we showed people the curve, that the struggle was buying them something, compliance and morale both rose. The framework needs its own justification taught alongside it.
3. One learner gamed it and learned nothing. They followed every rule, asked only “explainer” questions at Level 1, but phrased them so precisely (“explain how to write a function that takes X and returns Y, with an example”) that the explanation was the answer. The ladder is a guide for honest effort, not a fence against someone determined to avoid learning. No framework survives a learner who does not want to learn.

That last one is the real limit. Paul Graham, in How to Do Great Work, makes the point that taste and judgement are built, not borrowed: you cannot outsource the thing that makes the work yours. AI can write your code. It cannot own your understanding, and it cannot want it for you. The ladder buys time and structure for understanding to form. It cannot manufacture the desire.

A template you can take

If you mentor, teach, or lead a team, here is the ladder as a portable process. It maps cleanly onto onboarding a junior engineer, not just a classroom.

Four practices make it stick in the real world:

• Name the level out loud. “This one is Level 0” sets the expectation before the work starts, and removes the awkwardness of saying no mid-task.
• Teach the why, not just the rule. Show learners the struggle curve. People accept friction they understand the purpose of.
• Promote on evidence, not on time served. The test is the same every time: could you have done this without AI, and can you explain it? Yes earns the next rung.
• Re-check the rung, not the output. Working code tells you nothing about which level produced it. Periodically watch how the work gets done.

Anthropic’s own guidance for Claude for Education lands in the same place: the goal is a tool that develops a learner’s thinking rather than replacing it. The ladder is an operational way to keep that promise: a dial you turn deliberately, instead of a switch stuck on “off” or “on.”

We did not ban AI. We built a ladder, and the whole point of a ladder is that you are meant to climb it, but only one rung at a time, and only once you have earned the one you are standing on.