greenheart — Pipeline de Engenharia Verificável
0zoriginals/greenheart
Pipeline verificável local-first para AI-assisted code shipping, não apenas geração
Ver no GitHubAgent open-source que transforma Claude Code em um pipeline de engenharia com 7 fases e gates mecânicos obrigatórios. Local-first, sem vendor lock-in, com 27 slash-commands e validação automática de código. Metodologia de trabalho auditável e reproduzível para desenvolvimento de IA assistido.
Instalação
npx convez-ai 0zoriginals/greenheart1 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
Casos de uso
- Estruturar workflows de desenvolvimento com Claude Code em fases controladas
- Implementar gates de qualidade mecânicos entre cada etapa de desenvolvimento
- Auditar e reproduzir processos de codificação assistida por IA
- Evitar vendor lock-in mantendo metodologia própria na máquina local
Veredito

Ferramenta sólida para desenvolvedores que priorizam soberania e auditoria em workflows de IA. Abordagem pragmática: metodologia em vez de magic-box. Ideal para quem quer controle total e reprodutibilidade, não para quem busca automação acrítica.
README
A tradução para o português deste README ainda está na fila.
Stop renting your dev workflow.
greenheart is the open-source methodology plugin that turns Claude Code into a verifiable engineering pipeline. Local-first. Vendor-free. Gates you can't silently skip.
npx greenheart-cli install
macOS · Windows (Git Bash) · Linux · No signup. No account. No vendor lock.
The pitch in three lines
- Cursor rents you a workflow. Devin rents you a magic-box. Cline rents you a cloud. We hand you a methodology you can fork and run on your own machine.
- AI tools made you ship faster. They didn't make your code more trustworthy. greenheart is the 7-phase pipeline that makes AI-assisted code reproducible, verifiable, and shippable — not just generatable.
- 27 slash-commands. 4 mechanical quality gates. Zero telemetry. This is the methodology layer Claude Code was missing.
What you actually get
greenheart runs inside your Claude Code session. It adds 27 slash-commands that turn a chaotic "ask AI and hope" workflow into a 7-phase pipeline with mechanical gates between each phase.
Every connection is a gate. Skip it, the next phase rejects you. Try to bullshit it, validate.cjs catches the drift. Solid lines are required paths; dashed are optional or sibling-or-paths (your choice).
What greenheart is not
| It's not | Use instead |
|---|---|
| An IDE | Keep your editor. greenheart layers on Claude Code. |
| A Cursor / Cline replacement | They're tools. We're a methodology. Use Claude Code for AI-pasting. Use greenheart for AI-shipping. |
| A Devin / Bolt agent | Agents are magic-boxes. We're the opposite: every step writes an audit-trail. |
| A SaaS | No signup. No account. No API key vending. Your subscription, your machine. |
| For enterprise procurement | We're for solo devs who ship to real users. If you need SOC2, look elsewhere. |
Why this, not Cursor / Cline / Devin
| greenheart | Cursor | Cline | Devin / Bolt | |
|---|---|---|---|---|
| Open-source | ✅ MIT | ❌ closed | ✅ Apache | ❌ closed |
| Local-first | ✅ your machine | ❌ cloud-coupled | ❌ cloud-coupled | ❌ cloud-only |
| No vendor lock | ✅ runs on Claude Code | ❌ vendor platform | ❌ vendor platform | ❌ vendor platform |
| Methodology layer | ✅ 7-phase pipeline | ❌ IDE only | ❌ tool only | ❌ agent only |
| Mechanical quality gates | ✅ validate / smoke / qa | ❌ linter only | ❌ linter only | ❌ none visible |
| Multi-lens planning | ✅ deepplan (5 sub-agents) | ❌ | ❌ | ❌ |
| Manual OR auto execution | ✅ both | ❌ one mode | ❌ one mode | ❌ auto only |
| Audit trail per step | ✅ artifact per phase | ❌ | partial | ❌ |
| Your subscription | ✅ Claude Code | extra | extra | extra |
| Telemetry | ✅ zero | ❌ | partial | ❌ |
The 7 phases
1. CONTEXT vision (V1-V8) · discuss (5-7 questions or PRD)
↓
2. DISTILL compress context → deterministic 12-field XML brief
↓
3. INVESTIGATE deepplan (optional, 5 parallel sub-agents)
↓
4. PLAN plan (board.json + briefs) · planandwork (copy-paste prompts)
↓
5. EXECUTE autoexecute (parallel OS terminals) · or manual spawn
↓
6. VERIFY verify · review · adversarial · smoke (4 mechanical gates)
↓
7. CLOSE close (SIGNOFF.md) · ship (PR + release)
Each phase has commands. Each command writes artifacts. Each artifact is auditable.
Phase 1 — Context engineering (vision / discuss)
Before any code, you tell greenheart what you're building. Not by typing a one-liner into a prompt-box. By answering 5-8 structured questions that produce a permanent, version-controlled context document.
/greenheart:vision— project-, feature-, or phase-scope context (V1-V8 for projects)/greenheart:discuss— phase-level requirements (5-7 questions, or PRD-mode for critical tasks)
Phase 2 — Distill (distill)
The vision/discuss output gets compressed into a deterministic 12-field XML brief (goal, context, inputs, outputs, requirements, constraints, errors, edge_cases, out_of_scope, open_questions, acceptance_criteria, source_quotes). Every downstream LLM phase reads the brief. No conversation re-reading. No drift.
Phase 3 — Deepplan (deepplan, optional)
For non-trivial architectural decisions: spawn 5 parallel sub-agents that investigate the problem through different lenses (Implementation-Path / Risk-Hunter / Alternative-Approach / Verification-Strategy / Codebase-Surface). Brain synthesizes their reports into FINDINGS.md. Then plan runs on top.
Phase 4 — Plan (plan / planandwork)
Generate a plan-spec with block-breakdown, worker-briefs, and either:
/greenheart:plan→board.jsonfor autonomous execution/greenheart:planandwork→MANUAL-SPAWN-PROMPTS.mdwith copy-paste-ready prompts for manual terminal-spawning
Same pipeline. Your engagement choice.
Phase 5 — Execute (autoexecute / manual)
Either spawn parallel OS-terminal workers autonomously (autoexecute opens real Windows Terminal / iTerm / GNOME Terminal tabs), or paste the prompts yourself. Each worker runs in fresh context with allowed-tool whitelist and forbidden-action blacklist.
Phase 6 — Verify (verify / review / adversarial / smoke)
Four mechanical gates per block:
verify— 5-Gate Brain-Verify (Regression / Tests / E2E / Boot-Smoke / Spot-Check)review— Dual-Agent Code-Review (Junior Bug Hunter + Senior Critic + auto-fix)adversarial— 4-Dim Adversarial-Wave (Functional / Security / Performance / UX, parallel)smoke— Workflow-map + E2E user-journey
Skip a gate, the next phase rejects you. Try to silently bypass, the system writes a logged skip-file (audited).
Phase 7 — Close (close / ship)
close writes SIGNOFF.md (commit-attribution, gate-results, recurrence-watches, lessons). ship creates the PR + release-tag. Both gated on the previous phases passing.
Quick start
# 1. Install (no signup, no account, no API key)
npx greenheart-cli install
# 2. Open Claude Code in your project
cd your-project
# 3. Bootstrap a new project
/greenheart:hi
/greenheart:init
# 4. Define what you're building
/greenheart:vision
# 5. Compress it into a brief
/greenheart:distill
# 6. (Optional) Multi-lens investigation
/greenheart:deepplan
# 7. Plan + execute
/greenheart:plan
/greenheart:autoexecute
# 8. Or, if you prefer manual control:
/greenheart:planandwork
# (paste the prompts into your own terminals)
# 9. Close + ship
/greenheart:close
/greenheart:ship
That's the whole pipeline. The rest is variants for specific situations.
The 27 commands at a glance
ENTRY hi · init · vision
ORIENT where · think
PLAN discuss · distill · deepplan · plan · planandwork
TOOL tdd · debug
EXECUTE autoexecute
VERIFY verify · review · adversarial · smoke
CLOSE close · ship · recurrence
SUPPORT pause · resume · session-report · forensics · learn · wiki · help
Run /greenheart:help for full descriptions.
FAQ
Q: 27 commands sounds like a lot.
You don't memorize 27. You learn the 7-phase pipeline (vision → distill → plan → execute → verify → review → close). The rest are variants. Average session uses 4-6 commands.
Q: Doesn't Claude Code already have plan-mode? Claude Code has a plan-mode. greenheart has a methodology. Plan-mode plans one task. greenheart's pipeline plans, verifies, reviews, adversarially tests, and signs off — across multi-block phases, with mechanical gates between each.
Q: Why not Cursor / Cline? Cursor and Cline are IDE-replacements. They want to be your editor. greenheart isn't your editor. greenheart is the process around the editor. Use Claude Code (or Cursor, or Cline) for the AI part. Use greenheart for the pipeline around it.
Q: Is this a SaaS?
No. No signup. No account. No API key vending. No telemetry. You install via npx, files land in ~/.claude/plugins/greenheart/, the commands run inside your Claude Code session. Your code never leaves your machine via someone else's API.
Q: Will it slow me down? At the right moments, yes. Planning takes longer. Verification takes longer. Adversarial review takes longer. But total time-to-shipped-feature drops because you stop debugging AI-hallucinated production bugs in week 3.
Q: What if I want to skip a gate? The system writes a logged audit-file with reason + risk-acknowledgement. Three silent skips → drift warning. Six silent skips → ship-block. You can skip. You just can't silently skip.
Q: Open-source = no support? Correct. We're not promising enterprise SLA. We're promising the code is MIT-licensed and forkable. If maintenance stops, you own it. That's the deal.
Q: How do I know this isn't another abandoned side-project? Read the commit log. Active maintenance. Mechanical gates catch drift even when the author drifts. MIT-licensed — you can fork if needed.
Built on Claude Code
greenheart is a plugin, not a replacement. It assumes you're running Claude Code and adds 27 slash-commands on top.
- Claude Code does: the AI part (code generation, file editing, terminal commands)
- greenheart does: the pipeline around it (context, plan, execute, verify, gate)
You pay for Claude Code (your subscription). You don't pay for greenheart. There is no greenheart account. There is no greenheart cloud. There is no greenheart telemetry.
Install
npx greenheart-cli install
Three things happen:
- Clone/pull
~/.claude/plugins/greenheart/ - Sync 27 slash-commands →
~/.claude/commands/greenheart/ - Sync 5 worker-templates →
~/.claude/agents/greenheart/
That's it. Open Claude Code, type /greenheart:hi, and you're in.
Contributing
PRs welcome. Issues welcome. Discord welcome.
This is a solo-built project with a mechanical drift-defense (validate.cjs + mutation-tests + smoke-checks). Read CONTRIBUTING.md, fork, send a PR.
License
MIT. Your fork, your rules. No vendor can take this away.
Built for solo devs who ship to real users.
— Yusuf (0zoriginals)
Issues · Discussions · npm