Starting a new Firebase project involves many architectural decisions that affect long-term maintainability. This skill guides you through CLI setup, architecture patterns, and emulator configuration with proven best practices from production deployments.

Firebase development issues can be difficult to troubleshoot without a systematic approach. This skill provides a step-by-step workflow for diagnosing emulator problems, rules violations, function errors, auth issues, and deployment failures.

Firebase projects require specific architecture decisions and CLI workflows. This skill guides you through initializing projects, adding Cloud Functions, debugging emulators, and validating security rules with proven patterns from production apps.

CSS validation requires manual review of semantic naming, dark mode coverage, and Tailwind composition. This skill automates pattern checking and generates actionable reports with file and line references.

This skill transforms messy CSS from inline styles and repeated utility classes into organized semantic components. It extracts patterns, adds dark mode support, creates tests, and ensures maintainable styling with Tailwind composition.

Managing consistent CSS styles across projects is difficult and error-prone. This skill guides you through creating semantic component classes, adding dark mode support, and maintaining test coverage.

Developers waste time crafting commit messages and struggle to maintain consistency across team repositories. This skill analyzes git changes and automatically generates properly formatted conventional commit messages.

Manual code review is time-consuming and error-prone. This skill provides systematic code analysis using Claude to identify bugs, security vulnerabilities, performance issues, and quality concerns across files or entire directories.

Understanding git repository changes requires running multiple commands and parsing output. This skill automates branch analysis, commit history extraction, and file change statistics for faster code review and PR preparation.

Manually running tests and analyzing failures is time-consuming. This skill automates test execution across different project types, detects the correct test command, runs tests, and handles failures by implementing fixes.

Managing Git branches can be confusing, especially when dealing with errors or sync issues. This skill automates branch investigation and creation while handling common problems like conflicts and uncommitted changes.

Need to implement features or fix bugs. This skill provides a structured workflow for investigating code, making changes, and creating conventional git commits.

Lovable uses two-way GitHub sync for frontend but requires Lovable prompts for backend operations. This skill provides exact prompts for deploying edge functions, applying migrations, and managing database operations without memorizing documentation.

Finding specific files and code patterns in large projects takes too much time. This skill provides fast, focused search and navigation capabilities to locate files, symbols, and definitions without deep analysis.

Need to write new features, fix bugs, or refactor existing code. This skill provides a focused AI subagent that follows project conventions and makes precise code modifications with minimal targeted edits.

Complex software projects often suffer from unclear requirements and architectural decisions made without proper trade-off analysis. This skill provides structured guidance for system design, helping you clarify requirements, compare alternatives, and identify risks before implementation begins.

This minimal skill template provides a foundation for creating custom API integration prompts. It enables developers to extend Claude with specialized API interaction patterns for their specific use cases.

Complex AI tasks often fail due to unclear scope or missing requirements. This skill provides a structured workflow for gathering requirements, drafting implementation plans, and getting user approval before writing any code.

This skill provides guidelines for writing maintainable code and following best practices during development. It helps developers create cleaner, more reliable software through structured planning and quality-focused workflows.

Writing effective tests requires understanding the right patterns for each scenario. This skill provides universal testing strategies, from the test pyramid to TDD workflows, so you can build reliable test suites.