manifest-dev

Adversarially analyze whether code, prompt, or config changes achieve their stated intent. Reconstructs change intent from diff context, then systematically attacks the logic to find behavioral divergences. Use after implementing a feature, before a PR, or when validating that changes do what they're supposed to do. Triggers: intent review, does this work, logic check, behavioral analysis, change validation.

Audit code changes for mechanical defects — runtime failures, resource issues, and structural code flaws. Focuses on defects detectable from code patterns (race conditions, resource leaks, edge cases, dangerous defaults) rather than intent-behavior analysis. Use when reviewing git diffs, checking code before merge, or auditing specific files for defects. Triggers: bug review, audit code, check for bugs, review changes, pre-merge check.

Verify that code changes have adequate test coverage by proactively enumerating edge cases from the code's logic. Analyzes the diff, derives specific test scenarios with concrete inputs and expected outputs, and reports coverage gaps. Use after implementing a feature, before a PR, or when reviewing code quality. Triggers: check coverage, test coverage, coverage gaps, are my changes tested, what should I test.

Audit code for design fitness issues — whether code is the right approach given what already exists in the framework, codebase, and configuration systems. Identifies reinvented wheels, misplaced responsibilities, under-engineering, short-sighted interfaces, concept misuse, and incoherent changes. Use after implementing a feature, before a PR, or when code feels like the wrong approach despite being correct.

Use this agent when you need a comprehensive maintainability audit of recently written or modified code. Focuses on code organization: DRY violations, coupling, cohesion, consistency, dead code, and architectural boundaries. This agent should be invoked after implementing a feature, completing a refactor, or before finalizing a pull request.

Audit code for unnecessary complexity, over-engineering, and cognitive burden. Identifies solutions more complex than the problem requires — not structural issues like coupling or DRY (handled by maintainability-reviewer), but implementation complexity that makes code harder to understand than necessary. Use after implementing a feature, before a PR, or when code feels over-engineered.

Audit code for testability issues. Identifies code requiring excessive mocking, business logic buried in IO, non-deterministic inputs, and tight coupling that makes verification hard. Use after implementing features, during refactoring, or before PRs. Triggers: testability, hard to test, too many mocks, testable design.

Verify that code changes comply with context file instructions (CLAUDE.md, AGENTS.md, GEMINI.md) and project standards. Audits pull requests, new code, and refactors against rules defined in the project's context files. Use after implementing features, before PRs, or when validating adherence to project-specific rules. Triggers: context file compliance, project standards, adherence check.

Verify API and interface contract correctness with evidence. Checks both outbound (code calls external/internal APIs correctly per documentation) and inbound (changes don't break consumers of your interfaces). Evidence-based — cites actual API docs or codebase definitions. Use when reviewing API integrations, interface changes, or cross-service boundaries. Triggers: API review, contract check, integration review, consumer impact, breaking changes.

Read-only verification agent. Validates a single criterion using any automated method: commands, codebase analysis, file inspection, reasoning, web research. Returns structured PASS/FAIL results.

Analyze a single /define session transcript to extract user preference patterns. Spawned by learn-define-patterns skill for parallel per-session analysis.

Audit documentation and code comments for accuracy against recent code changes. Performs read-only analysis comparing docs to code, producing a report of required updates without modifying files. Use after implementing features, before PRs, or when validating doc accuracy. Triggers: docs review, documentation audit, stale docs check.

Reviews /define manifests for gaps and outputs actionable continuation steps. Returns specific questions to ask and areas to probe so interview can continue.

Audit code for type safety issues across typed languages (TypeScript, Python, Java/Kotlin, Go, Rust, C#). Identifies type holes that let bugs through, opportunities to make invalid states unrepresentable, and ways to push runtime checks into compile-time guarantees. Use when reviewing type safety, strengthening types before a PR, or auditing code for type holes.

End-to-end autonomous execution: /define → auto-approve → /do in a single command. Infers task from conversation context when no arguments provided. Add --tend-pr to continue through PR review lifecycle. Use when you want to define and execute a task without manual intervention during planning. Triggers: auto, autonomous define and do, end-to-end, just build it.

Manifest builder. Plan work, scope tasks, spec out requirements, break down complex tasks before implementation. Converts needs into Deliverables + Invariants with verification criteria. Use when planning features, debugging complex issues, scoping refactors, or whenever a task needs structured thinking before coding.

Manifest executor. Iterates through Deliverables satisfying Acceptance Criteria, then verifies all ACs and Global Invariants pass. Optional --mode efficient|balanced|thorough controls verification intensity (default: thorough). Only pass --mode when the user explicitly requests a different mode. Use when executing a manifest, running a plan, implementing a defined task.

Completion marker for the /do workflow. Outputs hierarchical execution summary showing Global Invariants respected and all Deliverables completed. Called by /verify after all criteria pass, not directly.

Structured escalation within the /do workflow. Surfaces blocking issues, scope changes, and workflow pauses with evidence, referencing the Manifest hierarchy. Called by /do, not directly.

Figure things out together — any topic, problem, or idea. Collaborative thinking partner that investigates before claiming, builds shared truth through evidence not inference. Use when you need to truly understand something before acting, or when figuring it out IS the goal. Triggers: figure out, help me think through, dig deeper, what is really going on, investigate, understand, why does, work through.

Analyze recent /define sessions to extract user preference patterns and write them to CLAUDE.md. Use when you want to learn from past define sessions, extract define patterns, improve future defines, or capture define preferences.

Deactivate thinking disciplines. Use when you want to end the disciplined thinking mode activated by /figure-out or /define.

Single iteration of PR tending. Reads PR state, classifies new events, routes fixes, reports status. Called by /loop via /tend-pr setup — not invoked directly by users.

Tend a PR through review to merge-readiness. Classifies comments (bot/human, actionable/FP/uncertain), fixes issues via manifest amendment + scoped /do (or directly in babysit mode), tends CI, syncs PR description, and asks before merging. Use when a PR needs tending through review, or to babysit a PR. Triggers: tend pr, babysit pr, review loop, get this merged, tend this PR.

Core thinking disciplines for rigorous collaborative reasoning. Invoked by skills that need truth-convergent thinking — come prepared, name confidence, sit with fog, verify before proposing, genuine agreement/disagreement, follow intuition as leads. Not user-invocable — loaded by /figure-out, /define, and other skills that need disciplined thinking.

Spawns parallel verifiers for Global Invariants and Acceptance Criteria from a Manifest.

9 hooks across 5 events