Skip to content
  1. Skills at a glance
  2. Design and review
  3. /pstack:figure-it-out

/pstack:figure-it-out

Auto

In 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.
Say it like this
/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.

Just askingWith /pstack:figure-it-out
Starts coding the big task right away.Hands over a phase list first, with a done test and a rigor level.
Trusts its own report that the work is done.Inspects the real artifact and marks VERIFIED, NOT VERIFIED, or INCONCLUSIVE.
Saves all the checking for the end.Measures each small change against the done test and reverts what didn't help.

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

  1. 1StartMakes reading the Principles section of poteto-mode the first todo, then adds the phases.
  2. 2Phase A: FrameBefore starting, states a falsifiable done test, quantified scope, and a rigor level. A long run gets one checkpoint with you.
  3. 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.
  4. 4Phase C: Run the loopTreats each unit as an experiment: hypothesis, smallest change, measure against the done test, keep or revert.
  5. 5Phase D: Keep the audit trailLogs the run with show-me-your-work, a row per landed step, usually committed with the code.
  6. 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.

See the wording worth borrowingRead the full text

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.

  1. 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."
  2. 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."
  3. 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."
  4. 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

An unofficial beginner's guide to pstack, not its official docs. pstack is made by poteto; the official repo is the source of truth for commands and behavior. The original guide source is on GitHub.

Hosted by airali. Adapted from Xiaoxiaodong's MIT-licensed guide.