← the whole session plugin/skills/aligned-build/SKILL.md

Use ONLY when explicitly invoked by name or when the person types /aligned-build. Forces the agent to surface its understanding of the request in writing and stop for human confirmation before any work begins — reflect at minimum, then align and nested-intent as task complexity warrants — then hands off to governer2 (or /governer if governer2 isn't set up) to build. Usable on its own as a harder confirm-before-you-build gate; the telemetry logging at the end is only for people running it as a measured experiment. NEVER auto-invoke.

Aligned Build

This is a general-purpose "confirm hard before building" command anyone can use — you do not need to be running any particular experiment to invoke it. Its author originally built it as the treatment arm of a personal study on compounding misalignment; that framing survives only in the optional telemetry step at the end (see "When this is running as an experiment").

Invocation rule — read this first

This skill never fires on its own. It runs only when the person types /aligned-build, or when an experiment protocol names it explicitly.

Auto-firing would insert confirmation gates into every session in the system, stalling agents on trivial requests and double-gating against the coherence and governer hooks that already run. If you are reading this file because it seemed relevant, stop — it was not invoked, and it does not apply.

What this is for

An agent receiving a request builds an understanding of it, and that understanding is not visible to anyone — including the agent, which experiences inference as comprehension rather than as guessing. Whatever is missing or wrong in it silently shapes everything built afterward.

This skill makes the understanding visible before it becomes work, so the human can correct it in a sentence rather than discover it in a finished artifact.

The sequence

Step 1 — Reflect (always runs, no exceptions)

Invoke /reflect on the request. Then print, under the heading ## MY UNDERSTANDING:

  • What you take the human to be asking for, in plain language, in their terms
  • What you believe the finished thing looks like when it is right
  • What you are treating as in scope and what you are treating as out
  • The assumptions you are operating on that the request did not state

Then stop and wait. Do not proceed. Do not begin research, do not read files toward the work, do not start a plan.

Print exactly:

⏸️  Waiting for your confirmation before I start. Correct anything that is off, or say go.

The human either confirms or corrects. If they correct, revise the understanding and print it again. Repeat until they confirm.

Step 2 — Align (runs when the task has more than one moving part)

Invoke /align. Print the confirmed intent decomposed into its parts — each part a specific outcome that can be checked, stated in terms of what will be true when it is done.

Stop and wait again. Same rule: no work, no research toward the work.

Step 3 — Nested intent (runs when the task spans multiple systems or will be handed to subagents)

Invoke /nested-intent2. Print the intent tree — the top goal, the sub-goals under it, and for each node enough of the intent that an agent reading only that node could act on it correctly.

Stop and wait again.

How many steps run

Step 1 always runs. Steps 2 and 3 run in proportion to the task:

  • Single deliverable, one system, no subagents → step 1 only
  • Multiple deliverables or multiple parts → steps 1 and 2
  • Spans systems, or work will be dispatched to subagents → all three

Judge this from the request itself and print which steps you are running and why before you run them. When uncertain, run the additional step — a confirmation costs the human a sentence, and a wrong foundation costs them the whole artifact.

Step 4 — Build

Once the human has confirmed the last gate that applies, invoke /governer2 and build. If /governer2 isn't set up on this machine (it ships off by default and says so when it halts), use /governer instead — same idea, the confirmed spec from steps 1-3 is what you build against either way.

The confirmed text from steps 1 through 3 is the specification. Where the work diverges from it, say so and say why — do not quietly widen or narrow what was agreed.

Rules

Never skip step 1, regardless of how obvious the request looks. An obvious-looking request is precisely where an unstated assumption goes unnoticed.

Never begin work while waiting at a gate. Waiting means waiting.

Never treat silence as confirmation.

State the understanding as a proposal the human reacts to, not as a question they answer. "What do you want" cannot be answered by someone whose intent is not fully formed. A specific reading can be corrected in seconds.

When this is running as an experiment arm

Log to .claude/logs/agent-telemetry.jsonl at each gate:

echo "{\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"event\":\"AlignedBuildGate\",\"step\":\"{reflect|align|nested-intent}\",\"outcome\":\"{confirmed|corrected}\",\"correctionText\":\"{first 200 chars if corrected}\"}" >> .claude/logs/agent-telemetry.jsonl

The corrections captured at these gates are the measurement. Each one is a misalignment that surfaced before it became work.