Building custom agents for specific tasks requires understanding Claude Code's agent schema, Task tool parameters, and prompt engineering patterns. This skill provides guided workflows and comprehensive reference documentation for creating effective specialized agents.

Code reviews catch bugs before deployment but are time-consuming. This skill provides structured checklists, security patterns, and best practices for MERN stack reviews to ensure nothing critical is missed.

Writing backend tests takes significant time and requires knowledge of test frameworks. This skill analyzes your code structure, detects your testing setup, and generates comprehensive tests covering happy paths, error cases, and edge cases.

This guide helps developers create high-quality MCP servers that enable AI models to interact with external APIs and services. Covers Python FastMCP and TypeScript SDK patterns with best practices for tool design.

Building ChatKit chatbots requires integrating multiple technologies with proper security patterns. This skill provides complete architectural guidance for creating production-ready chatbots with user isolation and real-time capabilities.

Writing tests first helps catch bugs early and improves code design. This skill guides you through test-driven development cycles with pytest, from writing failing tests to achieving green coverage.

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.

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.

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.

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.

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 and security vulnerabilities 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.