Building TypeScript projects without strict typing leads to bugs and maintenance issues. This skill provides expert guidance on strict TypeScript configuration, async patterns, and performance best practices for production-ready Node.js applications.

Writing clear, consistent commit messages takes time and discipline. This skill analyzes your Git diffs and generates Conventional Commits messages that follow established conventions. The AI examines changed files and creates meaningful commit headers with bulleted change summaries.

Developing e-commerce sites involves complex domain logic for products, cart, checkout, orders, and inventory. This skill provides structured guidance on domain design patterns, state transitions, API design, and security best practices for building robust online stores.

Code written without tests first lacks verification and catches bugs too late. This skill guides you through the Red-Green-Refactor TDD cycle to write failing tests before implementation, ensuring every feature has automated verification from the start.

Random fixes waste time and create new bugs. This skill provides a four-phase methodology to find root cause before attempting any fix. It prevents symptom-level patching and ensures lasting solutions.

Code reviews catch bugs before production. This skill provides structured review templates and workflows to validate every code change at key development stages.

Code review feedback often requires verification before implementation. This skill ensures Claude evaluates suggestions technically, asks clarifying questions when needed, and pushes back when feedback is incorrect or unclear.

Developers often struggle with the final steps of feature development. This skill provides a clear, structured process for completing branches with proper testing and integration options. It guides you through verifying tests pass, choosing between merge or PR workflows, and safely cleaning up worktrees.

Inconsistent naming conventions create confusion and technical debt. This skill systematically audits all filenames against your CLAUDE.md standards and identifies violations.

Users need guidance on creating and configuring specialized AI assistants that can handle complex tasks. This skill provides templates, best practices, and step-by-step instructions for building effective subagents.

Stop wasting time figuring out how to structure complex development work. This skill creates detailed implementation plans that guide you step-by-step through feature development, refactoring, or bug fixes.

Catch bugs before they reach production with systematic 6-pass code reviews. Get actionable feedback on runtime failures, architecture issues, and verification strategies.

Codebases accumulate technical debt, deprecated patterns, and hidden bugs over time. This skill provides a systematic framework for comprehensive code review that identifies problems across deprecations, architecture, types, and code smells.

Codebases accumulate dead code, duplication, and architectural issues over time. This skill provides a systematic framework for comprehensive code analysis, identifying cleanup opportunities and quantifying technical debt.

Working on multiple features simultaneously requires constant branch switching, which disrupts context and slows progress. This skill creates isolated git worktrees that let you work on separate branches in parallel directories without switching, while automatically verifying gitignore safety and running clean test baselines.

Writing tests after code leads to bugs and poor design. This skill enforces strict TDD discipline with red-green-refactor cycles for bulletproof code.

Random fixes waste time and create new bugs. This skill provides a 4-phase framework to find root causes before attempting any solution. Stop guessing and start investigating.

Implement complex projects by dispatching subagents for independent tasks. Each task gets two-stage review ensuring spec compliance and code quality. Stay in the same session for fast iteration.

Manual code review is time-consuming and inconsistent. This skill dispatches a structured code-reviewer subagent to systematically evaluate code changes against requirements, architecture standards, and production readiness criteria.

Code review feedback requires technical verification, not blind implementation. This skill guides AI agents through evaluating feedback critically, asking clarifying questions, and pushing back when necessary with technical reasoning.