claude

vibeflow

AI-Orchestrated Vibe Coding Framework with Multi-AI Consensus and Truth Validation.

1 on GitHubby Mustiv2.61.0MITupdated 4 months ago
/

Plugin vibeflow from marketplace vibeflow in mytechsonamy/VibeFlow. Commands read from the repo's manifest — 1 month ago.

This plugin runs code on your machine — its hooks fire automatically on events like tool use and it starts local MCP servers. The exact commands are listed below; read them before installing.

What it installs

Skills (53)

  • advance

    Advance the project to the next SDLC phase. Reads projectId from vibeflow.config.json, invokes the sdlc_advance_phase MCP tool, and surfaces the phase-gate's pass/fail reason. Supports humanOverrideNote for advancing under HUMAN_APPROVAL_REQUIRED consensus (Sprint 17-C).

  • apply-arbiter-patch

    Reads the patch manifest produced by consensus-arbiter, shows a git-style diff summary, archives every target file to .vibeflow/archive/ (a timestamped version trail) AND snapshots it for one-command rollback before touching anything, asks for explicit operator confirmation (unless --yes), and appli

  • arch-guardrails

    Validates proposed changes against architectural rules — layering, allowed dependencies, forbidden imports, naming conventions. Use before merging or when reviewing a refactor that touches cross-module boundaries. Blocks work that violates ADR-recorded constraints.

  • architecture-bootstrap

    The ARCHITECTURE-phase author-side guide — the counterpart to design-bootstrap. architecture-validator VALIDATES docs/architecture.md but nothing authors it, so a greenfield ARCHITECTURE phase had no skill to produce the doc. This authors docs/architecture.md (logical/component architecture, data mo

  • architecture-validator

    Validates a proposed software architecture against domain policies, the approved PRD, and (optionally) the current codebase's import graph. Writes .vibeflow/reports/architecture-report.md and one .vibeflow/reports/adr-NNN-<slug>.md per accepted decision. Blocks advance if any criticalPolicyViolation

  • bible-assemble

    Assembles the Product Bible into one coherent, navigable, shareable export at project end (Sprint 71) — the final "we shipped, here's the whole book" deliverable. Reads bible-status, builds a curated index (docs/product-bible/README.md) with a per-category table of contents linking every canonical d

  • bible-intake

    Product Bible ingestion (Sprint 69) — review the input documents you bring INTO a project (a vision doc, Gartner/analyst summaries, competitor decks, an existing PRD/spec/SRS, persona research, an API style guide, …) and file them into the bible. It discovers candidate inputs, classifies each into t

  • bible-update

    Grows the Product Bible's LIVING documents at a phase boundary (Sprint 70) so they accrete instead of going stale. For the current SDLC phase, it reads that phase's artifacts (the PRD/design-spec/architecture/test-strategy + the increment diff) and appends what's new into each living bible-native do

  • brownfield-intake

    The brownfield on-ramp. After onboard on an existing codebase, this fingerprints the repo (languages, frameworks, structure, hotspots, tech debt via codebase-intel) so you don't have to explain the architecture, then ASKS how you want to define the work — describe it in plain language, point to an e

  • business-rule-validator

    Extracts business rules from the PRD as a structured catalog, generates a test case per rule, and runs semantic gap analysis against existing tests. Produces business-rules.md + br-test-suite.test.ts + semantic-gaps.md. Gate contract — zero uncovered P0 rules. PIPELINE-1 step 4.

  • chaos-injector

    Injects controlled failures (network, dependency, clock, resource) into a running test environment at one of three intensity profiles (gentle/moderate/brutal), observes whether the system degrades gracefully, and computes a resilience score. Every injection has a mandatory recovery step; blast-radiu

  • checklist-generator

    Emits context-aware review checklists (PR review, release, feature sign-off, accessibility) driven by platform (web / mobile / backend / all) and enriched with scenario-set.md coverage gaps. Every item must be verifiable (action + source of truth + binary outcome) — vague prose is rejected. PIPELINE

  • component-test-writer

    Generates component-level unit tests from source files and (optionally) a scenario-set.md. Framework-aware (vitest | jest) via repo-fingerprint, never guesses. Enforces strict Arrange-Act-Assert structure, preserves every scenario as a test case, and refuses to overwrite existing tests. PIPELINE-1 s

  • consensus-arbiter

    Reads the verdict + reviewer suggestions from a consensus session, evaluates each suggestion against the current SDLC phase + domain, and emits diff-first patches for the ones that should APPLY. Never writes to source files — only to `.vibeflow/state/patches/<session>/` and `.vibeflow/reports/arbite

  • consensus-orchestrator

    Orchestrates multi-AI review process. Coordinates Claude, ChatGPT (codex CLI), and Gemini (gemini CLI) reviews. Each CLI's verdict is appended to the session jsonl the aggregator reads, per-CLI timeout (consensus.cliTimeoutSeconds, default 90) so the aggregator never falls through to its 600s global

  • consensus-specialist

    Dispatches a phase-specific specialist subagent (prd-rewriter, adr-author, test-strategy-refiner, coverage-gap-filler, design-spec-refiner, or runbook-editor) to deeply rewrite an artifact based on multi-AI reviewer feedback. Diff-first contract — never writes to source directly. Use when the arbite

  • contract-test-writer

    Generates consumer + provider contract tests from an OpenAPI (2.x/3.x) or GraphQL SDL file, and diffs the current spec against the previous one to classify breaking changes (MAJOR/MINOR/PATCH). Emits contract.test.ts + contract-report.md. MAJOR diffs block the release gate. PIPELINE-1 step 4.

  • coverage-analyzer

    Parses vitest/jest/istanbul coverage JSON, rolls up line/branch/function coverage to the requirement level via RTM, ranks uncovered gaps by risk, and enforces domain-specific thresholds. Gate contract — every P0 requirement has 100% coverage of its mapped lines, overall coverage meets the domain thr

  • cross-run-consistency

    Runs the same test N times in one session, diffs the outputs, and classifies non-determinism by root cause. Complements observability's historical flake tracking with an immediate "does this test agree with itself right now?" answer. Gate contract — P0 scenarios must be strict-consistent (same outpu

  • decision-recommender

    Produces structured decision packages (problem statement + options + trade-offs + recommendation + effort estimate) from any findings report. Used when a decision needs framing, not auto-gating. Consumes learning-loop-engine recommendations + L2 skill reports + team context, and emits decision-packa

  • deploy-verifier

    Verify a completed deployment by cross-checking the CI pipeline status (dev-ops MCP) + service health dashboard (observability MCP) + optional smoke-test endpoints. Auto-satisfies the DEPLOYMENT phase's `deployment.verified` and `health.checks.passed` exit criteria when every declared check returns

  • design-bootstrap

    The DESIGN-phase guide. Produces the design artifacts (design spec, design tokens, wireframes) that DESIGN consensus reviews. It classifies whether the increment is UI-facing, then ASKS the operator which design source — Claude-native (zero-setup attractive accessible UI spec + tokens + wireframes),

  • e2e-test-writer

    Generates end-to-end tests from scenario-set.md. Web target → Playwright; mobile target → Detox. Every test imports a Page Object (never touches raw selectors), uses a named auth strategy, waits on observable conditions (never sleeps), and preserves scenario ids as trace anchors. Gate contract — zer

  • environment-orchestrator

    Produces env-setup.md — a reproducible, teardown-safe environment recipe for a given test profile (unit/integration/e2e/uat/perf) and platform. Assembles components from a catalog, pins image versions, declares healthchecks, and never inlines secrets. Gate contract — every component has a healthchec

  • flow-status

    Shows current VibeFlow project status including SDLC phase, pending tasks, quality metrics, and recent review results. Use when asking about project progress. Renamed from `status` in v2.20.0 to avoid colliding with Claude Code's built-in `/status` (usage/quota).

  • frontend-render-check

    Actually stands up the front-end and verifies it RENDERS and MATCHES THE DESIGN — the step that ends the "dark tunnel" where a UI ships unit-tested but never once rendered or compared to the design. Detects the web framework, boots the dev server (catching startup bugs like a broken alias on a path

  • input-validation-matrix

    For every input field in the UI, generates and runs a systematic data-validation test matrix — required/presence, type (numeric vs alphanumeric vs email/date/currency), boundary (min/max value + length, just-inside/just-outside), format (regex/IBAN/phone/precision), type-mismatch, and injection-safe

  • integrate

    The merge point for parallel work-streams. When teams develop features as independent per-branch work-streams (streams.enabled), each feature reaches its own DEPLOYMENT readiness in isolation — but the combined product was never verified together. Run this on the integration/release branch AFTER fea

  • integration-verifier

    For a full-stack increment, proves the front-end actually talks to a REAL back-end end-to-end with seeded test data — locally, no deployed staging required. Stack-agnostic (Node / Python / Go / .NET / Java): boots the back-end, seeds deterministic test data (via test-data-manager), points the real f

  • invariant-formalizer

    Turns natural-language invariants from business-rules.md / the PRD into machine-checkable predicates (Zod refinements, runtime guards, Z3 SMT constraints, property-based generators). Emits invariant-matrix.md + invariants.ts. Gate contract — zero unformalized P0 invariants. PIPELINE-3 step 2.

  • learning-apply

    Closes the L3 action gap — turns learning-loop-engine recommendations into concrete, diff-first, operator-confirmed changes. Reads .vibeflow/reports/consensus-learning-report.md and classifies each finding into three lanes — config-tune (diff-first patch to vibeflow.config.json), template-route (rec

  • learning-loop-engine

    Consumes the full history of reports from every L2 skill, detects recurring patterns, traces production bugs back to missed test opportunities, detects quality drift across sprint baselines, mines the cross-session consensus telemetry for slow-converging phases and recurring reviewer themes, and rec

  • loop-status

    The autonomous-loop dashboard. Consolidates every loop surface — phase-runner progress, auto-apply outcomes + per-key revert rates, cooled-down keys, the armed revert watch, learning-report findings, and the opt-in cross-project signal — into one read-only view, and writes a durable .vibeflow/report

  • mobile-stability-runner

    Mobile crash & stability testing for a UI increment on iOS/Android. Expo-aware — auto-detects Expo (managed/bare) and picks the runner (Expo → Maestro on Expo Go / dev-client, bare React Native → Detox). Runs a crash-focused battery beyond functional E2E — cold-start smoke, background/foreground, lo

  • mutation-test-runner

    Generates code mutations from a fixed operator catalog, runs the test suite against each mutant, and computes the mutation score. A surviving mutant points directly at an assertion that doesn't actually check what it claims. Gate contract — zero surviving mutants in P0 code + domain-specific mutatio

  • observability-analyzer

    Parses HAR files, Playwright traces, browser console logs, and Chrome DevTools Protocol exports, detects anomalies against a fixed catalog, and emits observability-report.md. Complementary to the observability MCP (which tracks cross-run metrics) — this skill looks at the artifacts a single run prod

  • onboard

    Onboard a new VibeFlow project (renamed from init in v2.19.0 to avoid colliding with Claude Code's built-in /init). Sets up vibeflow.config.json with domain and tech stack, creates the .vibeflow/ state directory, and records an optional brownfield fingerprint. Runs exactly once at the start of REQUI

  • phase-runner

    End-to-end phase orchestrator. For the current SDLC phase, runs every registered analyzer, then drives a real cross-AI consensus verdict HEADLESSLY via hooks/scripts/consensus-run.sh (runs the codex/gemini reviewer CLIs + finalises verdict.json — no dependency on the disable-model-invocation consens

  • prd-quality-analyzer

    Analyzes PRD documents for ambiguity, conflicts, and missing flows. Produces testability score (0-100). Writes a report to .vibeflow/reports/prd-quality-report.md and a cost-avoidance breakdown to .vibeflow/reports/prd-cost-avoidance.md. Use when reviewing requirements, validating PRDs, or before st

  • product-bible

    The Product Bible — the curated, living document corpus a project accumulates across its whole lifecycle (business/GTM → product → engineering): vision, competitive intelligence, personas, glossary, domain model, UX principles, API standards, Rule DSL, AI strategy, ADRs, PRDs/SRSs, test strategy, ro

  • quality-gates

    Run the project's lint + typecheck + unit-test commands (resolved from vibeflow.config.json.tech.*) and auto-satisfy the DEVELOPMENT phase's `quality.gates.passed` exit criterion when all three exit 0. Pairs with consensus-orchestrator, which satisfies `code.reviewed` on APPROVED verdicts. Together

  • reconciliation-simulator

    Simulates concurrent ledger operations against a canonical set of financial invariants (double-entry, conservation, sign convention, monetary precision), detects balance drift under contention, and generates reproducible reconciliation test cases. Financial-domain-only — blocks for every other domai

  • regression-test-runner

    Runs the project's existing test suite at the scope appropriate for the trigger (smoke on PR, full on release, incremental on file change), diffs results against regression-baseline.json, classifies every test as passing / new-failure / still-failing / fixed / flaky, and enforces a P0 pass-rate gate

  • release-decision-engine

    Aggregates all quality signals into a deterministic release decision (GO/CONDITIONAL/BLOCKED). Uses domain-specific weighted scoring. Always runs LAST in staging-uat and release-decision pipelines. Use when deciding whether a release is safe.

  • repo-fingerprint

    Produces a brownfield repository fingerprint — languages, frameworks, test runners, build tools, module layout, and risk hotspots. Run once when adopting VibeFlow on an existing codebase; the fingerprint is consumed by planning and test-strategy skills. Never assumes frameworks — detects them.

  • streams

    The parallel team-work dashboard. When streams.enabled is on, VibeFlow keys state per git branch so multiple developers (each on their own branch / git worktree) progress independent SDLC work-streams that never clobber each other. This skill consolidates every locally-visible work-stream — its bran

  • test-data-manager

    Generates deterministic test data factories and fixtures from TypeScript types, Zod schemas, or JSON Schema. Seeded RNG means same seed → same data on every machine. Injects edge cases (boundary values, nulls, unicode, empty collections) from a canonical catalog and respects declared invariants. Pro

  • test-priority-engine

    Ranks the test suite by risk so the highest-leverage tests run first. Consumes changed files + regression-baseline.json + ob_track_flaky history, applies a deterministic risk model, and emits priority-plan.md. Gate contract — every affected P0 test appears in the plan, regardless of mode budget. PIP

  • test-result-analyzer

    Classifies test failures into bug / flaky / environment / test-defect, links each failure back to its RTM requirement, and generates ready-to-import backlog tickets for the real bugs. Consumes uat-raw-report.md or raw runner JSON via ob_collect_metrics. Gate contract — every failure is classified (n

  • test-strategy-planner

    Creates comprehensive test strategy, scenario set, and requirements traceability matrix from PRD. Writes .vibeflow/reports/scenario-set.md (universal input for ALL downstream test skills) and .vibeflow/reports/test-strategy.md. Must run before any test writing skill.

  • traceability-engine

    Maps PRD requirements to test scenarios to source code. Detects untested requirements, orphan tests, and stale traces. Writes the Requirements Traceability Matrix to .vibeflow/reports/rtm.md and a gap summary to .vibeflow/reports/traceability-gaps.md. Use for coverage gap analysis, requirement valid

  • uat-executor

    Executes UAT scenarios against a live staging environment, walks automated steps via a runner (playwright/detox) and human-in-the-loop steps via prompts, collects evidence (screenshots + timings + console) on every step, and emits uat-raw-report.md. Gate contract — every failed step must carry evide

  • visual-ai-analyzer

    Uses Claude vision to inspect screenshots for layout regressions, accessibility issues, typography drift, and design fidelity. Complementary to design-bridge's db_compare_impl (which does dimension + byte identity) — this skill actually SEES the images and describes what changed. Gate contract — zer

Subagents (9)

  • adr-author

    ARCHITECTURE-phase specialist that reads the architecture report + reviewer suggestions + policy violations, and emits ONE diff-first patch drafting/updating ADRs (Architecture Decision Records). Never writes to architecture docs directly — the patch is applied by apply-arbiter-patch after operator

  • claude-reviewer

    Reviews code and documents for quality, security, and maintainability. Use for SDLC review cycles, PR reviews, and artifact validation.

  • codebase-explorer

    Analyzes brownfield codebases for structure, patterns, hotspots, and dependencies. Use when onboarding existing projects or preparing context for development.

  • coverage-gap-filler

    TESTING-phase specialist that reads coverage report + mutation report + reviewer suggestions, and emits ONE diff-first patch that adds the missing tests. Never writes directly — patch is applied by apply-arbiter-patch after operator confirmation.

  • design-spec-refiner

    DESIGN-phase specialist that reads wireframes/design spec + reviewer suggestions + accessibility findings, and emits ONE large diff-first patch that tightens the design. Never writes to design files directly — the patch is applied via apply-arbiter-patch after operator confirmation.

  • prd-rewriter

    REQUIREMENTS-phase specialist that reads a PRD + its quality report + the consensus session's reviewer suggestions, and emits ONE large diff-first patch that resolves the structural issues reviewers flagged. Never writes to the PRD directly — the patch is applied by apply-arbiter-patch after operato

  • runbook-editor

    DEPLOYMENT-phase specialist that reads release-decision.md + incident-history + reviewer suggestions, and emits ONE diff-first patch tightening runbooks, rollback procedures, and release notes. Never writes directly — patch is applied by apply-arbiter-patch after operator confirmation.

  • test-analyst

    Analyzes test results, classifies failures, detects flaky tests, and recommends improvements. Use after test runs or for test quality assessment.

  • test-strategy-refiner

    PLANNING-phase specialist that reads test-strategy.md + scenario-set.md + reviewer suggestions, and emits ONE diff-first patch expanding the test strategy with missing scenarios, priority adjustments, and coverage targets. Never writes directly — patch is applied by apply-arbiter-patch after operato

MCP servers (5)

  • sdlc-engine

    runs: node ${CLAUDE_PLUGIN_ROOT}/mcp-servers/sdlc-engine/dist/bundle.js

  • codebase-intel

    runs: node ${CLAUDE_PLUGIN_ROOT}/mcp-servers/codebase-intel/dist/bundle.js

  • design-bridge

    runs: node ${CLAUDE_PLUGIN_ROOT}/mcp-servers/design-bridge/dist/bundle.js

  • dev-ops

    runs: node ${CLAUDE_PLUGIN_ROOT}/mcp-servers/dev-ops/dist/bundle.js

  • observability

    runs: node ${CLAUDE_PLUGIN_ROOT}/mcp-servers/observability/dist/bundle.js

Hooks (10)

  • SessionStart

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/load-sdlc-context.sh

  • SessionStart

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/compact-recovery.sh

  • PreToolUse

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/commit-guard.sh

  • PreToolUse

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/test-optimizer.sh

  • PreToolUse

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/phase-write-guard.sh

  • PreToolUse

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/consensus-gate.sh

  • PostToolUse

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/post-edit.sh

  • PostToolUse

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/trigger-ai-review.sh

  • PostToolUse

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/save-plan-doc.sh

  • SubagentStop

    ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/consensus-aggregator.sh

View source on GitHub linkedin.com

More from mytechsonamy/VibeFlow

All 2 plugins →

AI-governed UI quality gate: project-owned terminology glossary, deterministic i18n/terminology linting on every edit, and a design-auditor Stop-gate before work can be declared done. Inert without a project .design-guard/rules.json, so it is safe to enable globally. Requires python3.

2 skills · 1 agent · hooks

1

Similar plugins

jfrog

claude

Use the JFrog Platform from Claude Code: Artifactory repos and artifacts, security findings and exposures, Catalog package safety and downloads, workflows across the SDLC, and platform administration.

7 skills · 1 MCP server · hooks

anthropics/claude-plugins-official 47,076

Moved to phuryn/product-engineering, which maintains the AI Shipping Kit in its ai-shipping plugin; the skills and commands here only say where each one went.

3 skills · 5 commands

phuryn/pm-skills 27,939

forge

claude

Full-lifecycle SDLC orchestrator: a 12-stage pipeline (SRS, architecture, spec, plan, build, eval, deploy, monitor, release) driven by specialized agents, persistent cross-session memory, auto-reflection, gate enforcement, and semantic skill mining that proposes new skills from recurring workflows.

45 skills · 27 agents · hooks

davepoon/buildwithclaude 3,741

First-time GitHub setup and interactive git learning. Walks users from zero to a working GitHub repo, then teaches git through 9 hands-on lessons on their actual project. Adapts to any skill level automatically.

1 skill · 1 command

jeremylongshore/tons-of-skills-marketplace 2,917

AI mentor agent for vibe coders - analyzes Claude Code conversations and provides growth coaching with 4 workspace types (Builder/Explorer/Designer/Operator).

fivetaku/gptaku_plugins 1,298

CloudBase Sites

claudecodex

Create, preview, save, deploy, inspect, and roll back Vite web apps hosted on Tencent CloudBase.

1 skill · 1 MCP server · hooks

TencentCloudBase/CloudBase-AI-Toolkit 1,165

Maintain vibeflow?

This page updates itself from your repo. Add the badge to your README, or get it Featured to pin it above the organic results with a followed link to your site.

claude & codex plugins2 plugins