convez.ai
AgenteDevOps & InfraestruturaIntermediário
0zoriginals

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 GitHub
InicialPluginScore · de 0 a 100

Agent 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/greenheart

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
0
Forks
0
Acompanhando
0
Saúde
57%
Último commit
há 5 meses
Versão
v0.5.1
Issues abertas
0
Contribuidores
4

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

npm version License: MIT Claude Code Local-First No Telemetry

macOS · Windows (Git Bash) · Linux · No signup. No account. No vendor lock.


The pitch in three lines

  1. 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.
  2. 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.
  3. 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 notUse instead
An IDEKeep your editor. greenheart layers on Claude Code.
A Cursor / Cline replacementThey're tools. We're a methodology. Use Claude Code for AI-pasting. Use greenheart for AI-shipping.
A Devin / Bolt agentAgents are magic-boxes. We're the opposite: every step writes an audit-trail.
A SaaSNo signup. No account. No API key vending. Your subscription, your machine.
For enterprise procurementWe're for solo devs who ship to real users. If you need SOC2, look elsewhere.

Why this, not Cursor / Cline / Devin

greenheartCursorClineDevin / 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 Codeextraextraextra
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.json for autonomous execution
  • /greenheart:planandwork → MANUAL-SPAWN-PROMPTS.md with 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:

  1. Clone/pull ~/.claude/plugins/greenheart/
  2. Sync 27 slash-commands → ~/.claude/commands/greenheart/
  3. 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

Ver o original no GitHub

Bom para

Relacionados