The aspirational ladder — from first climb to the frontier of what AI can do right now.
The other ladders end at Rung 5. This one doesn’t end at all. The AI Ladder, the Research and Teaching Ladders, and the Staff Ladder all climb the same five rungs — Play, Direct, Apply, Interrogate, Verify — because those five build the one skill everything else stands on: judgment. This ladder shows what that judgment is for. Above Rung 5, the exercises stop being about using AI and start being about building with it — assistants, tools, knowledge bases, connected systems, agents, and teams of agents. The top rung is wherever AI is this month.
Why keep climbing? Because the tools have not stopped where the chatbot stopped. What was research-lab work two years ago — assistants that remember your context, AI grounded in your own documents, agents that plan and carry out multi-step work, teams of agents that check each other — is now available to anyone with a browser. The gap between people who know this and people who don’t is becoming the real digital divide, and it is not a technical gap. Every rung on this ladder can be climbed without writing a line of code.
Climb a five-rung ladder first. Rungs 1–5 here are the same Play → Verify climb as the student, faculty, and staff ladders. Everything above Rung 5 assumes the judgment those rungs build — especially Rung 5’s habit of verifying. The higher you climb, the more the AI does on its own, and the more that habit is what keeps you safe.
One exercise per rung, and the tools change. Below Rung 6, any free chatbot works. From Rung 6 up, exercises use features found in the major AI platforms — projects and custom assistants, notebooks, connectors, agents. Names differ by platform and change often; the exercise describes the capability, and you find its current name in whatever tool you use.
The same rule as every ladder: no protected data. The higher rungs connect AI to real documents, accounts, and tools, so the rule gets sharper as you climb: no student records, no personnel matters, nothing confidential — and from Rung 9 up, grant access one tool at a time and read what you’re approving. From Rung 13 up, nothing that sends, publishes, pays, or deletes runs unattended.
The claims here are sourced. This ladder asserts things about what AI can and cannot do. Those assertions are surveyed, dated, and linked to primary sources in What the evidence says near the bottom — including the findings that cut against the ladder. Read that section first if you would rather be shown than told.
Notes are optional, but up here they earn their keep. Every rung adds power, and every rung’s exercise ends by asking where you stay in the loop. A line per rung on where that was is all you need for the write-up at the end.
| # | Rung & exercise | The question to ask |
|---|---|---|
| Rung 6 — ReuseStop retyping yourself. A saved assistant that already knows your context. | ||
| 06 | Build a standing assistant for one recurring task In your AI tool, create a project / custom assistant / saved instructions (every platform has one). Give it your standing context — your role, your audience, your format rules — and use it for a week on a task you repeat. | What did the standing context change — and what do you still have to say every time, because it’s judgment, not context? |
| Before you climb on: does something you built get used more than once without re-explaining? | ||
| Rung 7 — BuildMake working things — a bot, a tool, a small app. No code required. | ||
| 07 | Build a small working tool and hand it to someone Describe a tool in plain English — a tutor bot for one topic, a form-letter generator, a calculator, a quiz app — and have the AI build it as a working artifact or shareable bot. Then give it to one real person and watch them use it. | Where did your design survive contact with a user — and are the fixes it needs things AI can make, or decisions you have to? |
| Before you climb on: has one other person actually used something you built — and could you say whether it does work you were already doing, changes the form of what you hand over, or does something nobody was doing at all? | ||
| Rung 8 — GroundGive it your knowledge. AI that answers from your documents, not the internet’s. | ||
| 08 | Build a knowledge notebook over your own documents Load a set of your (non-confidential) documents into a notebook-style AI tool — one that answers only from what you gave it, with citations back to the page. Ask it ten real questions, including two you know it cannot answer from those documents. | Did it stay inside your documents or drift to general knowledge — and did it admit the gaps or paper over them? A grounded system that can’t say “that’s not in here” isn’t grounded. |
| Before you climb on: could you say exactly which documents an answer came from? | ||
| Rung 9 — ConnectGive it hands. Connectors link AI to your calendar, files, email, and tools. | ||
| 09 | Connect one tool, run one real task, audit the access Connect a single low-stakes tool (calendar or a shared drive folder) to your AI. Read the permission screen out loud before approving. Run one real task through it — “find my free hour Thursday and draft the invite” — approving each action before it fires. | Did the access match the task — and which permission would you refuse for a higher-stakes tool? From this rung up, the skill is deciding what AI may touch, not what it can do. |
| Before you climb on: could you name what a connected AI can and cannot reach in your accounts? | ||
| Rung 10 — DelegateAgents. AI that plans and carries out multi-step work while you supervise. | ||
| 10 | Hand an agent a bounded multi-step task Pick a task with real steps — a deep-research report, a document assembled from several sources, a small website. Ask the agent to state its plan first. Approve or edit the plan, let it run, then audit the result the way Rung 5 taught you: trace two claims, check one number. | Where did the agent need you — the plan edit, the mid-course correction, the audit catch — and what does that say about which tasks you’d delegate next and which never? |
| Before you climb on: could you name a task you would delegate to an agent tomorrow — and one you never would? | ||
| Rung 11 — OrchestrateTeams of agents. One produces, another independently checks, and work runs on a schedule. | ||
| 11 | Set up a maker and a checker Have one AI session produce a piece of work. Then give the output — and nothing else, no history, no context — to a second, fresh session with one job: find what’s wrong. Fix, and repeat once. Bonus climb: schedule a recurring AI task and review its first three runs. | What did the independent checker catch that the maker’s own session never would — and where did you, the third role, overrule them both? Orchestration is deciding who checks whom. |
| Before you climb on: does any AI work of yours get independently checked before you trust it? | ||
| Rung 12 — EngineerShape the knowledge itself — maps, graphs, and tests that outlive any one conversation. | ||
| 12 | Turn a domain you own into an explicit knowledge map — and a test Take a domain you know cold. Have the AI extract its entities and relationships into an explicit map — a knowledge graph or structured wiki — and correct what it got wrong; only you can. Then write ten questions with known answers and run them against any system you’ve built on this ladder. That’s an eval — the frontier’s version of Rung 5. | What did the AI’s map get wrong about a domain you own — and what does your eval score say about whether your system is ready for someone else to rely on? |
| Before you climb on: could you prove — not feel — that a system you built gives right answers? Everything above this rung is work that happens when you are not in the room. | ||
| Rung 13 — Run UnattendedWork that happens while you are not there. Supervision stops being watching and becomes auditing. | ||
| 13 | Let an agent work without you in the room Take a task you already delegated successfully at Rung 10 and run it again without supervising: a written brief up front, no approvals mid–flight, a full transcript to read afterwards. Choose something bounded and reversible — nothing that sends, publishes, pays, or deletes. | Reading the transcript afterwards, how many times would you have stopped it — and what would have happened if you hadn’t? That count, not the output, tells you whether the task is ready to run unattended. The measured reality: the best agents finish 30% of realistic office tasks on their own.[4] |
| Before you climb on: could you reconstruct, from a record, everything an agent did while you weren’t watching? | ||
| Rung 14 — GovernRules, limits, and tests for work nobody watches. The rung that makes Rung 13 defensible to someone else. | ||
| 14 | Write the operating rules for one unattended task, then try to break them For the task you ran at Rung 13, write one page: what it may touch, what it may never touch, what it must stop and ask about, who is accountable, and how you would know it had failed. Then feed it a case that should trip a stop rule and see whether it stops. Check your page against a published framework — NIST’s AI Risk Management Framework is the one most US institutions use.[7] | Did your own rule actually stop it? If not, is the fix a better rule, a narrower task, or not running it unattended at all? On campus this is also the rung where CSU and CSUN policy stops being background and becomes your constraint. |
| Before you climb on: if this failed at 2 a.m., could someone other than you find out what it did, who is answerable, and how to turn it off? | ||
| Rung 15 — DiscoverUse AI to find something nobody knew — and be willing to find nothing. | ||
| 15 | Run one real question through an AI loop, with a null result allowed Take a question in your own field where you do not know the answer. Have AI generate candidates — hypotheses, designs, algorithms, readings — then test them against something real: data you hold, a computation, a literature check, a small pilot. Before you start, write down what would count as a finding and what would count as nothing. Report whichever you get. | Did it find something you would defend in front of your own field — and if it found nothing, did you say so? A loop that cannot return a null result is not research, it is generation. That this rung is real and not speculative is itself evidenced.[6] |
| Before you climb on: nothing — this is where the ladder stops having rungs and starts having colleagues. What the evidence says about where the next rungs are forming is in the survey below. | ||
The rungs above name the machinery — assistants, notebooks, connectors, agents. They do not say what the thing you build is for. There are three answers, and they are not the same climb.
Same job, same output.
You stop doing something by hand and nobody downstream can tell. The report looks exactly as it always did; you just didn’t make it this time. Start with a task you do on a schedule that has never once needed a judgment call.
Same job, new output.
The work is the one you already do, but what you hand over changes form. A document people read becomes a page people can question. A fixed set of numbers becomes numbers they can change and watch move.
New job, new output.
Work nobody was doing, because it was never worth a person’s time. Watching something that changes unpredictably. Reading every response instead of a sample. Trying two hundred versions where you would have tried three.
Why this matters on this ladder. Every rung above 5 can be climbed while only ever automating — running faster at exactly the work you already did. That is a real climb and it is worth making. But the rung self-checks ask whether you operated the machinery, not whether the work changed. At each frontier rung, ask yourself which of the three you just did. If the answer has been “automate” seven times, the next climb is sideways, not up.
Six kinds of work, any of which can be automated, upgraded, or invented on. This is the menu, not a sequence — pick the one where your own week hurts most.
Presentation — explaining something to people: interactive explainers, comparisons, walkthroughs, checklists.
Content — turning one form of content into another: a recording into notes, notes into a summary, a summary into a post.
Data — pulling numbers together and making them legible.
Documents — doing the same operation to many files: reading, renaming, extracting, converting.
Intake — collecting things from people in a structured way, and knowing what came in.
Admin — the small recurring operations that hold a role together and appear in no job description.
The second axis, and the one the rungs are silent on. The same tool built at each of these four tiers is four different amounts of work — and four different amounts of responsibility. This is where the ladder keeps going after Rung 15.
Built for nobody.
It answers one question — can this be done at all — and then you throw it away. It is allowed to be ugly and allowed to break. Almost every good build starts here, and most should stop here.
Built for you, or a few people who will text you when it breaks.
Reliable enough to depend on, and you may skip polish, onboarding, and most edge cases. This is where the majority of useful work lives, and there is no shame in staying here.
Built for named people who are not you.
Real work happens inside it, so access, reliability, and what it does when it fails now cost trust, time, or money. Rung 12’s eval is what makes this tier honest.
Built for strangers you will never meet.
A different job, carrying every burden of software made for general use. Nothing on this ladder prepares you for it, and knowing that is itself a rung.
Rung 7 skips a tier on purpose — do not let it. Its exercise sends you straight to one real person, which is already the personal tier. Build the throwaway prototype first and let it be bad. Crossing into production changes what you owe people, and that is a decision to make deliberately rather than by drifting into it.
The words on the upper rungs, translated. No prior knowledge assumed.
An AI that doesn’t just answer — it plans a task, takes the steps (searching, writing files, using tools), checks its work, and comes back with the result. You supervise instead of operate.
A standard plug that lets an AI reach a tool you use — calendar, email, files, campus systems — with permissions you grant. MCP is the emerging common standard, so one plug fits many AIs.
Making AI answer from a specific set of documents — yours — instead of its general training, citing back to the page. The difference between “what the internet thinks” and “what our policy says.”
Your domain drawn as an explicit map — the people, concepts, and rules as nodes, the relationships as lines. AI answering over a map beats AI answering over a pile of pages, because the connections are stated, not guessed.
A living, AI-readable home for what a team knows — documents, procedures, decisions — that both people and AI systems can query and keep current. Tribal knowledge, written down and wired up.
Linking several AI roles into a workflow — one drafts, one critiques, one verifies, on a schedule if you want. The design question is human: who does what, and who checks whom.
A test you write for an AI system: questions with known right answers, scored. The grown-up version of “it seems good” — and the only honest basis for letting others rely on what you built.
An agent that runs on a trigger — a clock, an inbox, a file landing — with nobody watching it work. You read the transcript afterwards instead of approving each step. Everything on Rungs 13–15 depends on that transcript existing.
A measurement, not a marketing word: the length of task — timed by human experts doing it themselves — that a model finishes about half the time. It is the most honest single number we have for “how much can it do at once,” and it comes with heavy caveats.[1]
A rule enforced by the system rather than by your attention: an account the agent cannot reach, an action it must ask about, a budget it cannot exceed. Rung 14 is the practice of writing guardrails and then testing that they actually hold.
Building working software by describing it in plain English and iterating on what the AI produces. It has made “I can’t code” stop being the barrier — judgment about what to build is the barrier now.
Every number below is linked to its primary source. Where the evidence cuts against this ladder, it is here too.
This page makes claims about what AI can do. Those claims should be checkable, and the sources should be organisations that publish their methods and their failures — not vendors describing their own products. Six findings, all dated, all linked. If the survey date above has gone stale, treat the numbers as stale with it.
METR, a non-profit evaluation lab, measures the length of task — timed by human experts — that a model completes with 50% reliability. In its January 2026 measurement the top model reached 320 minutes, a little over five hours.[2]
Across 2019–2025 that figure doubled roughly every 196 days. Measured only from 2023, it doubles every 131 days.[2] Whatever you believe about AI, the direction of that curve is measured, not asserted.
Why it matters here: it is why Rungs 10 and 13 exist at all. Five years ago there was no task long enough to delegate.
METR says so itself, in its own FAQ. It measures task difficulty, not how long an AI runs. The tasks are “primarily software engineering, machine learning, or cybersecurity tasks.” An eight-hour horizon does not mean AI can automate jobs. And above sixteen hours, “measurements… are unreliable with our current task suite.”[1]
Why it matters here: a number quoted without its caveat is the thing skeptical colleagues are right to distrust. Quote both.
Carnegie Mellon researchers built a simulated software company — browsing, coding, messaging colleagues, filing work — and put agents to work inside it. The most capable agent completed 30% of tasks autonomously.[4]
Why it matters here: seventy percent is the number to hold next to any agent demo, including the ones on this ladder. Rung 13 asks you to audit a transcript for exactly this reason.
METR ran a randomised controlled trial: 16 experienced open-source developers, 246 real issues, in large repositories they already knew well. With AI tools they were 19% slower. They had expected to be 24% faster — and afterwards still believed they had been 20% faster.[3]
Why it matters here: this is the single best argument for Rung 5. Self-report is not evidence, including your own, including about this ladder.
Stanford researchers tested the AI legal research tools sold to lawyers as hallucination-free — all built on retrieval over authoritative documents, which is exactly the Rung 8 idea. The tools hallucinated between 17% and 33% of the time: better than a general chatbot, nowhere near safe to trust unchecked.[5]
Why it matters here: it is the evidence behind Rung 8’s test question and behind Rung 12’s eval. “We grounded it in our own documents” is a reduction in risk, not a removal of one.
Google DeepMind’s AlphaEvolve found a way to multiply two 4×4 complex matrices using 48 multiplications — the first improvement on Strassen’s 1969 result for that case. Put to fifty-plus open mathematics problems, it improved the best known solution on about 20% of them. A scheduling change it discovered recovered, on average, 0.7% of Google’s worldwide computing capacity, and ran in production for over a year.[6]
Why it matters here: Rung 15 is not aspirational framing. The loop has already produced results that stand up in the relevant field.
How to argue with this page. Each claim above names an organisation, a date, and a figure, and links to the primary source rather than to coverage of it. Two of the six findings are unflattering to AI, and they are here because a survey that only reports the good numbers is advertising. If you check one of these and find it stale, misread, or superseded, that correction is worth more to this page than another success story — say so and it gets fixed, with the date changed.
This ladder is a moving target, on purpose. Rungs 1–5 are stable — judgment doesn’t go out of date. Everything above is a survey of what AI can already do, taken on the date in the footer, and it will be re-surveyed as the frontier moves: rungs will be renamed, exercises replaced, and new rungs added above 15. If you’re reading this and Rung 15 sounds ordinary, the ladder is due for a climb of its own.
From writing song lyrics on Rung 1 to running a research loop on Rung 15 — with the ladder still going up past both of us. That distance is the lesson. Start wherever you are — and welcome to the Ladder.
All links are to the publishing organisation, not to coverage of it. All accessed 15 September 2026.
Not used as sources, deliberately: vendor benchmark blogs, press coverage of research, and analyst forecasts. Where a vendor is cited (source 6) it is for a mathematical result that other people can verify, not for a claim about the vendor’s product.
The other ladders end with a short write-up. This one asks for the same: one to two pages on what you thought AI was at Rung 1, at Rung 6, and at your highest rung, and what you would now let it run on its own and what you would not. The difference is that it expects you to rewrite it every year, because the top will have moved. The people the college most needs are the ones who’ve made climbing itself the habit: they reach a frontier rung, help name the next one, and guide others up behind them.