lauren
4.7 KiB
Steer with principle names
pstack ships 21 principles as individual skills. Each playbook carries the rules that matter for its work inline, at the step where they apply, and the root skill keeps the cross-cutting rules plus a pointer index it reads at the start of every multi-step task. The leaf skills are the deep references.
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. Naming one sends the agent to the leaf skill for the full treatment, not just the inline sentence it already met in the playbook.
The 21, 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.
- 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.
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.