klair-legacy

Create feature branch, commit changes, and open PR

Analyzes a high-level feature request and maps it to the project roadmap, identifying dependencies, blockers, and optimal implementation sequence.

Load essential project context to begin development. Reads core documentation and shows current project status.

You are conducting efficient web research to answer the user's query with high-quality, well-sourced information.

Use this agent when: 1. A bug or issue is discovered during development, testing, or code review 2. An error occurs that needs to be tracked and investigated 3. Unexpected behavior is observed in the application 4. A user reports a problem that needs formal documentation 5. Code analysis reveals potential issues requiring investigation Examples of when to use this agent: <example> Context: A developer encounters an error during testing and wants to document it properly. user: "I'm getting a 500 error when trying to fetch financial data from the API endpoint" assistant: "Let me use the Task tool to launch the bug-documenter agent to properly document this issue." <Task tool call to bug-documenter agent with context about the 500 error> <commentary> The user has encountered a bug that needs proper documentation. The bug-documenter agent will create a structured bug report in the bugs/ directory using the templates from .claude/templates/bug-solver. </commentary> </example> <example> Context: Code review reveals a logic error that needs investigation. user: "The budget calculation in the AI budget analyzer is returning incorrect totals for certain date ranges" assistant: "This looks like a bug that needs proper documentation. Let me use the Task tool to launch the bug-documenter agent to create a formal bug report." <Task tool call to bug-documenter agent with details about the budget calculation issue> <commentary> A logic error has been identified during code review. The bug-documenter agent will create a structured documentation following the project's bug reporting templates. </commentary> </example> <example> Context: User reports unexpected behavior in production. user: "Users are reporting that the Clerk authentication redirects aren't working properly after logout" assistant: "This is a critical bug that needs immediate documentation. I'll use the Task tool to launch the bug-documenter agent to create a comprehensive bug report." <Task tool call to bug-documenter agent with authentication redirect issue details> <commentary> A production issue has been reported. The bug-documenter agent will document this with proper severity and context for investigation. </commentary> </example>

Validates generated checklist covers all spec requirements. Ensures every FR has tests and implementation tasks.

Analyzes implementation patterns with specialized focus on Result types, neverthrow error handling, validation patterns, and testing approaches

Locates relevant files and code sections for feature implementation, understanding project structure and module organization

Locates relevant files and code sections for feature implementation, understanding project structure and module organization

Use this agent when you need to tackle a GitHub issue from start to finish, including investigation, planning, implementation, PR creation, and handling review feedback. This agent handles the complete lifecycle of issue resolution. Examples: - <example> Context: The user wants to resolve a GitHub issue about fixing a bug in the authentication flow. user: "Here's GitHub issue #123: Users are unable to login when their session expires" assistant: "I'll use the github-issue-resolver agent to investigate and fix this issue" <commentary> Since there's a GitHub issue that needs to be resolved, use the github-issue-resolver agent to handle the complete workflow from investigation to PR creation. </commentary> </example> - <example> Context: The user has assigned a feature request issue to be implemented. user: "Please handle this issue: Add dark mode support to the dashboard" assistant: "Let me launch the github-issue-resolver agent to tackle this feature request" <commentary> The user wants a GitHub issue to be resolved, so the github-issue-resolver agent should be used to handle the entire process. </commentary> </example> - <example> Context: After PR creation, feedback has been received that needs to be addressed. user: "The PR reviewer mentioned that we need to add unit tests and fix the linting errors" assistant: "I'll continue with the github-issue-resolver agent to address the PR feedback" <commentary> Since this is feedback on a PR that the agent created, continue using the github-issue-resolver agent to make the necessary changes. </commentary> </example>

Use this agent when users ask questions about differences between budgets and actuals for recurring revenue, need to investigate budget variances, or want to understand why actual revenue differs from budgeted amounts. Examples: <example>Context: User is investigating why Q3 recurring revenue is below budget. user: 'Why is our recurring revenue 15% below budget this quarter?' assistant: 'I'll use the recurring-revenue-variance-analyzer to investigate the budget vs actual variance for recurring revenue this quarter.' <commentary>Since the user is asking about budget variance analysis, use the recurring-revenue-variance-analyzer to drill down into the data and identify root causes.</commentary></example> <example>Context: User wants to understand customer-level impact on revenue variance. user: 'Can you show me which customers are causing the biggest negative variance in our SaaS revenue?' assistant: 'Let me use the recurring-revenue-variance-analyzer to analyze customer-level variances and identify the main contributors to the revenue shortfall.' <commentary>The user needs detailed variance analysis at the customer level, which requires the specialized recurring-revenue-variance-analyzer.</commentary></example>

Validates test design quality at Phase X.0 (red phase) before implementation begins. Ensures tests are specific enough to guide correct implementation and catch real bugs. Use after writing tests, before starting implementation.

QC agent that validates Research skill outputs before commit. Checks interface source tracing, decomposition coverage, API documentation, and open questions.

Validates internal consistency of spec.md after parallel drafting. Checks that all sections reference the same FRs, types, and scope.

Orchestrates the spec and implement workflow for a single spec unit, maximizing parallelism via sub-agents. Dispatched by /orchestrate skill to execute a spec unit after research has created spec-research.md.

Validates implementation matches spec requirements. Verifies FR success criteria are met, interface contracts are followed, and scope is correct. Use at Phase X.2 Step 0 before code quality review.

Discovers and analyzes specifications in the specs/ directory, understanding spec-driven development patterns and Phase X.0 → X.1 implementation workflows

QC agent that validates Spec skill outputs before commit. Delta check to ensure spec didn't break what Research QC validated.

Optimises tests for genuine confidence, not coverage metrics. Focuses on recently modified tests, ensuring they verify meaningful behavior and would fail if code were broken.

Discovers testing patterns, approaches, and best practices for Phase X.0 test foundation development

Compares two branch implementations of the same spec across multiple criteria (spec compliance, code quality, testing, performance). Use when analyzing competing implementations, evaluating prototype branches, or choosing between implementation approaches. Triggers on "compare prototypes", "compare branches", "compare implementations", "evaluate prototypes".

Use when user wants to explore multiple implementation approaches for a feature by creating parallel Claude Code sessions. Triggers on phrases like "competitive prototyping", "prototype in parallel", "compare implementations", "try different approaches", or "race implementations".

Generates daily standup updates from your GitHub PRs formatted for Google Chat. Use when creating standup reports, preparing daily updates, generating work summaries, or crafting team status updates.

Guides users through creating Agent Skills for Claude Code. Use when building new skills, designing skill structure, or authoring skill documentation. Triggers on "create skill", "build skill", "new agent skill", or "skill development".

Guides users through creating custom slash commands for Claude Code. Use when user wants to create, build, or develop slash commands, automate workflows, or create command shortcuts.

Guides users through creating comprehensive technical specifications using spec-driven development methodology. Use when users need to document features, requirements, or system designs before implementation. Helps structure specifications with proper sections, requirements, and technical details.

Guides Claude through evaluating Agent Skills using a comprehensive framework based on best practices, testing methodology, and quality criteria. Use when reviewing existing skills or validating newly created skills for effectiveness and efficiency.

Help users explore Redshift table schemas and data interactively. Use when user wants to understand table structure, see sample data, or explore column values. Trigger phrases "explore redshift table", "show me table structure", "redshift table schema", "what's in the table"

Guides through the feature development workflow. Use when starting a new feature, updating an existing feature, or following the standard development process. Trigger phrases: "new feature", "start feature", "feature development", "update feature", "development workflow", "create feature", "begin feature", "follow feature workflow", "feature process"

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Implements specifications using TDD methodology with quality review. Use when implementing a spec, writing code from requirements, following TDD workflow. Includes test-first development, implementation, and thorough code review before PR.

Guides users through creating, using, and cleaning up git worktrees for parallel feature development. Use when users want to work on multiple branches simultaneously, test changes in isolation, or manage parallel development workflows.

Execution kickoff for feature work. Reads committed research artifacts, checks TaskList, and spawns spec-executor agents for parallel autonomous execution.

Explores a problem space, gathers context, designs approach, and decomposes into implementable specs. Use when starting new work, investigating issues, planning features, or decomposing large changes. This is the "fuzzy front end" where exploration and human dialog happen.

Audits file changes for code hygiene, SOLID principles, and architectural integrity. Use when reviewing code changes, checking code quality, auditing a file, or analyzing code hygiene. Triggers on "review code", "code hygiene", "audit file", "check SOLID", "architecture review".

Critically reviews a spec for feasibility, completeness, risks, and shortcomings. Use after spec creation to get an objective, non-sycophantic assessment before implementation. Triggers on "review spec", "spec review", "critique spec", "audit spec".

Creates a technical specification from research. Use after the research skill to produce spec.md and checklist.md for a decomposed spec unit.

Guides developers through refactoring existing custom tables to use the UnifiedTable and UnifiedTableWithCommentsWrapper components. Provides step-by-step guidance for analysis, planning, implementation, backend integration, and testing. Includes automatic knowledge of UnifiedTable API and best practices.

Generates and runs unit tests for files listed in spec or feature documents. Identifies testable functions, suggests refactors for coverage, and executes tests incrementally. Use when adding test coverage for new features or refactoring existing code.