devflow

Map system architecture by identifying components, their responsibilities, integration points, and data flow. Generates descriptive architecture documentation showing what the system is and how it's structured (not how to work with it).

Read the project manifest and fetch current versions of all project artifacts from their respective backends. Use this agent when pm/sync-artifacts needs to gather all artifacts for consistency checking.

Analyze an existing codebase's architecture — tech stack, project structure, dependencies, integration points, and patterns. Use this agent when pm/define-architecture needs to understand a brownfield codebase before making architecture decisions.

Review changed files for code health issues — files that are too long, poor modularity, duplication, overly complex functions. Use during complete-issue to catch refactoring opportunities before the PR.

Fast codebase metrics gathering for size/complexity assessment. Uses tokei or simple bash commands to analyze LOC, directory structure, technology stack, and entry points without deep code reading. Returns structured metrics for strategy decision.

Deep analysis of a specific codebase component to identify patterns, conventions, and rules. Reads code samples to understand file organization, testing patterns, error handling, and common conventions. Generates prescriptive rules for working with the component.

Search doc backends for team conventions captured by capture-conventions. Use this agent when pm/define-architecture needs to check if team conventions exist and surface relevant sections as context for architecture decisions.

Identify major architectural decisions in legacy code that warrant ADR documentation. Detects framework choices, architecture patterns, infrastructure decisions, and significant design choices. Returns candidates with context for user quiz.

Read PRD and architecture documents, then propose a task breakdown with dependency chains. Use this agent when pm/plan-iterations needs to decompose requirements into buildable tasks.

Compare an implementation plan against actual changes (git diff) and produce a structured deviation report. Use this agent during complete-issue to surface what changed from the plan.

Compare gathered material against a target template and produce a section-by-section coverage report. Use this agent when pm/define-prd needs to assess how complete existing material is against the PRD template.

Search all configured doc backends in parallel for material related to a specific topic. Use this agent when pm/define-prd or other PM skills need to gather existing material from multiple sources before assessment.

Search all configured backends in parallel for prior art related to a problem or topic. Use this agent when pm/discover needs to check if a problem has been explored before, if similar capabilities exist, or if past attempts were shelved.

Scan changed files for security vulnerabilities. Use during complete-issue as a mandatory pre-PR security check.

Research technology options using Context7 MCP for current documentation and comparisons. Use this agent when pm/define-architecture needs to evaluate technology choices with up-to-date information.

Reviews code health and security, creates a PR/MR, and transitions the issue to done. This is the final step in the DevFlow build workflow. Use this after implementing changes to create a pull request or merge request and close the issue.

Creates issues with codebase analysis. Use this when the user wants to create a new issue, file a bug, or add a feature request to Jira, GitLab, or GitHub.

Fetches an issue from the configured tracker (Jira, GitLab, or GitHub), analyzes its requirements, and assesses feasibility against the current codebase. This is the first step in the DevFlow build workflow. Use this when starting work on an issue.

Executes an approved implementation plan, following TDD workflow by default. Implements code changes unit by unit with mandatory pause points for developer review. Use this after plan-issue once the plan has been approved.

Backend operations dispatcher for issue tracking (Jira, GitLab, GitHub) and VCS (GitHub PRs, GitLab MRs). Loads DevFlow configuration, validates parameters, and executes the correct MCP tool calls. Use this when any workflow step needs to perform backend operations like fetching issues, creating issues, transitioning status, creating branches, or creating PRs/MRs. Never invoked directly by users.

Analyzes a fetched issue, researches the codebase, and develops a detailed implementation plan with TDD by default. Use this after fetch-issue to create a plan before implementation.

Sync advisor for after a PR/MR has been merged. Assesses local git state, explains what needs to happen, and guides the developer through each step with explicit approval. Never makes destructive changes without the developer's conscious authorization.

Reviews a pull request or merge request from within Claude Code. Fetches PR/MR details, summarizes changes, optionally checks out the branch, runs code analysis, and posts review comments back to GitHub or GitLab with developer approval. Works with GitHub PRs (via gh CLI) and GitLab MRs (via GitLab MCP). Use this when the user wants to review a PR/MR, says "let's review this PR," or provides a GitHub/GitLab PR/MR URL or number.

Scans for security vulnerabilities in branch changes, full repo, or specific files. Supports interactive triage — fix, dismiss, create ticket, or defer each finding. Use this to perform security analysis before creating a PR/MR or on any part of the codebase.

Explains the DevFlow SDLC workflow — what commands are available, how they connect, and the recommended order of operations. Use this when the user asks things like "how does DevFlow work," "what's the workflow," "show me the DevFlow commands," "what should I run next," or "walk me through the SDLC process."

Configures DevFlow backends for issue tracking, documentation, and VCS. Use this skill when the user wants to set up, configure, or reconfigure their DevFlow development workflow backends, or when another command/skill says to run setup.

Fetches the latest Claude Code release notes, researches how changes impact primitives (skills, agents, hooks, plugins), and updates your RAG Memory knowledge base. Use this periodically to keep your knowledge of Claude Code capabilities current.

Audits project documentation (READMEs, API docs, guides) against actual source code to find outdated, missing, or inaccurate content, then updates it. Use this when documentation may have drifted from the code after refactors, API changes, or feature additions.

Discovers all documentation files in a project and verifies cross-references, links, and internal consistency between them. Use this to find broken references, orphaned docs, or mismatched cross-links within project documentation.

Systematically analyzes and documents a legacy codebase using size-aware progressive disclosure. Generates CLAUDE.md, component rules, architecture documentation, and selective ADRs. Use this when inheriting an undocumented codebase that needs understanding before new work begins.

Read-only audit comparing a repository against stored team conventions. Shows deltas only — no file changes, no enforcement, no suggestions. Use this when the user asks things like "how does this repo compare to our conventions," "check if we're following team standards," or "audit this repo against our conventions." Requires conventions to have been captured first.

Guided interview to capture team-wide development conventions (coding standards, branching strategy, tech stack, testing requirements, architecture patterns) and store them in the configured documentation backend. Use this when the user asks things like "capture our team conventions," "document our coding standards," "set up team conventions," or "record how our team works."

Helps create or update a repo's CLAUDE.md and .claude/rules/ files based on Claude Code best practices and what's actually in the repo. The developer makes all decisions. Use this when the user asks things like "set up CLAUDE.md," "create project instructions for Claude," "configure Claude Code for this repo," or "generate rules for this project."

Your always-available DevFlow workflow companion. Ask anything about the workflow at any time — what to do next, what a skill does, how two phases connect, what just happened, or how to get unstuck. Reads your current project context to give you relevant, specific answers. Use this when you hear things like "what should I do next?", "what does complete-issue do?", "I just finished planning, what's next?", "how do security-review and complete-issue relate?", "I'm stuck, help me figure out where I am", "explain the build cycle", or "how does [X] connect to [Y]?"

Intelligent workflow for storing and organizing external knowledge. Use this skill when the user asks to store, remember, capture, or preserve any information externally or mentions saving to a knowledge base.

Interactive onboarding for new DevFlow users. Teaches what the plugin is, how it works, and gets you started based on your role and situation. Use this after installing DevFlow, when you want a guided introduction, or when you hear things like "walk me through DevFlow," "what is DevFlow," "how do I get started," "introduce me to the plugin," or "I just installed this, now what?"

Discovers all DevFlow plugin primitives — skills, agents, hooks, and commands — with descriptions and entry points for each workflow. Use this when the user asks things like "what does DevFlow include," "list all skills," "show me available commands," "what agents are available," or "give me an overview of the plugin."

Defines or updates the technical architecture for a project. Includes brownfield analysis of existing code, technology selection, system design, and Architecture Decision Records (ADRs). Use this after the PRD is defined to establish the technical design.

Creates, imports, or updates a Product Requirements Document (PRD). Supports multi-source ingestion (existing docs, conversations, specs), template-based gap assessment, and iterative human-approved drafting. Use this after problem discovery to formalize requirements.

Frames a problem or opportunity into a structured problem statement with clear scope boundaries. Searches for prior art and checks feasibility before investing in full requirements. This is the first step in the upstream SDLC workflow, before creating a PRD.

Breaks PRD requirements and architecture decisions into buildable issues grouped into iterations/sprints. Creates issues in the configured tracker (Jira, GitLab, GitHub). Bridges upstream planning to the build workflow. Use this after PRD and architecture are defined.

Read-only consistency check across upstream artifacts — PRD, architecture doc, ADRs, and tracker issues. Shows where artifacts have drifted from each other. No file changes, no enforcement. Use this to verify alignment between planning documents.

Creates a RAG Memory collection for storing AI agent preferences — learned patterns, user preferences, and workflow customizations that persist across sessions. Use this during initial RAG Memory setup.

Interactive wizard to scaffold RAG Memory collections tailored to your use cases (project docs, conventions, knowledge base, agent preferences). Use this for initial RAG Memory setup to create a well-organized collection structure.

1 hook across 1 event