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.

Creating MCP servers requires deep knowledge of protocol specifications, agent-centric design, and evaluation methodologies. This skill provides comprehensive guidance, reference implementations, and evaluation tools to build high-quality MCP servers that enable effective LLM-tool integration.

Developers waste time deciding how to finish branches. This skill presents clear options and handles the chosen workflow safely. It verifies tests pass and requires confirmation for destructive actions.

Multiple test failures waste time when investigated one by one. This skill provides a pattern for dispatching multiple Claude agents to investigate and fix independent problems concurrently, reducing debugging time.

Building complex artifacts with raw HTML is slow and limited. This skill provides a complete development environment with React, Tailwind CSS, and 40+ pre-built shadcn/ui components. Initialize a project, develop with modern tools, and bundle everything into a single portable HTML file.

Transform vague requirements into clear system designs. Use EventStorming methodology to create navigable design catalogs with Mermaid diagrams.

Understanding large codebases requires time and effort. CodeConscious provides an autonomous cognitive assistant that builds persistent memory across sessions, enabling deep code exploration, pattern recognition, and continuous learning from project history.

Traditional text search misses code structure. AST-Grep finds and transforms code using syntax-aware patterns that understand your code's meaning. It searches by AST structure rather than plain text, enabling precise code analysis and large-scale refactoring.

Developers waste time switching between disconnected development tools. This toolkit seamlessly integrates 8 custom AI tools with 10+ popular CLI utilities like ripgrep and jq through a unified discovery system.

Managing multiple git branches can clutter your main working directory and make context switching difficult. This skill provides a structured approach to creating isolated git worktrees that let you work on multiple features simultaneously without interference.

TypeScript strict mode catches bugs at compile time that would cause runtime errors. This skill helps you configure and enforce strict type checking for safer, more reliable code.

Writing tests after code leads to gaps and missed edge cases. This skill provides a structured TDD workflow with RED-GREEN-REFACTOR cycles, real implementation testing without mocking, and E2E validation using Playwright.

Bug fixes often fail when they only address symptoms. This four-phase debugging framework ensures you understand the root cause before attempting solutions. Reduces debugging time and prevents recurring issues.