Skip to main content
skill CX Codex

tracer-bullets — Claude Code skill: what it does, how to install

The tracer-bullets Claude Code skill splits multi-layer work into end-to-end slices. Each slice is checked before work moves on.

MIT 107 installs ★ 29 updated 2026-08-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill tracer-bullets -a claude-code
Open on GitHub

What tracer-bullets does

The skill breaks a feature into small paths through its relevant layers, then calls for a check before the next path begins. For CRUD work, that can mean starting with the API and tests, adding a data-backed list page, then building create, edit, and delete flows. The approach avoids completing one whole layer before touching the next.

It activates for tasks spanning multiple layers, multi-step flows, and implementation planning. It can also organize slices as ordered subtasks and assign them to subagents. Single-layer changes, one-file fixes, and work already split into ordered slices by a task tracker are excluded.

What it helps with

  • Split a multi-layer feature into end-to-end slices
  • Check each slice before starting the next
  • Set an implementation order for a CRUD feature
  • Find slice boundaries in a multi-step flow

Example prompts for the agent

  • Break this CRUD feature into vertical slices and say how to verify each one.
  • Plan the implementation order for this multi-step flow, with each slice crossing the relevant layers.
  • Turn this task into small ordered subtasks for subagents.

How to install tracer-bullets

1Skills CLI (Vercel)

npx skills add oakoss/agent-skills --skill tracer-bullets -a claude-code

2Manually: put the files in place

~/.claude/skills/tracer-bullets/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tracer-bullets/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tracer-bullets

How do I install tracer-bullets in Claude Code?

Run npx skills add oakoss/agent-skills --skill tracer-bullets -a claude-code. The skill file is at ~/.claude/skills/tracer-bullets/SKILL.md.

What does tracer-bullets do?

It divides multi-layer work into end-to-end slices and checks each one before proceeding. A CRUD feature can move from API and tests to the interface and a full-flow test.

When does tracer-bullets skip slice planning?

It skips single-layer changes, one-file fixes, and tasks that a task tracker has already split into ordered vertical slices.

Source text

SKILL.md · MIT
---
name: tracer-bullets
description: |
  Builds multi-layer features as vertical end-to-end slices instead of horizontal layers. Each slice is verified before the next begins.

  Use when: starting any task that spans 2+ layers (DB, API, UI, tests), building CRUD features, implementing multi-step flows, decomposing features into subtasks, or planning implementation order.
license: MIT
metadata:
  author: oakoss
  version: '1.0'
  source: https://www.aihero.dev/tracer-bullets
user-invocable: false
---

# Tracer Bullets

Build features as vertical slices through all layers, verifying each slice before starting the next. From The Pragmatic Programmer: get feedback as quickly as possible. Don't build horizontal layers in isolation (all endpoints, then all UI, then all tests). Build one thin vertical path, verify it works, then expand.

Skip for single-layer changes, one-file bug fixes, or work already decomposed into ordered vertical slices by a task tracker.

## Quick Reference

| Principle                  | Practice                                                              |
| -------------------------- | --------------------------------------------------------------------- |
| Vertical over horizontal   | Build one slice through all layers, not one layer across all features |
| Verify before advancing    | Tests pass, page renders, round-trip works before next slice          |
| One slice per session      | Each slice should be completable in a single agent session            |
| First feature sets pattern | First CRUD establishes conventions; subsequent CRUDs go faster        |
| Check before building      | Task trackers may already decompose the work into slices              |
| Skip when trivial          | Single-layer work or proven patterns don't need this ceremony         |

## CRUD Feature Slices

| Slice | Scope                       | Verifies                                           |
| ----- | --------------------------- | -------------------------------------------------- |
| 1     | Backend/API + tests (no UI) | Data layer works, conventions set, tests prove it  |
| 2     | List page with real data    | Data flows DB -> server -> rendered page           |
| 3     | Create dialog               | Full round-trip: form -> server -> DB -> refresh   |
| 4     | Edit + delete               | Full CRUD cycle, mutation patterns, confirm dialog |
| 5     | E2E test                    | Locks in the whole feature                         |

## Non-CRUD Adaptations

Same principle, different slices:

- **Import flow**: parse one row -> display one row -> validate + dedupe -> review + commit
- **Dashboard**: one widget with real data -> empty/onboarding state -> layout with all widgets
- **Search/palette**: one entity type -> all entity types -> quick actions
- **Multi-step wizard**: first step end-to-end -> add steps one at a time -> final submission

## Common Mistakes

| Mistake                                              | Correct Pattern                                                    |
| ---------------------------------------------------- | ------------------------------------------------------------------ |
| Building all API endpoints before any UI             | Build one endpoint + its UI + its test, then the next              |
| Starting UI before the backend is tested             | Slice 1 is backend-only with tests; prove the data layer first     |
| Building the full create/edit/delete UI in one pass  | Create dialog first (slice 3), then edit + delete (slice 4)        |
| Skipping verification between slices                 | Run tests and check output before starting the next slice          |
| Making slices too large for one session              | Split further; a slice that can't finish in one session is too big |
| Applying tracer bullets to trivial single-layer work | Skip for one component, one utility, or patterns already proven    |

## Delegation

- **Decompose into subtasks**: Use the project's task tracker to create ordered vertical subtasks before writing code
- **Isolate each slice**: Delegate each slice to a subagent so failures stay contained and context stays fresh
- **Find slice boundaries for non-CRUD work**: Pick the smallest path through all layers as slice 1, then expand

## References

No reference files. Source: [Tracer Bullets: Keeping AI Slop Under Control](https://www.aihero.dev/tracer-bullets)

© oakoss · MIT · oakoss/agent-skills

Similar skills

All skills for Backend and APIs →

From the same set106

The whole set →
tauri This Claude Code skill covers Tauri v2 apps with web frontends and Rust backends. It activates for project setup, IPC, permissions, or app releases. CX Codex +1 108installs turborepo This Claude Code skill helps configure Turborepo in JavaScript and TypeScript monorepos. Use it to set up task pipelines, caching, package filters, and CI workflows. CX Codex +1 108installs realtime-sync realtime-sync guides agents through designing low-latency sync using WebTransport, CRDT conflict resolution, and batched AI token streaming. CX Codex +1 108installs plan-first-development The plan-first-development Claude Code skill structures project planning and tracks progress across sessions. It activates for new projects, major features, and work split into phases. CX Codex +1 107installs expert-instruction The expert-instruction Claude Code skill helps design system instructions for AI agents. It covers agent roles, behavioral limits, response formats, and tool-use guidance. CX Codex +1 106installs codebase-packager The codebase-packager Claude Code skill prepares large repositories for AI coding tasks. It builds digests, packs source context, and traces connections across files. CX Codex +1 105installs skill-management skill-management — a Claude Code skill for creating, reviewing, and validating skills against the Agent Skills standard. It comes into play during structure checks, description edits, and manifest comparisons. CX Codex +1 105installs meta-agent-creator The meta-agent-creator Claude Code skill helps define custom subagents and configure their settings. Use it to shape task delegation and control which tools an agent can access. CX Codex +1 104installs

Project sponsors

Companies that keep this analytics open