cursor__plugins/pstack/docs/guide/08-principles.md

Steer with principle names

pstack ships 23 principles as individual skills. /poteto-mode reads their index at the start of every multi-step task, applies the ones the task triggers, and names each applied principle in its reply along with the decision it changed.

You don't invoke principles. You use their names to steer. Each name points at a complete rule the agent has already read, so one phrase redirects the work more precisely than a paragraph of instructions.

Steering in practice

Say the agent is about to bolt a new adapter onto three existing ones:

use subtract before you add. delete the obsolete adapters first, then design what's left.

Say it claims success because the build passed:

apply prove it works. run the real import flow and show me the written records.

Say two parallel attempts are about to write to the same branch:

separate before serializing shared state. give each attempt its own worktree, no locks.

Each phrase lands because the rule behind it is specific. The agent still has to say, in its reply, which decision the rule changed. A principle citation with no decision behind it is the tell that it name-dropped instead of applying.

The 23, briefly

The core principles decide how much to build and when to rethink the design:

• Laziness Protocol prefers deletion and the smallest change that solves the problem.
• Foundational Thinking chooses the core data structures before writing logic.
• Redesign from First Principles integrates a new requirement as if it had been there from day one.
• Attack the Premise questions the premise that two or more failed fixes shared, after a census of which actors hold the imbalance.
• Subtract Before You Add removes dead weight before building on top of it.
• Minimize Reader Load collapses layers and hidden state a reader must hold in their head.
• Outcome-Oriented Execution converges rewrites on the target design instead of preserving throwaway compatibility states.
• Experience First chooses the user's result over implementation convenience.
• Exhaust the Design Space builds two or three competing prototypes when there's no precedent.
• Build the Lever builds the script that does or proves the work, so a reviewer can rerun it.

The architecture principles decide where state, validation, and compatibility live:

• Model the Domain encodes repeated rules in one structure, not scattered conditionals.
• Boundary Discipline validates at the boundary and trusts internal types.
• Type System Discipline makes illegal states unrepresentable.
• Make Operations Idempotent converges retries on the same end state.
• Migrate Callers Then Delete Legacy APIs migrates and deletes in one wave.
• Separate Before Serializing Shared State removes the sharing before adding coordination.

The verification principles define what counts as proof:

• Prove It Works verifies the real artifact, not a proxy.
• Fix Root Causes reproduces and traces to the cause before changing code.
• Sequence Work into Verifiable Units ends each small unit in a check before starting the next.
• Test Behavior, Not Implementation calls the code the way its users do and asserts a literal expected value, and deletes a test that would still pass if every imported function returned undefined.

The delegation principles keep parallel work sane:

• Guard the Context Window routes bulk reading to subagents and keeps findings in the main chat.
• Never Block on the Human proceeds on reversible work and presents the result.

And one meta principle:

• Encode Lessons in Structure turns advice you've repeated twice into a lint, check, or script.

Don't memorize the list. Skim it now, then come back when you catch the agent doing something a name here would have prevented. That's how the vocabulary sticks.

Next: Make it yours.