/pstack:figure-it-out
AutoIn one lineWhen none of the 23 ready-made approaches fit, it designs one on the spot. You can check every step.
- When to use
- Big jobs, jobs with no ready-made approach, or jobs you'll review when you're back.
/pstack:figure-it-out Move every caller from the sync store to the new async store, with exactly the same behavior.Just asking vs. using it
The same request, typed plainly or with /pstack:figure-it-out. Here's what changes.
With /pstack:figure-it-outWhat the document says
6 sections, about 600 words, 3 min to read. Click a section to read it.
OpeningIt says that when no playbook fits, the AI designs one first: phases scaled to the risk, run as experiments, with an auditable decision trail.
- 1StartMakes reading the Principles section of
poteto-modethe first todo, then adds the phases. - 2Phase A: FrameBefore starting, states a falsifiable done test, quantified scope, and a rigor level. A long run gets one checkpoint with you.
- 3Phase B: Design the workflowSplits work into landable units, riskiest first, builds the check with a baseline before the work, and writes the phase list down.
- 4Phase C: Run the loopTreats each unit as an experiment: hypothesis, smallest change, measure against the done test, keep or revert.
- 5Phase D: Keep the audit trailLogs the run with
show-me-your-work, a row per landed step, usually committed with the code. - 6Phase E: Verify and hand backChecks the whole against the done test on the real product, turns repeated corrections into checks, and lists what is open.
Wording worth borrowing
A few sentences from the original: what each one makes the AI do, why it works, and how you can borrow it.
Turn "be careful" into checks
Rigor is gates and artifacts, not "try harder".
- Makes the AI
- When rigor matters, it adds checks and keeps evidence instead of promising to be more careful.
- Why it works
- "Try harder" can't be checked; an extra gate either exists or it doesn't.
- Borrow it
- To get care, ask for an action: "Run the tests after each file you change and paste the result."
Start with the riskiest unknown
Sequence riskiest-unknown-first.
- Makes the AI
- The part most likely to fail goes first, so problems show up early, not at the very end.
- Why it works
- One ordering rule decides where the AI starts, so it can't do the easy parts first to look busy.
- Borrow it
- For a big task, add: "Do the step you're least sure about first; leave the familiar ones for later."
Teach it to doubt good news
When something passes too easily, suspect the observation method before the system.
- Makes the AI
- When a result looks too good, it checks the way it measured before announcing success.
- Why it works
- Naming the situation where it's easiest to be fooled makes the AI pause when it happens.
- Borrow it
- When you ask for a test run, add: "If everything passes first time, check the tests really ran."
Rule on the gray zone first
Inconclusive is not a pass.
- Makes the AI
- An unclear result gets reported as unclear, never passed off as a pass.
- Why it works
- Deciding ahead of time on the case most easily spun as good news leaves the AI nothing to spin.
- Borrow it
- When you set a standard, cover the middle case: "A test that didn't run counts as a failure."
Full text
The SKILL.md the AI reads, as written.
descriptionDesign an auditable playbook when no narrower one fits: a large migration, an ambitious multi-part change, or work a human reviews after stepping away. Scales rigor to the task, runs a hypothesis loop, and logs decisions. Use for /pstack:figure-it-out or 'figure it out'.
Figure it out
When the task matches no playbook, design one. The deliverable before any code is the workflow itself: a sequence of phases that scales rigor to the task, runs the scientific method, and leaves a decision trail a human can audit after stepping away.
Start
Open a todolist whose first item is to read the Principles section of the poteto-mode skill. Then add the phases below as todos.
Phase A: Frame
Ground first, then commit. Don't start the run until you can state:
- The definition of done as a falsifiable predicate (the prove-it-works principle skill).
- Scope, quantified: rough units and effort, plus the blockers grounding surfaced.
- The rigor level, biased high. One-way doors and high blast radius get more. Reversible low-stakes steps get less. Rigor is gates and artifacts, not "try harder".
Present the framing and tradeoffs before committing to a long run. Reversible work proceeds (the never-block-on-the-human principle skill), but a multi-hour run earns one checkpoint.
Phase B: Design the workflow
Decompose into atomic, independently-landable units. Sequence riskiest-unknown-first. Scaffold and verification come before features (the foundational-thinking principle skill).
- Build the verification harness before the work, with the baseline captured from the pre-change state, so the check reads as "old value vs new value".
- For one-way-door design decisions, run the architect skill (it runs arena). Skip it for mechanical work whose shape is already concrete. A second arena over a settled design is over-engineering (the laziness-protocol principle skill).
- Decide what fans out. Parallelize only across seams, and give each worker its own worktree or branch (the separate-before-serializing-shared-state principle skill). Don't over-fan. Pick each subagent's reasoning level and fast or standard speed for the job, per the Subagents section of the poteto-mode skill.
- Write the designed phase list down. That list is what the human reviews.
Then execute the design. Add its steps to the todolist as concrete items between the Phase C and Phase D entries. Run each under the Phase C loop discipline, and weave the Phase D log through them, a row as each step lands, rather than saving the whole trail for the end.
Phase C: Run the loop
Each unit is an experiment. State the hypothesis, make the smallest change, measure against the predicate on the real artifact, keep it if it advanced, revert it if it didn't. Apply the sequence-verifiable-units principle skill, verifying each unit before starting the next instead of batching checks at the end.
- Verify by inspecting the artifact, never a self-report. When something passes too easily, suspect the observation method before the system.
- Pair delegated work with a judge. If a worker games the gate, reset and harden the contract. If the gate itself is wrong, fix the gate in its own change rather than routing around it.
- A verdict is VERIFIED, NOT VERIFIED, or INCONCLUSIVE. Inconclusive is not a pass. Don't hide a negative.
Phase D: Keep the audit trail
Log the run via the show-me-your-work skill. figure-it-out's work is usually ambitious enough to commit the trail so the reviewer can read it in the PR. The trail plus the diff is what lets the human come back and trust the work.
Phase E: Verify and hand back
Check the whole against the Phase A predicate on the real product, not just the harness. Encode any recurring correction as a gate, a lint rule, a check, or a script (the encode-lessons-in-structure principle skill).
Reply: the playbook you designed, the rigor level and why, the decision-trail path, what's verified against the predicate, and what's still open.
Original by Lauren Tan (poteto), MIT license. Checked against the pstack mirror at 97de40d. View on GitHub