convez.ai
SkillAutomaçãoAvançado
1JayPeng

Do It — Orquestrador de Workflow TDD

1JayPeng/doit-skill

Um comando executa spec, TDD, E2E, review e commit automático

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill que automatiza o ciclo completo de desenvolvimento spec-driven com TDD para Claude Code. Um único comando `/doit` executa especificação, planejamento, testes, review, simplificação, commit e push — eliminando orquestração manual e integração de ferramentas.

Instalação

$npx convez-ai 1JayPeng/doit-skill

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 3 meses
Versão
v1.0.1
Issues abertas
0
Contribuidores
1

Casos de uso

  • Implementar features completas com workflow TDD automatizado
  • Corrigir bugs com testes e validação integrada
  • Otimizar token e contexto durante desenvolvimento iterativo

Veredito

Ferramental robusto para dev workflow completo, mas requer stack extenso de dependências. Ideal para equipes que querem eliminar fricção em ciclos spec-driven; exige curva de aprendizado para troubleshoot integração de 10+ ferramentas.

README

A tradução para o português deste README ainda está na fila.

Do It — Do It Skill

One command. Everything done.

Type /doit <what you want> in Claude Code. doit handles the rest: spec, plan, TDD, E2E tests, review, simplify, commit, push.

> /doit I need a user authentication system

[DOIT] Type: F (feature) -> Full workflow
[DOIT] Phase 0: Classifying...
[DOIT] Phase 1: Grilling idea with internet research...
...
[DOIT] Phase 8: Committed + pushed to origin/feat/auth
[DOIT] Phase 10: Session summary complete

No manual phase orchestration. No tool juggling. /doit dispatches every phase, calls every tool, and ships code.

English · 简体中文


Prerequisites

doit is a workflow orchestrator — it relies on specialized tools for each phase. All are installed automatically by the setup script, but understanding the stack helps troubleshoot:

LayerToolRole
Code graphcodegraph精准代码图查询 — 跨语言 AST 符号查找,调用图,影响分析
Code analysistokensave即时改动检测 + 高级分析 — 类型检查,死代码,复杂度,测试覆盖,代码编辑
Session contextcontext-modeCommand output indexing, semantic search, token savings

| Cross-session memory | MemPalace | Specs, decisions, knowledge graph — survives restarts | | Token optimization | Headroom | CCR (Compress-Cache-Retrieve) proxy compression — token savings | | Context optimization | lean-ctx | Lean context window management — token savings | | Token optimization | RTK | Auto-wraps Bash commands, saves 60-90% tokens | | Code review | code-review | OWASP security, architecture review | | Brevity mode | caveman | Token-compact responses, commit messages | | Web search | Tavily MCP | Internet research for spec grilling (optional) | | Skill creation | skill-creator | Skill eval framework, iterative improvement | | Python | uv | Fast Python package manager |

All tools degrade gracefully. If a tool is missing, doit skips that step and continues with the remaining capabilities.

Install

One line. All tools.

curl -fsSL https://v6.gh-proxy.org/https://raw.githubusercontent.com/1JayPeng/doit-skill/master/scripts/setup.sh | bash

Installs doit-skill + all dependencies. Detects what's already installed. Re-run to update.

# Skip optional tools
curl -fsSL https://v6.gh-proxy.org/https://raw.githubusercontent.com/1JayPeng/doit-skill/master/scripts/setup.sh | bash -s -- --skip-optional

# Dry run
curl -fsSL https://v6.gh-proxy.org/https://raw.githubusercontent.com/1JayPeng/doit-skill/master/scripts/setup.sh | bash -s -- --dry-run

# Verify
./scripts/doctor.sh

Alternative install methods:

# Via npx
npx skills add 1JayPeng/doit-skill

See setup.md for details.


Usage

Everything starts with /doit. One command covers all scenarios:

# New feature
> /doit Add user authentication with OAuth2

# Bug fix
> /doit The login page crashes when email is empty

# Simple change
> /doit Rename the config file to settings.yaml

# Resume (no argument)
> /doit

doit auto-classifies the request:

TypeWhenWhat Happens
F (feature)New functionality, cross-moduleFull pipeline: spec -> plan -> TDD -> E2E -> review -> simplify -> commit
B (bug)Something brokenDebug workflow: diagnose -> regression test -> fix -> verify -> commit
S (simple)Single file, quick fixExecute directly, skip ceremony
R (resume)No argumentResume from where you left off

How It Works

doit addresses a fundamental problem: AI agents jump straight to code without thinking. This produces code that looks correct but misses edge cases, has duplicated logic, or doesn't solve the stated problem.

doit inserts structured thinking between "user asks" and "agent codes":

User request -> Classify -> Spec (grill + REQ) -> Plan (code graph)
    -> Execute (TDD per REQ) -> E2E (real env) -> Review -> Simplify -> E2E verify -> Commit

Each phase is mandatory. Phases can't be skipped. The workflow enforces quality gates that prevent common failures:

GateWhat it prevents
Spec before codeBuilding the wrong thing
TDD per REQCode without tests
E2E after executeTests that pass but feature doesn't work
Review + SimplifyDuplication, over-engineering, dead code
E2E verify after simplifySimplification breaking working code
Commit + PushLost work

Four Major Principles

doit enforces four coding principles throughout the workflow, built into each phase's execution rules:

PrincipleWhat it preventsApplied In
Think Before CodingWrong assumptions, hidden confusionPhase 1 grill — challenge assumptions before writing REQs
Brevity FirstOver-engineering, bloated abstractionsPhase 3 minimal implementation, Phase 6 remove unnecessary code
Surgical EditsUnrelated edits, touching working codePhase 3 only modify planned files, Debug minimum change
Goal-Driven ExecutionVague success criteria, endless clarificationPhase 3 testable verification per REQ, Phase 7 compare against spec

How each principle enforces itself:

  • Think Before Coding → Phase 1 grill challenges every assumption. No code until spec is clear.
  • Brevity First → Phase 6 (Review + Simplify) removes unnecessary abstractions, merges duplicates, reduces line count.
  • Surgical Edits → Each phase only touches files identified by the plan. No drive-by refactoring.
  • Goal-Driven Execution → Every REQ has testable verification. E2E loop compares actual output against spec REQs.

Workflow Phases

PhaseWhatTools
-1Detect project environmentBuilt-in
0Classify request (R/S/F/B)Built-in, caveman, mempalace
1Spec generation + grillTavily MCP, grill-me, mempalace
2Plan with code graphcodegraph + tokensave, mempalace
3Execute TDD + Review+SimplifyRTK, uv, tokensave, context-mode
4E2E tests (mandatory)tokensave, context-mode
5Code reviewcode-review, tokensave
6Review + Simplify (mandatory)tokensave
7E2E Verification Looptokensave, context-mode
8Git commit + Pushgit
9.5Completion Summary + Knowledge Extractionmempalace
9.5.5Knowledge Distillation (structured learning)learn/, mempalace, context-mode
10Session SummaryRTK, context-mode, headroom, mempalace

E2E Verification Loop

Phase 6 (Review + Simplify) rewrites code. Phase 7 re-runs all E2E tests to verify the rewrite didn't break behavior, then compares actual output against spec REQs. If output doesn't match spec, fix the code — never change the spec to match broken output.

Simplify done -> E2E tests -> Pass? -> Spec alignment -> Match? -> Commit
                       ↓                ↓               ↓
                      Fail           Fix code       Done

Max 3 iterations. After 3 failures, escalate to user.

Review + Simplify (Mandatory)

Phase 5 reviews code for duplication, security vulnerabilities (OWASP Top 10), over-abstraction, and dead code. Phase 6 simplifies: merges duplicate logic, deletes dead code, flattens unnecessary abstraction layers, and reduces line count.

Unreviewed code cannot be committed. After simplification, Phase 7 re-runs all E2E tests to verify nothing broke.

E2E Quality

Phase 4 tests the user's full journey — exit codes, stdout, file output, database state — not unit tests with subprocess.

LevelWhatMode
L0Required params, happy pathAuto
L1Boundary valuesAuto
L2Conflicting param combinationsHITL
L3Fuzzy/random input, stabilityHITL

Five-Layer Memory

doit integrates five memory layers so context survives across sessions:

LayerToolWhat It Stores
Code graphCodeGraphPrecise AST-based symbols, call edges, cross-language — survives code changes
Code analysisTokenSaveImmediate change detection, diagnostics, complexity, test coverage — survives code changes
Session contextContext-ModeCommand output, semantic search index — survives tool calls
Cross-sessionMemPalaceSpecs, decisions, knowledge graph, agent diary — survives restarts
Token optimizationHeadroomCCR (Compress-Cache-Retrieve) proxy compression — token savings

CodeGraph + TokenSave complementary: CodeGraph provides precise code graph queries (callers/callees accurate, cross-language support), TokenSave provides immediate change detection (15ms indexing) and advanced static analysis (diagnostics, dead code, complexity, test coverage). Both run in parallel for cross-validation.

MemPalace (30 MCP tools, KG + semantic search, diary). Follows read-write symmetry: every phase that writes also reads back in subsequent runs. Phase 0 sweeps 10 parallel calls to reconstruct project context.

RTK auto-wraps every Bash command via PreToolUse hook, saving 60-90% tokens across all phases.

See tool-integration-guide.md for per-phase tool call details.

Bundled Skills

Six skills ship inside skills/, installed with doit:

SkillPurposeUsed In
grill-meIdea grillingPhase 1
tddTDD loopPhase 3
diagnoseBug diagnosisDebug D0
prototypeThrowaway prototypesPhase 1
handoffSession handoffAny phase
improve-codebase-architectureArchitecture deepeningPhase 5

External Tools

All external tools are installed by setup.sh. If a tool is missing, doit degrades gracefully.

RTK (Rust Token Killer)

Token-optimized CLI proxy — saves 60-90% tokens on all Bash commands. GitHub

# 1. Install binary to $HOME/.local/bin/rtk
curl -fsSL https://v6.gh-proxy.org/https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

# 2. Add $HOME/.local/bin to PATH (install script does NOT do this)
export PATH="$HOME/.local/bin:$PATH"
# Persist for future shells:
grep -q 'export PATH=.*\$HOME/.local/bin' ~/.bashrc 2>/dev/null || \
  echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc

# 3. Initialize for Claude Code (installs hooks + RTK.md globally)
rtk init -g

Rust (required by TokenSave)

# Install via rustup (Tsinghua mirror for China)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \
  | RUSTUP_DIST_SERVER=https://mirrors.tuna.tsinghua.edu.cn/rustup \
    RUSTUP_UPDATE_ROOT=https://mirrors.tuna.tsinghua.edu.cn/rustup/rustup \
    sh -s -- -y
source "$HOME/.cargo/env"

# Configure cargo mirror (USTC) — optional, speeds up downloads in China
mkdir -p ~/.cargo
cat > ~/.cargo/config.toml <<'EOF'
[source.crates-io]
replace-with = 'ustc'
[source.ustc]
registry = "sparse+https://mirrors.ustc.edu.cn/crates.io-index/"
EOF

TokenSave

Code graph MCP server — symbol lookup, impact analysis, call graphs. GitHub

# 1. Install (requires Rust)
cargo install tokensave

# 2. Configure for Claude Code
tokensave install --agent claude

# 3. Initialize in project
tokensave init

Context-Mode

Context window management — command output indexing, semantic search. GitHub

# Install as Claude Code plugin
claude plugin marketplace add mksglu/context-mode
claude plugin install context-mode@context-mode

Headroom

Context optimization — proxy compression + memory persistence. GitHub

# 1. Install via uv
uv tool install "headroom-ai[mcp,proxy]"

# 2. Register MCP server
headroom mcp install

lean-ctx

Context optimization — lean context window management with AI agent integration. Website

# 1. Install binary
curl -fsSL https://leanctx.com/install.sh | sh

# 2. Verify
lean-ctx --version

# 3. Connect all AI tools
lean-ctx onboard
source ~/.bashrc
lean-ctx init --agent claude

# 4. Manual fallback (if step 3 doesn't configure Claude Code)
claude mcp add lean-ctx lean-ctx

# 5. Verify
lean-ctx doctor

After installation, usage rules appear at ~/.claude/rules/lean-ctx.md.

MemPalace (memory layer)

Cross-session semantic memory — specs, decisions, knowledge graph, agent diary. GitHub

# 1. Install plugin
claude plugin marketplace add MemPalace/mempalace
claude plugin install --scope user mempalace

# 2. Install CLI (optional, for mempalace init)
uv tool install mempalace

# 3. Initialize in project
mempalace init .

caveman

Brevity mode — token-compact responses, commit messages. GitHub

# Install as Claude Code plugin
claude plugin marketplace add JuliusBrussee/caveman
claude plugin install caveman@caveman

# Install hooks (statusline badge)
npx -y "github:JuliusBrussee/caveman" --with-hooks --skip-skills

# Configure statusline in settings.json
# setup.sh does this automatically — it sets statusLine to caveman-statusline.sh

code-review

Code review — OWASP security, architecture review. GitHub

claude plugin install code-review

uv

Fast Python package manager. GitHub

pip install uv

Tavily MCP

Internet search for spec grilling. Tavily

# Add to .mcp.json (requires API key):
claude mcp add --transport http tavily https://mcp.tavily.com/mcp/?tavilyApiKey=<your-key>

CodeGraph

Cross-language code graph — AST-based symbol lookup, call graphs, impact analysis. Fallback when TokenSave is unavailable. GitHub

# Install via npm
npm i -g @colbymchenry/codegraph

# Configure MCP server
codegraph install --yes

# Initialize in project
codegraph init -i

skill-creator

Skill creation and evaluation framework — iterative skill improvement with eval viewer. GitHub

# Install via npx skills CLI
npx skills add anthropics/skills@skill-creator

# Verify
npx skills list | grep skill-creator

Used by doit-skill's knowledge distillation module (Phase 9.5.5) to test and iterate on extracted knowledge patterns.

Resume Mid-Session

A single /doit invocation may not complete the entire workflow. To continue from where you left off, simply type /doit again. doit determines the current phase from conversation context, git state, and spec files. MemPalace diary entries and KG facts provide cross-session recovery when filesystem state is insufficient.


Recent Changes

2026-06-07 — Knowledge distillation module (Phase 9.5.5):

  • New learn/ module: structured knowledge extraction at Phase 9.5.5
  • Knowledge injection at Phase 1/2 — injects relevant past sessions before grill
  • Historical data migration from git, mempalace, worklog
  • Multi-layer storage: mempalace + context-mode + filesystem
  • skill-creator integration for eval-driven skill improvement
  • setup.sh: installs skill-creator via npx skills CLI

2026-06-12 — MemPalace as sole memory layer:

  • Removed AgentMemory (never actually used in practice)
  • MemPalace is primary: semantic search + KG + diary
  • setup.sh: Clean MemPalace installation without agentmemory
  • doctor.sh: Checks MemPalace plugin + CLI

2026-06-04 — Workflow as iron rule — no phase can be skipped:

  • New iron rule: "完整工作流不可跳过" — every phase mandatory, in order, no skipping
  • New iron rule: "Review + Simplify 不可跳过" — unreviewed code cannot be committed

2026-06-04 — MemPalace read-write symmetry integration:

  • Iron rule: "MemPalace read-write symmetry" — MP calls same level as tokensave, mandatory when available
  • Phase 0: embedded 10 parallel MP sweep calls (4 core + 4 knowledge rooms + 2 sessions feedback)

2026-06-04 — Comprehensive code review fixes:

  • Security: Fixed command injection vulnerability in scripts/add-dependency.sh
  • Bug: Fixed goto_step_9 bash syntax error in env-check.md

Structure

doit-skill/
├── SKILL.md          # Main entry point
├── env-check.md      # Phase -1: environment detection
├── classifier.md     # Request type detection
├── doc-capture.md    # Doc capture (pre-phase)
├── doit-config.md    # Config reference
├── spec.md           # Phase 1: grill + REQ generation
├── plan.md           # Phase 2: code graph scan
├── debug.md          # Debug workflow D0-D6 (Type B)
├── execute.md        # Phase 3: TDD loop + Review+Simplify
├── e2e.md            # Phase 4: end-to-end testing
├── review.md         # Phase 5: code review
├── review-simplify.md -> shared/review-simplify.md
├── commit.md -> shared/commit.md
├── errors.md         # Failure handling
├── shared/           # Shared phases (Feature + Debug)
│   ├── review-simplify.md
│   ├── e2e-verify.md
│   └── commit.md
├── skills/           # Bundled skill dependencies
│   ├── grill-me/     # Idea grilling
│   ├── tdd/          # TDD loop
│   ├── diagnose/     # Bug diagnosis
│   ├── prototype/    # Throwaway prototypes
│   ├── handoff/      # Session handoff
│   └── improve-codebase-architecture/
└── scripts/          # Install and utility scripts
    ├── setup.sh      # Full install
    ├── doctor.sh     # Dependency health check
    └── add-dependency.sh

Adding Dependencies

Add a bundled skill

./scripts/add-dependency.sh <skill-name> bundled

Add an optional skill

# Edit package.json
"dependencies.optionalSkills": {
  "new-skill": "recommended"
}

Add an external tool

# Edit package.json
"dependencies.tools": {
  "new-tool": "install-command"
}
Ver o original no GitHub

Bom para

Relacionados