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.

Clean architecture requires clear separation between operations that change state and those that return data. This skill provides patterns and code examples for implementing Command Query Separation and CQRS in .NET applications.

Writing maintainable TypeScript code is challenging without clear guidance. This skill provides practical examples of DRY, KISS, and YAGNI principles to help you write cleaner, more readable code that your team can understand.

Writing modern frontend code with Next.js, React 19, and shadcn/ui requires understanding Server Components, data fetching patterns, and performance optimization. This skill provides comprehensive guidelines and proven patterns for building type-safe, performant web applications.

Writing backend code for Supabase can be complex with many moving parts. This skill provides ready-to-use patterns for Edge Functions, database design, Row-Level Security, and integrations so you can ship faster with fewer bugs.

Ensures your code actually works by creating isolated test environments and executing code with realistic inputs. This skill moves beyond static analysis to verify genuine functionality through systematic testing, debugging, and validation workflows.

Manual code reviews are slow and inconsistent across reviewers. This skill orchestrates 15 specialized AI agents to validate PRs systematically across security, performance, architecture, and documentation dimensions in a repeatable 4-hour workflow.

Manual code reviews are time-consuming and inconsistent across teams. This skill orchestrates five specialized AI agents to perform comprehensive security, performance, quality, testing, and documentation analysis on pull requests in parallel, delivering standardized review reports with actionable feedback.

Finding bugs in complex codebases wastes valuable development time. This skill provides a structured 5-phase debugging workflow that identifies root causes and validates fixes automatically.