architecture-patterns
29
reducing-complexity
Managing complexity is software's primary technical imperative - all other goals are secondary
obra
development
sorting
stars
current ordering strategy
query
all entries
refine the visible subset
architecture-patterns
29
designing-before-coding
Design in pseudocode first, iterate approaches, then translate to code
obra
development
architecture-patterns
28
rails-business-logic
Specialized skill for Rails business logic with ActiveInteraction, AASM state machines, and ActiveDecorator. Use when implementing complex operations, state transitions, or presentation logic. Enforces interaction pattern over service objects.
alec-c4
development
architecture-patterns
28
swift-concurrency
Guide for building, auditing, and refactoring Swift code using modern concurrency patterns (Swift 6+). This skill should be used when working with async/await, Tasks, actors, MainActor, Sendable types, isolation domains, or when migrating legacy callback/Combine code to structured concurrency. Covers Approachable Concurrency settings, isolated parameters, and common pitfalls.
jamesrochabrun
development
architecture-patterns
27
architecture-patterns
brainbaseのアーキテクチャパターン（EventBus、Reactive Store、DI Container、Service Layer）への準拠をチェックし、違反箇所を修正提案する4 Phase Orchestrator Skill。
Unson-LLC
development
architecture-patterns
26
multi-agent-orchestration
Multi-agent coordination and synthesis patterns. Use when orchestrating multiple specialized agents, implementing fan-out/fan-in workflows, or synthesizing outputs from parallel agents.
yonatangross
development
architecture-patterns
26
distributed-locks
Distributed locking patterns with Redis and PostgreSQL for coordination across instances. Use when implementing exclusive access, preventing race conditions, or coordinating distributed resources.
yonatangross
development
architecture-patterns
26
database-versioning
Database version control and change management patterns. Use when managing schema history, coordinating database changes across environments, implementing audit trails, or versioning database objects.
yonatangross
development
architecture-patterns
26
clean-architecture
SOLID principles, hexagonal architecture, ports and adapters, and DDD tactical patterns for maintainable backends. Use when implementing clean architecture, decoupling services, separating domain logic, or creating testable architecture.
yonatangross
development
architecture-patterns
26
message-queues
Message queue patterns with RabbitMQ, Redis Streams, and Kafka. Use when implementing async communication, pub/sub systems, event-driven microservices, or reliable message delivery.
yonatangross
development
architecture-patterns
26
cqrs-patterns
CQRS (Command Query Responsibility Segregation) patterns for separating read and write models. Use when optimizing read-heavy systems, implementing event sourcing, or building systems with different read/write scaling requirements.
yonatangross
development
architecture-patterns
26
asyncio-advanced
Python asyncio patterns with TaskGroup, structured concurrency, and modern 3.11+ features. Use when implementing concurrent operations, async context managers, or high-performance async services.
yonatangross
development
architecture-patterns
26
idempotency-patterns
Idempotency patterns for APIs and event handlers. Use when implementing exactly-once semantics, deduplicating requests, or building reliable distributed systems.
yonatangross
development
architecture-patterns
26
langgraph-routing
LangGraph conditional routing patterns. Use when implementing dynamic routing based on state, creating branching workflows, or building retry loops with conditional edges.
yonatangross
development
architecture-patterns
26
swift-concurrency
Expert guidance on Swift Concurrency concepts. Use when working with async/await, Tasks, actors, MainActor, Sendable, isolation domains, or debugging concurrency compiler errors. Helps write safe concurrent Swift code.
calvingit
development
architecture-patterns
26
outbox-pattern
Transactional outbox pattern for reliable event publishing. Use when implementing atomic writes with event delivery, ensuring exactly-once semantics, or building event-driven microservices.
yonatangross
development
architecture-patterns
26
saga-patterns
Saga patterns for distributed transactions with orchestration and choreography approaches. Use when implementing multi-service transactions, handling partial failures, or building systems requiring eventual consistency with compensation.
yonatangross
development
architecture-patterns
26
grpc-python
gRPC with Python using grpcio and protobuf for high-performance microservice communication. Use when implementing service-to-service APIs, streaming data, or building polyglot microservices requiring strong typing.
yonatangross
development
architecture-patterns
26
domain-driven-design
Domain-Driven Design tactical patterns for complex business domains. Use when modeling entities, value objects, domain services, repositories, or establishing bounded contexts.
yonatangross
development
architecture-patterns
26
event-sourcing
Event sourcing patterns for storing state as a sequence of events. Use when implementing event-driven architectures, CQRS, audit trails, or building systems requiring full history reconstruction.
yonatangross
development
architecture-patterns
26
system-design-interrogation
Use when planning system architecture to ensure nothing is missed. Provides structured questions covering scalability, security, data, and operational dimensions before implementation.
yonatangross
development
architecture-patterns
26
celery-advanced
Advanced Celery patterns including canvas workflows, priority queues, rate limiting, multi-queue routing, and production monitoring. Use when implementing complex task orchestration, task prioritization, or enterprise-grade background processing.
yonatangross
development
architecture-patterns
26
langgraph-state
LangGraph state management patterns. Use when designing workflow state schemas, using TypedDict vs Pydantic, implementing accumulating state with Annotated operators, or managing shared state across nodes.
yonatangross
development