architecture▌

"Scope determines structure" - Where a component lives depends on its usage.

Build scalable, maintainable React components using modern patterns including functional components, hooks, composition, and TypeScript for type safety.

Implement proven backend architecture patterns for maintainable, testable, and scalable systems. \n \n Covers three core patterns: Clean Architecture (layered dependency inward), Hexagonal Architecture (ports and adapters), and Domain-Driven Design (bounded contexts, aggregates, value objects) \n Includes complete directory structures, code examples, and implementation patterns for Python backends using FastAPI, asyncpg, and similar frameworks \n Demonstrates practical separation of concerns: do

Analyzes coupling between modules using the three-dimensional model (strength, distance, volatility) from "Balancing Coupling in Software Design". Use when asking "are these modules too coupled?", "show me dependencies", "analyze integration quality", "which modules should I decouple?", "coupling report", or evaluating architectural health. Do NOT use for domain boundary analysis (use domain-analysis) or component sizing (use component-identification-sizing).

React composition patterns that scale. Use when refactoring components with boolean prop proliferation, building flexible component libraries, or designing reusable APIs. Triggers on tasks involving compound components, render props, context providers, or component architecture. Includes React 19 API changes. Do NOT use for React/Next.js performance optimization (use react-best-practices instead).

Master advanced WordPress development patterns including REST API endpoints, WP-CLI commands, performance optimization, and caching strategies for scalable WordPress applications.

Recommendation: Use TypedDict for most cases. Use Pydantic when you need validation or complex nested structures.

This skill provides guidance for quality focused software development and architecture. It is based on Clean Architecture and Domain Driven Design principles.

Analyze codebases for architectural friction and propose module-deepening refactors as testability improvements. \n \n Explores codebases organically to surface shallow modules, tightly-coupled components, and untested seams rather than following rigid heuristics \n Applies John Ousterhout's \"deep module\" principle: small interfaces hiding large implementations for better testability and AI navigability \n Generates multiple radically different interface designs (minimalist, flexible, caller-o

High-level system architecture design, decision documentation, and technology trade-off evaluation for distributed systems. \n \n Guides full architecture workflows from requirements gathering through stakeholder review, with explicit trade-off analysis and failure mode planning \n Produces architecture diagrams (Mermaid format), Architecture Decision Records (ADRs), and technology recommendations with documented rationale \n Covers architectural patterns, microservices structuring, scalability