convez.ai
AgenteAutomaçãoAvançado
llamallamaredpajama

IDC Workflow — Pipeline de Desenvolvimento Multi-Agent

llamallamaredpajama/idc-workflow

Pipeline autônomo de desenvolvimento: ideia em, código testado e mergeado para fora

Ver no GitHub
InicialPluginScore · de 0 a 100

Plugin Claude Code que automatiza o ciclo completo de desenvolvimento de software através de um pipeline governado (Think → Plan → Sequence → Build → Ripple) com rastreamento de mudanças e automerge. Implementa guardrails inteligentes que bloqueiam apenas alterações funcionais, deixando tudo mais passar automaticamente até código mergeado e testado.

Instalação

$npx convez-ai llamallamaredpajama/idc-workflow

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
42%
Último commit
há 3 meses
Versão
v0.1.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Automatizar fluxo completo de desenvolvimento sem intervençãomanual em cada etapa
  • Validar mudanças de forma inteligente e bloquear apenas as que afetam função do produto
  • Rastrear e governar múltiplos agentes trabalhando simultaneamente em componentes
  • Implementar CI/CD com gates humanos apenas onde importa (PRD)

Veredito

Ferramenta sofisticada e bem arquitetada para quem quer automatizar o ciclo de desenvolvimento completo com filosofia clara (guardrails, não trilhos). Exige compreensão do fluxo IDC e integração com repositório, mas libera tempo significativo em equipes que trabalham com múltiplos agentes.

README

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


IDC is a water rig for software. You drop an idea into the Think Tank; the rig carries it down the pipe — planning, building, reviewing — purifies it through a Filter of real tests, and pours it out the Faucet as merged, working code in your Glass. The flow runs on its own and automerges when it's clean. It stops to ask you exactly one question — and only that one: when a change would alter what your software does for its users.

The whole system, in one picture

An idea enters the Think Tank and firms up into one consideration. It flows into the pipe and spins a run of turbines — each a stage of development. The Diverter Valve (the one gate) lets anything that doesn't change your product's function flow straight through; anything that does gets diverted up to the PRD, behind a lock only you can open. The water is screened by the Filter and poured out the Faucet. The only way anything flows backward is the Bleed Valve — a controlled return that runs all the way back to the gate.

→ The full mental model, part by part, lives in docs/mental-model.md.

Table of contents

What IDC is

IDC — the Iterative Development Cycle — is the rig in the picture above: a pipe with a few turbines (Think → Plan → Build), one Diverter Valve that can divert flow to the PRD, and one Bleed Valve for controlled backflow. Everything flows autonomously and automerges when green; the rig intervenes only where a real derailment would otherwise ship.

StageCommandThe part of the rigWrites
Think/idc:think🛢️ Think Tank — free brainstorm (zero teammates) → one function-first consideration.docs/considerations/
Plan/idc:plan⊙ Planning turbine — consideration → goal-contract issues: domain experts, the five-layer doc chain (only the PRD gated), matrix sequencing, board admission.docs/prd/, docs/specs/, docs/plans/, matrices, issues
Build/idc:build⊙ Implementer → ▒ Filter → ⊙ Finisher — each issue's goal contract runs as a goal loop; independent review screens every PR; automerge on PASS.source, tests, review reports, tracker status
Ripple/idc:ripple🩸 Bleed Valve — heals doc/reality drift in one PR (PR body = change order); PRD changes take the gate.every affected canonical doc
Autorun/idc:autorun🚰 Faucet — open it and the whole pipe drains on its own; loop it with /loop.—

Autorun opens the faucet full: unplanned considerations → plan → build eligible waves as they land → exit when nothing actionable remains.

The five guardrails

IDC v2 trusts the model and keeps only the parts of the rig that catch real derailments. There are exactly five:

#Guardrail (the part)What it prevents
1The one locked valve to the PRDYour product's function never changes without your consent.
2Parallel pipes on separate sections (matrix)Wide builds never collide.
3The Filter (real verification surfaces)Nothing reaches the Glass that isn't green on genuine functional tests.
4The Bleed Valve (Ripple)Docs and reality never silently diverge.
5One-way flow + the metered dashboardThe chain stays auditable end to end.

The one gate. When planning or ripple determines the PRD must change, the affected issues park Blocked behind a single approval issue (a plain-terms summary + the PRD diff). You get a push notification and open the valve from the GitHub web UI — on your phone. Nothing else asks for permission.

Install

IDC is opt-in per repo — its /idc:* commands must never appear in a repo you didn't choose. Claude Code installs a plugin's files machine-wide but decides where its commands activate by an enablement scope. So: register the marketplace once, then install at project scope inside each repo you want governed — never the default user scope, which would turn IDC on in every repo on the machine.

# once per machine — register the marketplace (installs/enables nothing on its own)
claude plugin marketplace add llamallamaredpajama/idc-workflow

# per repo — install AND enable for THIS repo only
cd <your-repo>
claude plugin install idc@idc-workflow --scope project

--scope project enables IDC in the repo's own .claude/settings.json and registers it disabled (idc@idc-workflow: false) at the global user scope — an explicit off-switch, stronger than merely being absent — so IDC stays invisible everywhere else. (Already installed at the default user scope from an older version? Seal the leak with claude plugin disable idc@idc-workflow --scope user — your project-scoped repos keep working.)

Updating. Bump-driven: claude plugin update idc@idc-workflow --scope project (the --scope project matters — the bare command errors for a project install). A plugin update rebuilds Claude Code's version-keyed cache, so a session may need a restart to pick up new command definitions.

A GitHub board needs the project OAuth scope: gh auth refresh -h github.com -s project.

Quickstart

Start a new Claude Code session in the repo (so the commands load), then:

/idc:init        # install the rig: contract + config + board + receipt
/idc:doctor      # pressure-test it (read-only health check)
/idc:think       # cast in your first idea
/idc:plan        # → goal-contract issues on the board
/idc:build       # drain the buildable issues to merged, reviewed code

/idc:init scaffolds the governance contract + config (filling domains from a codebase scan), provisions a 5-field GitHub Projects board linked to this repo — or uses the zero-setup filesystem backend — enables the plugin for this project only, and writes an install receipt. /idc:doctor's first check fails loudly if IDC is ever enabled at the global user scope.

The commands

Nine slash entry points:

CommandThe part of the rig
/idc:think🛢️ Think Tank — brainstorm → one consideration
/idc:plan⊙ Planning turbine — consideration → goal-contract issues
/idc:build⊙▒⊙ the build triplet — issues → merged, reviewed code
/idc:ripple🩸 Bleed Valve — heal doc/reality drift in one PR
/idc:autorun🚰 Faucet — open the whole pipe, drain it hands-off
/idc:init🔧 install the rig (idempotent)
/idc:doctor🔧 pressure-test the rig (read-only)
/idc:update🔧 upgrade the fittings after a plugin bump
/idc:uninstall🔧 remove the rig in one revertable commit

Architecture

The spine everything traces to is a five-layer canonical chain. Planning reaches Build only by turning plans into issues — the water in the pipe; Build reaches planning only through the Bleed Valve (Ripple). Flow is one-way, and a sensor on every turbine keeps the chain auditable end to end.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#9CA689','primaryTextColor':'#1b1a1c','primaryBorderColor':'#252427','lineColor':'#6f7a5e','fontFamily':'Trebuchet MS, Verdana, sans-serif'}}}%%
flowchart LR
    subgraph chain["Five-layer canonical chain — only the PRD is gated"]
        direction LR
        PRD["PRD"]:::doc --> SPEC["Arch spec"]:::doc --> MP["Master plan"]:::doc --> SUB["Subphase plans"]:::doc --> PIL["Pillar plans"]:::doc
    end
    PIL --> ISS["Tracker issues<br/>· the water in the pipe ·"]:::wall
    ISS --> BUILD["Build"]:::stage
    BUILD -.->|"Bleed Valve — the only way back"| PRD

    classDef doc fill:#F9FAFD,stroke:#252427,color:#252427;
    classDef stage fill:#9CA689,stroke:#252427,color:#1b1a1c;
    classDef wall fill:#252427,stroke:#252427,color:#F9FAFD;

Write-authority boundaries — each role is the sole writer of its surface and edits nothing upstream of it. When a lower role finds a higher layer wrong, it opens the Bleed Valve (files a Ripple) and pauses only the affected issue.

RoleMay writeMust NOT write
Thinkdocs/considerations/ onlyany canonical doc, tracker, source, tests
PlanPRD, spec, master/subphase/pillar plans, pillar matrices, tracker issuessource, tests
Buildsource, tests, review reports, tracker statusPRD, spec, plans
Rippleevery affected canonical doc (one PR), affected open issuessource, tests

See docs/mental-model.md for the water-rig picture in full, docs/architecture.md for the precise architecture, and docs/installing.md for detailed install + troubleshooting.

The dashboard

The tracker is the rig's dashboard — instrumentation bolted onto the pipe, a sensor on every turbine. Its backend is selected in docs/workflow/tracker-config.yaml and hidden behind an adapter — roles never hard-code backend semantics. Two backends ship: github (a GitHub Projects v2 board, first-class) and filesystem (a root TRACKER.md, zero external setup). /idc:init links the github board to this repo, so it shows on the repo's Projects tab and issue sidebar. The board carries five sensor readings:

FieldValues
StatusBlocked · Todo · In Progress · Done
StageConsideration · Planning · Buildable (which part of the pipe the drop is in)
WaveWave N (which parallel pipe — matrix-assigned)
PhasePhase N (master-plan phase trace)
Domainsingle-select (master-plan domain trace)

Plus native blocked-by links, an attempt:<n> label, and claim comments. Every issue body is a self-sufficient 6-element goal contract, so an outside agent can work it cold.

Runtime model

The process is written against three abstract primitives; exactly one thin adapter per runtime maps them to mechanics. There is no per-runtime process tree.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#9CA689','primaryTextColor':'#1b1a1c','primaryBorderColor':'#252427','lineColor':'#6f7a5e','fontFamily':'Trebuchet MS, Verdana, sans-serif'}}}%%
flowchart LR
    subgraph core["One core · three primitives"]
        direction LR
        DW["Durable worker"]:::p
        BF["Bounded fan-out"]:::p
        GL["Goal loop"]:::p
    end
    core --> CL["Claude adapter"]:::ad
    core --> CX["Codex adapter"]:::ad
    core --> PI["Pi adapter"]:::ad

    classDef p fill:#F9FAFD,stroke:#252427,color:#252427;
    classDef ad fill:#9CA689,stroke:#252427,color:#1b1a1c;

Model selection is tier-symbolic (reasoning / standard / utility in WORKFLOW-config.yaml, resolved by the adapter at spawn time); the Codex runtime runs untiered at highest effort. /idc:init --codex wires the Codex adapter (scripts/install-codex.sh --revert undoes it).

What ships

This repo is the plugin and its own marketplace:

  • 9 commands — the pipeline (think · plan · build · ripple · autorun) plus init, doctor, and the lifecycle pair update / uninstall.
  • 8 agents — the per-stage orchestrator playbooks, the durable-worker implementer + finisher, and the review coordinator + review agent.
  • 13 skills — the runtime adapters (Claude · Codex · Pi), the tracker adapter + its two backends, the gate-issue helper, the consideration schema, the goal-contract shape, matrix analysis, the schema check, the merged review engine, and ripple doc-sync.
  • templates/ — the per-project scaffold /idc:init copies into a governed repo (WORKFLOW.md, WORKFLOW-config.yaml, the 5-field tracker-config.yaml, and a lean docs/workflow/ tree).

Developing on this plugin

# live-test without installing — load the plugin for one session
claude --plugin-dir /path/to/idc-workflow

# reference integrity (namespacing, no personal paths, no dangling refs, release discipline)
bash scripts/lint-references.sh

# the functional verification suite (real round-trips, throwaway sandbox)
bash tests/smoke/run-all.sh

--plugin-dir loads the working tree directly, bypassing Claude Code's version-keyed cache — the reliable way to test unreleased changes.

Repository layout

.claude-plugin/   plugin.json (manifest) + marketplace.json (self-hosted marketplace)
agents/           8 agents — stage playbooks + implementer + finisher + review coordinator/agent
skills/           13 reusable procedures (runtime adapters, tracker, review engine, …)
commands/         9 slash commands (think|plan|build|ripple|autorun|init|doctor|update|uninstall)
templates/        per-project scaffold copied by /idc:init
scripts/          lint-references.sh, release check, the filesystem tracker + stage helpers,
                  install-codex.sh, run-evals.sh
tests/smoke/      the v2 functional verification suite
docs/             mental-model, architecture, installing, PRD/specs/plans, developer notes, assets
llms.txt          agent-readable index of the whole plugin

License

MIT © 2026 llamallamaredpajama

Ver o original no GitHub

Bom para

Relacionados