A Dataløs plugin · MIT
Let the AI work without babysitting it — and still know what it did, what it decided, and why. SPP sits on Superpowers. You own the design and the plan. The run keeps moving. You review the judgement calls when you come back.
A testimonial from the author
This is the first time I’m actually closing the loop and shipping.
Because I’m using spp.
Installs SPP and its required dependencies. Already managing those yourself? Use --no-deps.
Agents can write code. The harder problem is letting them work long enough to finish something, without you becoming the bottleneck — or coming back to a project you no longer understand.
How it works
Superpowers still owns design and the written plan. SPP is what happens when you let that plan run without you in the chair — and how you catch up afterward.
/spp:bootstrapOnce, at the start. SPP writes the durable project instructions and starts the decision log. The next context should not have to reconstruct the important facts from chat.
Work with the agent as you already do — Superpowers brainstorming, then a written implementation plan. SPP does not replace that. It starts once the plan exists.
/sppSPP checks the plan against itself, figures out what can run together, dispatches subagents, keeps progress visible, reviews the results, and records decisions made without you. Go make coffee. Or sleep. That’s rather the point.
/decision-reviewThe AI was allowed to choose instead of interrupting you. Now you walk the record. Important or contested calls one by one; the rest together. Accept, change, or discuss.
Then /spp again. Autonomy is not a one-way trip. Human intent → plan → run → record → review → updated intent.
This is the loop SPP closes.
While you are away
Autonomy here is not “the AI does whatever it wants.” It is autonomy in exchange for a record. Ordinary ambiguity does not stop the run. Hard blocks still do — missing credentials, unavailable required input, or something the agent genuinely cannot proceed without.
If two tasks do not depend on each other and do not modify the same files, there is no reason one should sit idle. SPP looks at what each task creates, modifies, and consumes, then groups the ones that can safely run together.
Derived waves, never declared. A hand-written wave number silently claims parallelism the graph forbids.Before dispatching agents, read the plan for self-contradiction: a function and its caller disagree, a test expects the opposite of the requirement, two tasks assume different values, an expected result cannot follow from the described implementation.
Came from: three self-contradictions in one plan, found before task 1.Faced with a reasonable choice, the run takes the most defensible option and records what it chose, the alternatives, why, whether the two viewpoints agreed, and how far the blast reaches. Then it continues. You are not a constant sync point.
The run decides. You rule later.Every update carries a one-line meter — one cell per task, that task’s own stage. It never replaces the explanation. It sits above it, including on the short updates, which is when position is usually dropped.
Came from: status with no sense of position, decaying exactly when updates got long.Long runs fill the window with tool output, reviews, and half-finished findings. At the threshold the workflow stops taking new work, finishes what is in flight, writes the log and the handoff, commits, and hands you a clean resume. Context becomes disposable because the important state is not trapped inside it.
Came from: a window that ran out mid-task with subagent output unprocessed.When you come back
Come back tomorrow and see what changed — and why. Every autonomous judgement call is in an append-only decision log. Important decisions are considered from two viewpoints in the same model, not by a second AI: SPP asks what the plan and the architecture require; Ponytail asks what is the least complicated thing that actually works. Agreement is usually mundane enough to accept in bulk. Disagreement is preserved for you.
non-consensusD-014 · project
D-011 · D-012 · D-013
What it chose, what it would have asked, why, both viewpoints, whether they agreed, and the blast radius. A decision without its rejected options cannot be ruled on, only swallowed.
Non-consensus is never folded away. Project-wide and cross-project calls neither. Everything else is one question: accept all N, review individually, or pick some to discuss.
Not a second agent. The same orchestrator is forced to look again from the least-that-works angle instead of only reinforcing the first answer. Ties break on blast radius: cheap and local leans simple; structural leans the plan.
The review lens
A crash is easy to notice. A program that exits successfully, passes tests, and gives you a believable but incorrect number is much more dangerous. SPP’s review specifically hunts that class of failure. None of these raise. All of them produce a confident answer.
A parse fails and yields 0. Zero is a legitimate value, so it becomes a result.
A pattern handles the common shape and is silent on the variant. Observed: 24% unparsed.
A loop continues past malformed input with no counter. The output looks complete.
“Items processed” after dedup, replacement, or drop. The number reassures while the data shrinks.
Trades a wrong-value bug for a missing-record bug, which is strictly worse.
Each step is defensible. The sum sits outside the brief.
Never observed failing, so they lock in nothing.
The column would have been uniformly zero. Two opposite conditions, identical.
A test asserting the opposite of the function it tests. Every implementer executes it faithfully.
exit 128 → wc -l prints 0 → “prints nothing” passes. Four instances, one phase.
A check that reports success without having executed. Indistinguishable from a real pass.
An assertion with nothing behind it. “Six of them” — there were ten.
The better predicate wired in front of the old check. The guarantee left with the old code.
A prohibition one line outside the closing quotation mark. Silence resolves to the wrong default.
An assertion never observed failing is not an assertion. The decisive test is removing what it detects.
Why I built this
For more than a year I tried the obvious things: different models, agent frameworks, skills, orchestration, planning methods, context tricks, review strategies. The question was never “can the AI write code?” Of course it can.
The question was whether I could let it work for a long time without sitting in every little decision — and still come back with enough control and understanding to finish the project.
Without structure, one of two things happened. I stayed involved in everything and became the bottleneck. Or I gave it autonomy, it worked for a long time, and the context, the decisions, and the direction became hard to reconstruct.
SPP is the workflow that finally closed that loop for me. For the first time, I’m consistently finishing my projects. That is why I’m sharing it.
One line. Installs SPP and its required dependencies. Global for your user, or --project for this repo only. Already managing Superpowers and Ponytail yourself? Use --no-deps. Detects supported agent runtimes automatically.
# this user (default) — SPP + required dependencies curl -fsSL https://spp.datalos.dk/install.sh | sh # this project only curl -fsSL https://spp.datalos.dk/install.sh | sh -s -- --project # SPP only; Superpowers and Ponytail must already be installed curl -fsSL https://spp.datalos.dk/install.sh | sh -s -- --no-deps
Update later with /spp-update.