Spec-Driven Development
LichAmnesia/lich-skills
Runs a gated Spec, Plan, Build, Test, Review, Ship workflow so non-trivial changes are specified, verified and reviewed before they ship, with a named artifact per phase.
Applies a 12-stage verified workflow, from research to deploy, to non-trivial coding tasks, scaled to lightweight, standard or full mode by task size.
$ npx skills add artemiimillier/bulletproof --skill bulletproof -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install artemiimillier/bulletproof bulletproof --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
Claude Code skills documentation · loads skills from .claude/skills/
Install the "bulletproof" agent skill from https://github.com/artemiimillier/bulletproof/tree/main into .claude/skills/bulletproof/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bulletproof", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add artemiimillier/bulletproof --skill bulletproof -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install artemiimillier/bulletproof bulletproof --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "bulletproof" agent skill from https://github.com/artemiimillier/bulletproof/tree/main into .agents/skills/bulletproof/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bulletproof", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add artemiimillier/bulletproof --skill bulletproof -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install artemiimillier/bulletproof bulletproof --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "bulletproof" agent skill from https://github.com/artemiimillier/bulletproof/tree/main into .cursor/skills/bulletproof/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bulletproof", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add artemiimillier/bulletproof --skill bulletproof -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install artemiimillier/bulletproof bulletproof --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "bulletproof" agent skill from https://github.com/artemiimillier/bulletproof/tree/main into .gemini/skills/bulletproof/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bulletproof", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install artemiimillier/bulletproof bulletproofInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add artemiimillier/bulletproof --skill bulletproof -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "bulletproof" agent skill from https://github.com/artemiimillier/bulletproof/tree/main into .github/skills/bulletproof/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bulletproof", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add artemiimillier/bulletproof --skill bulletproof -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install artemiimillier/bulletproof bulletproof --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "bulletproof" agent skill from https://github.com/artemiimillier/bulletproof/tree/main into .opencode/skills/bulletproof/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bulletproof", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
bulletproofApplies a 12-stage verified workflow, from research to deploy, to non-trivial coding tasks, scaled to lightweight, standard or full mode by task size.
The skill sets a core rule of coding only to solve the actual problem, asking before every change whether it is the most efficient solution. Tasks are sized small, medium or large, which selects a lightweight path for one or two files, stages 1 to 10 for a feature touching 3 to 10 files, or all 12 stages for architecture changes and new services. Self-audit, verification and impact checks run inside each implementation phase, and the remaining stages run once afterward.
It also manages context: quality is said to drop once the window passes about 40% full, so the agent stays within 40 to 60%, compacts manually near 50% and saves a handoff note before clearing context between major stages. Stage 1 is read-only research with parallel explore agents plus a search for existing solutions. The repo ships templates for research, spec, plan and handoff, a code-reviewer agent and three worked examples.
12 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 49e9c28. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Shell commands in SKILL.md call:
npmsemgrepnpxpythonpytestruffFrom the folder's file list and the shell code blocks in SKILL.md.
Links to these hosts (documentation or services it may open):
t.megithub.comFrom URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Bulletproof Workflow loads about 3.5k tokens when it runs. Until then it costs about 49 tokens; SKILL.md has 1,077 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from artemiimillier/bulletproof at commit 49e9c28, republished under its MIT licence (© artemiimillier). 1,077 words, ~3,525 tokens.
.claude/skills/bulletproof/SKILL.md (or your agent's skills folder). This skill also uses 12 other files; get the full folder from GitHub.Author: Artemiy Miller (@artemiimillier) · Telegram · who.ismillerr@gmail.com · TG Channel Version: 5.0 · March 2026 License: MIT Compatible: Claude Code, Codex, Gemini CLI, Cursor, Windsurf, OpenCode
Code to solve problems, not code for code's sake.
Before EVERY change ask: "Does this actually solve our problem? Is this the most efficient solution?" If the answer isn't clear — stop, research alternatives, pick the best one.
Not every task needs the full pipeline.
| Size | Examples | Mode | Stages |
|---|---|---|---|
| S | Bug fix, small edit, 1-2 files | Lightweight | 1 → 4 → 5 → 6 → 7 → Gates (skip spec/plan) |
| M | New feature, module refactor, 3-10 files | Standard | Stages 1-10 |
| L | Architecture change, new service, 10+ files | Full | Stages 1-12 (all) |
How stages relate: Stages 5-6-7 (Self-Audit, Verification, Impact) run inside each implementation phase as an inner loop. Stages 8-12 run once after all phases complete as an outer loop.
Code quality degrades when context fills beyond 40% ("Dumb Zone"). Rules:
/compact at 50% — don't wait for auto/clear → fresh startEvery major stage = clean context window:
/clearBefore /clear always create progress/<task>-handoff.md.
See templates/handoff.md for format.
Don't dump the entire codebase into context:
"For details, see path/to/docs.md" (not @file)Mode: Read-Only. No code. No changes.
thoughts/research/YYYY-MM-DD-<task>.md
(see templates/research.md for format)→ /clear
Mode: Read + Write only in specs/. No code.
Spec = WHAT and WHY. Not how. Spec = contract.
thoughts/research/specs/YYYY-MM-DD-<name>.md
(see templates/spec.md for format)Skip for size S tasks.
→ /clear
Mode: Read + Write only in plans/. No code yet.
specs/) and Research (thoughts/research/)Before finalizing the plan, answer 3 questions:
1. DOES THIS SOLVE THE PROBLEM?
Compare every plan item against acceptance criteria from spec.
If any criterion is uncovered — the plan is incomplete.
2. IS THIS THE MOST EFFICIENT SOLUTION?
Search: who has already solved this problem? What approach did they use?
Name 2-3 alternative approaches (including ones found via research).
For each: pros, cons, effort.
Justify why the chosen approach is better than all alternatives.
3. IS THERE "CODE FOR CODE'S SAKE"?
Every change must directly serve acceptance criteria.
If a change isn't tied to solving the problem — remove it.
Drive-by refactoring = separate task, not part of this one.Ctrl+G — plan opens in editor> NOTE: annotations"Address all notes, don't implement yet"Create plans/YYYY-MM-DD-<name>.md
(see templates/plan.md for full template with Challenge Log, phases, prompts)
→ /clear
Each phase = separate session, fresh context, feature branch.
Phases can be run in parallel via separate Claude Code sessions/terminals when they don't depend on each other. Check the plan for dependencies before parallelizing.
Guard phrase to start coding: Only begin implementation after the plan is finalized and all annotation notes are addressed. The trigger: "Implement Phase N according to plan."
Order within each phase:
feature/<task>in_progresscompleted, write to Changelog/clearMandatory BEFORE marking completed:
Check the phase implementation:
1. SPEC COMPLIANCE
Open spec. Walk through every acceptance criterion.
For each: implemented? Where exactly in code?
If any not covered — finish it.
2. CHALLENGE THE SOLUTION
Look at the written code with fresh eyes.
Does this actually solve the problem from spec?
Is there a simpler/more efficient way?
Any "code for code's sake" — changes unrelated to the task?Not just linting. Thoughtful review with false-positive filtering.
Check ALL code from this phase for:
- Logic errors (wrong conditions, off-by-one, race conditions)
- Data handling (null/undefined, type mismatches)
- Security (injection, auth bypass, exposed secrets)
- Performance (N+1 queries, memory leaks, unnecessary re-renders)For EACH found bug:
1. Is this a REAL bug or a false positive?
2. Can you prove this bug is reproducible?
3. If you can't prove it — it's NOT a bug. Don't touch it.
RULE: Don't fix code "for beauty" or "just in case".
Fix ONLY proven bugs that actually affect functionality.
Every "fix" without proof = risk of introducing a new bug.Final code cleanliness check:
- Logic: is the data flow correct from input to output?
- Efficiency: any redundant operations?
- Readability: is the code understandable without comments?
BUT: don't refactor "for beauty". Only if it affects correctness.The most underestimated stage. 75% of AI agents break previously working code.
MANDATORY CHECK BEFORE MERGE:
1. REGRESSION
What other modules/functions depend on changed files?
Run ALL project tests (not just current phase).
If anything broke — this is priority #1.
2. SIDE EFFECTS
Did any contracts/interfaces change (API, props, types)?
If yes — who uses them? Are all consumers updated?
3. THINK AHEAD
What problems could these changes cause in a week/month?
Edge cases we haven't tested?
What happens with: zero data? Huge data? Concurrent requests?
What if the user does something unexpected?
4. COMPATIBILITY
Backward compatibility preserved?
Data migrations needed?
Feature flags needed for gradual rollout?completed → run gates across entire projectNew session. No implementation bias.
@code-reviewer agent (see agents/code-reviewer.md)semgrep --config=auto .
# or
/security-review # built into Claude CodeIf review/scan found issues:
mv plans/<file> plans/archive/A phase CANNOT be completed without passing ALL required gates.
# Frontend
cd frontend && npx tsc --noEmit # 0 type errors
cd frontend && npm run lint # 0 lint errors
cd frontend && npm test # all tests green
# Backend
cd backend && python -m py_compile app/main.py
cd backend && pytest --tb=short -q
cd backend && ruff check .npx madge --circular src/ # circular dependencies
npm audit --audit-level=high # dependency vulnerabilities
pip-auditsemgrep --config=auto .
# or /security-reviewIf a gate fails — fix and re-run. Never skip.
Add to .claude/settings.json:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [{
"type": "command",
"command": "bash -c \"CMD=$(echo $TOOL_INPUT | jq -r '.command // empty'); echo \\\"$CMD\\\" | grep -qE '(git push.*(main|master)|rm -rf /|DROP TABLE)' && echo 'BLOCKED: Use feature branch / safe alternative.' >&2 && exit 2 || exit 0\""
}]
}
],
"Stop": [
{
"hooks": [{
"type": "prompt",
"prompt": "You are a JSON-only evaluator. Respond ONLY with raw JSON, no markdown.\n\nReview the assistant's final response. Reject if:\n- Rationalizing incomplete work ('pre-existing', 'out of scope', 'follow-up')\n- Listing problems without fixing them\n- Skipping test/lint failures with excuses\n- Making changes unrelated to the stated problem ('code for code's sake')\n- Claiming completion without running verification gates\n\nRespond: {\"ok\": false, \"reason\": \"[issue]. Go back and finish.\"}\nor: {\"ok\": true}"
}]
}
]
}
}feature/<task> branch{
"matcher": "Write|Edit",
"hooks": [{
"type": "command",
"command": "npx prettier --write \"$FILE_PATH\" 2>/dev/null || true"
}]
}Claude generates well-formatted code; the hook handles the last 10% to avoid CI failures.
{
"matcher": "Write|Edit",
"hooks": [{
"type": "command",
"command": "bash -c \"CONTENT=$(echo $TOOL_INPUT | jq -r '.content // empty'); echo \\\"$CONTENT\\\" | grep -qiP '(api.?key|secret|password)\\s*=\\s*[\\x27\\\"][^\\x27\\\"]{10,}' && echo 'BLOCKED: Hardcoded secret. Use env vars.' >&2 && exit 2 || exit 0\""
}]
}Fragile (regex-based) but catches obvious mistakes. For production, use semgrep or /security-review instead.
| Stage | Model | Why |
|---|---|---|
| Research, Planning | Opus | Cross-file reasoning |
| Implementation | Sonnet | Speed, cost-efficiency |
| Code Review, Security | Opus | Deep analysis |
| Anti-rationalization hook | Haiku | Fast, cheap gate |
project/
├── .claude/
│ ├── settings.json # hooks config
│ ├── skills/
│ │ └── bulletproof/
│ │ ├── SKILL.md # ← this file
│ │ ├── templates/
│ │ │ ├── research.md
│ │ │ ├── spec.md
│ │ │ ├── plan.md
│ │ │ └── handoff.md
│ │ └── agents/
│ │ └── code-reviewer.md
│ └── agents/ # project-level agents
├── CLAUDE.md # project brain
├── specs/ # WHAT and WHY
├── plans/ # HOW
│ └── archive/ # completed plans
├── thoughts/research/ # research artifacts
└── progress/ # handoff files© artemiimillier, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 12 other files in the repository root of artemiimillier/bulletproof.
Open the folder on GitHubat commit 49e9c28
Bulletproof Workflow next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Bulletproof Workflow this skillartemiimillier/bulletproof | 153 | — | ~3.5k | Automated safety check: Pass | MIT | |
| Spec-Driven DevelopmentLichAmnesia/lich-skills | 234 | — | ~3.5k | Automated safety check: Pass | MIT | |
| GSD Phase Discussionopen-gsd/gsd-core | 10k | 1 repos | ~1.5k | Automated safety check: Warn | MIT | |
| SPARC Development Methodologyruvnet/ruflo | 74k | 2 repos | ~829 | Automated safety check: Pass | MIT | |
| PRP PlanWirasm/prp | 2.3k | — | ~4k | Automated safety check: Pass | MIT | |
| Spec-Driven Feature Developmenttech-leads-club/agent-skills | 7k | — | ~4.3k | Automated safety check: Pass | CC-BY-4.0 |
LichAmnesia/lich-skills
Runs a gated Spec, Plan, Build, Test, Review, Ship workflow so non-trivial changes are specified, verified and reviewed before they ship, with a named artifact per phase.
open-gsd/gsd-core
Asks adaptive questions about a project phase and records the decisions in a CONTEXT.md that later research and planning agents can act on without asking again.
ruvnet/ruflo
Applies the SPARC method (specification, pseudocode, architecture, refinement, completion) with 17 specialized modes and multi-agent orchestration, from research to deployment.
Wirasm/prp
Writes an implementation-ready plan for a feature, bug fix, refactor or chore from a PRD, issue or description, grounded in codebase evidence, and can post it back to the source issue.
tech-leads-club/agent-skills
Plans and implements a feature through four phases, specify, design, tasks and execute, with testable requirements, atomic commits and a separate verifier checking the work.
wshobson/agents
Use this skill when creating, managing, or working with Conductor tracks - the logical work units for features, bugs, and refactors. Applies to spec.md…
Categories
Applies a 12-stage verified workflow, from research to deploy, to non-trivial coding tasks, scaled to lightweight, standard or full mode by task size. The skill sets a core rule of coding only to solve the actual problem, asking before every change whether it is the most efficient solution. Tasks are sized small, medium or large, which selects a lightweight path for one or two files, stages 1 to 10 for a feature touching 3 to 10 files, or all 12 stages for architecture changes and new services.
Bulletproof Workflow fits situations like: building a feature that touches several files and needs a plan and a spec; fixing a complex bug without introducing regressions; changing architecture or adding a service with verification at each stage; keeping a long session productive by saving handoffs and clearing context between stages.
Run `npx skills add artemiimillier/bulletproof --skill bulletproof -a claude-code`. Or copy the skill folder (the artemiimillier/bulletproof repository) into .claude/skills/bulletproof in your project. Claude Code loads it when a task matches its description.
Run `npx skills add artemiimillier/bulletproof --skill bulletproof -a codex`. Or copy the skill folder (the artemiimillier/bulletproof repository) into .agents/skills/bulletproof in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add artemiimillier/bulletproof --skill bulletproof -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/bulletproof, .gemini/skills/bulletproof, .github/skills/bulletproof and .opencode/skills/bulletproof in your project.
Going by SKILL.md and its folder, Bulletproof Workflow needs the command-line tools its instructions call (npm, semgrep, npx, python, pytest and ruff).
SKILL.md names 2 domains. As links in the text: t.me and github.com. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Bulletproof Workflow is published under the MIT licence (from the LICENSE file in the skill folder). It allows redistribution, so the full SKILL.md is shown on this page.
About 3.5k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Bulletproof Workflow: Spec-Driven Development (LichAmnesia/lich-skills, 234 stars), GSD Phase Discussion (open-gsd/gsd-core, 10k stars), SPARC Development Methodology (ruvnet/ruflo, 74k stars) and PRP Plan (Wirasm/prp, 2.3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
artemiimillier (a GitHub user) maintains it in artemiimillier/bulletproof, which has 153 GitHub stars. The repository was last updated on March 21, 2026.
Source: artemiimillier/bulletproof on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.