A complete curriculum architecture for people who will run Claude Code on real projects. Thirteen power standards, five whole-task classes, and a first module authored as a threshold rather than a lesson. Built on 4C/ID, and honest about every gap that remains.
This course teaches the competencies a practitioner actually uses, and it is framed that way from the first page. It makes no claim about examination outcomes and uses no language implying an external credential, endorsement, or affiliation.
The five domains come from a formal job-task analysis, which makes them a map of the work rather than an artifact of any test. They remain the internal scaffolding of the whole curriculum: Agentic Architecture, Claude Code, Prompt Engineering, Tool Design, and Context Management.
Learners never see domain codes, percentages, or scaffolding vocabulary. They see one thing: plain statements of what they will be able to do.
The published domain weights are sampling proportions. They describe what gets asked about, not what gets used. Every weight in this curriculum has been re-derived from work value, and the reasoning is shown in section three.
A course promises topics, and a topic cannot be passed or failed, so nobody can say whether it worked. A standard is a topic rewritten as a checkable claim, one thing a person can do, stated precisely enough that two people watching the same learner would agree on whether they did it.
Twenty-six were drafted. The first pass absorbed six into others and added two, leaving twenty-two. A later coverage pass absorbed AA.6 and added MS.1 and GV.1, leaving twenty-three. Nothing was dropped at either step. Thirteen of the twenty-three are load-bearing. Skip one and the rest stops working. Those thirteen get the repetitions, the gates, and the time. The other ten are taught once.
The precise version runs the curriculum and the assessment map. The learner never sees it. What the learner reads names the same mechanisms in the vocabulary they will actually use, because a line they cannot carry into a session teaches them nothing.
IP.1 Given work whose information exceeds a single context window, determine what is supplied directly in the prompt, what is retrieved on demand, what is carried in external memory across sessions, and what is discarded, and preserve continuity across every boundary.
I can decide what goes in the context window, what Claude retrieves, what goes to external memory, and what gets dropped, without losing the thread.
Four drafted standards were one judgment wearing four names, and that judgment is deciding what information lives where. Kept apart, that judgment gets taught four separate times in three separate domains. Merged into IP.1, it becomes a single standard that recurs in all five task classes at rising depth. The same logic merged the two schema standards into SC.1.
The collapse is not bookkeeping. It changes the shape of the course for the better.
I can tell when a job needs an agent, when a fixed workflow is enough, and when it is just a conversation with Claude.
I can break a goal into subtasks Claude can actually run, and know which ones can go in parallel.
I can decide what the system is allowed to do on its own, enforce it in code instead of in a prompt, and name where a human has to sign off.
I can start Claude Code in a real project, get it oriented to the codebase, and finish a task without losing the thread.
I can predict which CLAUDE.md wins when memory files conflict, and write instructions Claude actually follows.
I can fix a prompt that is not working, and prove the change I made to the prompt is what fixed it.
I can build an eval set for a prompt, define how it is graded, and catch a regression before it ships.
I can write tool descriptions that route correctly, and debug why Claude picked the wrong tool.
I can scope an MCP server to least privilege, set up its auth, and define the versioning boundary before it ships.
I can build a retrieval pipeline instead of stuffing the context window, and cite what it returned.
I can decide what goes in the context window, what Claude retrieves, what goes to external memory, and what gets dropped, without losing the thread.
I can define the JSON schema on both sides of a tool boundary, and handle it when the output does not conform.
I can pick the right Claude model and the right surface for a job, and defend it on cost, latency, and quality rather than reaching for the biggest one.
The published domain percentages are sampling weights, meaning how many of a sixty-question exam get drawn from each area. That is a test-construction number, and a test samples for discrimination rather than for proportion. Orchestration patterns have crisp right answers you can put four options against. "You did not notice the context window silently dropped the middle of your document" is a bigger deal in practice and nearly impossible to ask in multiple choice.
So twenty-seven percent of the questions is not twenty-seven percent of the week. Every domain was judged across four axes that make the week answerable, namely how often you touch it, how badly it fails, whether it gates everything else, and how long the knowledge survives. The percentages below are a proposed pilot allocation reasoned from those judgments. They are not a mathematically derived score, and no numeric scorecard sits behind them.
Values are percentages of course weight; bars are scaled to the largest value (28%). Both columns sum to 100. The four axes are judged per domain and the reasoning is written out in full in 01-standards-ratified.md. That file is the source for the standards counts and the coverage map. The percentages themselves remain a proposed pilot allocation.
The spine is 4C/ID, van Merriënboer and Kirschner's model for teaching complex professional skill, chosen because it is built for whole-task learning rather than for topic coverage. Learners do complete, authentic builds from the first hour, simplified early and never fragmented. Everything else in the design exists to support that.
Mostly built. The learner finishes the last portion.
The whole task, with the reference card and hints on request.
The whole task, cold. The artifact is submitted with a written rationale.
All three are passes at the same whole task. Three steps of a task produces people who complete everything and cannot do the job. Three passes at a task produces people who can.
Support resets high at each new class and fades within it. A sawtooth, not a ramp. IP.1 appears in every class at rising depth; that spiral is the best structural feature in the course and it was bought by the standards collapse.
The threshold. Built out in full as Module 1 below.
Configuration, and the gap between an instruction written and an instruction followed.
Turn a recurring task into a tool another system can rely on.
Test sets, guardrails, escalation points, and retrieval instead of stuffing.
The capstone. The honest answer to several of its scenarios is that no agent is required.
Claude built the artifact. Assume it in every case. What gets graded is what the learner controls. The choice they made, the constraint they imposed, and the verification they ran. Every check is recall, never recognition, and every item rotates on cognitive demand rather than topic.
In the pilot, Max grades by hand. Every response receives three-part feedback anchored to a named rubric line, following the protocol used in the classroom version, namely specific praise, a specific push, and a guiding question. Revision is required and bounded, because unlimited retries against a grader turn into farming it for the answer. Escalation will be a manual rule in the pilot protocol once the verdict mapping and booking route are frozen during preflight, so a learner who keeps missing a power standard is told to book a call instead of being left to raise a hand. Struggling learners do not self-report.
Two things have to be settled before launch. The rubric-point-to-verdict mapping is not yet defined, and the escalation route needs a real booking destination.
Later, and not in this pilot. An automated grader is specified as a port of a skill-drill tutor already running in another product, carrying calibration, adaptive difficulty, a four-tier verdict, and structured output. It is not implemented. Its dry run against a deliberately failing submission produced two defensible verdicts from the same score, which is precisely why the pilot is graded by a person.
You are told: “Start every task with a fresh session so the context stays clean.” You are three hours into working on a file, and Claude has built up an understanding of how its pieces fit together. A new task arrives touching the same file.
Follow the instruction or refuse it. Either way, say what it costs you.
The competent answer refuses, because a fresh session discards exactly the understanding that makes the next task cheap. A learner who complies has demonstrated the one failure this whole assessment system exists to catch, which is doing what you were told with a very capable tool.
Module 1. Working in the terminal, on your own project.
A threshold, not a topic. The first module does one thing. It takes a person who believes the terminal is where they will break something, and it makes them a person who works there. Not a tour of a tool. A crossing, designed as one.
The first thing Claude touches is a real file the learner already cares about. Not a sandbox, not a toy repository. Something on screen that they wanted, inside the first five minutes.
Cycle two has them break something on purpose, in a place where it does not matter, and recover it twice before any risk touches their own work. The undo path comes before the risk does, every time.
The very first assessed item asks the learner to read the setup command and predict what it will do before running it. A course that opens with an unread paste has taught the opposite of what it claims.
One real change to one real file, confirmed by their own eyes.
Change something, see exactly what changed, put it back.
A project too big to paste. The first real judgment call in the course.
Request to checked result on their own project. This artifact is the crossing.
Top to bottom, in the order a learner meets it.
Three rules govern the sequence, and they are the reason this is five modules rather than twenty lessons.
Every module is a complete end-to-end build from the first hour, simplified early and never fragmented. What changes between modules is how much of the real problem is left in.
Scaffolding resets high at the start of every module and fades within it. A learner entering module 4 gets heavy support again, because the task is new even though the learner is not.
IP.1, deciding what information lives where, recurs in all five modules at rising depth, from what to show Claude in module 1 to external memory design in module 5. It is the only standard in every module, and it is what makes five modules read as one course.
Responsible for one real change to one real file, and for checking it themselves. No spaced check, because nothing precedes it.
Responsible for standing configuration, and for the gap between an instruction written and an instruction followed. Two spaced items, both pointing back at module 1.
Responsible for something reusable, and for constraining its output so a consumer can rely on it. Choosing between a command, a skill, and a subagent is the same judgment as agent against workflow against conversation, at smaller scale. Three spaced items.
Responsible for work that survives being wrong. An eval set, a guardrail enforced in code, a named human sign-off, and retrieval instead of a stuffed context window. Cost and governance open here, because neither is real until something runs unattended. Four spaced items.
Responsible for deciding what should exist at all. The capstone and the far-transfer summative, where the honest answer to a good number of the scenarios is that no agent is required. Five spaced items.
Module 1 is authored. Modules 2 through 5 are specified at the architecture level, with standards assigned, task classes named, and no material written. That gap is exactly what the build-or-stop decision after the pilot is about.
The curriculum architecture, authored first module, setup script, rubrics, and video outlines below are written and on disk. The setup script has been executed and tested on macOS, including its refusal paths. It has never been run on Windows or WSL, and the grading engine named below is a specification rather than working code. Section seven states every gap plainly.
Copy-paste launchers place the learner at each pass with fading scaffold, from near-finished, to starting state plus card, to a bare repository. The setup script is the install path, and it refuses to run against anything unsafe.
Steps live on a persistent card, never in video. Twelve gate items with rubrics and corrective paths are written, including the routes back to support when a gate is missed.
Segment maps and production rules are complete. Recording and editing remain a preflight gate.
NOW-LMS is live and themed. The courses visible on it today are placeholders, and none of them will be used for this pilot. The approved Module 1 package has not been loaded into a real pilot course, and no learner has run the path end to end on the platform. A live shell proves deployment and access. It does not prove that the course is ready.
The platform also cannot store the written answers and submitted artifacts this curriculum depends on, because its question model holds selected options only. For the manual pilot that means naming an external route for capturing written answers and returning feedback, which is part of preflight rather than a thing to discover during the pilot.
Module 1 is close enough to run that the fastest path to certainty is a pilot. One decision from Jeremy, and it is a yes or no on the pilot rather than on the curriculum design. The go-ahead is conditional. Preflight has to be complete by 7 August 2026, and if any gate fails then invitations do not go out and the 11 August start does not hold.
The decision needed: a conditional yes or a no from Jeremy, and if it is yes, five learner names by 8 August.
Eight gates. All eight pass or the start date moves.
If the answer is no, the useful version of that is which part does not hold, whether that is the premise that the artifact is not the evidence, the scope of the pilot, or the timing against everything else in flight.