Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/saadshahd/moo.md

Stay present with AI. A Claude Code plugin that keeps you understanding what you sign to own.
https://github.com/saadshahd/moo.md

agentic-workflow claude-code claude-code-plugins claude-code-plugins-marketplace claude-code-skills decision-making interactive-agents

Last synced: 7 days ago
JSON representation

Stay present with AI. A Claude Code plugin that keeps you understanding what you sign to own.

Awesome Lists containing this project

README 

          
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](https://github.com/obra/superpowers).



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



## Try it



```bash

/plugin marketplace add saadshahd/moo.md

/plugin install hope@moo.md

```



- Run the whole loop with `/hope:full `, or run the stages directly: `/hope:intent ` then `/hope:shape `, 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 ``, 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 `` into a confirmed statement of what you want. `/shape` turns the `` into a chosen approach before any code exists.



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



![The loop](assets/loop.png)



## 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.



![freeze](assets/freeze.png)



## 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.



![Deciding stays, doing leaves](assets/delegate.png)



## 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.



![over](assets/over.png)



## 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](https://saadshahd.github.io/blog/the-engineers-anxiety-at-the-penalty-kick/) — "Ownership without comprehension is just a signature."

- [One Flew Over the Context Window](https://saadshahd.github.io/blog/one-flew-over-the-context-window/) — what the agent never carries between sessions.