vibe-engineering

Dispatches research agents to find real projects, papers, and documented failures before proposing any feature, architecture, or technology choice. Triggers on creative/design tasks, not on implementation of already-designed specs.

Validates completed work against defined acceptance criteria. Use after completing a task that has specific success criteria defined in issues, specs, or task descriptions.

Generates edge case, failure mode, and spec-driven test cases. Covers boundary values, nil inputs, concurrency, resource exhaustion, malformed data, and requirement-linked traceability tests.

Detects and prevents shortcut rationalization — when the agent is about to skip a step, simplify a requirement, or optimize away a constraint. Triggers proactively when rationalization patterns are noticed.

Provides a persistent cross-session task queue for work that should be done but isn't blocking current tasks. Enables background and future-session work tracking.

Safely integrates commits from parallel agent branches using sequential cherry-pick. Use after parallel work completes in isolated branches or worktrees.

Audits tests for concurrency safety — race conditions, shared mock state, cleanup ordering. Use when writing tests that involve goroutines, async operations, or shared mutable state.

Enforces tiered test coverage standards with three dimensions — line coverage by tier, spec-to-test traceability, and spec-to-code implementation mapping. Use before claiming code is complete.

Records resolved bugs in a persistent journal — symptom, root cause, difficulty, fix, prevention. Organized by category for future reference.

Extracts and records architectural decisions from diffs, conversation context, and explicit choices. Supports automatic extraction from staged changes, deduplication against prior decisions, and persistent ADR-format logging with spec traceability.

Challenges recommendations, designs, or synthesis by adversarial review across 5 dimensions. Use before shipping any significant recommendation or design document.

Performs a fast 6-point quality check for technical documents (specs, design docs, READMEs). Use after editing any specification or design document.

Generates fuzz test scaffolding for parsers handling external input (YAML, JSON, config files, user input). Seeds corpus from existing fixtures and runs initial pass.

Assesses production readiness or audits a codebase against its specs. Supports quick static mode, deep 17-dimension audit, or single-dimension focus.

Closes production readiness gaps from a gap analysis document. Autonomously loops dependency analysis, parallel agent dispatch, test gate, re-audit, and repeats until target dimensions reach target score.

Implements snapshot/golden file tests with temporal normalization so tests don't break daily. Use when implementing tests that compare output against expected snapshots.

Generates a session continuity document at the end of a long session or when switching context on a multi-session project. Enables seamless resumption.

Performs end-of-iteration review with quality grading, metrics, and trend analysis. Use at the end of each development iteration or sprint.

Analyzes large tasks for independent subtasks that can be safely parallelized. Produces a DAG-based dispatch plan with dependency ordering and maximum parallelism.

Detects recurring implementation patterns and records them for reuse. When the same code pattern appears 3+ times, it belongs in the pattern library.

Scans staged changes for secrets, debug statements, TODOs without references, and other common commit mistakes. Use before creating any commit.

Sets quality expectations for implementation — "imagine this serves 1 million users." Checks for observability, error handling, input validation, graceful degradation.

Enforces the Implement→Review→Test→Fix→Loop cycle until work is clean. Use after any non-trivial implementation to prevent "good enough" exits.

Extracts learnings from completed work, feedback, or failures. Updates a persistent learnings file with capped entries. Use after receiving feedback, fixing bugs, or completing complex tasks.

Validates PRD, user stories, or feature requirements against SMART criteria. Use when reviewing requirements to catch vagueness before it causes expensive rework.

Dispatches SOTA research before proposing any new feature, architecture, or technology choice. Use when facing design decisions, not when implementing existing specs.

Documents rollback procedures before making risky changes. Covers what's changing, verification steps, rollback procedures, and blast radius assessment.

Performs deployment with pre-flight checks, atomic replacement, post-deploy verification, and automatic rollback. Use before any deployment to staging or production.

Generates a behavioral scenario acceptance matrix for comprehensive test coverage planning. Maps user scenarios to acceptance criteria with stable IDs.

Detects and redirects scope creep during implementation. Catches unrequested features, unnecessary refactoring, and over-engineering.

Queries all configured services for health status — uptime, restarts, errors, resources. Use when checking the health of running services.

Performs smart context summarization when the context window is approaching capacity. Identifies what to keep, what to summarize, and creates a compact resume state.

Bidirectional sync between specification documents and code. Detects spec drift from staged changes, updates spec to reflect approved decisions, and ensures every commit represents a reconciled snapshot of spec, tests, and code.

Compares specification documents against implementation code to find divergences. Use when implementation of a spec or design doc is claimed complete.

Enforces structured output format for analyses, reports, and recommendations — Executive Summary, Detailed Analysis, Next Steps, Metrics. Prevents wall-of-text responses.

Bootstraps the agent to check for applicable vibe-engineering skills before every action. Loads at conversation start for skill discovery.

Routes users to the right vibe-engineering skill for their current task. Use when user asks "what skill should I use?" or seems unsure about which skill to invoke.

Systematically fixes large backlogs of issues using prioritized waves. Use when facing 10+ issues, bugs, or gaps to address.