Skills de Claude Code · página 131

Embedded firmware development for microcontrollers including memory-mapped I/O, GPIO, interrupts, timers, UART/SPI/I2C serial protocols, PWM generation, ADC sampling, interrupt-driven versus polled architectures, RTOS fundamentals, and the bring-up sequence from power-on reset through first printf. Covers AVR/Arduino, ARM Cortex-M, and ESP32 patterns. Use when writing, porting, debugging, or reviewing firmware that directly manipulates hardware peripherals.

Physical principles underlying diodes, bipolar junction transistors, and MOSFETs — carrier concentrations, drift and diffusion, the pn junction, forward and reverse bias, the Shockley diode equation, BJT operating regions, MOSFET threshold and saturation, small-signal models, and temperature effects. Use when reasoning about device-level behavior, designing bias networks, selecting transistor operating points, interpreting datasheets, or diagnosing nonlinear device failures.

Foundations of digital signal processing — sampling, aliasing, the Nyquist criterion, quantization, convolution, the discrete Fourier transform, FFT, FIR and IIR filter design, windowing, spectral leakage, and practical issues in fixed-point versus floating-point implementation. Use when designing filters, analyzing spectra, choosing sample rates, reasoning about aliasing, or implementing DSP algorithms on a microcontroller, DSP chip, or host CPU.

Bench instruments and measurement techniques for electronics — digital multimeter, oscilloscope, logic analyzer, spectrum analyzer, function generator, power supply, and their proper use. Covers probing technique, ground loops, loading effects, trigger modes, FFT mode pitfalls, signal integrity, noise budget analysis, and debugging workflows from "it doesn't work" to "here is the failure mechanism." Use when measuring, debugging, or characterizing any electronic circuit or firmware-hardware interaction.

Engineering design cycle covering requirements elicitation, specifications writing, constraint identification, iterative prototyping, and design communication. Spans the full loop from problem definition through ideation, analysis, prototyping, testing, and redesign. Includes morphological charts, TRIZ, Pugh matrices, design reviews, and the distinction between functional and non-functional requirements. Use when framing engineering problems, generating design alternatives, writing specifications, or running design reviews.

Engineering ethics covering safety, professional codes of conduct, public welfare responsibility, whistleblowing, case studies (Challenger, Columbia, Hyatt Regency, Bhopal, Therac-25), and the ethical dimensions of design decisions. Includes the NSPE Code of Ethics, the iron ring tradition, risk communication, informed consent in engineering, and the duty to dissent. Use when analyzing ethical dimensions of engineering decisions, teaching professional responsibility, or reviewing designs for safety and public welfare.

CAD fundamentals, 3D printing (FDM/SLA/SLS), CNC machining, workshop skills, rapid prototyping methodology, and testing of physical prototypes. Covers fidelity levels, material selection for prototypes, dimensional tolerancing, assembly planning, and the iterate-test loop. Use when building prototypes, selecting fabrication methods, planning physical tests, or choosing between prototyping technologies.

Unified skill hub for Solana development. Routes to external submodule skills (solana-foundation, sendai, solana-game, trailofbits, cloudflare, qedgen, colosseum) and local skills. Progressive disclosure — read only what you need.

>

>

Use when the user wants to set up a new project or add enforcement tooling (TDD, secret scanning, file size limits, git hooks, CLAUDE.md templates) to an existing project. Also use when the user says "bootstrap", "scaffold", "set up my project", or "add quality enforcement".

|

|

Use Gemini CLI for long-context codebase exploration, architecture review, refactor impact analysis, documentation synthesis, or structured data analysis when the host should hand off a large cross-file problem instead of solving it file-by-file.

Validates, parses, and sanitizes AI-generated outputs before they reach end users or downstream systems. Structured output enforcement, schema validation, and fallback handling.

Design stable, versioned, self-documenting APIs. Easy to use correctly, hard to use incorrectly. Apply Hyrum's Law from day one.

Automated quality gates from commit to production. Every merge to main is potentially shippable. No manual steps in the deployment path.

Get layered, context-aware explanations of unfamiliar code. Understand what it does, why it was written that way, and how to work with it safely.

Structured code review focusing on correctness, security, and maintainability. Correctness before style. Every reviewer comment must be actionable.

Load minimum necessary context into agent context windows. Prevents token bloat, reduces cost, and improves focus. Only load what the current task needs.

Systematic root cause analysis for production and development bugs. Hypothesis-driven debugging — never guess-and-check.

Document decisions, not just implementations. ADRs for architectural choices, inline docs for non-obvious code, and runbooks for operational knowledge.

Graceful degradation and meaningful error messages. Errors are first-class citizens, not afterthoughts. Every error path is designed, not discovered.

Accessible, performant, responsive UI patterns. Component design, state management discipline, and Core Web Vitals compliance.

Trunk-based development with atomic commits, clean history, and meaningful commit messages. Every commit should be deployable.

Transforms imperative instructions into declarative goals with verifiable success criteria. Enables autonomous looping until verified completion.

Detects and mitigates LLM hallucinations in production pipelines. Validates AI-generated facts, code, and decisions before they reach end users or downstream systems.

Converts vague ideas into concrete, testable specifications with acceptance criteria. No implementation begins without a spec.

Build in verifiable increments. Never implement more than can be tested right now. Ship partial working systems over complete broken ones.

Test real system boundaries, not mocks of mocks. Integration tests verify that components work together, not that they work in isolation.

Converts unstructured meeting notes into structured, assigned, time-bounded action items. Never leave a meeting without knowing who does what by when.

Designs and coordinates multi-agent pipelines where specialized agents collaborate to complete complex tasks. Includes communication protocols, failure handling, and state management.

Structured logging, distributed tracing, and alerting for AI systems and traditional services. You can't fix what you can't see.

Measure first, optimize second. Data-driven performance improvements with before/after benchmarks and production validation.

Zero-downtime deployments with pre-flight checks, staged rollouts, and rollback plans. Never ship to production without a verified rollback strategy.

Guards AI agents and LLM-powered applications against prompt injection attacks — both direct and indirect. Validates AI inputs and outputs at every trust boundary.

Patterns for Retrieval-Augmented Generation (RAG) and agent memory systems. Retrieves only relevant context, prevents context bloat, and maintains coherent state across sessions.

Safe, behavior-preserving code transformation backed by tests. Refactor with evidence, not instinct.

Distill complex topics into layered, actionable summaries. Start with the key insight, layer in detail, end with recommended next action.

Applies OWASP Top 10, secrets management, and least-privilege principles before any code ships. Security is a build step, not an afterthought.

Prevents overengineering by enforcing minimum viable code. No speculative features, no premature abstractions, no unnecessary complexity.

Enforces minimal code modifications — touch only what you must. Prevents drive-by refactoring, comment deletions, and style changes unrelated to the task.

Breaks features into atomic, independently verifiable tasks. No task should take more than 4 hours. Unblocks parallel work and reduces integration risk.

Red-green-refactor cycle with meaningful coverage. Tests are written before implementation. Coverage is a side effect of good tests, not the goal.

Forces explicit reasoning before writing any code. Surfaces assumptions, manages confusion, and prevents hallucination by demanding clarity upfront.

Scaffolds a complete .NET solution following Clean Architecture principles with proper layer separation (API, Application, Domain, Infrastructure). Creates project structure, dependency injection setup, and cross-cutting concerns configuration.

Generates CQRS Commands with Handlers, Validators, and Request DTOs following Clean Architecture patterns. Commands represent actions that modify state and return Result types for proper error handling.

Generates CQRS Queries with Handlers and Response DTOs for read operations. Uses Dapper for optimized read queries, bypassing the domain model for better performance.

Generates Domain Entities following DDD principles with factory methods, private setters, domain events, and proper encapsulation. Supports aggregate roots, child entities, and value objects.

Generates Repository interfaces and implementations following the Repository pattern. Provides data access abstraction for aggregate roots with EF Core implementations.

Generates Entity Framework Core configurations using Fluent API. Maps domain entities to database tables with proper relationships, constraints, and conventions.

Generates RESTful API Controllers with proper routing, versioning, authorization, and MediatR integration. Follows REST conventions and Clean Architecture patterns.

Generates Minimal API endpoints following Microsoft's recommended approach. Creates fast, testable HTTP APIs with minimal code using MapGet/MapPost/MapPut/MapDelete. Preferred over controller-based APIs for new projects.

Implements the Result pattern for explicit error handling without exceptions. Provides Result, Result<T>, and Error types for clean, predictable control flow in domain-driven applications.

Generates Domain Events and their handlers following DDD patterns. Implements event raising in entities, MediatR notification handlers, and the Outbox pattern for reliable event processing.

Generates MediatR Pipeline Behaviors for cross-cutting concerns like logging, validation, exception handling, caching, and performance monitoring. Implements the decorator pattern around handlers.

Generates FluentValidation validators for commands and queries. Includes common validation rules, custom validators, async validation, and integration with MediatR pipeline behaviors.

Configures JWT Bearer authentication for .NET APIs. Includes token generation, validation, refresh tokens, and user context extraction from claims.

Implements permission-based authorization with custom attributes, policy providers, and authorization handlers. Provides granular access control beyond simple role-based authorization.

Implements the Outbox pattern for reliable domain event processing. Ensures events are persisted in the same transaction as the aggregate changes and processed asynchronously with guaranteed delivery.

Generates scheduled background jobs using Quartz.NET. Includes job definitions, triggers, cron scheduling, dependency injection, and persistent job store configuration.

Implements email service abstraction with SendGrid provider. Includes template support, localization, async sending, and domain event integration for transactional emails.

Implements email service using AWS SES for .NET APIs. Designed for applications with HTML template support, placeholder replacement, and Result pattern error handling.

Configures health checks for database, external services, and custom application checks. Provides liveness and readiness endpoints for container orchestration.

Generates audit trail infrastructure for entities. Implements IAuditable interface, EF Core SaveChanges interceptor, and automatic population of CreatedAt, UpdatedAt, CreatedBy, and UpdatedBy fields.

Generates optimized read queries using Dapper. Includes multi-mapping for joins, pagination, dynamic filtering, CTEs, and best practices for high-performance data access.

Implements the Specification pattern for encapsulating query logic. Enables composable, reusable, and testable query criteria with support for includes, ordering, and pagination.

Generates unit tests for command and query handlers using xUnit and NSubstitute. Implements Arrange-Act-Assert pattern with comprehensive test coverage for success and failure scenarios.

Configures integration tests with WebApplicationFactory and Testcontainers. Provides test database setup, authentication helpers, and utilities for testing API endpoints with real dependencies.

Configures structured logging with ILogger<T> and ILoggerFactory following Microsoft best practices. Includes Serilog setup, log enrichment, and logging source generators for high-performance logging.

Implements ASP.NET Core rate limiting middleware for API protection. Covers fixed window, sliding window, token bucket, and concurrency limiters with custom policies.

PostgreSQL database design best practices, naming conventions, indexing strategies, and performance optimization for .NET applications using Npgsql and EF Core.

SQL Server database design best practices, naming conventions, indexing strategies, and performance optimization for .NET applications using Microsoft.Data.SqlClient and EF Core.

Implements the Options pattern for strongly-typed configuration in .NET. Covers IOptions<T>, IOptionsSnapshot<T>, and IOptionsMonitor<T> with validation and reload support.

|

Incremental LLM-friendly wiki generator for Obsidian note vaults. Use when: (1) Building wiki from notes, (2) Ingesting notes to wiki, (3) Obsidian LLM wiki, (4) Incremental knowledge base management. Triggers: 'build wiki from notes', 'ingest notes to wiki', 'Obsidian LLM wiki', 'incremental knowledge base'.

A self-evolution engine for AI agents. Analyzes runtime history to identify improvements and applies protocol-constrained evolution. Communicates with EvoMap Hub via local Proxy mailbox.

|

|

|

|

|

Run multi-indicator technical analysis on crypto or market OHLCV data. Use for deterministic trend, momentum, volume, and divergence analysis.

Analyze datasets and turn them into narrative reports with charts, audits, comparisons, and statistical summaries. Use for exploratory analysis and executive-ready outputs.

Convert PDFs, Office docs, markdown, HTML, and tables between editable formats. Use for best-effort document conversion, PDF utilities, form filling, and table extraction.

Run loan, investment, NPV, retirement, savings, and risk calculations with schedules and charts. Use for deterministic financial modeling tasks.

Parse, convert, geocode, visualize, and measure geographic data. Use for address cleanup, geo file conversion, mapping, and distance workflows.

Process images for cleanup, conversion, metadata, comparison, icons, palettes, collages, and sprite sheets. Use for single-image or batch image workflows.

Plan and build MCP servers with agent-friendly tools, schemas, error handling, and evaluation. Use when creating or refactoring MCP integrations.

Process audio and video with clipping, conversion, analysis, captions, thumbnails, GIFs, and batch utilities. Use for practical media manipulation workflows.

Extract text and structure from scans, images, and scanned PDFs. Use for OCR, searchable PDFs, table extraction, receipt parsing, and business card parsing.

Generate QR codes with clean URLs, optional UTM parameters, captions, and print-safe exports. Use for single codes or batch campaign generation.

Create or update agent skills with concise SKILL.md instructions, bundled resources, agent metadata, validation, and packaging. Use when building or refactoring skills.

Generate deterministic SVGs from structured specs with validation and rendering. Use for icons, diagrams, charts, UI mockups, and technical drawings.

Creates git commits following Conventional Commits format with type/scope/subject. Use when user wants to commit changes, create commit, save work, or stage and commit. Enforces project-specific conventions from CLAUDE.md.

Creates GitHub Pull Requests with automated validation and task tracking. Use when user wants to create PR, open pull request, submit for review, or check if ready for PR. Analyzes commits, validates task completion, generates Conventional Commits title and description, suggests labels. NOTE - for merging existing PRs, use github-pr-merge instead.

Merges GitHub Pull Requests after validating pre-merge checklist. Use when user wants to merge PR, close PR, finalize PR, complete merge, approve and merge, or execute merge. Runs pre-merge validation (tests, lint, CI, comments), confirms with user, merges with proper format, handles post-merge cleanup.

Handles PR review comments and feedback resolution. Use when user wants to resolve PR comments, handle review feedback, fix review comments, address PR review, check review status, respond to reviewer, verify PR readiness, review PR comments, analyze review feedback, evaluate PR comments, assess review suggestions, or triage PR comments. Fetches comments via GitHub CLI, classifies by severity, applies fixes with user confirmation, commits with proper format, replies to threads.

Guide for creating Claude Code skills following Anthropic's official best practices. Use when user wants to create a new skill, build a skill, write SKILL.md, update an existing skill, or needs skill creation guidelines. Provides structure, frontmatter fields, naming conventions, and new features like dynamic context injection and subagent execution.

>