Curriculum
This curriculum is for builders using LLMs inside existing systems, where there are real constraints, real tests, real maintenance risk, and more than one plausible answer.
The failure mode is familiar: the model produces a decent-looking patch, the chat summary sounds confident, and nobody can tell whether the work actually served the aim. Intent was vague. Context was dumped instead of selected. Evidence came after implementation, if it came at all. Review became vibes. Dissent arrived too late. The next session has to rediscover everything.
The curriculum uses the same four nested loops as the README, with review, dissent, and salvage available as anytime checks:
| Loop | What happens |
|---|---|
| Ground the ask | State intent, fit the model to the task, supply selected context, and assemble a checkable prompt. |
| Frame the work | Map the problem space, choose the problem statement, and compare solution levels before implementing. |
| Execute with evidence | Define checks, delegate one bounded slice, verify behavior, review correctness, and stress fragile assumptions. |
| Preserve what should survive | Promote repeated procedures, use bounded subagents, extract durable knowledge, and salvage drifting runs. |
Those loops only become useful when the learner can preserve the decisions that matter:
- Intent Engineering states the behavior change before asking for output, then uses burst/pause/review instead of a single prompt-and-pray pass.
- Model-fit framing turns a vague ask into work the model can actually do: transform supplied context, compare options, critique against criteria, or expose missing context.
- Open Horizons skills make each phase a gate: what is allowed to move forward, what must stop, and what evidence would change the decision.
- Context packs select the project facts a future agent or reviewer needs, with provenance, constraints, landmines, and stop triggers.
- Prompt and context assembly combines the intent note, model-fit note, context pack, output contract, and reviewer checks into one request the model can answer without guessing.
- Problem statements narrow the terrain into one selected slice, rejected alternatives, and an invalidation signal.
- Authored skills capture a repeated local procedure only after the work shows it is worth preserving.
- Subagents create bounded roles when the work needs independent eyes, narrower tools, or isolated context.
- Evidence and evals define the trace, test, reviewer question, or runtime check before implementation starts.
- Knowledge extraction records the metis, signal, guardrail, outcome update, or ADR that a later session can actually consume.
How to use this curriculum
Use four passes. Do not turn them into homework for its own sake.
- Overview pass — read the grouped tables below and understand the sequence of decisions.
- Deep-dive pass — read the linked module when that skill is the active bottleneck.
- Reference pass — follow Go deeper links when you need source material, official mechanics, or a sharper model.
- Application pass — use
docs/tutorial.mdfor the builder loop, then focused tutorials for context-to-agent composition or eval design.
A good artifact is not a note-shaped souvenir. It preserves at least one decision, one assumption or evidence check, and the next consumer: another skill, subagent, reviewer, maintainer, or future session. Use Artifact Contracts as the standard. If an artifact cannot change the next action, shrink it, merge it, or delete it.
Overview curriculum
1. Ground the ask
| Module | Learner can do this | Artifact | Deep dive | Go deeper |
|---|---|---|---|---|
| Intent Engineering | Name the behavior change, use the model for a short burst, pause before commitment, and preserve the current understanding. | Intent note. | intent-engineering.md | Intent Engineering; Alignment Is the Constraint. |
| Model-fit framing | Reframe the ask so the model transforms supplied context instead of guessing missing facts. | Model-fit note. | model-fit.md | LLM Prompt Types; Anthropic context engineering. |
| Context construction | Build a selective context pack with provenance, constraints, landmines, and stop triggers instead of dumping the repo. | Context pack. | context-construction.md | The Context Stack. |
| Prompt and context assembly | Combine stable instructions, dynamic context, examples when needed, output contract, missing-evidence behavior, and reviewer checks. | Prompt assembly. | prompt-and-context.md | LLM Prompt Types; The Context Stack. |
2. Frame the work
| Module | Learner can do this | Artifact | Deep dive | Go deeper |
|---|---|---|---|---|
| Open Horizons phase skills | Use /aim, /problem-space, /problem-statement, /solution-space, /execute, /review, /dissent, and /salvage as gates that decide whether work may continue, stop, narrow, or restart. | Session artifacts. | open-horizons.md | Open Horizons; Open Horizons Skills. |
Problem space (/problem-space) | Map terrain: systems, stakeholders, constraints, assumptions, evidence, and blast radius. | Problem-space map. | problem-space.md | Documenting Strategy; Real-World Strategic Clarity. |
Problem statement (/problem-statement) | Narrow the map to one selected framing, name rejected framings, and define the evidence that would prove the framing wrong. | Selected problem statement. | problem-statement.md | problem-space.md; Documenting Strategy. |
Solution search (/solution-space) | Generate multiple solution levels, score them against the aim, and reject the nearest plausible patch when it does not change the failure mode. | Solution-space comparison with selected level. | beyond-nearest-peak.md | Beyond the Nearest Peak. |
3. Execute with evidence
| Module | Learner can do this | Artifact | Deep dive | Go deeper |
|---|---|---|---|---|
| Evidence and evals | Define checks before implementation, including the tempting patch that should fail if the problem is deeper. | Evidence checklist. | evidence-and-evals.md; evals-tutorial.md | Implementing SLOs for Data Quality; OpenAI evaluation best practices; Anthropic agent evals. |
| Agent brief | Turn aim, mechanism, feedback, guardrails, and selected solution level into an execution contract. | Agent brief. | agent-briefs.md | strategy-clarity.md; Alignment Is the Constraint. |
Execution (/execute) | Delegate one bounded implementation slice, keep the stop triggers visible, and detect drift before it compounds. | Patch or stopped execution report. | execution-review-salvage.md | /execute; The Salvage Loop. |
Verification and review (/review) | Check the work against evidence and aim, not the agent's summary or your desire for the patch to be done. | Review findings. | execution-review-salvage.md | /review; Dissent Mode. |
Dissent (/dissent) | Stress the accepted-looking answer, name the assumption that could break, and decide whether to proceed, adjust, or reconsider. | Dissent memo. | execution-review-salvage.md | Dissent Mode. |
4. Preserve what should survive
Skill and subagent authoring are listed here because their job is preservation. They are not mandatory after every run; promote only when a procedure or bounded role has proved reusable.
| Module | Learner can do this | Artifact | Deep dive | Go deeper |
|---|---|---|---|---|
| Skill authoring | Author a SKILL.md when the current project exposes a repeated procedure worth preserving. | Project skill. | authoring-skills.md | Claude Code Skills. |
| Subagent authoring | Author a specialized role when the work needs independent judgment, scoped tools, or isolated context. | Project subagent. | subagents.md | Claude Code Subagents. |
| Knowledge extraction | Record the metis, signal, guardrail, outcome update, or ADR that should constrain the next run. | .oh/ artifact or ADR. | knowledge-extraction.md | record artifact shape; The Context Stack. |
Salvage (/salvage) | Keep the learning and restart smaller when the run drifts, instead of defending the bad patch because it almost works. | Salvage note and restart plan. | execution-review-salvage.md | The Salvage Loop. |
Focused tutorials
| Tutorial | Combines | Artifact | Deep dive |
|---|---|---|---|
| Builder loop | Ground the ask, frame the work, execute with evidence, and preserve what should survive. | Builder-loop artifact set. | tutorial.md |
| Context to agent interface | Context Construction, Prompt and Context Assembly, Authoring Skills, and Authoring Subagents. | Context pack, prompt assembly, and promotion decision for project skill or subagent. | context-to-agent-tutorial.md |
| Eval design | Evidence and Evals, Agent Briefs, Review, and Knowledge Extraction. | Eval objective, fixture set, harness check, grader, threshold, action policy, and production signal. | evals-tutorial.md |
Open Horizons corpus applied
| Source | Curriculum use |
|---|---|
| Intent Engineering | Produces an intent note that can survive a burst, pause, structured pass, and review. |
| LLM Prompt Types | Separates model-suited transformations from brittle retrieval or closed-ended asks, then pairs the ask with context and evaluation criteria. |
| Open Horizons | Turns Aim / Do / Reflect into nested feedback loops, so every phase knows what signal it is preserving. |
| Alignment Is the Constraint | Requires every task, skill, subagent, and eval to carry aim, mechanism, feedback, and guardrail before speed can help. |
| Documenting Strategy | Treats artifacts as connected strategy and tactics, not loose notes. Every tactic should be necessary, viable, sufficient, and connected. |
| Real-World Strategic Clarity | Keeps outcomes, mechanisms, satisfaction criteria, and running logs tied together so the work can be checked later. |
| Beyond the Nearest Peak | Makes solution search observable: shallow breadth, score, select, deepen. Do not accept the first plausible patch just because it is close. |
| The Context Stack | Gives context a governance model: task identity, decision logs, provenance, guardrails, promotion paths, and agent-spawn forecasting. |
| Dissent Mode | Produces managed contradiction: dissent memos, safe-to-fail probes, stop-the-line triggers, and review that can change the decision. |
| The Salvage Loop | Treats the code draft as disposable and the learning as the asset. |
Why skills, subagents, and extraction are in the curriculum
A phase name is cheap. Naming /review does not make review happen. Naming /dissent does not mean anything got challenged.
The harness has to carry enough context that another agent, reviewer, or future you can audit the work without trusting the chat summary.
Skills preserve procedures when there is a procedure worth repeating:
- how to frame a project slice;
- how to compare solution levels;
- how to write a reviewable brief;
- how to run a fragile project-specific check;
- how to salvage a failed run without keeping the bad patch.
Subagents preserve roles when the work needs a different set of eyes or a narrower runtime boundary:
- independent reviewer;
- codebase scout;
- test-gap hunter;
- migration planner;
- release checker;
- domain-specific validator;
- knowledge extractor.
Knowledge extraction preserves learning when the next session should not have to rediscover it:
- metis: what we learned from doing the work;
- signal: what measurement tells us the outcome is moving;
- guardrail: what must not happen again;
- outcome update: what changed in status, mechanism, or affected files;
- ADR: what architectural decision now constrains future work.
Skills, subagents, and extraction exist to preserve judgment across sessions: the procedure, the role boundary, the evidence, and the learning that should change the next run. Open Horizons-shaped paperwork is failure in a nicer outfit.
Apply to a real slice
Use a real project with enough texture for judgment: tests, more than one subsystem, a known annoyance or recurring failure, and enough history that the debt is not hypothetical. If the project is blank, the exercise has no terrain. Pick a smaller real slice instead.
The learner improves that slice and leaves behind the artifacts the run actually earned:
- an intent note;
- a model-fit note;
- a context pack;
- a prompt assembly;
- problem-space and problem-statement artifacts;
- a solution-level comparison;
- evidence checks;
- an agent brief;
- a patch or stopped execution report;
- review and dissent findings;
- one durable knowledge artifact;
- a project skill or subagent only if the run exposed a reusable procedure or role boundary;
- a salvage note if the run drifted.
The next-session test is the standard: a new agent or maintainer should be able to read the artifacts, recover the aim, constraints, chosen framing, evidence checks, role boundaries, and failure modes, then continue the same project slice without rediscovering the whole problem. If the artifacts do not make that possible, the curriculum produced paperwork, not learning.