slice

---
name: slice
description: Implement one tracer-bullet slice following the inside-out methodology. Use when you have a tracer-bullet card ready to build. Implements functional core first, then imperative shell, then end-to-end wiring, then alignment refactor.
argument-hint: "[paste tracer-bullet card (or provide path to it)]"
---

# Tracer-Bullet Slice

Implement **one** thin end-to-end slice of functionality, following the inside-out procedure.

## Input

The slice is defined by a **tracer-bullet card**: $ARGUMENTS

**Preconditions**:
- A concept capsule must exist. If none → `/pragma:capsule` first.
- A card must exist. If none → `/pragma:card` first.

Extract from the card: (1) target behavior, (2) boundary crossings, (3) risks/assumptions, (4) definition of done. If the card is incomplete, stop and recommend rerunning `/pragma:card`.

## Procedure

Follow these steps in order. Do not skip or reorder.

### 0. Preflight gates

Before writing implementation code:

- Confirm card includes explicit **BUY-OR-BUILD** decision. If missing, stop and refine `/pragma:card`.
- If requirement behavior is still unclear in practice, stop and run `/pragma:spike` first to prototype/observe.

### 1. Spec tests first (red)

Before implementing behavior, translate card Definition of Done into tests:

- Add or update tests named in the card DoD
- Run tests and confirm at least one fails for the expected reason
- If tests pass unexpectedly, tighten test assertions or refine the card scope
  before writing implementation code

This is the "create the needle" step: define a narrow path to success first.

### 2. Functional core (pure domain logic)

Implement using the functional core / imperative shell pattern (Bernhardt):

- Define types/structures using capsule glossary terms
- Write core function(s) as pure transformations — no I/O, no side effects
- Write tests covering the target behavior
- Enforce invariants at construction boundaries

No frameworks, no infrastructure, no I/O in this step. No speculative abstractions.

### 3. Imperative shell (thin I/O adapter)

Add the minimal I/O boundary connecting the core to the real world. The shell calls the core, never the reverse. No business logic in the shell.

### 4. Wire end-to-end

Connect the full path: entry point → shell → core → shell → output. Make it actually run. Write or update an integration test proving the target behavior.

### 4.5. Commit the behavior (recommended)

Commit the smallest set of changes that makes the E2E path pass.
Message style: `Behavior: <target behavior>`

### 5. Alignment refactor — NOT optional

Refactor immediately while context is fresh:
- **Naming**: all names match the capsule glossary? Rename if not.
- **Module boundaries**: can you complete "This module hides the decision about ___" (Parnas) for each module?
- **Dead code**: delete anything speculative, unused, or "for later."
- **Slice cohesion**: does this slice form a coherent vertical unit?

### 6. Verify

Run the project's existing verification harness. All checks must pass. If any fails, fix and re-run from step 1 of verification.

### 7. Commit the refactor

Separate from the behavior commit. Message style: `Refactor: align slice to capsule`

### 8. Classify authority deltas (mandatory)

Before closing the slice, classify what changed and route updates to the
correct authority artifact:

- Semantics changed (glossary/invariant/happy-path/non-goal meaning) → `/pragma:capsule update`
- Strategy changed (cross-cutting decision/rationale/reversal trigger) → `/pragma:roadmap update`
- Phase control changed (scope/status/ordering/deferment/exit criteria) → `/pragma:milestone update`
- Confidence changed (assumption validated/invalidated/confidence shift) → `/pragma:assumptions update`
- Enforcement readiness changed (invariant now enforceable in code/tests) → `/pragma:contract`

Use explicit `none` for lanes with no change.

### 9. Update the assumptions ledger (mandatory)

Run `/pragma:assumptions update` with the slice summary, assumptions made, and validation evidence.

## Constraints

- **One slice only.** No adjacent behaviors, future features, or "while we're here" improvements.
- **Needle before thread.** Do not write behavior code until spec tests go red for the right reason.
- **No speculative abstractions.** No generic frameworks, no "future extensibility."
- **No new abstractions unless forced.** Only abstract when two concrete cases demand it.
- **Refactor is part of done.** A slice is not done until step 5 is complete.
- **Explicit assumptions.** State them. If risky, flag for a spike.
- **No silent authority drift.** Any non-`none` authority delta must be surfaced
  and routed before additional delivery work.

## Output

1. **Behavior delivered**: what is now true that wasn't before
2. **Files changed**: list
3. **Authority Delta**:
   - Semantics: `none` | `/pragma:capsule update` — [reason]
   - Strategy: `none` | `/pragma:roadmap update` — [reason]
   - Phase control: `none` | `/pragma:milestone update` — [reason]
   - Assumptions: `none` | `/pragma:assumptions update` — [reason]
   - Enforcement: `none` | `/pragma:contract` — [reason]
4. **Assumptions made**: anything that should be validated
5. **Suggested next step**: what slice or action follows
6. **Ledger**: run `/pragma:assumptions update` (mandatory after every slice)
7. **Lifecycle**: `State: delivery`, `Next: first non-'none' authority delta command (otherwise /pragma:assumptions update)`, `Loop: /pragma:consult` (default unless user explicitly continues directly)