Managing complex implementation plans with multiple subagents is challenging. This skill provides structured templates and workflows to coordinate subagents with built-in code review checkpoints.

Poor architecture leads to technical debt and difficult maintenance. This skill provides SOLID principles and Clean Architecture patterns to help you build maintainable, testable systems from the start.

Code changes can break things and be hard to reverse. This skill automatically creates backups, saves change diffs, and enforces modular code structure before every edit. Your code stays safe and reversible.

Poor Core Web Vitals hurt user experience and SEO rankings. This skill provides clear guidelines, code examples, and checklists to achieve optimal LCP, INP, and CLS scores for better user engagement.

Hardcoded values create maintenance nightmares and security risks. This skill helps Claude Code detect and refactor magic numbers, hardcoded strings, URLs, and credentials into properly organized constants and environment variables.

Building custom MCP servers requires understanding protocol architecture, transport options, and tool definition patterns. This skill provides structured guidance for creating production-ready MCP servers that connect Claude to external services and APIs.

Long code files are hard to maintain and understand. This skill automatically checks line counts and helps you split oversized files into manageable, well-organized modules. Keep your codebase clean and navigable.

Developers struggle with inconsistent commit messages and branch naming conventions. This skill provides standardized Git workflows including conventional commits, branch strategies, and pre-completion verification checklists to ensure clean, traceable code changes.

Complex implementation plans often lead to errors when executed all at once. This skill breaks plans into controlled batches with mandatory review checkpoints, ensuring safe incremental progress with architectural oversight.

Poor error handling leads to silent failures, frustrated users, and hard-to-debug issues. This skill provides patterns and best practices for robust error handling in async code, API calls, and React components.

This skill streamlines the code review process from both perspectives. It provides templates for creating effective PRs and guidelines for responding to reviewer feedback constructively.

Frontend and backend teams often face integration issues when APIs are poorly defined or change frequently. This skill enables collaborative API design using OpenAPI specifications, generating TypeScript types and clients automatically for type-safe development across your entire stack.

Many websites fail accessibility standards, excluding users with disabilities. This skill ensures all UI components meet WCAG 2.2 requirements including semantic HTML, ARIA labels, keyboard navigation, and color contrast ratios.

Understanding how agent frameworks execute code is critical for performance and scalability. This skill helps you analyze execution patterns, concurrency models, and event architectures to make informed architectural decisions.

Understanding unfamiliar codebases is time-consuming and error-prone. This skill generates comprehensive maps of repository structure, dependency graphs, and entry points to accelerate your analysis.

Designing an AI agent framework from scratch requires careful architecture decisions. This skill synthesizes reference architectures with core primitives, interface protocols, and implementation roadmaps based on established patterns.

Building production-grade AI agents requires understanding type safety, dependency injection, and structured outputs. This skill provides comprehensive documentation and examples for the Pydantic AI Python framework.

Writing tests after code leads to gaps in coverage and fragile designs. This skill guides you through the disciplined RED-GREEN-REFACTOR cycle to build tested, well-designed Node.js and TypeScript applications from the start.

SOLID principles help you write maintainable software. This skill teaches you to build testable, extensible TypeScript applications that adapt to changing requirements.

Node.js code often suffers from side effects and implicit dependencies that make testing difficult and bugs hard to trace. This skill provides proven functional patterns including pure functions, immutable updates, and monadic error handling to write maintainable TypeScript code.