convez.ai
AgenteAutomaçãoIntermediário
andrewcigan

Vibe Dev — Pipeline de Produto com Garantias

andrewcigan/vibe-dev-plugin

Harness-first para Claude Code: de ideia a produto com garantias enforçadas

Ver no GitHub
InicialPluginScore · de 0 a 100

Agent que transforma ideias de negócio em produtos funcionados com Claude Code, aplicando 38 mecanismos de validação (hooks, gates, verificações) para garantir que "pronto" significa realmente pronto. Direcionado para fundadores não-técnicos que querem resultado comprovado, não código compilado.

Instalação

$npx convez-ai andrewcigan/vibe-dev-plugin

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
5
Forks
0
Acompanhando
1
Saúde
28%
Último commit
há 1 mês
Versão
v9.0.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Fundadores não-técnicos que usam Claude Code para shipped produtos
  • Equipes que precisam de agentes de IA confiáveis e disciplinados
  • Validação automatizada de features (UI, API, jobs) antes de marcar como pronto

Veredito

Ferramenta sofisticada e bem pensada para quem usa Claude Code em produção. O foco em "enforcement real, não documentação" resolve um problema genuíno: agentes que declaram vitória sem provas. Implementação robusta, mas requer disciplina do usuário na setup inicial.

README

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

Vibe Dev v6

🌐 English: this file · Русский: README.ru.md

A harness-first plugin that turns a business idea into a shipped product — for founders who build with Codex and Claude Code.

Vibe Dev is built for entrepreneurs who don't write code but ship real products with AI agents. You stay at the level of business and architecture; the agent makes the technical decisions and does the work. The point of the plugin is to make the agent reliable — so "done" means done, not "the code compiled."

"The harness is enforcement, not documentation."

Every principle is backed by a real mechanism (hook / gate / agent / self-check), not a line in an instruction file that the agent can quietly ignore. Discipline is broken by exactly the link that's supposed to keep it — the agent itself. So the rules are turned into checkpoints that are actually enforced.

In v6.2 there are 38 such mechanisms, each with three attributes: where it's defined / what enforces it / what happens if you try to bypass it (full list in docs/traceability.md). The plugin's self-check verifies completeness — a claim without a live mechanism doesn't pass. New in v6.2: hook activation became a provable fact (a guard that "didn't turn on" can no longer stay silent), and clarity of the final message went from a wish to a blocking gate. Every new guard was verified with live runs on the Claude Code 2.1.170 engine.


Who it's for

  • Founders and non-engineers who want to ship a working product, not learn to code.
  • People who already work with Codex and Claude Code and want the agent to behave like a disciplined senior engineer instead of an eager intern.
  • Anyone tired of agents that declare "done" on code that was never actually run.

You describe the business. The agent picks the stack, writes the code, tests it, and only reports "done" when a verification command passed and the behavior matched expectations.


How it works (the harness in plain words)

An AI coding agent announces key moments: "about to save a file," "about to run a command," "showing a message to the human," "opening/closing a session." The plugin attaches small inspectors to those moments (hooks). Each inspector looks at the intent and returns one verdict:

  • block — the action is cancelled (e.g. you can't mark a feature "done" without evidence);
  • warn / inject — the action proceeds, but a note appears for the agent or a flag for the human;
  • pass — all clear, stay silent.

The map of "on this event, call this inspector" lives in hooks/hooks.json and is loaded automatically on install (Claude Code v2.1+) — no manual wiring. Strictness is per-project: minimal / standard / strict (existing projects aren't broken — they're migrated with /upgrade-project).


What it catches (key mechanisms of 38)

A. "Done" means verified, not claimed

MechanismWhat it catchesWhat it does
UI-evidence gatea UI feature is marked "done" on typecheck/tests, but a real click shows nothingblock (a screenshot / live run is required)
Surface-aware evidence (v6.2)a "no-UI" feature (API / scheduled job / CLI) is closed with no trace of a real call; a UI feature hides as a "library"the surface is inferred from files and can only tighten: ui → block, others → warn with an acceptance recipe
Test-strategy before builda medium/large feature goes into work without a thought-through verification planblock (no docs/test-strategy.md → it can't enter active)
Data-model review gatea DB schema is written without a separate critical review (the model "freezes," reworks are expensive)block (no docs/data-model-review.md → it can't enter active)
State-machine transitionsa feature jumps to an invalid state / a corrupted state fileblock (current project) / warn (legacy)

A2. Hook activation as a provable fact (new in v6.2)

MechanismWhat it catchesWhat it does
Heartbeathooks "look installed" but don't physically run (silent strictness theater)every live event writes a stamp with the version; readers check freshness
Two-phase profileprofile says "strict" but enforcement never turned onbootstrap writes pending-strict; only a live hook promotes it to real strict — the promotion is the proof
Git pre-commit backstopthe plugin was removed/broken and nobody noticedan INDEPENDENT post in .git/hooks: a pending profile or stale heartbeat → block the commit
Fail-loud + crash artifactsa guard crashed and silently "allowed everything" (a real bug, 2026-06-06)crash → loud warning + crash log + a probe at session start
Real-shape fixture corpusa gate green on synthetic data, broken on real filesself-check runs gates against 6 anonymized real feature_list files
/doctor"why are the guards silent?"self-diagnosis: profile / heartbeat / crashes / install + a fix table

B. Safety and money

MechanismWhat it catchesWhat it does
Bulk-API gatea mass external-API job with no limit check (real case: a project banned for 2 days + wasted money)block without a pre-launch checklist (the checklist now requires explicit volume × price)
Model-swap guardan edit introduces a model / setting that affects every answer (real case: 3 days of dropped client replies after "newer = drop-in")warn "this is a contract change, run a smoke test"
Vendor-lock research gatea specific provider is hard-wired into the architecture blindly, with no comparisonblock an integration feature without docs/research/*.md
Secret-in-prompt (v6.2)the user pasted a live key into a messagewarn: the key is compromised → rotate + move to .env
Secret-in-output (v6.2)a CLI printed a token — it lingers in the session contextwarn to the model: don't reuse the literal, suggest rotation (+ output masking on engines that support it)
Concurrent-write advisorytwo sessions write to one file (real case: data loss)warn (advisory)

C. Anti-stall

MechanismWhat it catchesWhat it does
User stop-signalthe human writes "wrong way / stop / that's not it" and the agent keeps grinding tacticallyinject "change the level, not the method; launch a diagnostic subagent"
Interrupt-recovery (v6.2.1)a dropped connection (closed laptop lid) or an inbound message kills the running tool — the system falsely logs "user rejected," and the agent stalls for hoursthe next message without a stop-word → inject "that was a disconnect, not a veto — continue the plan"; a real "stop" keeps its force
Repeated-failure detectorthe same command is launched a 3rd time in a row with no success and no structural changewarn before running: prompt for a diagnostic subagent (carrier verified against the live 2.1.170 event model)

D. Plain language (the non-engineer's biggest pain)

MechanismWhat it catchesWhat it does
Clarity gate on the final turn (v6.2)the turn ends with a person-days estimate or heavy jargon outside code blocksblock: the agent must add a plain-words version (≤10 lines); precision is held by a labeled corpus from real sessions + append limits
Jargon catcher (screen layer)jargon / a fork with no "what you lose" / person-days in any messageon-screen flag + a log metric (honestly display-only; on Desktop the event doesn't fire — the load-bearing layer is the gate above)
Onboarding (/setup)the system doesn't know how to talk to a new usera portrait at ~/.vibe-dev/portrait.md → gate strictness and fork format adapt (no portrait → a neutral default)

E. Process discipline

MechanismWhat it catchesWhat it does
WIP=1 / scopeedits spill outside the declared featureblock the commit (diff ⊆ affected_files)
Intent-without-actionthe agent ends a turn saying "I'll now do X" with no action takenblock (continue the turn)
Unified Stop dispatcher (v6.2)several end-of-turn guards cascade blocks and loop the turnpriorities + a shared cap of ≤3 blocks per turn; overflow → pass with a log entry
Architecture research gate (v6.2)architecture is written without studying best practices and existing solutionsblock writing ARCHITECTURE*.md without docs/research/*; the skip is allowed ONLY by an explicit user phrase
Closing mode (v6.2)"let's close the session" → the agent suddenly starts codingrights degrade: writes only to state files; new work → backlog; lifted by a normal next message
Lock pattern (v6.2)the agent fakes "user consent" markers (skip / closing).harness/locks/* markers are written ONLY by hooks on an explicit phrase — an agent write is block
Config-protect (v6.2)the agent weakens its own gates (profile, heartbeat, disabling)block in all profiles; disabling enforcement is the user's manual action only
Handoff loopat session close the plan stays in the chat (the next session won't see it)inject a cold-start checklist + detect a missed handoff at startup
User rules (/hookify)"never do X again" is forgotten and repeatedthe human freezes a correction into a permanent block/warn rule, no code needed

F. Harness infrastructure

MechanismWhat it does
Hooks out of the boxhooks.json auto-loads on install; with no file you can't "forget to turn it on"
Warnings reach the modelwarnings travel on the correct channel (otherwise they'd be silently lost)
Profiles + version lifecycleminimal/standard/strict; legacy projects aren't forced, they migrate on command
Traceability table + self-checkevery mechanism is described by 3 attributes; a row without a live mechanism fails the self-check
Personal-data gateif anything personal slips into the public build (email / client project / private path) — block the self-check

Honest — what's still discipline, not a mechanism: checking cross-module wiring on the real path, "the agent does it itself instead of sending you to the terminal," realistic test data. A hook can't reliably force these. We keep them as discipline + catch them on real projects. We don't pass them off as "bulletproof."

Built after auditing all ~20 real projects from earlier versions (12 retrospectives + ~150 memory notes + 6 bug journals); v6.2 followed an audit of 54 live sessions on v6.1 + harness practice research + an independent critique of the plan.


7 subsystems

Instructions (CLAUDE.md routing + domain-rules.yaml) · State (feature_list.json + SESSION.md + error-journal) · Verification (4 layers + dual critique + negative gate) · Scope (affected_files, WIP=1) · Lifecycle (init, cold-start, clean-exit, /upgrade) · Learning (feedback memory, retrospectives, anti-patterns) · Cost & Safety (bulk-gate, concurrent-lock, secrets-scope).


Commands

CommandWhat it does
/setupOnboarding: 6 simple questions → a portrait (how to talk to you)
/new-projectBusiness interview + bootstrap the harness (4 files at start)
/resume <project>Cold-start test + diff against the previous session
/feature <id>WIP=1 + dual critique (test-researcher + user-perspective-critic)
/verify4-layer verification (syntax + runtime + e2e + user)
/hookify"never do X again" → a permanent block/warn rule
/handoff · /end-sessionClean exit + persist state into files
/auditExternal harness assessment + error rate
/stuckStuck protocol + an LLM quorum
/shipFinal validation ≥90% + retrospective
/research · /architecture · /dev-plan · /upgrade-project… (full list in skills/)

Pipeline

  • FAST (5 stages) — internal tools, simple MVPs, bots: interview → architecture + stack → design handoff (if UI) → /feature loop → /ship.
  • FULL (10 stages) — products going to market: ideas R1/R2 → validation → research → architecture + prototype → design → wave plan → /feature loop → /ship + marketing launch.

Install

Claude Code

# 1. Add the marketplace from GitHub
claude plugin marketplace add andrewcigan/vibe-dev-plugin
# 2. Install and enable the plugin
claude plugin install vibe-dev@vibe-dev

Or locally (for developing the plugin itself):

claude --plugin-dir "/path/to/vibe-dev-plugin"

In Claude Code you get the full harness: auto-loaded hooks, the slash commands above, and profile-based strictness.

Codex

Codex reads AGENTS.md automatically. Point it at the harness:

git clone https://github.com/andrewcigan/vibe-dev-plugin
# then run Codex with the repo's AGENTS.md as your project rules

In Codex the harness drives the agent through AGENTS.md, the domain rules, the state files, and the methodology — the same principles and workflow, applied as the agent's operating instructions.

The plugin's technical id is vibe-dev (command names and install depend on it). Version: 6.2.1.


Version

v6.2.1 — Interrupt-recovery: a technical interruption (client disconnect / message delivery) no longer paralyzes the agent into "waiting for instructions" — the next prompt without a stop-word continues the plan automatically.

v6.2.0 — Enforcement as a provable fact (37 mechanisms): provable hook activation (heartbeat

  • two-phase profile + independent git pre-commit backstop + /doctor), fail-loud (a crashed guard can't stay silent), clarity gate on the final message, surface-aware evidence, mandatory research before architecture, closing mode, secret hygiene, config-protect. Every new guard was verified with live runs on the 2.1.170 engine. Built from an audit of 54 live v6.1 sessions. Full change list — CHANGELOG.md.

v6.1.0 — public release: enforcement from text into mechanism (20 mechanisms) + onboarding (/setup) + personal-data gate, after an audit of ~20 real v5 projects.


Notes

  • The harness was built for, and currently converses in, Russian (its clarity gates and prompts are Russian-language). The methodology, mechanisms, and pipeline are language-agnostic; UI/interface localization is not done yet.
  • Author: Andrei Tsyhan.
Ver o original no GitHub

Bom para

Relacionados