🇧🇷 Versão em Português · 🌎 English version

Dev Team Kit — 87 Specialist Skills for Coding Agents

A complete team of software specialists inside your coding agent.
Every task is routed to the right specialist, run on the right model, and shipped at production quality.

✨ What’s new

• v2.103.0 — skill 88 (Anatomy) added: detailed interactive isometric figures (SVG, WebGL shaders, 3D) that explain technical concepts as real physical machines with pure Node engine and geometric collision audit.
• v2.102.0 — skill 86 gets decision guides (film types, six styles with a signature move, pure-function effects in fx.mjs, per-agent action table).
• v2.99.0 — skill 86 can prove a film is deterministic (check-film.mjs), listen to a track for tempo, downbeat and drops and cut whole bars (beats.mjs), and review frames with clean-context reviewers that score seven dimensions.
• v2.98.0 — skill 84 gets a briefing engine (idea → verified facts → shot pack, briefing-qa.mjs rejects numbers without a source) and ten clip-type prompt templates.
• v2.97.0 — skill 86 ships a 1080p reference film (“Relay”) and a quality bar, with motion blur and a scored soundtrack.

See CHANGELOG.md for the full version history.

📖 Full Wiki — recommended starting point

Every skill, subagent, command, policy, plugin and MCP tool documented — in the format of aihero.dev’s “5 Agent Skills I Use Every Day”.

---

📊 Quality Bench — measured results, not marketing claims

We tested every skill and subagent with a published rubric. 53 isolation scenarios + 3 end-to-end tests. Same model, same prompt — with and without the kit. Numbers are measured, code is real, results are auditable.

Includes before/after with full output text, per-skill delta scores, process-based test results, and v2.10.1 fix verification. Methodology in eval-bench/.

---

Why It Matters (For Anyone)

If you use AI to build product — whether you’re an experienced dev, an indie hacker shipping SaaS, or someone who only knows how to describe what they want — this kit changes the game. In plain language, here’s what it does:

💰 Saves your API bill (up to 70%)

AI loves to read everything: the entire output of an npm install, repeated stack traces, huge file lists. All of that turns into tokens, which turn into money. The kit automatically compresses that noise before sending it to the model — you only pay for what matters.

🧠 Understands what you want before it starts coding

Instead of a generic agent that “guesses” the implementation, the kit has an orchestrator that reads your request, classifies the complexity, and assembles the minimum sufficient pipeline. If you’re vague, it asks. If you’re clear, it runs. It never makes things up.

🗂️ Persistent memory across sessions

Most agents forget everything when you close the window. This one remembers: what you decided, which files matter, the patterns your project follows, the bugs that came up before. Result: less rework, fewer tokens spent re-contextualizing, and far sharper answers each session. It also remembers what didn’t work (state: rejected + the reason, so the agent doesn’t re-try a dead end), survives context compaction with a recovery packet, and can share that memory with Codex, Grok Build and other agents.

🤖 Autonomous mode — fire and forget

Hand off a complex task with /auto or /loop and go grab a coffee. The agent runs, tests, fixes, validates and only stops when it’s ready, working and tested. There’s a safety circuit: if it gets stuck on the same error 3 times, it detects and warns — no burning API for nothing.

🖼️ Professional image generation, no placeholders

Landing page with a gray “image here” box? Never again. The kit integrates fal.ai with prompts written by a generative-AI specialist — you describe the scene, the system translates it into a technical prompt, and delivers production-ready images. Illustrations, hero images, icons, mockups, all consistent with your brand.

🔒 Security before deploy, not after the leak

A security auditor thinks like an attacker and reviews the code before it reaches production. Critical findings come with a proof of concept. No more discovering vulnerabilities on the customer’s account.

🧪 Tests that actually prove it works

A QA engineer that follows the “prove-it” principle: if you say it works, prove it with a test. No “looks ok”. Covers happy path, failure paths, edge cases and regressions.

🎨 Design and copy that sell

• Designer with competitive analysis: looks at competitors and recommends what converts
• Copywriter specialized in marketing: ready-to-ship copy for landing pages, email, ads
• SEO that optimizes before Google indexes — your site is born findable

🚀 From zero to deploy without hiring 5 freelancers

Backend, frontend, mobile (Tauri), observability, analytics, accessibility (WCAG), refactoring, release, canary deployments (v2.12+), documentation — 81 specialists in total (85 installed skill directories; ID 16 is reserved). Each task goes to the right professional, on the right AI model (Haiku for simple, Sonnet for medium, Opus for architecture) — you don’t pay Opus to generate boilerplate.

🔌 Works with everything you already use

Native Claude Code plugin + universal MCP server that runs in Cursor, Windsurf, Copilot, Gemini CLI and any MCP-compatible agent. Zero vendor lock-in. Switched tools? Your team comes with you.

🆓 Free, Apache-2.0, open source

No subscription. No trial. No hidden premium tier. Clone it, install it, use it forever — including in commercial projects. Apache-2.0 with a NOTICE file enforces attribution downstream: anyone repackaging the kit must preserve credit to the people whose ideas shaped it.

---

What It Is

The Dev Team Kit is a set of 79 specialized skills that turns any compatible coding agent into a complete development team — with orchestrator, backend, frontend, QA, security, deploy, design, copy, SEO, observability, blog publishing automation and more.

What you get:

• Structured pipeline — every task goes through the right steps, in the right order, no improvising
• QA, Security and Reviewer mandatory — no delivery ships without validation
• Automatic model routing — haiku for boilerplate, sonnet for implementation, opus for architecture
• Lifecycle hooks — the agent detects vague context, re-reads files before editing, monitors token cost
• Built-in MCP server — 38 tools exposed for any MCP client
• Persistent memory — working set, context pack, learned skills with confidence scoring accumulated per project
• Multi-platform install — Claude Code, Cursor, Windsurf, Copilot, Gemini CLI and more

Built on Context Engineering principles

The kit’s architecture maps to the context engineering hierarchy: individual skills are atoms, templates are molecules, learned-skills + working-set are cells, dispatched subagents are organs, and protocol-shell-composed programs are the emergent field layer. New in v1.1: typed protocol shells for 3 pilot subagents, I/O schemas in schemas/skill-io/, iteration scoring in the auto-loop circuit breaker, and declarative programs/ definitions. See docs/WIKI.md → Context Engineering Stack.

5-min tour: docs/SKILLS-OVERVIEW.md — every skill, mode, subagent and policy in one navigable page (aihero.dev format).

---

Quick Install

Mode 1 — Global Plugin (Claude Code)

Installs the 87 skills and hooks globally. Works in any project with no extra configuration.

# Via Claude Code CLI
claude plugin install https://github.com/felvieira/claude-skills-fv

What gets installed globally: skills, hooks, commands (/audit-repo, /devkit-install-fv, /plan-feature, /review-release, /inventory-assets).

Mode 2 — Full Kit Per Repo (via command)

With the plugin installed, run inside the repo you want to configure:

/devkit-install-fv

This installs the full .bot/: MCP server, policies, templates, docs, hooks, learned-skills and multi-platform configs.

Mode 3 — Direct Bash

git clone https://github.com/felvieira/claude-skills-fv /tmp/dev-team-kit
bash /tmp/dev-team-kit/setup/install.sh /path/to/project

If the kit is already in .bot/, you can also run directly from the installed repo:

bash .bot/setup/install.sh

The installer ships setup/ and every kit directory under .bot/. Supports non-interactive profile flags:

• --profile lean — installs without MCP and heavy scripts
• --no-input — no prompts, uses defaults
• --yes — accepts everything automatically

In the table below, treat dev-team-kit as 38 tools backed by the 87 skills (87 installed skill directories; ID 16 is reserved). The MCP exposes 38 tools backed by the installed skills.

Install Modes Compared

---

Supported Platforms

For platforms without native hooks, the same rules live in policies/hooks.md — the agent applies them manually.

Operating systems

The hooks, guards, trigger evals, subagent conduct block and the media tools (skills 84, 85, 86, including a real render with ffmpeg + Chromium) run in CI on Linux (Validate), macOS and Windows (Cross-OS) on every push. That job caught three portability bugs that the Linux run could not see, all fixed in v2.102.0: /freeze denied files inside a frozen folder when the path went through a symlink (macOS /var → /private/var); 15 scripts exited silently, doing nothing, when started through a symlinked path; and the conduct sync tool did not understand CRLF line endings from a Windows autocrlf checkout. Not yet exercised on a real agent: the new tools under Cursor, Gemini CLI or OpenCode (they are plain Node, so nothing depends on the agent, but only Claude Code, Codex and Grok Build were driven for real).

What works where

“Verified” means it ran against the real agent (Grok 1.0.41, Codex 0.155) and not only in the kit’s tests.

Agents without slash commands drive the guards from the shell: node scripts/session-guard-cli.mjs careful on|off, freeze |off, status. To add the guards to Grok or a global Codex install: node scripts/install-memory-hooks.mjs --runtime grok --guards --apply.

---

The 87 Specialists

Management and Coordination

Repo-Wiki: documentation generated in the target project

When the Documenter skill runs inside a project, Repo-Wiki uses the current directory as its target and writes to docs/repo-wiki/ in that same project by default. The output includes Markdown, a coverage report, and a navigable offline HTML site:

/docs/repo-wiki/README.md
/docs/repo-wiki/overview.md
/docs/repo-wiki/architecture.md
/docs/repo-wiki/workflows.md
/docs/repo-wiki/boundaries.md
/docs/repo-wiki/database.md
/docs/repo-wiki/verification.md
/docs/repo-wiki/modules/
/docs/repo-wiki/report.json
/docs/repo-wiki/site/index.html

The overview summarizes the project’s purpose, audience, technologies and versions, entrypoints, useful commands, structure, and documentation limits. The architecture page contains an evidence-backed module map and Mermaid organogram; workflows, boundaries/contracts, database applicability, module deep dives, and execution verification are separate tracks. The HTML site supports offline search and filtering across all tracks without external requests. Snippets with known secret patterns are rejected and sanitized in the evidence renderer.

Use --repo, --output, and --site for explicit destinations. Run node scripts/run-repo-wiki-runtime.mjs --repo . --output docs/repo-wiki/runtime.json --allow-execution when local build/test evidence is authorized, then pass --runtime docs/repo-wiki/runtime.json to the generator. --mode Drift writes a delta report without rewriting docs; --mode Focused --focus narrows the inventory. The generator and builder return the effective absolute paths (repo, markdown_dir, report, site, and index), and the skill handoff must show them to the user together with inventoried/reviewed files, pending tracks and verification results. The documentation must not merely say “docs generated.”

Product and Design

Development

Content and Discovery

Deep SEO audits (Claude Code, opt-in): AgriciDaniel/claude-seo provides /seo audit , local, ecommerce, hreflang, Google and agent-readiness workflows when separately installed. Skill 14 remains the cross-client fallback; the kit does not install the external plugin or its always-on edit hook. Install and capability guide.

Quality and Delivery

Publishing and Automation (v2.11.0+)

Setup (one-time per user):

# Create your blog repo + GitHub Pages + config
node scripts/init-blog-repo.mjs \
  --path=/abs/path/to/blog \
  --user= \
  --repo=blog \
  --create-github

# Then in any Claude Code session:
# "publica um post sobre "  → skill 41 takes it from there

The init script creates ~/.dev-team-kit/blog-config.json so the skill knows where to publish. See scripts/init-blog-repo.mjs and templates/blog/ for details.

Game Development (v2.68.0+)

3D/2D Character Pipeline (v2.69.0+)

Campaign Production (v2.71.0+)

AI Video, Illustration and Code-Rendered Motion

---

Main Pipeline

flowchart LR
    A[Task] --> B[Orchestrator 09]
    B --> C[Context Manager 08]
    B --> D[Minimum sufficient pipeline]
    D --> E[Specialists 01–48]
    E --> F[QA 05 + Security 06 + Reviewer 11]
    F --> G[Deploy 07 or Release 24]
    B --> H[Model routing per step]

Common Pipelines

---

Model Routing — Right Model for Each Step

Automatic enforcement (Claude Code):

• EnterPlanMode → hook suggests /model opus
• ExitPlanMode → hook suggests /model sonnet
• Subagent without explicit model → hook warns and suggests tier by keywords

On other environments: follow policies/model-routing.md manually.

---

Hook System — Intelligence on Lifecycle Events

29 hook scripts are registered in hooks/scripts/runtime-dispatcher.mjs (plus the shared libs utils, memory-lib and compaction-lib) — the table above lists the user-facing ones. Toggle any via DEVKIT_DISABLED_HOOKS or the minimal profile.

Memory beyond Claude Code

Hooks only run where they are registered. Codex loads .codex/hooks.json (it registers PreCompact too); Grok Build ignores the Claude plugin ([compat.claude] hooks = false) and only reads ~/.grok/hooks/*.json. For agents that don’t speak this kit’s vocabulary, the dispatcher has a memory profile — learned-skill injection and pre-compaction capture only, no prompt/tool gates (~130 ms per prompt instead of ~750 ms measured). Grok discards the context a UserPromptSubmit hook returns, so its install uses memory-deferred: the context is stored at prompt time and delivered once on the first PostToolUse (verified end to end against Grok 1.0.41, including post-/compact recovery from its chat_history.jsonl):

node scripts/install-memory-hooks.mjs --runtime grok            # dry-run
node scripts/install-memory-hooks.mjs --runtime grok --apply    # writes only ~/.grok/hooks/dev-team-kit-memory.json
node scripts/learned-skills-to-ai-memory.mjs --project    # dry-run; --apply publishes learned-skills to ai-memory via docker exec
node scripts/memory-secrets-scan.mjs                            # which agent transcripts carry credentials (type and count, never the value)
node scripts/eval-memory-recall.mjs --strict                    # injection eval: positives carry the answer, negative controls inject zero

Per-agent compatibility (what was verified and what was not) is in policies/compaction-recovery.md; learned-skill states, freshness and accepted formats in policies/learned-skills.md.

The optional Docker ai-memory backend is not silently upgraded when you reinstall the kit: its SQLite migrations are forward-only. Inspect without changes: node scripts/ai-memory-setup.mjs --check. Upgrade a recognized kit-owned server with a new, external backup archive: node scripts/ai-memory-setup.mjs --upgrade --backup-to /absolute/new/ai-memory.tar.gz (or bash setup/install.sh --upgrade-ai-memory --backup-to ). See policies/memory-backends.md for Windows host CLI upgrades, unknown-container refusal and rollback.

Hook Profiles

Controlled by the env variable DEVKIT_HOOK_PROFILE (default: standard):

• DEVKIT_HOOK_PROFILE — sets the active profile (minimal, standard or strict)
• DEVKIT_DISABLED_HOOKS — comma-separated list of hookIds to disable regardless of profile

Context Guard — Strategic Compact

The context-guard-stop hook operates on two levels:

• 50% — non-blocking warning: suggests /compact while there’s still margin
• 75% — smart block: shows current task hint, files edited in the session and decisions from the working set before blocking

Context and catalog cost — measured inventory, not host telemetry

The kit now separates bytes stored on disk from the payload a host actually sends to a model. The current local inventory is:

The token figures are proxies, not measured provider or host tokens. Capture an actual systemMessage and pass it to scripts/skill-health.mjs or scripts/skill-catalog-budget.mjs with --observed to measure the observed payload. A smoke capture of the hook produced 423 chars; that is still not provider token telemetry. Complete SKILL.md bodies are lazy and must not be counted as fixed catalog cost without host evidence.

The catalog compactor is dry-run by default. Its current proposal removes 28,703 description characters (~7,176 proxy tokens per turn), but would drop 89 positive-fixture trigger lines. It therefore preserves complete trigger lines, reports the affected fixtures and blocks normal --apply until the losses are reviewed. Do not use --apply during an audit.

The generated inventory and flags are in docs/skill-health.md. Verify routing and trigger coverage with:

node scripts/eval-triggers.mjs --strict       # 86/86
node scripts/eval-plugin-routing.mjs          # 44/44
node --test scripts/tests/*.test.mjs          # 121 passed, 0 failed, 6 skipped

---

Subagents — Specialists Dispatchable via the Task Tool

The kit ships 16 Claude Code subagents in .claude/agents/, ready to dispatch with the Task tool or invoke from the prompt.

Every agent ends with the same Conduct block, generated from one source (policies/subagent-conduct.md) and guarded by a test: investigate before claiming and say what was not verified, return a self-contained report, batch independent reads, stay within the request. Agents that can write also confirm before anything destructive or visible to others (no --no-verify, no discarding unknown files), never weaken a test to make it pass, and clean up what they created. Agents without a dispatch tool (Codex, Grok, Cursor, Gemini, OpenCode) use the file as a role prompt (see AGENTS.md).

Core (5)

Detective Spec (4) — phases of /detective-spec

Static Analysis (5) — pipeline of skill 34

Content (1)

Quality (1)

Invocation example:

Dispatch the code-reviewer subagent to review changes in src/auth/login.ts

Use the debugger subagent to investigate the crash TypeError: Cannot read properties of undefined in api/users.ts

Subagents are copied to the consuming repo’s .claude/agents/ by install.sh. See docs/skill-guides/subagents.md for the full guide on when to use each.

---

MCP Server — 38 Tools for Any MCP Client

{
  "mcpServers": {
    "dev-team-kit": {
      "command": "node",
      "args": [".bot/mcp-server/dist/index.js"],
      "env": {
        "FAL_KEY": "fal-...",
        "BRAVE_SEARCH_KEY": "BSA...",
        "FIRECRAWL_KEY": "fc-..."
      }
    }
  }
}

Works in Claude Code, Windsurf, Gemini CLI, Cursor and any MCP client.

See mcp-server/README.md for full tool documentation.

---

API Keys Required

The installer prompts for each key and saves them in the project’s .env.local.

---

Daily Ergonomics

• read docs/quickstart.md to get into the flow fast
• reuse docs/repo-audit/current.md before exploring the repo
• use devkit_context_pack to start a task without re-reading half the repo
• use devkit_diff_brief to resume work or prep a review
• use devkit_working_set to persist hot files and next steps
• use commands/ as operational shortcuts
• consult docs/skill-call-matrix.md when there’s overlap between skills
• consult docs/skill-guides/ only on demand
• consult docs/skill-guides/ideation-frameworks.md — SCAMPER, HMW, First Principles, JTBD for the ideation phase
• consult docs/skill-guides/skill-discovery.md — decision tree to pick the right skill per task type
• consult docs/skill-guides/context-engineering.md — context hierarchy, trust levels and packing strategies
• consult docs/skill-guides/autonomous-loop.md — /auto protocol for autonomous execution

---

Slash Commands — Shortcuts by Development Phase

/loop — Auto-Loop v2 (Multi-Agent Orchestrator)

scripts/auto-loop/ is an autonomous orchestrator that ships tasks ready, working, polished and tested. Run it overnight, wake up to a PR ready to merge.

# Basic usage (single run, claude agent)
node scripts/auto-loop "your task here"

# Pick the agent
node scripts/auto-loop "task" --agent codex
node scripts/auto-loop "task" --agent claude

# Isolated worktree + parallel (3 tasks in 3 worktrees)
node scripts/auto-loop --worktree --parallel 3 -- "task A" -- "task B" -- "task C"

# Configurable polishing pass (default: standard)
node scripts/auto-loop "task" --polish=full

# Fine-grained control
node scripts/auto-loop "task" --max-tokens 200000 --stop-when "tests cover the new endpoint"

v2 features:

Circuit breaker: same error 3x, stall (3 iterations without git diff), budget exhausted, or task blocked — stops automatically.

Exit codes: 0 ok / 1 usage / 2 permanent error / 3 retryable exhausted / 4 breaker tripped / 5 stall / 6 token cap / 7 polish incomplete / 130 interrupted / 99 fatal.

Production-ready:

• 21 smoke tests under scripts/tests/auto-loop/, all green. Run: node scripts/tests/auto-loop/run-all.mjs.
• Cross-platform (macOS, Linux, Windows) — adapters spawn through the shell on Windows so npm-installed .cmd launchers resolve.
• Each run writes .auto/runs//status.json with {iterations, commits, exitCode, worktreePath, ...} for parallel parents and external tooling to consume.
• Opt-in real-LLM smoke: node scripts/tests/auto-loop/smoke-real.mjs (manual, costs tokens).

What changed 2026-04-30 → 2026-05-01:

• Initial v2 release on 04-30: multi-agent (claude + codex), integrated worktree, parallel mode, polishing pass, gnhf-inspired flags (--max-tokens, --stop-when, prevent-sleep, JSONL log, classified backoff, 2-stage Ctrl+C, robust resume), bilingual docs.
• Gap fixes shipped 05-01: codex E2E test with fake CLI shim (zero tokens), polish skill-path verification + retry path test, runner+worktree integration test, status.json wired into parallel summary (was showing - placeholders), Windows portability fixes (gitDiffSinceBaseline no longer POSIX-only; adapters resolve .cmd/.bat launchers).
• Tests: 17 → 21, all passing. Commands and exit codes unchanged.

---

Global Governance

• GLOBAL.md is the highest instruction layer
• policies/ standardize execution, risk, persistence, quality and evaluation
• templates/ reduce variation in handoff, plan, review and rejection
• policies/tool-safety.md — safe usage of write, network, MCP and external actions
• policies/model-routing.md — model tiers, enforcement and integration with cost-tracker
• policies/evals.md — minimum evidence for structural changes to the kit
• policies/search-first.md — research mandatory before implementing (feature, bugfix, integration, refactor)
• policies/iterative-retrieval.md — progressive retrieval in 3 rounds for delegated subagents and skills
• policies/anti-rationalization.md — common rationalization tables + rebuttals per critical skill
• policies/source-driven.md — mandatory source hierarchy for framework/lib decisions
• policies/confusion-management.md — STOP-NAME-OPTIONS-WAIT protocol for detected confusion
• policies/context-engineering.md — 5-level context hierarchy and 3 trust levels

Instruction Hierarchy

1. GLOBAL.md
2. policies/*.md
3. skills/*/SKILL.md
4. templates/*.md

---

Real Repo Structure

.
├── .claude/              ← slash commands (/spec, /plan, /build, /test, /review, /simplify, /ship, /pipeline, /best, /auto, /loop)
│   └── commands/
├── .claude-plugin/       ← Claude Code plugin manifest
│   └── plugin.json
├── .github/              ← CI workflows (validate-plugin, validate)
│   └── workflows/
├── AGENTS.md
├── CLAUDE.md
├── GLOBAL.md
├── README.md
├── commands/             ← slash commands (/audit-repo, /devkit-install-fv, ...)
├── docs/
│   ├── quickstart.md
│   ├── repo-audit/
│   ├── skill-guides/
│   └── skill-call-matrix.md
├── evals/
├── hooks/                ← lifecycle hooks for Claude Code
│   ├── hooks.json
│   ├── config.json
│   └── scripts/
├── mcp-server/           ← MCP server with 38 tools
├── patterns/ai-integration/
├── personas/             ← agent personas (code-reviewer, security-auditor, test-engineer)
├── policies/             ← model-routing, tool-safety, cost-optimization, evals
├── scripts/              ← generate-image.py and utilities
├── setup/                ← multi-platform install.sh
├── skills/               ← 79 specialists (*/SKILL.md)
├── src/                  ← reusable hooks, stores, components and middleware
└── templates/            ← handoff, plan, review, rejection

---

Installed Structure in the Consumer Repo

When installed via /devkit-install-fv or setup/install.sh:

consumer-repo/
├── AGENTS.md
├── CLAUDE.md
├── GEMINI.md
├── .mcp.json                     ← Claude Code project MCPs
├── .claude/settings.json         ← hooks registered
├── .claude/commands/             ← slash commands (/spec, /plan, /build, /loop, ...)
├── .claude/agents/               ← subagents dispatchable via Task tool
├── .github/copilot-instructions.md
├── .windsurf/rules/dev-team-kit.md
├── .windsurf/mcp.json
├── .gemini/settings.json
└── .bot/
    ├── GLOBAL.md
    ├── commands/                 ← operational commands (/audit-repo, /devkit-install-fv, ...)
    ├── docs/                     ← skill-guides, repo-audit, quickstart
    ├── evals/
    ├── hooks/                    ← lifecycle hooks
    ├── learned-skills/           ← project-accumulated knowledge (score 0-1, weekly decay, auto-archived in .archive/ below 0.3)
    ├── mcp-server/               ← compiled and ready
    ├── patterns/ai-integration/
    ├── personas/                 ← code-reviewer, security-auditor, test-engineer
    ├── policies/
    ├── scripts/
    ├── setup/
    ├── skills/
    └── templates/

The consumer repo also receives .claude/commands/ (48 slash commands) at the root, installed by setup/install.sh.

---

Quick Validation

pytest scripts/tests -q
node scripts/check-consistency.mjs
cd mcp-server && npm run build
bash scripts/smoke-install.sh

Design checkers — run these in the consumer repo

These verify the design rules instead of merely stating them. Point them at the app you’re building, not at this kit:

node scripts/check-design-generic.mjs src/    # indigo default, system-ui, AI gradient, pure black, 100vh
node scripts/check-contrast.mjs src/          # WCAG ratio computed, in BOTH themes
node bench/ab/score-design.mjs   # 0–100 score per arm, to compare across kit versions

Both exit 1 on failure (--warn reports only, --json for programmatic use). The design-anchor-guard hook applies the first set at write time and blocks a visual file carrying the statistical-default signature — escape hatch is a design-anchor: allow comment in the file.

Caveat worth knowing: check-contrast reads #hex and rgb() tokens. Colours declared in hsl(), oklch() or var() are skipped and still need manual verification.

---

Contributing

Want to add a skill, fix a bug or propose an improvement? See the full guide in CONTRIBUTING.md.

Quick summary:

1. Create the skill in skills/NN-name/SKILL.md and register it in plugin.json
2. For slash commands, add them to .claude/commands/ and register in plugin.json
3. Run node scripts/check-consistency.mjs before committing
4. Open a PR with an entry in CHANGELOG.md

---

Changelog

Full release history in CHANGELOG.md.

---

/swarm — Total Autonomy (v2.0.0+)

The only command that takes you from prompt → PR mergeable without human intervention.

/swarm "implement social auth with Google + GitHub"

The kit:

1. Creates isolated git worktree
2. Generates PRD + breaks into stories
3. Ralph loop: implements each story with fresh context (no contamination)
4. 4 parallel review agents: code + security + tests + anti-AI-writing
5. Synthesizes findings with severity decision matrix
6. Self-fixes CRITICAL/HIGH automatically
7. Creates PR with synthesis as comment, rebased on main

You come back to a PR ready for review.

When to use vs other commands

Inputs

/swarm "implement feature X"           # free text
/swarm fix #142                        # GitHub issue
/swarm --prd docs/prd/auth.md          # existing PRD
/swarm --resume                # continue stopped run

Autonomous + /swarm = manda e esquece

In ~/.claude/dev-team-kit-config.json set intent_classifier.autonomous: true:

• Hook detects feature intent → auto-suggests /swarm
• Claude auto-executes (no gates pause)
• You come back to a PR ready

Cleanup

Worktree NEVER deleted automatically. After PR merged:

git worktree remove .swarm//workspace
rm -rf .swarm/

Full protocol: policies/swarm-protocol.md.

---

Auto-Orchestration (v1.8.0+)

The kit detects intent from your prompt and suggests the appropriate program automatically — you don’t have to remember to invoke /run-program manually.

You say: "I need to add social auth to the app"
   ↓
[intent-classifier hook]
   → detects feature pattern → emits: /run-program spec-driven-development
   ↓
[Claude] invokes skill 39 (program-router)
   → asks via AskUserQuestion: dry-run / direto / ad-hoc / cancelar
   ↓
You choose → program executes with human gates where defined

4 autonomy levels

Active vs Autonomous — the key difference:

• Active = “show me the plan automatically, but pause at gates so I can approve them during execution”
• Autonomous = “execute everything without asking me anything”

The real difference is whether human gates during execution stay active.

Configure your level

// hook config (via /update-config or settings.json)
{
  "intent_classifier": {
    "enabled": true,         // false = Level 0 (manual)
    "auto_dry_run": true,    // DEFAULT v1.9.0+ — Level 2 Active
    "autonomous": false,     // true = Level 3 (autonomous, CI only)
    "suppress": []           // program ids to never suggest
  }
}

Edit ~/.claude/settings.json (Windows: C:\Users\\.claude\settings.json), save, and restart Claude Code.

Set up Level 3 (Autonomous) — your machine only (user-wide)

⚠ Zero human confirmations. Use only in non-interactive contexts (CI, scheduled tasks). Recomended: put this in user-wide config so the repo default stays Active (safer). File: ~/.claude/dev-team-kit-config.json

{
  "intent_classifier": {
    "enabled": true,
    "autonomous": true,
    "suppress": [
      "adversarial-dev",       // tem bash que mexe em $ARTIFACTS_DIR/app
      "comprehensive-review"   // postaria em PR sem revisão humana
    ]
  }
}

Pre-flight checklist before enabling Autonomous:

• [ ] Backup do repo / working tree limpa
• [ ] Programs perigosos no suppress list
• [ ] CI/cron tem timeout (ex: máx 30min)
• [ ] Logs persistentes em .run-program/*.log.json acessíveis para debug pós-mortem
• [ ] git push --force proibido (ver policies/tool-safety.md)
• [ ] Notification webhook em caso de falha

Set up Level 0 (Manual) — disable completely

{
  "intent_classifier": {
    "enabled": false
  }
}

Override temporário via env var

# bash/zsh — uma sessão só
export DEVKIT_INTENT_CLASSIFIER_AUTONOMOUS=true
claude

# powershell
$env:DEVKIT_INTENT_CLASSIFIER_AUTONOMOUS="true"; claude

Full reference: policies/auto-orchestration.md.

6 intent patterns detected

Skip auto: informational prompts (“o que é…”), trivial (“fix typo”), or already a /slash command.

---

Acknowledgements

This kit is the result of looking at a lot of prior art and re-implementing the ideas that fit our skill-kit model. Nothing here is copied code — each item below was reimagined as policy, skill, or zero-dep script in our own conventions. Links lead to the upstream projects that inspired each direction.

Full third-party attribution (license + scope) is in NOTICE, preserved per Apache-2.0 §4(d).

---

License & attribution

Licensed under the Apache License, Version 2.0. See LICENSE for the full text and NOTICE for the third-party attribution that must be preserved in any redistribution.

If you fork, repackage, or build on top of this kit: keep NOTICE intact. The people listed there shaped the patterns inside — attribution is the only thing the license asks of you.

---

🇧🇷 Leia em Português