Plaited behavioral programming patterns for event-driven coordination and symbolic reasoning. Use when implementing behavioral programs with behavioral()/useBehavioral, designing rule composition with bThread/bSync, orchestrating test runners or workflows, or building neuro-symbolic reasoning layers.
Default Web API patterns for bElement architecture, including modern HTML features, performance optimizations, and Shadow DOM compatible patterns.
Identify structurally duplicate logic (pipeline-spine duplication) across semantically distinct modules. Use when multiple implementations share the same orchestration skeleton (e.g., bounds→shape→chunking→reduction→wrap), and unification may require subtle abstraction. Produces a duplication map and a safe extraction/refactor plan.
Comprehensive architectural reference for AIDB core and MCP integration. Covers 6-layer architecture (MCP, Service, Session, Adapter, DAP Client, Protocol), component organization, data flow patterns, and design decisions. Use when explaining overall system design or understanding how layers interact.
Use when analyzing event-driven systems, message queues, async processing, and pub/sub patterns
Implement robust error handling with user-friendly messages, specific exception types, centralized error boundaries, and graceful degradation strategies. Use this skill when implementing error handling logic in any part of the application. When writing try-catch blocks, error boundaries, or exception handlers. When validating input and failing fast with clear error messages. When handling API errors, network failures, or external service timeouts. When implementing retry strategies with exponential backoff. When ensuring resources are properly cleaned up in finally blocks. When displaying error messages to users without exposing technical details. This skill applies to all error handling across frontend and backend code.
Professional software architecture skill for analyzing existing codebases, designing new systems, creating comprehensive planning documents, and guiding technical decision-making through structured architectural workflows.
Comprehensive guide for implementing AIDB tests following E2E-first philosophy, DebugInterface abstraction, and MCP response health standards
Design the complete system architecture including components, data flow, infrastructure, database schema, and API design. Use when starting stage 06 (architecture) or when user asks about system design, tech stack, or database schema.
Standardizes UX states for data fetching flows (loading, error, empty, success) and complex multi-view UI patterns. Provides state machine approach recommendations, loading skeletons, error boundaries, and empty state components. Use when implementing "loading states", "error handling", "empty states", or "state machines".
[Extended thinking: This workflow implements a sophisticated debugging and resolution pipeline that leverages AI-assisted debugging tools and observability platforms to systematically diagnose and res
Designs multi-layer caching strategy with edge CDN, server-side caching, cache invalidation, and CDN configuration. Use for "caching strategy", "CDN setup", "cache invalidation", or "performance optimization".
TypeScript functional programming. Use for pure functions, immutability, composition. Favors ternaries, switch, map/filter/reduce over imperative code. Concise, declarative patterns.
Idiomatic Rust development patterns for async applications. Covers error handling with Result/Option, ownership and borrowing, async/await with Tokio, traits and generics, serde serialization, Arc/Mutex for shared state, and clippy best practices. Use when writing Rust code, refactoring, handling errors, or implementing async patterns.
Day-to-day pattern development best practices. Use when actively developing patterns. Covers incremental development, commits, communication guidelines, and general development workflow.
Use when documenting significant architectural decisions. Creates focused ADRs explaining context, decision, and alternatives. Prevents vague documentation and implementation detail bloat. Triggers: 'create ADR', 'document decision', making technology/framework/persistence/auth choices, cross-cutting concerns.
Use when analyzing domain entities, value objects, aggregates, and business rules encoded in the model
Reference and maintain knowledge of the project's technical stack including frameworks, languages, databases, testing tools, and third-party services. Use this skill when making architectural decisions about which technologies to use. When adding new dependencies or integrating third-party services. When setting up development environments or deployment infrastructure. When choosing between different libraries or frameworks for a feature. When documenting the technology choices made in the project. When onboarding new team members to understand the tech stack. This skill helps ensure technology choices align with the established stack and provides a reference for all technical decisions.
Perform comprehensive code reviews following SOLID principles and best practices
Design and build software with high cohesion, low coupling, composition-first structures, and functional-style defaults (TigerStyle-inspired).
Best practices for using Hotwire Turbo to create reactive applications
Designs event-driven architectures with event sourcing, CQRS, pub/sub patterns, and domain events for decoupled systems. Use when users request "event sourcing", "CQRS", "domain events", "pub/sub", or "event-driven".
Organize design assets, optimize images and fonts, maintain brand asset libraries, implement version control for assets, and enforce naming conventions. Keep design assets organized and production-ready.
