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

Hello, mentors and teachers. If you are not sure how much AI to let your learners use, this article is about a simple framework we call the AI Access Ladder.

By the end of this article, you will understand the five levels of the ladder, why struggle is sometimes the point of a task, how to pick the right level for a given learner and task, and what happened when we tried it with real learners, including where it failed.

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

So we built a ladder instead of banning AI or waving it through. Each rung is a different level of access, from no AI at all to handing the whole task over. The mentor’s job is to put each learner on the rung that matches what they are trying to learn right now.

Five rungs, from no-AI to delegate

The ladder has five levels. Each level is a degree of how much of the thinking you let the model do for this task, not a step from beginner to advanced. A senior engineer learning a new domain belongs on a low rung. A beginner writing throwaway glue code can sit on a high one. The rung depends on the task and the learner together, never on the person alone.

Climbing the ladder means handing the thinking over to the machine, not getting better at coding. That is fine when the thinking is no longer where the learning is. It quietly does damage 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 made the term desirable difficulties well known. It is the finding that effortful recall, spacing, and struggle produce learning that lasts longer than smooth, easy review. The catch is in the word desirable. Not all difficulty helps. Past a point, difficulty becomes frustration.

Andrej Karpathy joked that “the hottest new programming language is English.” For a fluent practitioner, that is right. But a beginner needs to describe the problem well enough to get working code out. That takes the very mental model they have not built yet. Then accepting the code back skips the recall that would have built it. The interface feels like learning while skipping it. A Level 4 tool used at a Level 0 moment puts the learner on the flat left edge of that curve, productive on the screen and empty in the head.

This is also a growth-mindset argument. Carol Dweck’s Mindset argues that believing ability grows with effort changes what learners do when something is hard. AI offers an easy exit from “hard.” A learner with a fragile mindset will take it every time. The ladder removes the exit at the exact moments it would hurt most. It opens the exit again 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. The highlighted cell is 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 recall already happened.
• Refactoring code they understand, Level 3. They know what the function does and why. Co-writing the cleanup saves effort. It is 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 holding learners on Level 0 when a single prompt would “solve” their problem in seconds.

What the levels trade off

What we observed, including the failures

The framework is not magic, and the failures taught us more than the wins.

What worked. Some learners spent their first two weeks at Level 0 on fundamentals (closures, optionals, the view-update cycle). They debugged noticeably better for the rest of the program. When something broke, they had a model to reason from. They did not paste the error into a chat and hope. 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 failures:

1. Self-reported levels drift upward. Left to judge themselves, learners quietly climbed to Level 3 because it was faster. Then they stalled when a project needed a fundamental they had skipped. The ladder only works if a mentor checks the rung from time to time, 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 came across as gatekeeping. Once we showed people the curve, and that the struggle was buying them something, both compliance and morale rose. The framework needs its own reasoning taught alongside it.
3. One learner gamed it and learned nothing. They followed every rule. They asked only “explainer” questions at Level 1. But they 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 guides honest effort. It cannot fence in someone determined to avoid learning.

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, but it cannot own your understanding or want it for you. The ladder buys time and structure for understanding to form. It cannot create the desire.

A template you can take

If you mentor, teach, or lead a team, here is the ladder as a process you can carry with you. It fits onboarding a junior engineer just as well as a classroom.

Four practices make it stick:

• Name the level out loud. “This one is Level 0” sets the expectation before the work starts. It also removes the awkwardness of saying no mid-task.
• Teach the why, not just the rule. Show learners the struggle curve. People accept friction when they understand its purpose.
• 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. From time to time, 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 grows a learner’s thinking rather than replacing it. The ladder is a practical way to keep that promise.

Recap

The goal of this article was to give you a clear way to decide how much AI a learner should use for a given task. The main points:

• The ladder has five levels, from Level 0 (no AI) to Level 4 (delegate). The level belongs to the task-and-learner pair, not the person.
• Learning needs effort. Ask one question: is the struggle the point? If yes, keep AI low. If the skill is already owned, let AI take the work.
• Promote on evidence. The test is: could you have done this without AI, and can you explain it?
• Mentors must check the rung, not just the output. Self-reported levels drift upward.
• Teach the reasoning alongside the rule. People accept friction when they know what it buys them.

I hope this writing helps you. Thanks for reading, and if it was useful, share it with someone who mentors.