A 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. 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, so they remain the internal scaffolding of the whole curriculum.
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.
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 changes the shape of the course. One judgment, taught once and then revisited five times at rising depth, instead of four lookalikes taught separately.
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 start Claude Code in a real project, get it oriented to the codebase, and finish a task without losing the thread.
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 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 remaining eight, and all twenty-three in both registers, are in 01-standards-ratified.md.
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, set out below. 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 is a manual rule in the pilot protocol, so a learner who keeps missing a power standard is told to book a call rather than left to raise a hand.
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 tutor already running in another product, and 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.
The strongest item in module 1 is a judgment item of that last kind. It supplies a plausible instruction that is wrong for the situation the learner is in, and a learner who complies has demonstrated the one failure this assessment system exists to catch, which is doing what you were told with a very capable tool. The items themselves are held out of this document so they are not burned for anyone who reads it.
Module 1. Working in the terminal, on your own project.
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.
The first thing Claude touches is a real file the learner already cares about, on screen 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.
A standard is a competency. A target is the single thing one activity is for. These six cover the two standards this task class touches, CC.1 and IP.1.
Top to bottom, in the order a learner meets it.
The sequence follows three rules.
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.
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.
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.
Module 1 is close enough to run that the fastest path to certainty is a pilot. The decision is a yes or no on the pilot rather than on the curriculum design, and 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.
Roughly 27 to 31 hours in total, about half of it video. These are estimates rather than measured times.
Two of these need something from Intent. Gate 7 creates a course on learn.intentsolutions.io, which requires an account with course-creation rights, and gate 8 enrolls a test learner on it. Neither is possible without that access, so granting it is part of the yes.
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.