Development

Formats review deliverables with consistent structure for comparable findings. Use when finalizing any review or analysis that must be shared or compared.

Scores feature worthiness and enforces branch-size limits against overengineering. Use when evaluating whether a feature belongs in the current scope or branch.

Analyzes changesets with risk scoring, categorization by type and impact, and release note preparation. Use when extracting insights from raw change data.

Establishes CPU/GPU baselines before resource-intensive operations. Use before builds, training runs, or any task that pins cores or GPUs for over a minute.

Delegates tasks to Gemini CLI implementing delegation-core for Google's models. Use when delegation-core selects Gemini or 1M+ token context is needed.

Selects and routes to the right architecture paradigm. Use when choosing patterns for a new system or comparing trade-offs before making architecture decisions.

Employ space-based or data-grid architectures to scale high-traffic, stateful workloads across multiple nodes. Use when building high-scale systems with in-memory data grid patterns.

Employ a coarse-grained, service-based architecture (a lighter form of SOA) when microservices are not yet necessary but modular deployment is required. Use when building coarse-grained service-oriented systems.

Build serverless, Function-as-a-Service (FaaS) systems for event-driven or operations-light workloads. Use when building event-driven applications with minimal infrastructure management.

Compose processing stages using a pipes-and-filters model for ETL, media processing, or compiler-like workloads. Use when building data processing or transformation pipelines.

Maintain a single deployable artifact while enforcing strong internal boundaries between modules. Use when building systems that need module boundaries without distributed complexity.

Applies microservices for independent deployment and per-service scaling. Use when teams need autonomous release cycles with distinct capability scaling needs.

Build a minimal, stable core system that loads plug-ins to provide feature variability and extensibility. Use when building extensible plugin-based systems.

Applies layered n-tier architecture with enforced boundaries. Use when designing moderate systems needing clear presentation, domain, and persistence layers.

Employ the Hexagonal (Ports & Adapters) pattern to decouple domain logic from infrastructure, maximizing flexibility and testability. Use when designing systems that need strong separation between business logic and external dependencies.

Employ the "Functional Core, Imperative Shell" pattern to isolate deterministic business logic from side-effecting code for superior testability. Use when designing systems where pure functions and immutable data improve testability.

Structure systems around asynchronous, event-based communication to decouple producers and consumers for improved scalability and resilience. Use when building loosely coupled systems with asynchronous message-based communication.

Apply Command Query Responsibility Segregation (CQRS) and Event Sourcing (ES) for collaboration-heavy domains that require strong auditability and independent scaling of reads and writes. Use when designing systems requiring audit trails, event replay, or separate read/write scaling.

Model system responsibilities across clients, servers, and optional peer-to-peer nodes. Use when designing systems with clear client-server communication needs.

Evaluate Claude skill quality through auditing. Use when reviewing or auditing skills.

Guide creating Claude Code skills with TDD and persuasion principles. Use for new skill development.

Build composable skill modules with hub-and-spoke loading. Use when token budget is tight.

Guide creating Claude Code hooks with security-first design. Use for validation and enforcement.

Analyze skill complexity and get modularization recommendations