Premises and Thinking
This chapter covers 6 principles that matter before and during the first decisions of a task: which assumption to question, what to settle first, how widely to explore, and when to stop adding. A principle is a named pstack rule stored in its own skill file (its leaf); /poteto-mode reads the index of all principles and applies the ones a task triggers. The Principles Overview explains that mechanism.
Attack the Premise (principle-attack-the-premise)
Source: skills/principle-attack-the-premise/SKILL.md
- Rule: once 2 or more fixes that rest on the same premise have failed at the same gate, the leaf tells the agent to doubt the premise itself. The individual fixes are no longer the suspect.
- Method: write the premise down as the single sentence every failed fix assumed. Then, before attempting another fix, test that sentence: find an observation whose outcome would differ if the premise were false, and make it. Examine how the failures are distributed as well as how large they are.
- When the premise falls: look for what the failures have in common that the premise did not predict. If one component always ends up on the losing side, change whatever places it there; adding a mechanism that cleans up after it is the wrong response.
- Steering: the leaf is explicit that no new fix should begin until the premise has been written down and tested. Asking the agent to “state the premise in one sentence before the next fix” holds it to that order.
Foundational Thinking (principle-foundational-thinking)
Source: skills/principle-foundational-thinking/SKILL.md
- Rule: settle the shape of the data before writing logic. Define the core types early, trace every access pattern, and choose structures that suit the dominant paths. Remove duplication at the level of structure; there is no need to deduplicate every line.
- Shared state: before letting several actors share state, ask what would happen if another actor changed it at the same moment. Unless the answer is “nothing”, isolate the state.
- Scaffold first: after dead code has been removed, build whatever helps every later phase (CI, tests, shared types) before the features themselves. Commits stay small and single-purpose.
- Promise and steering: the description states the payoff: with the right data structures, the code downstream becomes obvious. You can ask to see the types and data structures before any logic is written, which makes this ordering visible.
Redesign from First Principles (principle-redesign-from-first-principles)
Source: skills/principle-redesign-from-first-principles/SKILL.md
- Rule: when a new requirement arrives, avoid bolting it onto the current design. Redesign as though the requirement had been a foundational assumption from the beginning.
- Method:
- Read every affected file and understand the existing design.
- Ask the leaf’s question: “if we were writing this from scratch with this new requirement, what would we build?”
- Propagate the change to every reference, including types, docs, examples, and rationale sections.
- Plan the whole redesign, then deliver it in increments.
- Purpose: the leaf presents this as the way to preserve option value while changes accumulate in an existing design.
- Steering: when a diff looks patched on, ask the agent to redesign from first principles and to answer the from-scratch question explicitly.
Exhaust the Design Space (principle-exhaust-the-design-space)
Source: skills/principle-exhaust-the-design-space/SKILL.md
- Rule: faced with a novel UI interaction or architectural decision for which the codebase offers no precedent, build 2 or 3 competing prototypes and compare them side by side before committing to one.
- Scope: the leaf extends the rule to product design decisions where the user experience depends on feel more than on logic.
- Steering: a request such as “build 3 options and compare them” brings this principle into play. It is most useful when the agent is about to settle an unprecedented decision with a single proposal.
Model the Domain (principle-model-the-domain)
Source: skills/principle-model-the-domain/SKILL.md
-
Rule: express the domain as a data structure instead of spreading it across conditionals. A well-chosen structure makes invalid states impossible to represent and removes branches altogether.
-
Typical substitutions:
Instead of Use Scattered booleans or phase checks A state machine Loose parameters A typed model Branching spread across files A map, registry, or discriminated union Ad hoc mutations A reducer An access pattern the current collection serves poorly An index, queue, or normalized collection -
Limits: the leaf warns against forcing a structure. Boring code is fine when the shape is clear, local, and unlikely to grow. An abstraction that adds indirection without removing any branches or invalid states deserves suspicion.
-
Warning signs: a feature that lengthens an if/else chain by one more branch, or a second boolean that must be kept in sync with the first, shows that this principle was skipped. Asking “could this branch be expressed as structure?” is a natural way to steer.
Laziness Protocol (principle-laziness-protocol)
Source: skills/principle-laziness-protocol/SKILL.md
- Rule: favor deletion and the smallest change that solves the problem. The principle applies while refactoring, while judging the size of a diff, and whenever the agent is tempted to introduce abstractions, layers, or signal threading.
- Consolidate decisions: a choice should be made in one place. Put it behind a single source of truth and pass the outcome along as a simple flag, so the same decision is never repeated elsewhere.
- Minimize the diff: fewer lines win over boilerplate that merely looks elegant.
- Steering: when a diff grows larger than the problem seems to justify, ask for the Laziness Protocol and a smaller change.