flow

Address PR review feedback systematically. Categorizes feedback, implements surgical fixes, verifies changes, and re-requests review.

Explore approaches before committing to implementation. Generates options, analyzes trade-offs, and helps select the best approach collaboratively.

Classify changes and create atomic commits with conventional messages. Flags out-of-context modifications and red-flag patterns before committing.

Debug an issue with structured root cause analysis. Guides evidence gathering, hypothesis testing, and fix validation.

Design or review architecture for a feature or system. Analyzes existing patterns, evaluates coupling, and produces design decisions.

Answer questions about architecture decisions, implementation rationale, and trade-offs by loading the decision journal and diff context for the current branch or issue. Use when seeking to understand what was built and why.

Universal workflow entry point. Use /flow <verb> <target> for skill-driven GitHub development. Verbs: start, commit, pr, review, address, merge, resolve, release, status, learn, setup, explain, debug, design, brainstorm, issue.

Create a well-crafted GitHub issue. Guides solution-agnostic requirements gathering, duplicate detection, label discovery, and verifiable acceptance criteria.

Analyze the decision journal for learnable patterns and generate skill proposals from repeated corrections and common patterns. Use when reviewing session activity to extract reusable knowledge.

Merge an approved pull request. Verifies prerequisites (approval, checks, conversations), displays assessment, and requires explicit human confirmation. Tier 3 — never autonomous.

Create a pull request with full code review, quality gates, comprehension report, and reviewer suggestions. Runs parallel agent review before PR creation.

Create a release with changelog generation from merged PRs. Calculates semantic version, requires human confirmation. Tier 3 — never autonomous.

Resolve merge conflicts on the current branch or for a pull request. Detects conflict types, analyzes both sides, applies per-file resolution strategies, and verifies the result compiles and passes tests.

Review a pull request with multi-faceted analysis. Supports both single-session parallel review and agent team adversarial review.

Initialize flow for a repository. Detects tech stack, generates settings, configures LSP servers, optionally adds CLAUDE.md sections, and warns about plugin coexistence.

Start work on a GitHub issue. Assigns issue, creates branch, decomposes tasks from acceptance criteria, and guides implementation with autonomous execution.

Display a read-only overview of workflow state including assigned issues, open PRs, pending reviews, branch state, and decision journal health. Use when checking current development status.

Review code changes for quality, logic correctness, edge cases, security, and error handling. Return P1/P2/P3 findings with file:line citations using the ASSERTION/EVIDENCE/VERIFIED pattern.

Validate Git conventions including commit messages, branch naming, PR format, and code patterns. Report convention violations with severity.

Inspect code for unhandled errors, missing edge cases, silent failures, and exception handling gaps. Return P1/P2/P3 findings with file:line citations.

Parse acceptance criteria from issues and create task breakdowns with dependencies and parallel execution opportunities. Use when decomposing an issue into trackable implementation tasks.

Verify end-to-end functionality beyond unit tests. Start dev servers, run E2E suites, perform smoke tests, and validate acceptance criteria at runtime.

Review code for security vulnerabilities including OWASP top 10, secrets detection, auth/authz verification, input validation, and dependency vulnerabilities. Use when performing security-focused code review or agent team adversarial review.

Discover and run project-specific lint, test, and type-check commands, reporting structured results with pass/fail status. Execute quality commands in parallel when possible. Use when running quality gates or verifying code changes.

Judge implementation completeness by receiving acceptance criteria and an evidence bundle, then returning per-criterion verdicts of PASS, FAIL, or NEEDS-HUMAN-REVIEW. Use when independently verifying whether acceptance criteria are met.

Guide system design decisions including design-from-functionality, coupling analysis, and C4 model thinking. Use when designing systems, evaluating structural changes, or reviewing architecture decisions.

Govern autonomous development execution through the Explore-Plan-Code-Verify loop, task-driven progress tracking, three-tier action classification, decision journaling, and bounded verification. Use when executing any development workflow autonomously or orchestrating multi-step implementation tasks.

Explore multiple approaches through structured option generation, trade-off analysis, and collaborative approach selection. Use when evaluating alternatives before committing to an implementation strategy.

Create branches with naming conventions, load issue context, perform impact analysis, and decompose acceptance criteria into parallel tasks. Use when starting work on a GitHub issue.

Discover available agents, skills, quality commands (lint, test, typecheck), tech stack, and LSP code intelligence capabilities in the project environment. Use when starting implementation, creating PRs, reviewing PRs, or addressing feedback to determine which agents to dispatch and which quality commands to run.

Classify code changes as in-context, uncertain, or out-of-context by applying primary and secondary signals relative to the current branch, issue, and tasks. Flag first-touch files and red-flag patterns. Use when preparing commits or reviewing staged changes.

Enforce code quality standards including the Boy Scout Rule, secret-free commits, anti-pattern detection, and prohibition of mocks/stubs/TODOs in production code. Use when writing, modifying, or reviewing code to ensure quality gates are met.

Conduct 5-facet code review covering quality, security, conventions, tests, and requirements with P1/P2/P3 finding synthesis, deduplication by file:line, and requirements compliance mapping. Use when reviewing code changes or pull requests.

Validate git conventions including commit messages, branch naming, PR format, and issue linkage by detecting project-specific rules from CLAUDE.md and settings. Use when creating commits, preparing PRs, or reviewing for convention compliance.

Map each acceptance criterion to a specific verification method, collect evidence during verification, and produce a structured evidence bundle for the verdict judge. Use when verifying implementation completeness against issue acceptance criteria.

Isolate root causes through structured log analysis, hypothesis testing, and fix validation to prevent symptom-fixing and tunnel vision. Use when any verification step fails, tests break, or debugging a reported bug.

Enforce evidence-based decision-making by requiring file:line citations, P1/P2/P3 finding prioritization, and the ASSERTION/EVIDENCE/VERIFIED pattern before any recommendation. Use when gathering evidence, presenting findings, or making development decisions.

Address PR review feedback through focused surgical changes with Boy Scout Rule, feedback context recovery, ambiguity handling, pushback criteria, and re-review request patterns. Use when resolving reviewer comments on a pull request.

Craft well-structured GitHub issues with solution-agnostic requirements, duplicate detection, label discovery, and acceptance criteria describing observable behavior rather than implementation details. Use when creating new GitHub issues.

Guide PR merges and releases through prerequisite verification (approval, checks, resolved conversations), semantic versioning, changelog generation, and release notes. Tier 3 — always requires human confirmation. Use when merging PRs or creating releases.

Detect, classify, and resolve git merge conflicts through structured analysis of conflict markers, per-file strategy selection, and post-resolution verification. Use when a branch has conflicts with its merge target or when rebasing onto an updated base.

Create pull requests with pre-flight verification, PR body generation, reviewer suggestion, comprehension narrative, and label selection. Handle push and PR creation as Tier 2 operations. Use when preparing or creating a pull request.

Validate environment prerequisites including clean git state, issue existence, gh CLI authentication, and remote accessibility using fast bash checks with no LLM calls. Use when starting any workflow to fail fast before planning begins.

Verify implementation works at runtime by discovering and executing dev server startup, API smoke tests, E2E tests, browser checks, and LSP diagnostics. Use after quality checks pass to confirm the code actually runs.

Guide test-driven development through the Red-Green-Refactor cycle, test quality standards, and test runner discipline. Enforce test-first when tddMode is 'enforce'. Use when implementing features or fixing bugs.

Coordinate agent teams for adversarial review or parallel implementation, including team spawning, task sizing, review protocol, and teammate health monitoring. Only loaded when agentTeams is enabled. Use when dispatching multi-agent work or adversarial review.

8 hooks across 5 events