fieldguides

Display current session ID

Orchestrate multiple agents for complex multi-domain tasks

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

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

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.

Builds and validates agentic development components for Claude Code and compatible agent platforms. Covers Claude plugins (plugin.json, marketplace.json), agents (.claude/agents/*.md, plugins/*/agents/*.md), skills (SKILL.md, scripts/, references/), slash commands (.claude/commands/*.md), hooks (hooks.json, PreToolUse/PostToolUse), rules (.claude/rules/*.md), and settings (.claude/settings.json). Use when creating, scaffolding, validating, or troubleshooting any .claude/**/*.* extensibility component, structuring a plugin for distribution, or choosing between component types.

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, /sanity-check 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: "/sanity-check this Redux implementation for a contact form" assistant: "I'll launch the skeptic agent for deep analysis of your approach." <commentary> User invoked /sanity-check 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 working with Bun runtime, bun:sqlite, Bun.serve, bun:test, or when Bun, bun:test, or Bun-specific patterns are mentioned.

Bun-first development: prefer native APIs over npm packages, audit for migration opportunities, eliminate unnecessary dependencies. Use when evaluating packages, starting projects, or migrating from Node.js.

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

Claude Code extensibility — agents, commands, hooks, skills, rules, and configuration. Use when creating, configuring, or troubleshooting Claude Code components, or when agent.md, /command, hooks.json, SKILL.md, .claude/rules, settings.json, MCP server, PreToolUse, or create agent/command/hook are mentioned.

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 designing, implementing, or reviewing CLI tools, or when flags, subcommands, help text, exit codes, or CLI patterns are mentioned.

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 find-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 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 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 requirements are unclear, brainstorming ideas, or when pathfind, brainstorm, figure out, clarify requirements, or work through are mentioned.

This skill should be used when profiling code, optimizing bottlenecks, benchmarking, or when performance, profiling, optimization, or --perf 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 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 evaluating complexity, planning features, or when over-engineering, simpler, is this overkill, or keep it simple 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.

Distills tool patterns from external repositories into teachable skills and plugins. Use when build plugin for, create skills for CLI, package as plugin, repo to plugin, or turn into plugin are mentioned.

Validates skill quality — preprocessing safety, frontmatter, line counts, references. Use when checking skills, validating SKILL.md, or when skillcheck, lint skill, or validate skill are mentioned.

Creates and validates Agent Skills (SKILL.md). Use when creating skills, writing frontmatter, or validating skill structure.

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 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 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 coordinating agents, delegating tasks to specialists, or when dispatch agents, which agent, or multi-agent are mentioned.

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