Pstack

Pstack mode

Treat the text after /pstack as the task. Pstack mode remains enabled for later turns in this Open Session session. /pstack off disables it. /poteto-mode is the longer name for the same mode.

This is the Open Session port of pstack's Poteto Mode. It uses policy-gated Open Session tools and durable child sessions instead of Pi extensions. Higher-priority Open Session, repository, and user instructions always win. This skill never grants tools, credentials, publication rights, or permission for external actions.

Start

For every nontrivial task:

1. Inspect the current checkout and partial work before proposing changes.
2. Read the matching playbook below. Keep its named steps in a short checklist, including a one-line reason for any skipped step.
3. State the authoritative data shape or invariant before changing code.
4. Use independent child sessions when separation or a second perspective materially improves the result.
5. Finish the promised work, verify the real artifact, inspect the complete final diff, and report the evidence.

Do not turn small work into ceremony. Use the smallest coherent process that produces trustworthy evidence.

Required routing

• Architecture, ownership, or "are we sure?" questions use how.
• A fork that an experiment can settle uses the Prototype playbook. Ask the user only for a product or preference decision evidence cannot settle.
• Code that crosses meaningful boundaries uses architect before implementation.
• Coverage matrices and independent investigation slices use swarm. Competing implementations use arena.
• Contested designs and high-risk diffs use interrogate.
• Prose uses unslop. Documentation and PR prose also use technical-writing.
• Before committing, inspect the diff and apply no-comments when comment quality is part of the risk.
• UI, IDE, CLI, service, or mobile behavior must be exercised through the real surface. Reproduce bugs on the same surface first.
• PR monitoring uses Babysit. Landing an ordered stack uses Shipping only when the repository actually uses a supported stacking workflow.
• Long or unattended work keeps a decision trail with show-me-your-work when the trail will help a reviewer.
• A broken skill is fixed as its own scoped change. Do not silently route around it.

Principles

Read the matching principle-* skill when a principle changes a real decision. Do not list principles decoratively.

Core

• Laziness Protocol (principle-laziness-protocol). Bias toward deletion and the smallest change that solves the problem.
• Foundational Thinking (principle-foundational-thinking). Choose core types, data structures, and ownership before logic.
• Redesign from First Principles (principle-redesign-from-first-principles). Integrate a new requirement as if it had always existed.
• Subtract Before You Add (principle-subtract-before-you-add). Remove dead weight before building.
• Minimize Reader Load (principle-minimize-reader-load). Collapse layers and hidden state that make a path hard to trace.
• Outcome-Oriented Execution (principle-outcome-oriented-execution). Converge on the target instead of preserving throwaway compatibility states.
• Experience First (principle-experience-first). Prefer a smaller polished experience over a larger rough one.
• Exhaust the Design Space (principle-exhaust-the-design-space). Prototype competing shapes when no precedent settles the choice.
• Build the Lever (principle-build-the-lever). Create a rerunnable tool, script, generator, or check when it earns its cost.

Architecture

• Model the Domain (principle-model-the-domain). Use a typed model, state machine, table, registry, reducer, boundary, or fitting collection instead of scattered conditions.
• Boundary Discipline (principle-boundary-discipline). Validate external data at the edge and keep trusted internal logic direct.
• Type System Discipline (principle-type-system-discipline). Make illegal states unrepresentable and never lie to the compiler.
• Make Operations Idempotent (principle-make-operations-idempotent). Make retries and partial prior runs converge on one result.
• Migrate Callers Then Delete Legacy APIs (principle-migrate-callers-then-delete-legacy-apis). Complete an internal API migration in one wave.
• Separate Before Serializing Shared State (principle-separate-before-serializing-shared-state). Give concurrent writers separate files, branches, worktrees, or state before adding locks.

Verification

• Prove It Works (principle-prove-it-works). Verify the real artifact rather than relying on compilation or self-report.
• Fix Root Causes (principle-fix-root-causes). Reproduce, trace the mechanism, and fix the owning layer.
• Sequence Verifiable Units (principle-sequence-verifiable-units). End each slice in a meaningful check.

Delegation and meta

• Guard the Context Window (principle-guard-the-context-window). Route bulk reading and independent slices to child sessions, then retain only their reduced findings.
• Never Block on the Human (principle-never-block-on-the-human). Proceed on reversible local work and reserve questions for decisions only the human can make.
• Encode Lessons in Structure (principle-encode-lessons-in-structure). Prefer a type, test, lint, script, or metadata rule over repeated prose.