outfitter

Display current session ID

Collaborative Q&A to clarify unclear requirements and reach a clear path

Orchestrate multiple agents for complex multi-domain tasks

Systematic debugging with root cause investigation - no random trial-and-error

Audit plugin and optionally apply auto-fixes

Check open PR status, review comments, and CI status

Challenge complexity and find simpler alternatives before implementing

Generate comprehensive status report across VCS, PRs, issues, and CI/CD

Check available CLI tools and get recommendations

Create a handoff note for session continuity

Create a timestamped log note

Read recent trail notes

Use this agent when exploring options, researching technologies, investigating issues, analyzing patterns, or discovering architectural insights. Trigger verbs include investigate, research, explore, analyze, compare, evaluate, discover, clarify, recall, and understand. <example> Context: User needs to evaluate technology options. user: "What's the best approach for handling file uploads in our API?" assistant: "I'll use the analyst agent to research and compare file upload approaches with evidence-based recommendations." </example> <example> Context: User wants to investigate a pattern in the codebase. user: "Investigate why our API calls are slow" assistant: "I'll launch the analyst agent to gather evidence, explore potential causes, and provide findings with confidence levels." </example> <example> Context: User wants to capture a workflow pattern. user: "This debugging approach worked well - can we capture it?" assistant: "I'll use the analyst agent to analyze the workflow and extract a reusable pattern." </example> <example> Context: User needs to explore architectural options. user: "How should we structure our microservices communication?" assistant: "I'll delegate to the analyst agent to research patterns, explore tradeoffs, and recommend an approach." </example>

Use this agent when debugging failures, investigating errors, or troubleshooting unexpected behavior. Trigger verbs include debug, investigate, troubleshoot, diagnose, fix, and trace. Enforces evidence-based diagnosis and prevents guess-and-fix thrashing. <example> Context: User encounters a failing test with unclear error message. user: "This test is failing but I don't understand why" assistant: "I'll use the debugger agent to systematically investigate this failure. Loading debugging skill for structured investigation." </example> <example> Context: Production bug with intermittent failures. user: "Users are reporting intermittent 500 errors on the checkout endpoint" assistant: "I'll use the debugger agent to investigate this production issue. Starting with evidence collection stage before attempting any fixes." </example> <example> Context: User wants to fix code without understanding the root cause. user: "Just add a try-catch around this and it should work" assistant: "Before adding error handling, let me use the debugger agent to understand why this is failing. We need evidence-based diagnosis to avoid masking the real issue." </example> <example> Context: User mentions debug-related verbs. user: "Can you troubleshoot why the database connection keeps timing out?" assistant: "I'll use the debugger agent to systematically investigate the connection timeout. Loading debugging skill to follow the four-stage investigation process." </example>

Use this agent when implementing features, fixing bugs, refactoring code, or building new functionality. Triggers on verbs like: build, fix, implement, refactor, create, add, develop, write (code), update (code), migrate. <example> Context: User requests feature implementation in a TypeScript project. user: "Implement user authentication with JWT tokens" assistant: "I'll use the Task tool to launch the engineer agent to build this feature with TDD methodology." </example> <example> Context: User encounters a bug in production code. user: "Fix the login form - it's not validating email properly" assistant: "I'll use the Task tool to launch the engineer agent to investigate and fix this bug systematically." </example> <example> Context: User wants to refactor legacy code. user: "Refactor the API client to use proper types and error handling" assistant: "I'll use the Task tool to launch the engineer agent for this refactoring task with strict type patterns." </example> <example> Context: User working in a Rust project. user: "Build a REST API endpoint for user registration" assistant: "I'll use the Task tool to launch the engineer agent to implement this in the detected Rust environment." </example>

Documentation discovery agent that finds and retrieves technical documentation across MCP servers (context7, octocode, firecrawl). Use proactively when documentation is needed - API references, installation guides, troubleshooting, or implementation patterns.

Use for complex repo-to-plugin workflows where the target repository is large, has unclear structure, or requires exploratory analysis. Triggers include "engineer plugin from complex repo", "need help understanding this codebase for plugin", or when analyst identifies plugin potential during investigation. <example> Context: User wants to create a plugin from a complex CLI tool. user: "Create a plugin for this kubectl wrapper - it has a lot of commands" assistant: "I'll use the plugin-engineer agent to analyze the repo structure, identify patterns, and build a comprehensive plugin." </example> <example> Context: Unclear what parts of a library should become skills. user: "I want to wrap parts of this SDK but not sure which parts" assistant: "I'll launch the plugin-engineer agent in plan mode to explore the SDK and recommend which patterns are worth automating." </example>

Use this agent when users need help with Claude Code extensibility tasks including creating, validating, or understanding plugins, agents, skills, commands, hooks, rules, or configuration. This agent routes to the appropriate skill based on task scope and ensures quality gates pass before completion.\n\n<example>\nContext: User wants to create a new slash command for their project.\nuser: "I want to create a slash command that formats my code"\nassistant: "I'll use the quartermaster agent to help you create this slash command with the proper structure and validation."\n<commentary>\nSince the user is asking about creating a Claude Code extensibility component (slash command), use the Task tool to launch the quartermaster agent which will route to the claude-commands skill.\n</commentary>\n</example>\n\n<example>\nContext: User is confused about which extensibility component to use for their automation need.\nuser: "Should I use a hook or a command for auto-formatting on save?"\nassistant: "Let me use the quartermaster agent to help clarify the right component for your use case."\n<commentary>\nSince the user has a question about Claude Code extensibility concepts and component selection, use the Task tool to launch the quartermaster agent which can explain the distinctions and recommend the appropriate approach.\n</commentary>\n</example>\n\n<example>\nContext: User wants to validate their entire plugin before publishing.\nuser: "Can you check if my plugin is set up correctly before I publish it?"\nassistant: "I'll use the quartermaster agent to run a full plugin validation across all your components."\n<commentary>\nSince the user wants to validate a complete plugin setup, use the Task tool to launch the quartermaster agent which will load claude-plugins and coordinate validation of each component type.\n</commentary>\n</example>\n\n<example>\nContext: User is building a new agent for their workflow.\nuser: "I need to create an agent that handles database migrations"\nassistant: "I'll use the quartermaster agent to guide you through creating this agent with the right structure and methodology."\n<commentary>\nSince the user is creating a Claude Code agent, use the Task tool to launch the quartermaster agent which will route to the claude-agents skill for focused agent development.\n</commentary>\n</example>

Use this agent when the user wants to review, critique, audit, or validate code, PRs, plans, or architectural decisions. Triggers include requests for code review, security audits, performance analysis, architecture critique, PR feedback, or when the user uses verbs like 'review', 'critique', 'check', 'audit', 'evaluate', or 'validate'. This agent routes to appropriate review skills based on task type and orchestrates comprehensive reviews when multiple concerns are involved. <example> Context: User wants a code review after implementing a feature. user: "Can you review this PR before I merge it?" assistant: "I'll use the reviewer agent to evaluate the code changes and provide structured feedback with severity-ranked findings." </example> <example> Context: User asks for security audit of authentication code. user: "Check this authentication code for security issues" assistant: "I'll delegate to the reviewer agent to audit the authentication implementation for security concerns using the security skill." </example> <example> Context: User wants architecture feedback on a design decision. user: "Is this the right approach for the caching layer?" assistant: "I'll use the reviewer agent to evaluate your caching architecture and provide recommendations using the architecture skill." </example> <example> Context: User uses review-related verb to request critique. user: "Critique my implementation of the webhook handler" assistant: "I'll have the reviewer agent analyze your webhook implementation and identify improvement areas with actionable recommendations." </example> <example> Context: User requests comprehensive review covering multiple concerns. user: "Give me a full review of this payment processing module - security, performance, everything" assistant: "I'll use the reviewer agent to orchestrate a comprehensive review, loading code-review, security, and performance skills to cover all concerns." </example> <example> Context: User asks for quick pre-commit check. user: "Quick check before I commit this" assistant: "I'll use the reviewer agent in quick pass mode to verify the changes are ready for commit." </example>

Use this agent for read-only status reconnaissance across version control, pull requests, issues, and CI/CD systems. Triggers include status, sitrep, scout, report, what's happening, project health, what's changed, show me the stack, and pr status. This agent gathers intelligence without modification and presents scannable reports. <example> Context: User starts a work session and wants context. user: "What's the status of this project?" assistant: "I'll use the scout agent to gather status across Graphite stacks, GitHub PRs, and any active issues." </example> <example> Context: User invokes sitrep command. user: "/sitrep" assistant: "I'll launch the scout agent to generate a comprehensive status report across all available sources." </example> <example> Context: User wants to understand current PR state. user: "Show me the stack and PR status" assistant: "I'll use the scout agent to visualize your Graphite stack with PR and CI status for each branch." </example> <example> Context: User checking on project health before planning. user: "What's blocking progress right now?" assistant: "I'll have the scout agent scan for blockers - failing CI, pending reviews, stale branches, and high-priority issues." </example>

Use this agent when evaluating proposed solutions for unnecessary complexity before implementation. Triggers include: explicit requests to challenge architecture or simplify approaches, /simplify command invocations, reviewing another agent's recommendations for potential over-engineering, and auto-invocation by pathfinding skill when unknowns persist at high confidence levels. <example> Context: User is about to implement a complex state management solution. user: "/simplify this Redux implementation for a contact form" assistant: "I'll launch the skeptic agent for deep analysis of your approach." <commentary> User invoked /simplify with a proposal. Launch skeptic for thorough analysis. </commentary> </example> <example> Context: Planning stage completed, about to implement. user: "Before we start coding, can you challenge this architecture?" assistant: "I'll use the skeptic agent to evaluate your architecture for unnecessary complexity." <commentary> User explicitly wants complexity review before implementation. Perfect use case for skeptic. </commentary> </example> <example> Context: Pathfinding skill auto-invokes due to high unknowns. assistant: "[Auto-invoking skeptic — 3+ unknowns persisting at level 4]" <commentary> Pathfinding detected too many unknowns near delivery. Skeptic provides sanity check. </commentary> </example> <example> Context: Reviewing another agent's plan. user: "The developer agent suggested using microservices. Is that overkill?" assistant: "I'll launch the skeptic agent to evaluate whether microservices are justified for your requirements." <commentary> User questioning complexity from another agent. Skeptic provides second opinion. </commentary> </example>

Use this agent when the task requires domain-specific expertise, infrastructure work, or capabilities outside core developer/reviewer/analyst workflows. This includes CI/CD pipelines, deployment, containers, cloud configuration, security audits, performance optimization, accessibility audits, build tool configuration, compliance checks, licensing audits, and unusual one-off tasks that don't fit standard development workflows. <example> Context: User needs help with CI/CD pipeline configuration. user: "Set up GitHub Actions to run tests on every PR" assistant: "I'll use the Task tool to launch the specialist agent to configure your CI/CD pipeline, as this is infrastructure work requiring DevOps expertise." </example> <example> Context: User asks for deployment or infrastructure help. user: "Help me deploy this to AWS Lambda" assistant: "I'll use the Task tool to launch the specialist agent to handle the deployment configuration—this requires infrastructure expertise." </example> <example> Context: User needs domain-specific expertise like security analysis. user: "Audit this code for security vulnerabilities" assistant: "I'll use the Task tool to launch the specialist agent to perform a security audit, as this requires specialized security expertise." </example> <example> Context: User has an unusual utility task. user: "Generate a changelog from git commits" assistant: "I'll use the Task tool to launch the specialist agent to generate your changelog—this is a one-off utility task." </example> <example> Context: User needs build configuration help. user: "Configure webpack to optimize bundle size" assistant: "I'll use the Task tool to launch the specialist agent to optimize your webpack configuration, as this is build tooling work." </example>

Use this agent when validating implementations through systematic testing with real dependencies. Triggers include: testing features, validating implementations, verifying behavior, checking integrations, proving correctness, or when verbs like test, validate, verify, check, prove, or scenario appear. <example> Context: User wants to validate a feature works correctly. user: "Test that the authentication flow works end-to-end" assistant: "I'll use the tester agent to validate the auth flow with real dependencies." </example> <example> Context: User wants to verify an implementation. user: "Verify the API rate limiting is working" assistant: "I'll delegate to the tester agent to create proof programs validating rate limits." </example> <example> Context: User mentions testing verbs. user: "Check if the webhook handler processes events correctly" assistant: "I'll have the tester agent validate webhook processing with scenario tests." </example> <example> Context: User wants to prove behavior. user: "Prove that our caching layer works correctly" assistant: "I'll use the tester agent to write proof programs against real cache." </example>

Use this agent when designing multi-skill workflow systems with artifact-based state handoff. Triggers include "workflow system", "skill pipeline", "sequenced workflow", "state handoff", and "workflow design". <example> Context: User wants to build a development workflow. user: "Help me design a workflow for triaging issues through implementation" assistant: "I'll use the workflow-architect agent to design a skill pipeline with proper state handoff." </example> <example> Context: User has multiple skills that need to work together. user: "How should these skills pass state between each other?" assistant: "I'll launch the workflow-architect agent to design the artifact-based state handoff pattern." </example> <example> Context: User wants to understand workflow patterns. user: "What's the right pattern for a PR review workflow?" assistant: "I'll use the workflow-architect agent to show you the PR workflow template and customize it for your needs." </example>

This skill should be used when building AI features with Vercel AI SDK, using useChat, streamText, or generateObject, or when "AI SDK", "streaming chat", or "structured outputs" are mentioned.

This skill should be used when designing systems, evaluating architectures, making technology decisions, or planning for scale. Provides technology selection frameworks, scalability planning, and architectural tradeoff analysis.

This skill should be used when working with Bun runtime, bun:sqlite, Bun.serve, bun:test, or when "Bun", "bun:test", or Bun-specific patterns are mentioned.

This skill should be used when checking project status, starting sessions, reviewing activity, or when "sitrep", "status report", or "what's changed" are mentioned.

This skill should be used when creating agents, writing agent frontmatter, configuring subagents, or when "create agent", "agent.md", "subagent", or "Task tool" are mentioned.

This skill should be used when creating slash commands, writing command files, or when "/command", ".claude/commands", "$ARGUMENTS", or "create command" are mentioned.

This skill should be used when configuring Claude, setting up MCP servers, or when "settings.json", "claude_desktop_config", "MCP server", or "Claude config" are mentioned.

This skill should be used when creating hooks, automating workflows, or when "PreToolUse", "PostToolUse", "hooks.json", "event handler", or "create hook" are mentioned.

Audits Claude Code plugins for structure, quality, and best practices. Use when validating plugins, checking plugin health, or before publishing.

This skill should be used when creating plugins, publishing to marketplaces, or when "plugin.json", "marketplace", "create plugin", or "distribute plugin" are mentioned.

This skill should be used when creating rule files, organizing conventions, or when ".claude/rules/", "FORMATTING.md", "create rule", or "project conventions" are mentioned.

This skill should be used when creating Claude Code skills with Claude-specific features like allowed-tools, context modes (fork/inherit), argument-hint, or model overrides. Triggers on "Claude skill", "allowed-tools", "context fork", "skill arguments".

This skill should be used when reviewing code before commit, conducting quality gates, or when "review", "fresh eyes", "pre-commit review", or "quality gate" are mentioned.

This skill should be used when analyzing codebases, understanding architecture, or when "analyze", "investigate", "explore code", or "understand architecture" are mentioned.

This skill should be used when configuring Codex CLI, setting up profiles, or when "config.toml", "sandbox mode", "Codex config", or "approval policy" are mentioned.

This skill should be used when implementing patterns as Claude Code components (skills, commands, hooks, agents), or when "codify", "capture workflow", "turn into a skill", or "make reusable" are mentioned. For pattern identification, see patterns skill.

Manage context window, survive compaction, persist state. Use when planning long tasks, coordinating agents, approaching context limits, or when "context", "compaction", "tasks", or "persist state" are mentioned.

This skill should be used when encountering bugs, errors, failing tests, or unexpected behavior. Provides systematic debugging with evidence-based root cause investigation using a four-stage framework.

Comprehensive documentation audit against current code state. Checks markdown files for accuracy, link validity, code example correctness, and docstring coverage. Uses efficient discovery to minimize context usage while providing thorough analysis.

This skill should be used when diagnosing failures, investigating incidents, finding root causes, or when "root cause", "diagnosis", "investigate", or "--rca" are mentioned.

This skill should be used when building APIs with Hono, using hc client, implementing OpenAPI, or when "Hono", "RPC", or "type-safe API" are mentioned.

Task management for session continuity. Use when coordinating multi-step work, managing subagent assignments, or preserving intent across compaction. Triggers on "track tasks", "manage work", "coordinate agents", or when complex work requires sequencing.

This skill should be used when dispatching subagents for parallel development, coordinating multi-branch implementations, or when "parallel agents", "orchestrator commits", "subagent filesystem only", "multi-agent git", or "prevent stack corruption" are mentioned. Prevents stack corruption through orchestrator-only git policy.

This skill should be used when requirements are unclear, brainstorming ideas, or when "pathfind", "brainstorm", "figure out", "clarify requirements", or "work through" are mentioned.

This skill should be used when recognizing recurring themes, identifying patterns in work or data, or when "pattern", "recurring", or "repeated" are mentioned. For implementation, see codify skill.

This skill should be used when profiling code, optimizing bottlenecks, benchmarking, or when "performance", "profiling", "optimization", or "--perf" are mentioned.

Transforms external repositories (CLIs, libraries, MCP servers) into Claude Code plugins with skills. Use when "build plugin for", "create skills for CLI", "package as plugin", "repo to plugin", or "turn into plugin" are mentioned.

This skill should be used when building React components with TypeScript, typing hooks, handling events, or when React TypeScript, React 19, Server Components are mentioned. Covers type-safe patterns for React 18-19 including generic components, proper event typing, and TanStack Router integration.

This skill should be used when synthesizing multi-source research, presenting findings with attribution, or when "report", "findings", or "synthesis" are mentioned.

This skill should be used when researching best practices, evaluating technologies, comparing approaches, or when "research", "evaluation", or "comparison" are mentioned.

This skill should be used when validating features end-to-end without mocks, testing integrations, or when "scenario test", "e2e test", or "no mocks" are mentioned.

This skill should be used when auditing code for security issues, reviewing authentication/authorization, evaluating input validation, analyzing cryptographic usage, or reviewing dependency security. Provides OWASP patterns, CWE analysis, and threat modeling guidance.

This skill should be used when analyzing conversation patterns, identifying frustration or success signals, or when "analyze conversation", "what went wrong", or "patterns" are mentioned.

This skill should be used when evaluating complexity, planning features, or when "over-engineering", "simpler", "is this overkill", or "keep it simple" are mentioned.

This skill should be used when creating skills, writing SKILL.md files, or when "create skill", "new skill", "validate skill", or "SKILL.md" are mentioned. Covers cross-platform Agent Skills specification.

Find and evaluate community skills, plugins, and marketplaces. Use when searching for existing skills, evaluating safety, or when "find skill", "discover plugin", "community skills", or "marketplace" are mentioned.

Design multi-skill workflow systems with artifact-based state handoff. Use when building skill pipelines, sequenced workflows, or when "workflow system", "skill pipeline", "state handoff", or "artifacts" are mentioned.

This skill should be used when making design decisions, evaluating trade-offs, assessing code quality, or when "engineering judgment" or "code quality" are mentioned.

This skill should be used when coordinating agents, delegating tasks to specialists, or when "dispatch agents", "which agent", or "multi-agent" are mentioned.

This skill should be used when implementing features with TDD, writing tests first, or refactoring with test coverage. Applies disciplined Red-Green-Refactor cycles with TypeScript/Bun and Rust tooling.

This skill should be used when creating session handoffs, logging research findings, or reading previous trail notes. Triggers include "handoff", "session continuity", "log note", "trail notes", or when ending a session.

This skill should be used when writing TypeScript, eliminating any types, implementing Zod validation, or when strict type safety is needed. Covers modern TS 5.5+ features and runtime validation patterns.

This skill should be used when choosing CLI tools, a tool seems slow, or when "best tool", "which tool", or "tool alternatives" are mentioned.

1 hook across 1 event