JSPM

  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 1943
  • Score
    100M100P100Q111471F
  • License MIT

Stack-agnostic spec-driven workflow for AI coding assistants

Package Exports

  • tracerkit

Readme

TracerKit

CI

A spec-driven workflow for Claude Code. Three skills take a feature from idea to verified archive: define, plan, verify.

Zero runtime dependencies — pure Markdown skills, no build step.

Get Started

1. Install TracerKit

npx tracerkit init

Skills are installed globally to ~/.claude/skills/ — available in every project, no per-project setup needed.

2. Use the skills

Open Claude Code in any project and start using:

/tk:prd add dark mode support     # define the feature
/tk:plan dark-mode-support        # break into vertical slices
/tk:verify dark-mode-support      # verify and archive

3. Manage your installation

npx tracerkit update              # refresh to latest, skip modified files
npx tracerkit uninstall           # remove TracerKit skills
Install per-project instead

To scope skills to a single project (team members get them via git):

npx tracerkit init .              # install to .claude/skills/ in current dir
npx tracerkit init /path/to/proj  # or specify a path

Per-project commands:

npx tracerkit update .
npx tracerkit uninstall .

Skills

Core skills

The three-step workflow that takes a feature from idea to verified archive.

/tk:prd <idea> — Write a PRD

Interactive interview to define a feature. Explores the codebase, asks scoping questions one at a time, designs deep modules, and writes a structured PRD.

Output: prds/<slug>.md

/tk:plan <slug> — Create an implementation plan

Reads a PRD and breaks it into phased tracer-bullet vertical slices — each phase is a thin but complete path through every layer (schema, service, API, UI, tests), demoable on its own.

Output: plans/<slug>.md

/tk:verify <slug> — Verify and archive

Read-only review that compares the codebase against the plan's done-when conditions. Runs tests, checks user stories, and stamps a PASS or NEEDS_WORK verdict. On PASS, automatically archives the PRD and plan to archive/<slug>/.

Output: Verdict block in plans/<slug>.md — on PASS: archive/<slug>/prd.md + archive/<slug>/plan.md

Helper skills

Useful but optional — this category will grow over time.

/tk:status — Workflow dashboard

Scans prds/ and prints a table of all features grouped by status (in_progress, created, done), with age, latest verdict, and blocker/suggestion counts. Read-only — no files are modified.

Metadata Lifecycle

Each PRD carries YAML frontmatter that tracks its position in the workflow. The skills update it automatically — you never need to edit it by hand.

Fields:

  • created — ISO 8601 UTC timestamp, set when the PRD is written
  • status — created | in_progress | done
  • completed — ISO 8601 UTC timestamp, set when verification passes

How it changes:

Stage Skill Frontmatter
Defined /tk:prd created: 2025-06-15T14:30:00Z
status: created
Planning /tk:plan status: in_progress
Verified /tk:verify (PASS) status: done
completed: 2025-06-20T09:00:00Z
Example frontmatter at each stage

After /tk:prd:

---
created: 2025-06-15T14:30:00Z
status: created
---

After /tk:plan:

---
created: 2025-06-15T14:30:00Z
status: in_progress
---

After /tk:verify (PASS):

---
created: 2025-06-15T14:30:00Z
status: done
completed: 2025-06-20T09:00:00Z
---

Why TracerKit?

Most planning tools produce horizontal task lists — nothing works until everything is done. TracerKit uses tracer-bullet vertical slices instead: each phase cuts through every layer (schema → service → API → UI → tests), so every phase is demoable on its own. Integration problems surface early, context stays focused, and AI assistants get small well-scoped phases instead of sprawling layers.

The term comes from The Pragmatic Programmer.

Compared to

vs. Spec Kit (GitHub) — Thorough but heavyweight. 5 phases, Python setup, rigid phase gates. TracerKit is 3 phases, zero deps, automated verification.

vs. Kiro (AWS) — Powerful but locked to a dedicated IDE. TracerKit works inside Claude Code with pure Markdown skills.

vs. OpenSpec — Similar philosophy, broader tool support. TracerKit trades breadth (Claude Code only) for depth — native skill discovery, subagents for verification, and fewer artifacts.

vs. nothing — AI coding without specs means vague prompts and lost context between sessions. TracerKit adds structure without ceremony.

Full comparison table
Spec Kit Kiro OpenSpec TracerKit
What it is CLI + extensions Agentic IDE (VS Code fork) Slash-command framework Claude Code skills (pure Markdown)
Setup Python + uv Dedicated IDE npm + init npx tracerkit init
Phases 5 3 3 3 (prd, plan, verify)
Artifacts 4 files 3+ files 4+ files 2 files (PRD, plan)
Verification Manual gates Diff approval Manual Automated PASS/NEEDS_WORK
Tool lock-in Any AI assistant Kiro IDE only Any AI assistant Claude Code only
Runtime deps Python + uv Proprietary IDE None None

Examples

New feature from scratch 
# 1. Define the feature
/tk:prd add dark mode support

# 2. Break into phased vertical slices
/tk:plan dark-mode-support

# 3. Implement each phase with Claude

# 4. Verify — auto-archives on PASS
/tk:verify dark-mode-support
Iterating on an accepted PRD

PRDs are living documents — refine them any time before or during implementation.

# Re-run the PRD skill — it detects the existing file and asks
# whether to start fresh or revise
/tk:prd update dark mode to detect system preference

# Regenerate the plan from the updated PRD
/tk:plan dark-mode-support
Verify → fix → re-verify loop 
# First verification attempt
/tk:verify dark-mode-support
# → NEEDS_WORK: missing toggle persistence, 2 failing tests

# Fix the blockers, then re-verify
/tk:verify dark-mode-support
# → PASS — auto-archived to archive/dark-mode-support/
Development flow diagram 
                         +------------------+
                         |   Idea / Issue   |
                         +--------+---------+
                                  |
                                  v
                       +----------+----------+
                       |  /tk:prd <idea>     |
                       |  Interview + Design |
                       +----------+----------+
                                  |
                              prds/<slug>.md
                                  |
                                  v
                       +----------+----------+
                       |  /tk:plan <slug>    |
                       |  Vertical Slices    |
                       +----------+----------+
                                  |
                             plans/<slug>.md
                                  |
                                  v
                       +----------+----------+
                       |   Implement phases  |
                       |   (you + Claude)    |
                       +----------+----------+
                                  |
                                  v
                       +----------+----------+
                       |  /tk:verify <slug>  |
                       |  Review + archive   |
                       +----------+----------+
                                  |
                         +--------+--------+
                         |                 |
                    NEEDS_WORK           PASS
                         |                 |
                         v                 v
                  Fix blockers      Auto-archived
                  then re-run       to archive/
                  /tk:verify

Contributing

  1. Fork the repo and create a feature branch
  2. Use TracerKit itself to plan your change (/tk:prd + /tk:plan)
  3. Implement following the plan phases
  4. npm run lint:fix && npm run test:run && npm run typecheck
  5. Conventional Commits (enforced by commitlint)
  6. Open a PR against main

License

MIT License © helderberto