Event-sourced systems need efficient read models for high-performance queries. This skill provides production-ready templates and patterns for building projections, read models, and materialized views from event streams using Python.

You need a reliable PayPal payment flow that handles checkout, subscriptions, and refunds. This skill provides clear steps for API calls, IPN verification, and sandbox testing.

Creating Node.js backend services requires understanding middleware patterns, authentication flows, and database integration. This skill provides ready-to-use code patterns and architectural guidance for Express and Fastify frameworks.

NFT builders need clear guidance on standards, metadata, and minting. This skill gives practical patterns for ERC-721, ERC-1155, and marketplace readiness.

App Router features can be hard to structure and choose. This skill provides clear patterns and examples for Next.js 14+ routing, data fetching, and Server Components.

Building distributed systems with microservices introduces complexity in service boundaries, inter-service communication, and fault tolerance. This skill provides battle-tested patterns for service decomposition, event-driven architecture, saga coordination, and circuit breaker implementation to help you build resilient, scalable systems.

Memory bugs cause crashes and security flaws in systems code. This skill teaches RAII, ownership, and resource management patterns in Rust, C++, and C.

Build sophisticated AI agents and workflows with LangChain. Learn to implement memory, tools, and chains for production-ready LLM applications that integrate with any data source.

Writing reliable tests for JavaScript and TypeScript applications is time-consuming and error-prone. This skill provides ready-to-use testing patterns for unit tests, integration tests, and component tests with mocking, fixtures, and TDD workflows.

You need reliable patterns for Godot gameplay systems. This skill provides proven GDScript structures for state machines, scene management, and performance optimization.

Concurrent Go code is hard to design and debug. This skill provides proven patterns, examples, and best practices you can adapt quickly.

You need a clean FastAPI structure with async and dependency injection patterns. This skill provides layouts and code examples to start a production ready API.

Event sourced systems fail without durable, ordered storage and clear access patterns. This skill guides you through schemas, storage options, and subscription design.

End-to-end tests catch critical bugs before users do, but flaky tests slow down deployment and erode confidence. This skill teaches proven patterns for building fast, reliable E2E test suites with Playwright and Cypress that improve code quality without slowing down your team.

Developing .NET backends requires understanding async patterns, dependency injection, and database access strategies. This skill provides proven templates and best practices for building APIs that are maintainable, testable, and performant.

You need solid DeFi contract templates but do not want to start from scratch. This skill provides ready-to-use structures for staking, AMMs, governance, and lending protocols that you can adapt quickly.

Build scalable applications with Command Query Responsibility Segregation. Separate read and write operations for optimal performance and maintainability.

Build high-performance Python applications with async/await patterns. Learn concurrent programming techniques for scalable I/O-bound systems.

Building maintainable backend systems requires proven architecture patterns. This skill helps you implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to create testable, scalable applications with proper separation of concerns.

Legacy AngularJS code blocks modern features and maintenance. This skill provides a clear, incremental migration path with hybrid patterns and best practices.