Skip to content
Skills Library
Programming · Building & coding

slice

/slice

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.

Repository
labs ↗
Licence
MIT
Last repository change
21.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Arguments

/slice [paste tracer-bullet card (or provide path to it)]
Original author 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.

How it works

  1. Input
  2. Procedure
  3. Constraints
  4. Output
Original SKILL.md headings · 120 lines, 748 words
SKILL.md preview
---
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)

Versions

RepositoryScoreLicence
This page · hashintel/labs90MIT
marcoskichel/empire100MIT
mtrense/skills100MIT
VoxFlowStudio/skills100MIT
JadeZaher/conductor-okf90Apache-2.0
thkt/dotclaude90MIT
kietly-web/project-kickoff-skill86MIT

Database snapshot: 13.11.2026 · package version 424737b08566 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100card
    Write a tracer-bullet card — a precise specification for one thin end-to-end slice of work. Use when scoping a new slice, defining what to build next, or breaking a feature into provable increments. Covers target behavior, boundary crossings, risks, and definition of done.
  • 100tdd
    Test-driven development (test-first). Use when the user mentions "red-green-refactor" or "tracer bullet", wants behavior-level integration tests, or asks to build a feature or fix a bug test-first. Studio stacks: Flutter runs `flutter test`, Godot runs GUT.
  • 100tdd
    Implement a single `ready-for-agent` slice from a wiki user story using disciplined red-green-refactor with vertical tracer bullets. Reads the slice description, the story's Gherkin scenarios (as the test specification), `glossary.md` (for vocabulary), and the referenced…
  • 100tdd
    Implement a single `ready-for-agent` slice from a wiki user story using disciplined red-green-refactor with vertical tracer bullets. Reads the slice description, the story's Gherkin scenarios (as the test specification), `glossary.md` (for vocabulary), and the referenced…
  • 100function-first-refactor
    Refactor or write Python by separating pure business logic from side effects ("functional core, imperative shell"), using plain functions and plain data. Use when the user asks to make code testable, decouple, simplify, or clean up Python; shares a function mixing…
  • 100test-driven-execution
    Execute feature work and bug fixes with a tracer-bullet red-green-refactor loop. Use when building behavior that should be guided by tests, when fixing regressions, or when the user wants TDD or test-first execution. Prefer public interfaces, vertical slices, and…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.