Introduction
You don't need a week to understand COMPASS. You need one hour and the right mental model. This module gives you the shape of the whole methodology so the rest of the track has somewhere to hang.
By the end you should be able to name the seven phases, explain the three fidelity levels, list the six transformations that move work forward, and say — without hand-waving — where ATLAS fits.
What you'll be able to do by the end
- Recite the seven COMPASS phases and what each one decides
- Explain why the same phases run at three different fidelity levels
- Trace a feature from a one-line request to a shipped release through six named transformations
- Place ATLAS as the shared source of truth, not "another tool"
1. Methodology, toolkit, infrastructure
Three things get confused constantly. Keep them separate:
| Pillar | What it is | What it is not |
|---|---|---|
| COMPASS | The methodology — the phases, gates, and artifacts that structure agentic delivery | Not a tool you install |
| Claude Code & co. | The toolkit — the agents and editors that do the work | Not the process |
| ATLAS | The infrastructure — where COMPASS state actually lives and is governed | Not the methodology, not the editor |
COMPASS is the how. The toolkit is the what you type into. ATLAS is the where the shared state lives. A team can know the methodology and still fail if every person's work evaporates into private chat history — which is exactly the gap ATLAS closes.
2. The seven phases
COMPASS encodes seven phases as its name:
Clarify · Observe · Model · Partition · Arrange · Synthesise · Ship
Each phase produces distinct outputs that feed the next, and each ends in a decision gate — an explicit checkpoint where you decide whether the outputs are good enough to proceed.
| # | Phase | Decides | Output |
|---|---|---|---|
| 1 | Clarify | What we're building and why it matters | Problem statement, vision, constraints, success criteria |
| 2 | Observe | What context we need before designing | Research findings, risk & assumption register, feasibility |
| 3 | Model | How the solution looks | Architecture, tech decisions, quality & delivery strategy |
| 4 | Partition | How to divide the work | Work breakdown, dependencies, acceptance criteria |
| 5 | Arrange | The exact plan to execute | Detailed implementation plans, verification checkpoints |
| 6 | Synthesise | Building and verifying it | Working, tested code; review records |
| 7 | Ship | Getting it to production safely | Deployed software, monitoring, release records |
Learning — the magnetic north
There's an eighth activity that isn't a phase: Learning. It doesn't sit on the path; it orbits every pass. Like magnetic north on a compass, it's the reference point that keeps the process calibrated — retros, captured patterns, measured outcomes that feed the next cycle's Clarify.
The one-line version Clarify why, Observe the context, Model the how, Partition the work, Arrange the plan, Synthesise the code, Ship to production — and Learn across every pass.
3. Move forward by default, retreat when evidence demands it
COMPASS is sequential but not rigid. Every phase has an explicit retreat condition — a trigger to step back when reality contradicts an earlier decision.
| At this phase | Retreat to | When |
|---|---|---|
| Observe | Clarify | The problem is fundamentally different than assumed |
| Model | Observe | Unknown technical constraints or untested assumptions surface |
| Partition | Model | The architecture won't decompose cleanly |
| Arrange | Partition | A work unit is too large or hides dependencies |
| Synthesise | Arrange | The plan is wrong or incomplete |
| Ship | Synthesise | Environment-specific issues slip past verification |
The principle: move forward by default, retreat when evidence demands it. A retreat isn't failure — it's the process working. Silently pushing a bad design forward is the failure.
4. Three fidelity levels
Here's the part people miss: the seven phases aren't a single-use sequence. They're a repeatable pattern you can run at different depths.
| Fidelity | Purpose | Primary output |
|---|---|---|
| Discovery | Establish a credible commitment (feasibility, estimate) | Proposal, high-level plan |
| Definition | Define the solution precisely enough to start building | Architecture, specs, detailed plans |
| Execution | Build, verify, deliver working software | Software in production |
Same phases, increasing depth. Critically, lower-fidelity outputs aren't thrown away — a Discovery-pass architecture sketch becomes the starting input for the Definition pass, which becomes the input for Execution. Each pass reduces uncertainty at its level. Presale is just a Discovery-fidelity pass through the same phases.
Not every project needs all three. A solo project might run one Execution pass; an enterprise engagement runs all three.
5. Six transformations — the artifact lineage
Inside ATLAS, a unit of work is a Journey: a lineage of artifacts that evolves through the phases, starting from a root feature_request. Six named transformations move that lineage forward, each producing a new linked artifact:
feature_request
│ enrich (deepen the request in place, within Observe)
▼
feature_request (v+1)
│ evolve (Observe → Model)
▼
feature_specification
│ decompose (Model → Partition)
▼
user_story ×N
│ plan (Partition → Arrange)
▼
implementation_plan
│ execute (Arrange → Synthesise)
▼
code_and_tests
│ converge (Synthesise → Ship)
▼
release_artifacts
That's the whole spine of delivery in six moves. The artifacts link to each other (derives_from, implements) so you can always trace a line of code back to the sentence in the feature request that justified it. Module 04 walks this chain hands-on.
6. Where ATLAS fits
ATLAS is the shared brain for a project. Its core premise:
Same data, same business logic, two entry points. Every teammate's Claude Code session reads and writes the same project state over MCP; humans see and act on that same state through a web app.
- Agents operate through the MCP server — sessions, artifacts, journeys, gates, handoffs.
- Humans operate through the web app — the phase board, gate ceremonies, reviews, the audit trail.
The methodology says advance through a gate when the criteria are met; ATLAS is where that gate actually exists, where the reviewers actually approve, and where the journey actually advances — atomically, with an audit trail. Without a shared source of truth, COMPASS is a nice diagram. With ATLAS, it's an operating system.
Recap — self-check
You've got this module if you can answer, out loud:
- What are the seven phases, in order, and what does each decide?
- Why does the same sequence run at Discovery, Definition, and Execution fidelity — and what happens to a lower-fidelity pass's outputs?
- Name the six transformations and the artifact each produces.
- In one sentence: what is ATLAS, and why can't COMPASS run on chat history alone?
If any answer is shaky, re-read that section before moving on. Module 02 turns to the skill that powers every phase: prompting that produces delivery-grade output.