Claude Skills

This skill helps developers implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for building maintainable and testable backend systems. It's ideal for designing new complex applications or refactoring existing monoliths to achieve loose coupling. The patterns guide you in creating scalable, well-structured codebases with clear domain separation.

This skill provides principles for designing intuitive and maintainable REST and GraphQL APIs. Use it when creating new APIs, reviewing specifications, or establishing team design standards. It covers resource-oriented architecture and helps optimize APIs for various use cases like mobile or third-party integrations.

This skill helps developers migrate AngularJS applications to Angular using hybrid mode and incremental component rewriting. It provides strategies for running both frameworks together, converting directives to components, and updating dependency injection. Use it when planning AngularJS upgrades or modernizing legacy Angular codebases.

This skill generates implementation plans from existing specifications by extracting requirements and converting them into step-by-step tasks. It validates that all spec requirements are covered and explicitly references spec sections. Use it when you have a validated spec and need to create actionable implementation tasks for development work.

This skill performs extended verification before marking work as complete by running tests and validating specification compliance. It blocks completion if either tests fail or the implementation doesn't meet spec requirements, serving as a final quality gate. Developers should use it after implementation but before committing or deploying to ensure both functionality and specification alignment.

This skill establishes the Specification-Driven Development (SDD) methodology and serves as the entry point for SDD conversations. It enforces mandatory use of applicable workflow skills and emphasizes spec-first development where specifications are the single source of truth. Developers should use this skill at the start of any SDD project to determine the appropriate workflow skill to invoke.

The spec skill creates formal, executable specifications directly from clear, well-defined requirements using spec-kit tools. It focuses on defining the WHAT and WHY, not the HOW, and is ideal when detailed requirements are provided upfront. Use this skill to skip exploratory dialogue when the feature scope is already well-defined.

This skill refactors specifications that have evolved organically to identify inconsistencies, remove redundancy, and improve structure while maintaining full feature coverage. It is designed for use on legacy or significantly updated specs to enhance clarity and maintainability, but should not be used during active implementation.

The spec-kit skill provides the technical integration layer for spec-kit CLI, automatically handling initialization, installation validation, and project setup. It ensures proper file/directory layout and serves as the single source of truth for all SDD workflow skills. Developers should use this low-level technical skill when building workflow skills that require spec-kit integration.

The review-spec skill analyzes technical specifications to validate their structure and quality before implementation. It checks for completeness, clarity, and implementability by identifying ambiguities, gaps, and missing requirements. Developers should use it after creating a specification to prevent confusion and rework during the development phase.

This skill reviews code against specification requirements to ensure implementation compliance. It checks for deviations, generates a compliance score with detailed reports, and can trigger spec evolution when mismatches are found. Use it after implementation completion or before deployment to validate that code matches the intended specification.

The `implement` skill generates implementation plans from validated specifications and executes them using Test-Driven Development while continuously verifying spec compliance. Use it when you have an approved spec and are ready to start coding a new feature. It ensures the implementation strictly matches the specification, triggering a different workflow if deviations are found.

The `evolve` skill handles spec/code divergence by analyzing mismatches and recommending whether to update the spec or fix the code. It provides reasoning for its recommendations and manages the evolution process, which can be executed with user control or through auto-updates. It is automatically triggered during code reviews or verification when compliance issues are found.

The Constitution Skill enables developers to create and manage project-wide standards that guide all specifications and implementations. It defines architectural principles, coding standards, API patterns, and quality requirements to ensure consistency across features. All project specs are validated against the constitution to maintain adherence to established guidelines.

The brainstorm skill transforms rough ideas into executable specifications through collaborative questioning and alternative exploration. It focuses on defining the "what" and "why" while deferring implementation details, producing a specification that serves as the source of truth. Use this skill when called from a command to refine initial concepts into validated, actionable specs.

This Claude Skill provides comprehensive TDD guidance using the RGRC cycle and Baby Steps methodology. It offers systematic test design techniques including equivalence partitioning, boundary value analysis, and decision tables for generating test cases. Use it when implementing TDD workflows, discussing test generation strategies, or building test-generator agents.

This skill provides framework-agnostic frontend component design patterns with rich React implementation examples. Use it when working with React, Vue, or Angular components to discuss patterns, hooks, state management, and architecture. It covers essential topics like Container/Presentational separation, React Hooks patterns, custom hooks design, and component composition strategies.

This Claude Skill automatically creates daily reports in esa.io by fetching Google Calendar events and structuring them into predefined templates. It triggers on keywords like "日報" and "daily report" to streamline team communication workflows. Developers can customize this project-specific automation for their team's reporting needs.

The code-principles skill provides fundamental software development guidelines including SOLID, DRY, KISS, and YAGNI for writing maintainable, understandable code. Use it when discussing architecture, refactoring, code quality, or design patterns to get practical decision frameworks and best practices. This skill is essential for code reviews and implementing clean code principles in development workflows.

The user-story-generator skill transforms feature descriptions into validated user stories through an interactive Q&A process. It decomposes features into 2-8 stories, performs automated INVEST validation, and outputs annotated stories in YAML and Markdown formats. Use this skill when you need to systematically break down a new feature into well-structured, developer-ready user stories.

The Technical Annotator skill automatically adds technical context, implementation hints, and effort estimates to user stories. It analyzes stories to recommend technology stacks, assess complexity, and identify implementation risks. Developers should use it when they need to enhance user stories with actionable technical intelligence for planning and decision-making.

The story-validator skill checks user stories against the INVEST criteria to ensure quality. It identifies issues, provides actionable improvement suggestions, and can optionally auto-fix common problems. Developers should use it to validate story quality in the backlog or when preparing stories for development.

The sprint-planner skill helps developers create optimal sprint plans by managing team capacity, checking story dependencies, and selecting work based on priorities. It activates when teams need to plan sprints, automatically fitting stories within capacity constraints while ensuring dependency readiness. The skill validates sprint feasibility and can sync with GitHub milestones for streamlined workflow integration.

The dependency-analyzer skill helps developers identify and visualize relationships between user stories. It detects critical issues like circular dependencies and blocking chains, and generates visual graphs using tools like Mermaid. Use this skill to analyze story dependencies, find bottlenecks, and get optimization suggestions.