Unsafe uploads can expose systems, exhaust resources, and leak private files. This skill provides practical patterns for validation, storage, and scalable transfer workflows.

FastAPI endpoints become inconsistent when authentication, models, and status codes vary. This skill provides concise router patterns and integration steps for reliable API development.

Production FastAPI services require careful async, data, security, testing, and deployment decisions. This skill provides structured guidance for designing and improving modern Python APIs.

Complex domains need traceable state changes, resilient workflows, and query models built for their access patterns. This skill guides practical event sourcing and CQRS decisions.

Agent quality is difficult to measure because runs vary and valid solutions follow different paths. This skill builds practical rubrics, test sets, and evaluation pipelines.

Unhandled failures obscure root causes and weaken application reliability. This skill applies typed errors, retries, circuit breakers, cleanup, and graceful degradation across common programming languages.

Complex failures create scattered evidence and uncertain fixes. This skill organizes errors, telemetry, hypotheses, fixes, validation, and prevention into one debugging workflow.

Single-perspective reviews can miss security, architecture, performance, and quality concerns. This skill coordinates specialized reviewers and synthesizes their findings into one prioritized assessment.

Complex failures can hide across logs, traces, services, and recent changes. This skill structures evidence, tests hypotheses, and recommends fixes with prevention steps.

Elixir projects require careful decisions about concurrency, supervision, data boundaries, testing, and performance. This skill provides focused guidance for idiomatic, fault-tolerant implementations.

End-to-end tests often become slow, flaky, and difficult to maintain. This skill provides Playwright and Cypress patterns for stable workflows, test data, CI, debugging, and accessibility.

End-to-end coverage becomes inconsistent when setup, browser checks, visual tests, and CI integration are planned separately. This skill organizes them into one Playwright workflow.

Slow setup and repetitive tasks reduce developer productivity. This skill reviews workflows and proposes measurable improvements to tooling, automation, documentation, and feedback loops.

Complex .NET backends need consistent architecture, data access, resilience, and testing patterns. This skill supplies focused guidance and reusable C# templates for those decisions.

Building reliable .NET APIs requires consistent patterns for data access, security, background work, and testing. This skill provides practical ASP.NET Core and EF Core guidance.

Complex .NET systems need clear architecture, reliable data access, and measurable performance. This skill guides production-ready C#, ASP.NET Core, testing, caching, and deployment decisions.

Complex domains need clear boundaries before implementation patterns are selected. This skill assesses DDD viability, defines strategic artifacts, and recommends focused next steps.

Django projects often need coordinated decisions across architecture, security, data access, testing, and deployment. This skill provides practical Django 5.x guidance for those decisions.

Discord bots fail when interactions, intents, commands, and scaling are designed incorrectly. This skill provides Discord.js and Pycord patterns for reliable bot architecture.

Complex application delivery requires coordinated decisions across architecture, implementation, testing, and deployment. This skill organizes those stages and routes work to specialized development skills.