The Promise
Stop prompting. Start briefing. Ship a deployed artifact overnight while you sleep — without waking up to a half-built mess and 40 clarifying questions.
The One-Sentence Setup
Most operators think the bottleneck is AI capability. The bottleneck is the spec the operator hands the AI — a prompt is a question, a brief is a contract.
The Core Insight
A prompt invites collaboration. A brief defines done. When the operator stays in the loop — typing, nudging, re-explaining — autonomy never happens, and the AI never gets past Level 2 on the Autonomy Ladder. The Hand-off Brief is the artifact that unlocks Level 4: the operator hands over a self-contained document, walks away, and comes back to deliverables. It works because it removes every reason for the AI to stop and ask: mission, settled facts, build order, guardrails, deliverable format. The briefs that produced a deployed landing page + funding playbook + Phase 0 codebase overnight were 4,000+ words. That length is not bloat. It is the price of autonomy.
The Mechanism — the 8 sections every brief contains
1. Who + Role + Authority
The first lines of the file. "You are Claude Code running on the operator's Mac. Full system permissions. Do not ask for approval. Execute." Posture is set in the first paragraph or the AI defaults to permission-seeking forever. Miss this and the AI asks before every file write.
2. The Mission
One paragraph. What done looks like in a single sentence, then the constraint, then the budget, then the deadline. If the operator cannot fit "done" into one sentence, the brief is not ready to send. Miss this and the AI optimizes for the wrong outcome — usually "be thorough" instead of "ship the thing."
3. The Read-First Files
A numbered list of files the AI must read before touching anything. Forces context loading. References Memory Architecture files, prior briefs, reference PDFs. Miss this and the AI re-discovers context the operator already wrote down, burning tokens and getting half of it wrong.
4. The Settled Facts (do not re-litigate)
A table of decisions already made. Tool choice, vendor choice, architecture choice, pricing, tier structure — anything the operator does not want re-argued. This single section saves roughly 30% of wasted cycles. Miss this and the AI helpfully proposes alternatives the operator already rejected six weeks ago.
5. The Autonomous Build Order
Numbered, sequential steps. Each step gets an explicit deliverable path and a success criterion. Parallelizable steps get a note: "dispatch in parallel." Numbered so the AI can checkpoint progress and the operator can audit it in the morning. Miss this and the AI builds in some order that makes sense to it — usually breadth-first when the operator needed depth-first.
6. Constraints + Guardrails
What the AI must not do. No purchases. No emails on the operator's behalf. No public deploys. No touching specific firewalled folders. This section names the Autonomy Ladder level for this specific mission. Miss this and the AI makes one judgment call that costs the operator a vendor relationship, a domain, or a privacy breach.
7. The Assumptions Log
An instruction: when the AI makes a judgment call that affects the deliverable, log it to ASSUMPTIONS.md. The operator reads this log in the morning and corrects what is wrong before it compounds. Miss this and the AI makes 200 invisible decisions in four hours. None of them are auditable.
8. The Morning Hand-off Spec
The exact format of the deliverable summary the AI writes at the end. TL;DR. Three actions for today. Three decisions only the operator can make. Folder map. What is not done. Without this, the operator gets thirty markdown files and no idea what shipped. Miss this and the operator wakes up to a pile of artifacts and spends an hour figuring out what happened overnight.
The Writing Process (5 steps, do them in order)
- Write the mission sentence first. If done cannot fit in one sentence, the brief is not ready. Stop. Think harder.
- List every decision already made. Label it "Settled Facts — Do Not Re-Litigate." This is the section operators forget. It is also the section that produces the biggest speed-up.
- Number the build steps. Sequential is fine. Parallelizable ones get a tag. The numbers exist so the AI can write "Step 4 complete" to a progress log.
- Write guardrails last. Counterintuitive. Writing them first makes them feel paranoid. Writing them after the build plan makes them feel like the boundaries on a clear-eyed plan, which they are.
- Specify the deliverable format. Exact filename. Exact section headings. Exact one-line description per artifact. Without this, the output is prose. With it, the output is a status doc.
The Pitfalls
- The Prompt-Instead-of-Brief Trap. Four sentences instead of four pages. The AI fills the gap with assumptions, and they are not the operator's assumptions. Fix: if the spec is under 500 words, it is a prompt, not a brief — keep writing.
- The Over-Prescription Trap. Every step micro-managed at line-of-code resolution. The AI loses room for judgment and ships worse than if the operator had named the mission and stepped back. Fix: prescribe the what and the why, not the how — unless the how is genuinely settled.
- The Unstated Authority Trap. The brief never says "act, don't ask," so the AI defaults to asking permission for every file write. Fix: paste the explicit authority line at the top — "Full system permissions. Do not ask for approval. Execute."
- The Missing Assumptions Log Trap. The AI makes hundreds of judgment calls in a four-hour run. None are recorded. The operator cannot audit them and they compound into a deliverable that is 80% right and 20% wrong in invisible ways. Fix: one line in the brief — "Log every assumption to ASSUMPTIONS.md."
- The No-Deliverable-Spec Trap. The operator wakes up to thirty markdown files and no map. Fix: section 8 of every brief — the Morning Hand-off Spec, with the exact filename and structure of the summary the AI writes at end.
The Drill (this week)
Take one work item on the plate right now — a landing page, a launch playbook, a research dossier, anything currently sitting at "I'll get to it." Open a new file. Write the 8 sections. Do not skip Settled Facts. Do not skip the Morning Hand-off Spec. Aim for 1,500-3,000 words. Save it as BRIEF-[work-item].md in the Operator Vault. Hand it to Claude Code with --dangerously-skip-permissions. Walk away for two hours. Read the morning brief when the run finishes. Measure: how many clarifying questions did the AI ask? Goal — zero.
The Tools
| Tool | What it does | Notes |
|---|---|---|
Claude Code (--dangerously-skip-permissions) | The executor the brief targets | Full system permissions on the operator's machine |
BRIEF.md template | Reusable skeleton in the Operator Vault | One template, the 8 sections pre-filled |
ASSUMPTIONS.md | Companion file the AI writes during execution | Operator reads it in the morning |
MORNING-BRIEF.md | End-of-session deliverable | Exact structure specified in section 8 |
| Anthropic prompt caching | Briefs cache cleanly across runs | Cuts cost on long-context iteration |
Cross-references
- The 4-Surface AI Stack — Briefs live in the Reason surface and orchestrate work across Act + Remember.
- The Orchestrator + Sub-Agent Pattern — The orchestrator (Coach) uses briefs to dispatch sub-agents, including the brief that produced this framework.
- The Autonomy Ladder — Every brief specifies the autonomy level for the mission inside it.
- The Persona Cascade — The AI executing the brief has its own persona; the brief sets posture and authority on top of that.
- The Memory Architecture — Briefs reference Memory files in the Read-First Files list.
One framework. One drill. One week at a time.
The Operator Stack is the architecture. Verala is the practice that runs it on your own communication delivery — voice, pitch, pause, presence. One foundation per week, until it's automatic.
Take the free 5-Foundation Voice Audit → · Book a 30-min intro call →