Async testing requires specific patterns that differ from synchronous code. This skill provides ready-to-use patterns for pytest-asyncio configuration, async fixtures, mocking async functions, and database test isolation.

SQLModel combines Pydantic and SQLAlchemy, creating confusion about models and schemas. Async SQLAlchemy has different rules than sync. This skill provides tested patterns for eager loading, relationships, sessions, and common database operations.

Building APIs with FastAPI requires understanding dependency injection, response models, and OpenAPI schema design. This skill provides battle-tested patterns that prevent common bugs and improve developer experience for frontend teams.

Async Python code often suffers from race conditions, session leaks, and connection pool issues. This skill provides battle-tested patterns for FastAPI and SQLAlchemy that prevent common async pitfalls.

Database migrations can cause data loss or downtime when done incorrectly. This skill provides tested patterns for creating, reviewing, and safely applying Alembic migrations.

Expo iOS builds require complex configuration of EAS Build, certificates, and TestFlight. This skill provides step-by-step guidance for configuring builds, submitting to TestFlight, and troubleshooting common issues.

Tests become hard to maintain when they are inconsistent, overly complex, or test implementation details. This skill provides proven Jest patterns for factory functions, mocking strategies, and TDD workflows.

Debugging without a systematic approach leads to symptom-focused patches that mask underlying problems. This skill enforces a four-phase methodology that traces problems to their source before any fixes are applied, resulting in higher-quality solutions.

React applications struggle with loading states, error handling, and empty states causing poor user experience. This skill provides battle-tested patterns for managing UI states, form submissions, and async data fetching.

Writing GraphQL operations manually leads to type errors and maintenance headaches. This skill provides proven patterns for queries, mutations, and Apollo Client integration with automatic type generation.

Building forms in React requires handling validation, state, and submission. This skill provides proven Formik patterns for creating accessible, validated forms with Yup schemas.

Building interfaces without design standards leads to inconsistent styling and maintenance problems. This skill provides component patterns and design tokens for unified, maintainable user interfaces.

Claude struggles to understand large codebases without proper structure. This skill provides automatic project mapping, symbol indexing, and duplicate detection so Claude can find functions, classes, and files instantly without slow grep searches.

Managing software projects without structured phases leads to missed requirements and incomplete features. This skill enforces five mandatory gates that prevent progress until each phase meets defined criteria, ensuring disciplined waterfall development.

Traditional scattered log statements make debugging difficult and lack context. This guide teaches you to emit one comprehensive event per request with all debugging context included.

Software projects need structured requirement tracking beyond simple todo lists. This skill provides waterfall-style feature management with requirements, test cases, and progress tracking in a persistent YAML format stored in your repository.

Building LLM applications without a clear methodology leads to wasted time and budget overruns. This skill provides a proven framework for evaluating task fit, architecting pipelines, and iterating efficiently.

LLM context windows limit task complexity and increase costs as conversations grow. This skill provides techniques to extend effective capacity through strategic compression, observation masking, KV-cache optimization, and context partitioning.

LLM agents fail unpredictably as context grows. This skill helps you identify and fix context degradation issues like lost-in-middle effects, poisoning, and attention collapse so your agents stay reliable at scale.

Long AI agent sessions quickly exceed context windows, causing failures. This skill provides proven compression strategies that preserve critical information while reducing tokens by 98%+.