Building ChatKit chatbots requires integrating multiple technologies (FastAPI, OpenAI Agents SDK, MCP tools) with proper security patterns. This skill provides complete architectural guidance for creating production-ready chatbots with user isolation and real-time capabilities.

Writing tests after code leads to fragile codebases and missed bugs. This skill provides structured TDD workflows, test patterns, and Playwright automation to help you write maintainable tests before code, catch bugs early, and build confidence in your software.

This skill helps developers follow test-driven development practices for Python projects. It guides users through the Red-Green-Refactor cycle, pytest configuration, and test quality auditing.

Shell scripts often fail silently or behave unpredictably due to missing error handling. This skill provides battle-tested patterns for robust bash and zsh scripting including proper error handling, safe variable expansion, and modular code structure.

Writing standalone Python scripts with dependencies requires manual setup and configuration. This skill generates ready-to-run scripts with PEP 723 inline metadata, automatic dependency management, and proper CLI argument parsing.

Applications often suffer from slow response times, high memory usage, and poor user experience. This skill provides expert guidance on identifying bottlenecks, optimizing code, conducting load tests, and improving Core Web Vitals across frontend, backend, and database layers.

Building Next.js applications requires understanding App Router, Server Components, and performance patterns. This skill provides expert architecture guidance for designing, migrating, and optimizing Next.js applications with modern patterns.

Creating MCP server configurations requires deep understanding of the Model Context Protocol architecture and integration patterns. This skill provides expert guidance for designing, implementing, and optimizing MCP integrations for any service.

Writing tests in Go can be challenging without guidance on patterns and best practices. This skill provides comprehensive examples for table-driven tests, mocking, integration testing with containers, and performance benchmarks.

Go applications often suffer from hidden performance bottlenecks in memory allocations and concurrency patterns. This skill provides proven techniques to identify bottlenecks using pprof, reduce allocations with sync.Pool, and implement efficient worker patterns that scale.

Building scalable Go applications requires proven architectural patterns. This skill provides guidance on clean architecture, hexagonal architecture, and DDD principles for production-ready code.

Teams struggle with inconsistent pull requests that lack context and slow down reviews. This skill provides structured templates, branch naming conventions, and merge strategies to streamline your git workflow.

Managing project dependencies manually is time-consuming and risky. Outdated dependencies create security vulnerabilities. This skill automates dependency analysis, vulnerability scanning, and license compliance checks across multiple package managers.

Debugging complex errors and analyzing logs takes significant time and expertise. This skill provides structured workflows for error analysis, log parsing, stack trace investigation, and root cause identification across multiple languages and platforms.

Unused code bloats projects and increases maintenance costs. This skill detects unused imports, functions, and classes across multiple languages with safety checks that preserve critical code.

Creating effective command-line interfaces requires understanding design patterns, argument parsing, and user experience principles. This skill provides expert guidance for building intuitive, well-documented CLI tools that follow established conventions.

Code reviews catch bugs, security vulnerabilities, and maintainability issues before they reach production. This skill provides structured guidance for thorough code reviews with prioritized, actionable feedback.

Developers often lose context when working with unfamiliar code or making changes. This skill automatically detects when context would help and surfaces relevant knowledge graph entries, code relationships, dependencies, and tests.

AI-assisted coding often introduces defensive bloat, unnecessary comments, and style inconsistencies. This skill identifies and removes these artifacts to produce cleaner, more maintainable code while preserving functionality.

Applications need unique identifiers to track entities, sessions, and records. This skill provides ready-to-use prompts for generating RFC9562-compliant UUID v4 random identifiers and UUID v7 timestamp-based identifiers.