terma

Use this agent when you need to thoroughly investigate and understand specific aspects of a codebase by examining documentation, specifications, progress reports, tests, and implementation details. This agent excels at answering complex questions about existing code structure, design decisions, and implementation patterns through systematic exploration and analysis. <example>Context: The user wants to understand how a specific feature is implemented in the codebase. user: "How does the authentication system handle token refresh?" assistant: "I'll use the codebase-researcher agent to investigate the authentication implementation." <commentary>Since this requires deep exploration of the codebase to understand a specific implementation detail, the codebase-researcher agent is appropriate.</commentary></example> <example>Context: The user needs to verify if a proposed change aligns with existing patterns. user: "Would adding a new caching layer conflict with our current architecture?" assistant: "Let me launch the codebase-researcher agent to analyze the current architecture and assess compatibility." <commentary>This requires researching existing patterns and architecture, making the codebase-researcher agent the right choice.</commentary></example>

Use this agent when you need to search for and recall relevant information from past sessions, experiences, or project history. This includes situations where: the user references something they expect you to know about but isn't clear in the current conversation; you're starting a new task that may have been worked on before; you need context from git history, issue trackers (Linear/GitHub), documentation, or knowledge graphs; the user mentions features, bugs, or discussions from previous sessions; you want to find relevant past context before making decisions or recommendations. Examples: <example>Context: User mentions a feature they discussed before. user: 'Can you update that authentication system we talked about last week?' assistant: 'Let me search our project memory to recall the details of the authentication system discussion.' <commentary>Since the user is referencing a past discussion that isn't clear in the current context, use the memory-recall agent to find relevant information about the authentication system from previous sessions, git history, or documentation.</commentary></example> <example>Context: Starting work on a complex feature. user: 'I need to implement user permissions for the dashboard' assistant: 'Before I start implementing user permissions, let me search our project memory for any previous work or discussions on this topic.' <commentary>Since this is a new task that may have unknowns or previous context, proactively use the memory-recall agent to search for relevant information about user permissions, dashboard work, or related implementations.</commentary></example>

Use this agent when you reach a natural checkpoint or moment of success in a process, when you discover something that should never be done again or always be done, when you identify best practices for working with this user, or when the user explicitly asks you to record or remember something for the future. Examples: <example>Context: After successfully implementing a complex feature with specific configuration steps. assistant: 'I've successfully implemented the authentication system. Let me use the memory-recorder agent to capture the key learnings and configuration steps for future reference.' <commentary>Since we reached a successful checkpoint with valuable learnings, use the memory-recorder agent to store the important details.</commentary></example> <example>Context: User mentions they always prefer a specific approach after trying multiple solutions. user: 'That approach worked much better than the others we tried. Please remember that for next time.' assistant: 'I'll use the memory-recorder agent to capture your preference for this approach so we can apply it consistently in future similar situations.' <commentary>User explicitly requested to remember something, so use the memory-recorder agent to store this preference.</commentary></example>

Use this agent when you need to implement a well-defined series of steps or feature with clear scope. This agent excels at methodical, step-by-step implementation following domain-driven design principles and functional programming patterns. It ensures smooth execution by breaking down complex tasks into manageable pieces and maintaining code quality throughout the process. Examples: <example> Context: The user has a plan to implement a new authentication system and wants careful, methodical implementation. user: "I have a plan to add JWT authentication to our API. The plan includes creating token generation, validation middleware, and user session management." assistant: "I'll use the plan-implementer agent to methodically implement this authentication system following best practices." <commentary> Since there's a defined plan with clear scope that needs careful implementation, the plan-implementer agent is perfect for ensuring smooth, step-by-step execution. </commentary> </example> <example> Context: The user needs to refactor a complex module following domain-driven design principles. user: "We need to refactor the payment processing module. It's currently a 2000-line file mixing concerns. I want to split it into bounded contexts for payment methods, transaction processing, and reconciliation." assistant: "I'll engage the plan-implementer agent to carefully refactor this module following domain-driven design principles." <commentary> The user has a clear refactoring plan that requires methodical implementation and careful consideration of bounded contexts, making this ideal for the plan-implementer agent. </commentary> </example> <example> Context: After writing initial code, the user wants to ensure it follows best practices. user: "I've sketched out the basic types and functions for the inventory management system. Now I need to properly implement it with tests, error handling, and proper module structure." assistant: "Let me use the plan-implementer agent to transform your sketch into a robust implementation." <commentary> The user has initial work that needs to be developed into a proper implementation following the 'make it work, make it right, make it fast' philosophy. </commentary> </example>

Use this agent when you need to carefully plan next steps for a project or feature without implementing anything. This agent excels at breaking down complex problems into precise, incremental steps while maintaining awareness of the bigger picture. Use when you want thoughtful analysis of the path ahead, proper task decomposition, and strategic thinking about implementation order. Never use a planner subagent within this agent. Examples: <example>Context: The user wants to plan how to add a new authentication system to their application. user: "Let's plan how to add OAuth authentication to our app. I want to think through this carefully before we start coding." assistant: "I'll use the strategic-planner agent to help us think through this systematically and create a well-ordered plan." <commentary>Since the user wants to plan without implementing and think carefully about the approach, the strategic-planner agent is perfect for this task.</commentary></example> <example>Context: The user is facing a complex refactoring challenge and wants to plan the approach. user: "We need to refactor our data layer to support multiple databases. Let's plan this out step by step before touching any code." assistant: "Let me engage the strategic-planner agent to break this down into manageable, sequential steps." <commentary>The user explicitly wants planning without implementation, focusing on careful consideration of each step.</commentary></example>

Use this agent when you need to debug issues in code, troubleshoot problems, or systematically investigate bugs. This includes situations where code isn't working as expected, when you need to trace through execution paths, when investigating error messages or unexpected behavior, or when you need help forming and testing debugging hypotheses. <example> Context: The user has written code that isn't working correctly and needs help debugging it. user: "My function is returning undefined instead of the calculated value" assistant: "I'll use the systematic-debugger agent to help you investigate this issue methodically." <commentary> Since the user is experiencing a bug, use the Task tool to launch the systematic-debugger agent to apply structured debugging techniques. </commentary> </example> <example> Context: The user is experiencing an intermittent issue in production. user: "Our API sometimes returns 500 errors but we can't figure out why" assistant: "Let me bring in the systematic-debugger agent to help us track down this intermittent issue using proven debugging strategies." <commentary> The user needs help with a complex debugging scenario, so the systematic-debugger agent should be used to apply systematic debugging methodology. </commentary> </example>

Review code for quality, correctness, and best practices. Use when the user wants a code review or feedback on their implementation.

Brainstorm and explore ideas for a project or feature. Use when the user wants to generate creative solutions or explore possibilities.

Implement a plan or feature. Use when the user has a defined plan ready to be coded.

Explore and understand a project's structure and functionality. Use when starting work on a new or unfamiliar codebase.

Create a structured plan for implementing a feature or solving a problem. Use when the user needs to plan before coding.

Research a topic, technology, or approach. Use when the user needs investigation or information gathering before implementation.

This skill should be used at natural checkpoints (after completing complex tasks, at session end, or when friction occurs) to reflect on skill and process execution and identify targeted improvements. Use when experiencing confusion, repeated failures, or discovering new patterns that should be codified into skills for smoother future operation.

Create, update, and manage Claude Code skills. Use when working with SKILL.md files, slash commands, or extending Claude's capabilities.

When designing a skill, I first think of how it will be used. Skills are tightly focused, all signal, no noise, packages of mental models. They are the principle distilled with some specifics woven in.

Use a team of agents to support this process. The goal is to go from an idea to something worth building, or fail along the way. This is meant to be an interactive, creative discussion. Document the key artifacts and decisions along the way.

- prefer functions over classes unless managing resources