Continuum
The discipline

Intent Engineering

A layer has opened above the editor. Its input is raw intent, its output is code verified on the remote, and the discipline in between is deciding what deserves a person. This page is the short version and the mapping: five claims, and the mechanism where Continuum makes each one checkable.

Writing code stopped being the scarce input. Well-formed intention became it. The work that decides an outcome now happens before an agent starts, turning demand into something executable, and after it stops, proving that what came back is what was asked for. Intent Engineering is the name for that work. Continuum is a workstation built for it, which means every claim below has to be a mechanism, not a belief.

The founding essay, for the long argument →

1

Demand arrives malformed.

A thread, a meeting, a feeling that a release is risky. None of it is executable. Turning it into ordered work is hours of unassisted thinking, and it is where the day actually goes.

a thread, a meeting note, an idea on the way out the same four things, in dependency order 1 2 3 4
Refinement adds no material. It gives the same four things an order, and each one an acceptance criterion.

What Continuum does about it. A captured signal is explored into findings, findings are resolved into decisions, decisions are written out as briefs a competent stranger could execute: what is in scope, what is not, what done means, what it waits for.

the line, stage by stage → · a real brief →

2

The session is not the unit of work.

A context window fills and the understanding built inside it ends. Anything that treats the conversation as the container loses the work when the container closes.

sessions: each one ends at the window, the next starts from nothing the task: one file on disk opens the next stage
The task crosses every break because each stage wrote down what the next one needs before it was allowed to open. The session is disposable by design; what it wrote down is not.

What Continuum does about it. The task is the unit. It moves through named stages, and each stage must leave a file on disk before the next may open. The next session resumes from files, not from memory.

what a task leaves behind → · modes and gates →

3

Judgment does not delegate. It concentrates.

More agents do not need less supervision. They need supervision worth interrupting a person for. Everything else has to be decided without you, and be inspectable afterwards.

decided without you, each with its criterion recorded stops and waits for you a scope call a fact only you know an outward-facing effect
Three kinds of decision cross to a person. Every other call is made with its criterion recorded and a link that reopens the exact moment: supervision scales by spending less judgment, not by delegating it.

What Continuum does about it. A scope call, a fact only you know, an outward-facing effect: those stop and wait, and reach you as a message. The rest moves, and leaves a receipt you can disagree with after lunch.

the rails → · receipts, defined →

4

Done is a claim until something checks it.

An agent that says it finished and an agent that finished look identical from the inside. Trust has to be replaced by a reading of something the agent does not control.

status: done checked against the remote origin/main sha 91e74f7 · read 18:04Z status: done the agent's own notes nothing under it to read
The two reports are identical; only one of them was measured against something the agent does not control. What could not be read reports as a gap, not as a pass.

What Continuum does about it. The verdict for a task comes from origin, never from the local checkout and never from the agent's own report. A task that publishes "done" against the evidence gets flagged instead of shipped.

a real ledger → · the scoreboard →

5

Context is the artifact. Code is the byproduct.

If the reasoning lives in a vendor's database, the work dies with the vendor. If it lives beside the code, it outlives every session, branch, machine and model that touched it.

your git the source the byproduct the work state YAML and markdown, no database one directory per task brief, stages, ledger the session the model vendor
Everything inside the box comes with a clone. Everything outside it can be replaced without the work losing anything.

What Continuum does about it. The path on disk is the structure: initiative, milestone, task. Anything that can read a directory can verify progress, including you, including a year from now.

three planes →

Where it goes next

The discipline is older than the tooling: people have been doing this by hand, badly, since the first agent finished a task nobody checked. What Continuum adds is that each of the five claims above is something a directory can prove. Read how the line runs, or open one real task and check the claims against it.