Rust developers often struggle with proper error handling patterns. This skill proactively reviews code and suggests idiomatic improvements using Result types, custom error types with thiserror, and proper error propagation with the ? operator.

Rust Lambda functions often mix I/O and CPU workloads. This skill helps you choose the right concurrency pattern using tokio, rayon, or spawn_blocking for optimal performance.

Rust developers often use outdated async patterns that add unnecessary dependencies and performance overhead. This skill provides expert guidance on native async fn in traits, async closures, and helps migrate from async-trait to cleaner, faster code.

Poor test coverage and overly complex tests slow down development and hide bugs. This skill provides guidance for writing focused tests that validate core user behaviors with clear names and mocked dependencies, ensuring fast execution and maintainable codebases.

Projects often fail due to inconsistent technology choices and duplicated tools. This skill ensures AI helpers follow your established technology stack including frameworks, databases, testing tools, and third-party services for architectural consistency.

This skill helps developers write resilient code with proper exception handling, user-friendly error messages, and graceful failure management. It guides Claude Code to create error boundaries, implement retry logic, and ensure proper resource cleanup in any language.

Inconsistent code styles make collaboration difficult and increase maintenance costs. This skill provides AI with coding standards for writing clean, maintainable code following industry best practices. Developers use these guidelines to ensure their codebase remains readable and team members can understand each other's work.

Frontend component development often leads to tightly coupled code that is difficult to maintain and reuse. This skill guides Claude Code to create modular, composable UI components following single responsibility principle with proper encapsulation.

Database queries often suffer from security vulnerabilities and performance issues. This skill provides Claude with expert guidance to write secure, optimized queries that prevent SQL injection and eliminate N+1 problems.

Database models often lack proper validation and relationships. This skill provides clear guidance for defining database models with proper naming conventions, relationships, constraints, and data integrity rules.

Building APIs without consistent standards leads to confusing interfaces and maintenance challenges. This skill provides structured guidance for designing RESTful APIs that follow industry best practices for URL structure, HTTP methods, status codes, and versioning.

Managing multiple development branches simultaneously is complex and error-prone. This skill provides slash commands to safely create, list, and remove git worktrees with automatic port allocation and service management.

Frontend bugs are hard to diagnose without the right tools. This skill provides guided workflows to identify and fix UI issues, performance problems, network errors, and console failures using Chrome DevTools MCP.

Testing web applications manually takes time and introduces errors. This skill provides Playwright automation scripts and server management tools to verify frontend functionality, capture screenshots, debug UI behavior, and view browser console logs.

Developers waste time writing tests that verify mocks instead of real behavior. This skill prevents five common testing anti-patterns by enforcing TDD principles and providing gate functions before each test decision.

Writing tests after code proves nothing. This skill enforces TDD discipline by making you write failing tests first, ensuring your tests actually verify behavior and catch bugs before they reach production.

Random fixes waste time and create new bugs. This skill enforces a rigorous four-phase debugging process that ensures you understand the root cause before attempting any solution, preventing symptom fixes that mask underlying problems.

Code issues caught early prevent costly fixes later. This skill dispatches a code-reviewer subagent to verify implementation against requirements before proceeding with development.

Many developers blindly implement code review feedback without verification. This skill ensures you evaluate feedback technically before implementation. It promotes code quality and prevents unnecessary changes.

Building Chrome extensions requires understanding service workers, security patterns, and Chrome Web Store compliance. This skill provides architectural guidance, code templates, and security best practices for creating professional extensions with optional AI integration.