Configuring Firestore databases, security rules, and queries across multiple platforms is complex and error-prone. This skill guides you through database provisioning, edition selection, security rule generation, data modeling, and SDK usage for Standard and Enterprise editions on Android, iOS, Flutter, Web, and Python.

Adding AI capabilities to web applications requires understanding Firebase SDK setup and Gemini API integration. This skill provides step-by-step guidance for integrating generative AI with text, images, chat, and streaming support.

Developers often struggle with the Genkit Python SDK due to its fast-changing API and complex setup requirements. This skill provides up-to-date code patterns, error fixes, and workflow guidance for building AI-powered applications with Genkit in Python.

Developers need guidance to use the Genkit framework correctly in Node.js and TypeScript projects. This skill provides reference documentation, common error solutions, and code patterns for building AI-powered applications with Genkit.

Building AI applications in Go requires understanding Genkit SDK patterns for generation, prompts, flows, and model providers. This skill provides comprehensive reference documentation for creating AI-powered Go applications with structured output, streaming, and tool calling.

Integrating AI models into Dart and Flutter applications requires understanding Genkit flows, tools, and plugins. This skill provides comprehensive reference documentation and code examples for the Genkit Dart SDK.

Translating Figma designs into production-ready code manually is time-consuming and error-prone. This skill provides a structured workflow for pixel-perfect UI implementation with automated design token mapping.

Get comprehensive code reviews that catch security vulnerabilities, performance problems, and architectural issues before they reach production. This skill analyzes your code systematically across multiple dimensions to provide actionable feedback.

Manual code review is time-consuming and error-prone. This AI code reviewer automatically analyzes source code to identify bugs, security vulnerabilities, style issues, and performance problems with actionable fix suggestions.

JSON data is difficult to read when minified or improperly formatted. This skill validates and prettifies JSON strings with user-specified indentation to improve readability for debugging, logging, and data inspection.

Users need a simple way to create personalized greeting messages in Ruby. This skill provides a lightweight Ruby script that outputs a customizable greeting with the user's name and Ruby version information.

Brainfuck is an esoteric programming language with only 8 commands. This skill provides a complete Hello World implementation demonstrating minimalist code that outputs greetings using pure ASCII manipulation.

New programmers often struggle to understand code through documentation alone. This skill transforms learning into interactive app-building sessions where every line is explained, concepts are introduced progressively, and learning happens through practical doing.

Traditional unit tests check specific inputs, but miss edge cases. This skill teaches you property-based testing with proptest to automatically generate test inputs and discover hidden bugs.

Developers building MCP servers need clear guidance on transport layer options. This skill explains stdio, SSE, and HTTP transports with implementation examples, security best practices, and deployment scenarios for different use cases.

Creating MCP tools manually requires understanding complex macro systems and type constraints. This skill provides expert guidance on using the rmcp crate to build type-safe tools with automatic schema generation, validation, and async patterns.

Developers writing deeply nested Rust control flow struggle with readability and maintainability. This skill proactively identifies nested if-let patterns (3+ levels) and suggests let chain refactorings for cleaner, more readable Rust 2024 code.

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.