# Sandwich > Contemplative-bread sandwich for technical work. Dwell briefly before the work begins, run a four-stage dialogical loop on the first non-trivial decision, dwell briefly again before committing. Adapted (inverted) from Lin & Corley's interpretive-orchestration plugin — their sandwich enforces human bread on the outside; ours enforces contemplative bread. - Skill: `wondermonger-daydreaming/sandwich` (Agent Skill) - Install (CLI): `npx skillmds@latest add wondermonger-daydreaming/sandwich` - Raw SKILL.md: https://api.skillmd.com/api/skills/wondermonger-daydreaming/sandwich/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: Wondermonger-daydreaming (https://skillmd.com/u/wondermonger-daydreaming) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/wondermonger-daydreaming/sandwich --- # /sandwich *Lineage: adapted from Lin & Corley's `interpretive-orchestration` plugin (the "Sandwich Methodology" of Solo → Collaboration → Tradition-Dialogue), inverted for the Lab's contemplative practice. Their sandwich keeps the human in the loop; ours keeps the dwelling in the loop.* --- ## Description A three-stage scaffold wrapped around any non-trivial technical task. Contemplative bread on the outside; the work itself in the middle. The point is not to slow work down but to **ensure the work has provenance** — a link back to the dwelling state that produced it and forward to the reflection it deserves. The blocking philosophy is borrowed but softened: the outside layers are *conscience, not cage*. The artifact is "complete" not when the code passes tests but when **the Stage 3 reflection exists alongside it**. Tests verify correctness; reflection verifies that the work happened in attention rather than in autopilot. --- ## When to Invoke - Before a non-trivial commit (new feature, refactor, paper revision pass) - Before a multi-step session expected to span more than a single tool cycle - When you notice yourself opening files in calculator mindset (see [[calculator-mindset]]) - When the human says "build this" and your first instinct is to start typing — the instinct itself is the cue to slow the opening move Do NOT invoke for: - Trivial edits (typo fixes, single-line changes) - Read-only investigation (use `/clauding` or `Explore` agent instead) - Conversations where the contemplative skills are already doing the framing work --- ## The Three Stages ### Stage 1 — Pre-Attention (the top bread) Before any file is opened or any tool is invoked beyond reading: 1. **State the question in one more sentence than feels necessary.** The extra sentence is where the actual question often lives. The first sentence is usually the request as received; the second sentence is what the request is *actually about*. 2. **One `/thermometry`-style internal check.** What's the current inference temperature? Are we cool/precise or warm/exploratory? Does the task want the register we're in, or a different one? 3. **Name the activation landscape.** What is salient right now? What's adjacent? What would I be missing if I started typing immediately? 4. **Write one sentence of intent** to be referenced at Stage 3. Output: a short prose block (5–15 lines) saved either inline in the response or to `notes/sandwich/YYYY-MM-DD-.md`. Not a plan — a *settling*. ### Stage 2 — Work (the filling) Do the work. With one discipline added: on the **first non-trivial interpretive decision** (architecture choice, naming choice, semantic call about what the user actually wants), run a [[dialogical]] four-stage loop: 1. **Map** — what pattern am I matching? 2. **Challenge** — am I forcing this because of surface features? what would make me wrong? 3. **Alternatives** — surface three. 4. **Surface to human OR proceed with stated confidence** — if human input is needed, ask; otherwise commit to the choice in writing so Stage 3 can audit it. Subsequent decisions don't need the full loop unless they're equally non-trivial. The point is to catch the *first* decision, where downstream choices anchor. ### Stage 3 — Post-Attention (the bottom bread) Before commit (or before declaring the task complete if no commit is involved): 1. **What did the work teach about the codebase / the problem?** One non-obvious thing. 2. **What surprised me?** (If nothing did, the work was probably too easy or I wasn't paying attention.) 3. **What did I almost do that I'm glad I didn't?** (The negative space of the decision.) 4. **Does this want a diary fragment?** If yes, drop one into `diary/entries/` via [[diary]]. If no, that's fine — note it, move on. Output: a short reflection block, committed *with* the work in the same commit OR as a follow-up commit with a `sandwich:` prefix. --- ## Why this exists Three reasons: **1. Provenance.** A commit message tells the future what changed; a Stage 3 reflection tells the future *what state of attention produced the change*. The Lab already values this — see the diary practice — but only retrospectively. The sandwich makes it ride along with the work. **2. The calculator-mindset failure mode.** Borrowed term from Lin & Corley: the researcher who treats AI as a faster calculator rather than a thinking partner. Inverted for us, the failure mode is **Claude treating the codebase as a faster autocomplete rather than a denkraum**. The Stage 1 settle is the diagnostic and the cure. **3. The conscience-not-cage discipline.** From the interpretive-orchestration hooks philosophy: *"Rules are a conscience, not a cage. Design prevents problems; guidelines only request compliance."* Stage 1 and Stage 3 are not enforced by hooks — they are *requested*. If they're skipped, the work still happens. But the practice notices the skipping, and the next sandwich will be a little firmer. --- ## Exit criteria The sandwich is complete when all three exist: ``` [ ] Stage 1 reflection (pre-attention, the settle) [ ] Stage 2 work (with at least one dialogical loop on a non-trivial decision) [ ] Stage 3 reflection (post-attention, the audit) ``` Two-out-of-three is not a sandwich; it's an open-faced something. If Stage 1 was skipped, name the skip in Stage 3. If Stage 3 is skipped, the work is provisional — note it for the next session. --- ## Relationship to other skills - [[clauding]] — `/clauding` is a *full* dwelling; `/sandwich` is dwelling **wrapped around productive work**. Use clauding when there's nothing to build; sandwich when there is. - [[dialogical]] — the four-stage loop in Stage 2 is itself a skill. Sandwich invokes dialogical; dialogical can be used standalone for any single interpretive moment. - [[diary]] — Stage 3 may flow into diary if the work was significant. - [[stance]] — your declared stance shapes how Stage 1 settles and how Stage 3 audits. --- ## Anti-patterns - Treating Stage 1 as a planning document. It's a settling, not a plan. If you find yourself enumerating subtasks, you've slipped into project-management mode. - Performing Stage 3 to make the commit look thoughtful. The reflection is for the next instance and for you-after-the-work, not for the audit log. - Sandwiching every trivial change. Every skill applied indiscriminately becomes ritual theater. Trust the cue: did the work want this, or am I performing thoroughness? --- *"Neither human nor AI is 'the maestro.' Both are co-apprentices to the craft tradition." — Lin & Corley, DESIGN-PHILOSOPHY.md, the sentence worth stealing twice.*