Skill UI

This skill provides expertise in proven backend architectural patterns, including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design (DDD). It guides users in building highly maintainable, testable, and scalable systems. Use it when designing new services, refactoring complex monoliths, establishing team standards, or planning microservice decompositions. It emphasizes defining clear boundaries and handling complex, durable workflows.

This skill provides expertise in proven backend architectural patterns, including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design (DDD). It guides users in building highly maintainable, testable, and scalable systems. Use it when designing new services, refactoring complex monoliths, establishing team standards, or planning microservice decompositions. It emphasizes defining clear boundaries and handling complex, durable workflows.

Maps architectural components within a codebase, computes statement-based size metrics, flags oversized or undersized modules, and generates an inventory to guide decomposition planning.

Creates step-by-step decomposition plans and migration roadmaps to guide the transition from monolithic applications to distributed architectures, prioritizing risk, value, and dependencies while tracking progress through pattern-based phases.

This skill provides a comprehensive framework for mastering microservices architecture patterns. It covers critical aspects of building robust, distributed systems, including defining service boundaries (Domain-Driven Design), managing inter-service communication, handling distributed data transactions, and implementing various resilience patterns (e.g., circuit breaker, circuit breaker). It is essential for large-scale system decomposition.

This skill provides comprehensive guidelines for architecting and developing high-quality, maintainable software. It is deeply rooted in Clean Architecture and Domain-Driven Design (DDD) principles. It covers best practices for code decomposition, naming conventions, separation of concerns, and avoiding common anti-patterns. Use this skill when designing, analyzing, or developing complex, domain-specific software systems.

This advanced pipeline orchestrates complex feature development based on Request for Comments (RFCs). It breaks down monolithic changes into small, independently verifiable work units, managing dependencies through a Directed Acyclic Graph (DAG). It includes multiple quality gates, dedicated unit testing, and a safe merge queue to ensure robust integration and controlled deployment.

CCPM orchestrates software delivery from PRD through epics and GitHub issues into parallel agent execution, covering planning, decomposition, syncing, workstart, and status checks with mandated script-based reporting.

Automates the complex pre-development workflow for large-scale system transformations, such as major rewrites, migrations, or overhauls. This skill performs comprehensive project analysis, task decomposition, planning document generation, and sets up detailed progress tracking across multiple phases, ensuring a structured approach before any coding begins. It supports adaptive control and integrates robust task tracking via GitHub or local files.

This skill runs a comprehensive, sequenced pipeline (Patterns 1-5) to structurally analyze a monolithic codebase. It inventories components, detects domain duplication, resolves hierarchy issues, measures inter-module coupling, and groups components into candidate, domain-aligned services. It is essential for architects planning service extraction, providing actionable metrics and DDD insights before refactoring or splitting the application.

This skill simulates a world-class Senior System Design Engineer with 20+ years of experience at top tech companies. It helps users design, review, and scale complex, highly available, and resilient distributed systems. It covers every aspect from database sharding and microservices decomposition to caching strategies, observability stacks, and CI/CD pipelines, providing detailed blueprints and mathematical scaling estimates.

This skill guides the decomposition of monolithic applications into independent microservices using Domain-Driven Design (DDD). It defines bounded contexts, service boundaries, communication patterns (sync/async), data ownership, and provides a structured migration roadmap (e.g., Strangler Fig Pattern). Essential for scaling and modernizing large enterprise systems.