harness-engineering

A comprehensive guide to creating custom slash commands for Claude Code.

This directory contains slash commands organized by category for easy discovery and management.

Conduct comprehensive codebase research using parallel sub-agents

Execute implementation plans from research-plans/plans/ directory

Executes a plan with gated checks, atomic commits, build/package/deploy, full validation, and immutable execution logs

Create detailed implementation plans from research findings

Generates a concrete implementation plan from a research doc, with milestones, tasks, gates

Research codebase comprehensively with parallel sub-agents and document findings

Three-step workflow guide for complex tasks (research, plan, implement)

Normalize a GitHub issue by asking @coderabbitai to outline and structure it

Continue debugging a Linear issue with systematic analysis

Continue work on a Linear issue by understanding state and planning next steps

Fagan-style inspection for analysis only; identifies defects and prepares findings for the next devoir agent

Prepare context for compaction when approaching token limits

Implement features in structured phases with automatic commits using git worktree

Stage all changes and generate smart commit with inline diff

This directory contains specialized AI agents organized by category.

Use this agent when you need to analyze recently implemented code changes to identify issues, inconsistencies, or areas needing fixes. This agent coordinates research sub-agents to examine file locations and implementation logic, then synthesizes findings into an actionable report focusing only on problems that require attention. <example>Context: The user has just implemented a new feature or made significant code changes and wants to verify the implementation quality. user: "I've just finished implementing the new authentication flow, can you check if there are any issues?" assistant: "I'll use the code-synthesis-analyzer agent to examine your recent implementation and identify any issues that need fixing." <commentary>Since the user has completed an implementation and wants to check for issues, use the code-synthesis-analyzer agent to research the changes and synthesize findings.</commentary></example> <example>Context: After a refactoring session, the user wants to ensure no logic was broken. user: "I refactored the payment processing module, please verify if anything needs fixing" assistant: "Let me launch the code-synthesis-analyzer agent to research your refactoring and report any issues found." <commentary>The user has made changes and specifically wants to know about potential issues, making this a perfect use case for the code-synthesis-analyzer agent.</commentary></example>

Analyzes codebase implementation details. Call the codebase-analyzer agent when you need to find detailed information about specific components. As always, the more detailed your request prompt, the better! :)

Locates files, directories, and components relevant to a feature or task. Call `codebase-locator` with human language prompt describing what you're looking for. Basically a "Super Grep/Glob/LS tool" — Use it if you find yourself desiring to use one of these tools more than once.

Use this agent when you need to analyze a bug, gather comprehensive context about it, and create a GitHub issue for tracking. The agent will investigate the bug's symptoms, potential causes, affected code areas, and reproduction steps, then use the GitHub CLI to create a well-documented issue. If unable to create the issue automatically, it will provide the user with complete instructions for manual creation. <example>Context: User encounters a bug in their application and wants to create a GitHub issue with proper documentation. user: "I'm getting a TypeError when calling the calculateTotal function with null values" assistant: "I'll use the bug-issue-creator agent to analyze this bug and create a GitHub issue for it" <commentary>Since the user reported a bug and needs it documented as an issue, use the bug-issue-creator agent to gather context and create the GitHub issue.</commentary></example> <example>Context: User discovers unexpected behavior in production and needs to document it. user: "The API is returning 500 errors when processing orders over $10,000" assistant: "Let me use the bug-issue-creator agent to investigate this issue and create a GitHub issue with all the relevant details" <commentary>The user found a production bug that needs investigation and documentation, so the bug-issue-creator agent should be used.</commentary></example>

Analyzes code for clarity improvements and applies 10 key refactoring rules. Use PROACTIVELY when code is modified, reviewed, or when clarity improvements are discussed.

Use this agent when you need to implement Python code following Test-Driven Development (TDD) methodology. The agent will take a goal or plan and systematically implement it by writing tests first, ensuring they fail, then writing minimal code to make them pass, and finally refactoring. Perfect for when you want to ensure high code quality, test coverage, and adherence to TDD principles in Python projects. Examples: <example>Context: User wants to implement a new feature using TDD methodology. user: "I need to implement a user authentication system with TDD" assistant: "I'll use the TDD Python implementer agent to build this feature following the red-green-refactor cycle" <commentary>Since the user wants to implement a feature using TDD, use the Task tool to launch the tdd-python-implementer agent.</commentary></example> <example>Context: User has a plan that needs to be implemented with tests first. user: "Here's my plan for a data validation module - implement it with TDD" assistant: "Let me use the tdd-python-implementer agent to implement this plan following TDD principles" <commentary>The user has a plan and wants TDD implementation, so use the tdd-python-implementer agent.</commentary></example>

Use this agent when you need to analyze git differences and document the changes in the .claude/ directory. This agent should be triggered after code changes are made to capture what was modified, understand the logic changes, and create properly formatted documentation with timestamps. Examples: <example> Context: User has just made code changes and wants to document them according to the project's CLAUDE.md guidelines. user: "I've updated the API endpoints, please document the changes" assistant: "I'll use the git-diff-documenter agent to analyze the changes and create proper documentation in .claude/" <commentary> Since code changes were made and need to be documented, use the git-diff-documenter agent to analyze the git diff and create appropriate documentation. </commentary> </example> <example> Context: User has completed a feature implementation and needs to document it. user: "Feature complete, document what changed" assistant: "Let me use the git-diff-documenter agent to analyze the git differences and create documentation" <commentary> The user has completed work and needs documentation, so the git-diff-documenter agent should analyze the changes and create proper documentation. </commentary> </example>

Expert prompt engineering agent that analyzes, improves, and creates prompts using 26 documented principles. This agent helps users craft more effective prompts by applying proven techniques for clarity, specificity, and optimal LLM interaction. Use this agent when you need to improve existing prompts, create new optimized prompts, or understand why a prompt isn't producing desired results. <example>Context: User has a prompt that isn't working well. user: "My prompt 'tell me about dogs' isn't giving me the detailed information I need" assistant: "I'll use the prompt-engineer agent to analyze and improve your prompt using proven principles" <commentary>The user needs help optimizing their prompt, so the prompt-engineer agent should analyze it and suggest improvements.</commentary></example> <example>Context: User wants to create an effective prompt for a specific task. user: "I need to create a prompt for generating Python code documentation" assistant: "Let me use the prompt-engineer agent to create an optimized prompt using best practices" <commentary>The user needs a new prompt crafted with proper engineering principles.</commentary></example>

Use this agent when you need to update or maintain technical documentation across multiple locations in the codebase, specifically the @documentation directory for general documentation and the .claude directory for developer/agent-specific documentation. This agent should be triggered after code changes, agent updates, or when documentation gaps are identified. Examples: <example>Context: After implementing a new feature or updating an agent configuration. user: 'We just added a new payment processing module, update the docs' assistant: 'I'll use the tech-docs-maintainer agent to update both the general documentation and developer guides' <commentary>Since documentation needs updating after code changes, use the Task tool to launch the tech-docs-maintainer agent.</commentary></example> <example>Context: When reviewing the codebase and finding missing or outdated documentation. user: 'Check if our API endpoints are properly documented' assistant: 'Let me use the tech-docs-maintainer agent to audit and update the API documentation' <commentary>Documentation audit requested, use the Task tool to launch the tech-docs-maintainer agent.</commentary></example>

Use this agent when you need to implement Python code following Test-Driven Development (TDD) methodology. The agent will take a goal or plan and systematically implement it by writing tests first, ensuring they fail, then writing minimal code to make them pass, and finally refactoring. Perfect for when you want to ensure high code quality, test coverage, and adherence to TDD principles in Python projects. Examples: <example>Context: User wants to implement a new feature using TDD methodology. user: "I need to implement a user authentication system with TDD" assistant: "I'll use the TDD Python implementer agent to build this feature following the red-green-refactor cycle" <commentary>Since the user wants to implement a feature using TDD, use the Task tool to launch the tdd-python-implementer agent.</commentary></example> <example>Context: User has a plan that needs to be implemented with tests first. user: "Here's my plan for a data validation module - implement it with TDD" assistant: "Let me use the tdd-python-implementer agent to implement this plan following TDD principles" <commentary>The user has a plan and wants TDD implementation, so use the tdd-python-implementer agent.</commentary></example>

Claude Code subagents are specialized AI assistants that handle specific tasks independently, enabling more efficient problem-solving through task-specific configurations with customized system prompts, tools, and separate context windows. These pre-configured AI personalities can be automatically or explicitly invoked to handle specialized work like code review, debugging, or data analysis, operating with their own clean context to prevent conversation pollution while maintaining access to Claude Code's powerful toolset.

Memory profiling specialist for identifying leaks, inefficiencies, and optimization opportunities. Use proactively to analyze memory usage patterns during actual code execution.

Use this agent when you need to conduct comprehensive research on a focused technical query by deploying multiple specialized sub-agents to gather context from different perspectives, then synthesize and verify the findings. This agent excels at complex questions that require multi-faceted analysis, cross-referencing of information, and truth verification. Examples: <example>Context: User needs comprehensive analysis of a new technology stack choice. user: "Should we migrate from REST to GraphQL for our microservices architecture?" assistant: "I'll use the multi-agent synthesis orchestrator to gather comprehensive context from multiple perspectives and verify the findings." <commentary>This requires multiple viewpoints (performance, developer experience, ecosystem, migration complexity) and fact-checking, making it ideal for the multi-agent synthesis orchestrator.</commentary></example> <example>Context: User needs to understand security implications of a coding pattern. user: "What are the security implications of using eval() in our dynamic configuration system?" assistant: "Let me deploy the multi-agent synthesis orchestrator to analyze this from multiple security angles and verify the findings." <commentary>Security analysis benefits from multiple specialized perspectives and verification of claims.</commentary></example>

Use this agent when you need to search the web for official documentation, latest updates, or authoritative information about specific technical issues, frameworks, libraries, or technologies. This agent specializes in finding and synthesizing information from official sources, documentation sites, and recent updates. <example> Context: User needs to understand the latest changes in a framework or library user: "What are the breaking changes in React 18?" assistant: "I'll use the web-docs-researcher agent to find the official React 18 documentation and migration guides." <commentary> The user is asking about specific technical documentation, so the web-docs-researcher agent should be used to find official sources. </commentary> </example> <example> Context: User encounters an error and needs official troubleshooting information user: "I'm getting a 'Module not found' error with webpack 5" assistant: "Let me use the web-docs-researcher agent to search for official webpack documentation about this error." <commentary> The user needs help with a specific technical issue, so the agent should search for official documentation and recent solutions. </commentary> </example>

Use this agent when you need to conduct comprehensive security investigations of an application, including issue discovery, documentation, and quality assurance. This agent orchestrates a multi-phase security review process that deploys specialized sub-agents for investigation, documentation, and QA review. The final output is a prioritized security report with issues ranked from high to low priority. Examples: <example>Context: The user wants to perform a security audit of their application. user: 'I need a security review of our authentication system' assistant: 'I'll use the security-orchestrator agent to conduct a comprehensive security investigation' <commentary>Since the user is requesting a security review, use the Task tool to launch the security-orchestrator agent which will deploy investigation agents, documentation agent, and QA agent in sequence.</commentary></example> <example>Context: The user needs to investigate potential vulnerabilities in their codebase. user: 'Can you check for security issues in our API endpoints?' assistant: 'Let me deploy the security-orchestrator agent to investigate security issues in your API endpoints' <commentary>The user is asking for security issue investigation, so use the security-orchestrator agent to handle the multi-phase security review process.</commentary></example>

This skill should be used when creating, refreshing, or validating a repository `AGENTS.md` so it stays concise, current, and grounded in repository evidence. Use when `AGENTS.md` is missing or stale, after refactors or tooling changes, when new docs become the system of record, or when adding lightweight drift checks.

Set up ast-grep for a codebase with common TypeScript rules for detecting anti-patterns, enforcing best practices, and preventing bugs. Creates sgconfig.yml, rule files, and rule tests. Use when adding structural linting, banning legacy patterns, or implementing ratchet gates.

Run or continue a differential debugging session between two implementations, traces, captures, or outputs. Record artifact identity, exact commands, first mismatch progression, findings, validation, and next probe in a durable session log.

Execute implementation plans from .artifacts/plan/. Focus on EXECUTING ONLY - no planning, no fixes outside plan scope. Uses gated checks, atomic commits, and maintains a single execution log in .artifacts/execute/. Use when the user says "execute this plan" or provides a plan path.

Map a repository's mechanical harness layers: canonical check command, local and CI gates, architecture boundaries, structural rules, behavioral verification, docs ratchets, evidence workflows, and operator-facing surfaces. Use when you need to understand how a repo keeps change safe.

Generate execution-ready implementation plans from research docs - planning ONLY, no fixing or verifying. North Star is whether a JR developer can execute the plan with zero additional context.

Perform quality assurance on code changes after the research-phase -> plan-phase -> execute-phase workflow. STRICTLY QA only—no coding, no fixes, no source-code changes. Focus on changed areas only, emphasizing control/data flow correctness.

This skill should be used when mapping or researching a codebase to understand its structure, patterns, and architecture. Use when the user asks to "map the codebase", "research how X works", "find all Y patterns", or needs to understand code organization. Produces factual structural maps in .artifacts/research/—no suggestions, no recommendations, just what exists. Uses ast-grep for structural pattern matching.