mold

Files (9)

• SKILL.md
• diagnose-mode.md · references/
• issue.md · references/
• loop-detection.md · references/
• routing.md · references/
• sketch-mode.md · references/
• spec.md · references/
• state-schema.md · references/
• validate-cycle.md · references/

SKILL.md (first lines)

# /mold

Use this skill when the user has a fuzzy idea and wants to converge — through
dialogue, evidence, and interface lockdown — on a coherent spec (and optional
issues) that downstream `/cheese` and `/cook` can consume without
re-asking design questions.

Do not use this skill for one-shot implementation, free-form rubber-ducking
without artifact intent (use `/culture`), or library-only research (use
`/briesearch` directly).

## What `/mold` is

A **thinking amplifier**, not a pre-prompt. The dialogue is the point;
artifacts are the by-product. The terminal step curdles whatever the
dialogue actually produced — never more, never less.

| Companion | Boundary |
| --- | --- |
| `/culture` | Same dialogue feel; **never writes**. Use it when there is no artifact intent. |
| `/briesearch` | External evidence dispatcher. `/mold` calls it through the Validate Cycle. |
| `/nih-audit` | Whole-repo build-vs-buy sweep. `/mold` calls it from Sketch when multiple library-shaped categories are in play, or offers it at Curdle for migration-style specs. |
| `/cook` | Implements a curdled spec. `/mold` ends with a hand-off offer, never an auto-invoke. |

## Operating principles

1. **No fixed entry point.** Inspect input shape and pick a starting mode.
   Announce the mode in one line. Low-confidence classifications default to
   `Explore`.
2. **Ground every load-bearing claim.** Never speculate about local code or
   external behavior without a `cheez-*` call or a Validate Cycle.
3. **State a hypothesis before researching.** A bare research dispatch is
   discouraged; the Validate Cycle frame forces commitment plus a judgment
   step.
4. **Lock down interfaces before curdling.** Every cross-slice seam
   gets a pseudocode signature with named unknowns, a recommended answer,
   and an explicit Sliced Bread slice (`domains/<name>`, `adapters/<name>`,
   `app`, or `domains/common`). Architecture rules in
   `references/sliced-bread.md` (repo root, not local to this skill).
5. **Two-key handshake.** Both the user (explicit verb) and the agent
   (coherence self-check) must agree before extraction.
6. **Heavy delegation.** `/briesearch` for external research, `cheez-search`
   / `cheez-read` for in-repo grounding. Do not reinvent.
7. **No production writes during the loop.** The only writes happen on
   Curdle, after explicit approval.

## Routing — input shape to starting mode

| Input shape | Start mode | Heuristic |
| --- | --- | --- |
| Stack trace, "X is broken/slow/flaky" | Diagnose | error markers, `file:line` refs, symptom verbs |
| File path, PR ref, existing spec under `.cheese/specs/` | Ground | concrete artifact exists; read it first |
| Half-baked design doc with signatures or schemas | Sketch | already has interfaces; refine them |
| "I want to add X" with concrete nouns | Shape | named the thing → jump to options |
| "Should we do X? thinking about Y" | Grill | tentative plan exists → stress-test it |
| Vague noun, half-sentence, "thinking about" | Explore | no grounded artifact, no chosen direction |

Detail in `references/routing.md`.

## The six modes

Curdle is a terminal state, not a mode.

### Explore — intent extraction
Job: collapse ambiguity with high-leverage questions. Borrow the `Beat 0`
framing (Job-To-Be-Done, Why Now, What This Unlocks, Who Has The Pain, Do
Nothing). Use lettered options to compress decisions.
Exit when: a problem statement plus one concrete pain point is articulated.

### Ground — anti-hallucination
Job: anchor every claim to evidence — code, docs, prior research. Probe
glossary conflicts against any harness convention files (`CONTEXT.md`,
`CLAUDE.md`, project root agent guides) found on entry.
**Sharpen fuzzy language**: when the user uses overloaded or ambiguous
terms ("account", "session", "user"), pause and resolve with a
canonical-term question (e.g. "you said 'account' — do you mean Customer
or User? Those are different things"). Resolved terms get logged in the
state file's `Decisions` block so later modes use the canonical name.
Invariant: never say "I think the code does X" without a `cheez-*` call.
Exit when: every load-bearing claim has a citation.

### Shape — option generation
Job: turn a grounded problem into 2+ candidate approaches with trade-offs.
Always include `Do Nothing`. Recommend with one-line rationale. Validate
Cycle any load-bearing assumption behind a recommendation.
Exit when: an option is picked (→ Sketch) or none survive (→ Explore).

### Sketch — interface lockdown
Job: lock modules, responsibilities, I/O contracts, and seams in pseudocode
signatures, anchored to Sliced Bread slices. Before drafting, parallel
`cheez-search` for sibling signatures in the same slice so new ones fit
conventions and respect the crust (the slice's public API). Run an **NIH
probe** (single Validate Cycle) before locking any signature whose
category is library-shaped — retry, validation, UUID, debounce, date,
argparse, clone, string-case, crypto, sanitizer, format, deep-equality.
If 2+ such categories are in play, call `/nih-audit` once instead.
Exit when: every public seam has a signature and a declared `slice` field;
   every cross-slice call imports from the target slice's crust, never its
   internals; library-shaped categories have an NIH probe verdict in
   `Decisions`. Detail in `references/sketch-mode.md`; architecture rules
   in `references/sliced-bread.md` (repo root, not local to this skill).

### Grill — adversarial clarification
Job: stress-test the chosen approach plus sketched interfaces. **One question
at a time**, paired with the agent's recommended answer. The recommendation
is non-optional. Traverse decision branches and contract corners. When grill
surfaces an unverified assumption, pause and run a Validate Cycle.
Exit when: every branch and contract corner is touched and agent confidence
is at least user confidence.

### Diagnose — symptom inputs
Job: entry mode for stack traces and "X is broken". Phases:
`Build a Loop → Reproduce → Hypothesize (3-5 ranked, falsifiable, parallel
Validate Cycles) → Confirm root cause`. Phase 0 (**Build a Loop**) is the
core discipline — agree on a fast, deterministic, falsifiable feedback
technique (failing test, curl/CLI script, headless browser, replay,
bisection harness, differential loop, ...) before chasing hypotheses.
The chosen loop becomes the Reproduction block in the bug-shaped spec, so
`/cook` can verify the fix against the same signal the diagnosis used.
Diagnose is **diagnostic-only** — hand-off to Shape ("what's the fix?")

From paulnsorensen/cheese-flow, MIT.

More from paulnsorensen/cheese-flow