Codebases accumulate technical debt through unclear names, duplicated logic, and deep nesting. This skill provides a disciplined approach to improve code structure while preserving behavior through test-driven safety nets and incremental changes.

Bugs keep returning because symptoms are fixed instead of root causes. This skill enforces a four-phase debugging framework that identifies the true source of issues before any fix attempts.

Code quality issues can slip through reviews and cause production bugs. This skill runs ESLint and TypeScript checks to catch syntax errors, style violations, and type mismatches before code is committed.

Users need to display new types of agent output in the chat feed. This skill provides structured instructions for adding new event types with TypeScript interfaces, React components, and WebSocket integration.

Creating blockchain bots requires understanding event-driven architecture and risk management. This skill guides AI assistants to help users design, implement, and deploy automated bots that respond to on-chain events.

Extending AI agent capabilities requires understanding backend tool patterns. This skill provides step-by-step instructions for adding new tools to the OpenAI function calling system, including helper functions, tool definitions, and security guardrails.

Trading on decentralized exchanges requires complex integrations with smart contracts and liquidity pools. This skill guides Claude Code through using the uniswap-sdk with Ape framework to build safe trading applications with proper indexing and route optimization.

Writing unit tests ensures code correctness and prevents regressions. This skill provides step-by-step guidance for creating tests that follow project conventions, use Robolectric for Android components, and maintain consistent naming and location patterns.

This skill provides expert guidance on implementing secure and modern Stripe integrations. It covers checkout flows, subscriptions, webhooks, and Connect platforms to help you avoid deprecated APIs and follow Stripe's recommended patterns.

Plugin developers need a standardized way to store per-project configuration. This pattern uses .claude/plugin-name.local.md files with YAML frontmatter for structured settings.

Connect Claude Code plugins to external services and APIs using Model Context Protocol. This skill provides configuration patterns for stdio, SSE, HTTP, and WebSocket server types with authentication support.

Writing and maintaining tests is time-consuming. Vitest provides a blazing-fast testing framework powered by Vite with Jest-compatible APIs, enabling developers to write unit tests with native ESM, TypeScript, and JSX support out of the box.

Teams need accurate guidance for Vite configuration and build workflows. This skill summarizes official patterns and examples so agents can propose correct settings and commands.

Building TypeScript libraries requires complex bundler configuration. This skill provides comprehensive documentation for tsdown, a blazing-fast bundler powered by Rolldown, covering configuration, plugins, and migration from tsup.

Building Vue applications requires predictable state management across components. Pinia provides a type-safe, intuitive API for defining stores with state, getters, and actions. This skill provides comprehensive references for building scalable Vue state management patterns.

Animated UI components can break keyboard navigation when browsers reject focus calls on invisible elements. This skill provides a retry mechanism pattern that ensures focus succeeds after CSS animations complete, making animated components fully accessible.

Claude often claims code works without verification. This skill enforces actual build and test execution before any completion claim, eliminating false positives and ensuring reliable code delivery.

.NET projects often have inconsistent build patterns that cause maintenance problems. This skill runs an automated linter to check for MSBuild violations and Central Package Management issues before they cause problems in your codebase.

Single-perspective reviews miss issues. This skill deploys architecture and implementation reviewers in competition to find more problems. The competitive framing makes agents try harder, producing deeper analysis before you proceed.

Manual code reviews are time-consuming and inconsistent. This skill provides a systematic framework for comprehensive code reviews covering security vulnerabilities, style violations, performance issues, and best practices with consistent severity levels.