Why introduce friction? Because YOU the human end up being the world model. The agent is just your hands.

moo/hope doesn't build, and doesn't author your code, rules, or taste. It works alongside build tooling like superpowers.

One idea runs through all three layers: never delegate a decision.

Try it

/plugin marketplace add saadshahd/moo.md
/plugin install hope@moo.md

• Run the whole loop with /hope:full <your seed>, or run the stages directly: /hope:intent <your seed> then /hope:shape <your intent>, each handing you a lean card.
• For work you used to do by hand, /hope:delegate routes it to agents while you keep every decision.
• When work depends on live external state, /hope:freeze snapshots it as fact (never memory) before a stage builds on it.
• As the work lands, /hope:over hands each load-bearing decision back so you reason it into your own model.

A loop

The loop is pure decision work. You drive it slowly, in your own context.

Every piece of work starts as a raw <seed>, the rough thing you fully typed. It is the one artifact that is fully yours.

/intent and /shape do not make the seed more honest. They make it explicit and specified. Each surfaces a decision as an interactive question, every choice previewed, a few at a time, and you answer. Every added detail stays yours because you chose it. /intent turns the <seed> into a confirmed statement of what you want. /shape turns the <intent card> into a chosen approach before any code exists.

The outcome is a card you carry comfortably outside the context window.

An anchor

freeze anchors the work to what is observed, not what you remember. When a stage depends on state that lives outside the repo — a service, a database, a queue, live logs — that state keeps moving, and memory of it goes stale the moment you look away.

freeze snaps the slice your work touches into one immutable value: every fact observed live or named as an open gap, never inferred. The stages decide against a fact, not a guess. It is the ground the other three stand on — and repo-local work skips it.

A mode

delegate is the line between deciding and doing.

You keep every decision. Each one is surfaced to you so you stay engaged. Only tactical, observable work fans out to agents: implement, test, verify, audit, explore.

This is also what stops compaction from silently rewriting your context. The verbose doing never enters your main thread, so it can never quietly mutate what you decided.

A discipline

over hands a decision back the moment it lands — in-flow, as soon as the work is done, never banked to the end. The agents that did the work are short-lived; what they carried vanishes with them, so the decision has to come back to you right away.

Agents grow the codebase faster than they grow your understanding of it. That gap is the part you are accountable for. over closes it. It finds what was load-bearing and hands each decision back as one forward question — you reason it into your own mental model, it confirms once. A short conversation, no score.

What the agent never carries is what over hands back.

Overview

The trap	Layer	Guard
AI fills in your decisions	/hope:intent & /hope:shape	interactive questions, each choice previewed
compaction mutates & drifts your context	/hope:delegate	doing stays out, deciding stays in
stale or remembered external state	/hope:freeze	snapshot facts, never infer
code grows faster than understanding	/hope:over	hand each decision back in-flow, you reason it into your own model

Reading

• The Engineer's Anxiety at the Penalty Kick — "Ownership without comprehension is just a signature."
• One Flew Over the Context Window — what the agent never carries between sessions.