All Skills

PyTorch patterns: training pipelines, model architectures, data loading, mixed precision, distributed training, and reproducibility best practices.

Zero-dependency session-aware REPL: session branching, search, export, compaction, and metrics for interactive agent operation.

Example project-specific skill template based on a real production application. Starting point for creating custom project skills.

Translate visa application documents from images to English with bilingual PDF output containing original and translation side by side.

Process, convert, OCR, extract, redact, sign, and fill documents using the Nutrient DWS API. PDFs, DOCX, XLSX, PPTX, HTML, and images.

Automatically extract reusable patterns from Claude Code sessions and save them as learned skills for future use. Legacy version superseded by v2 instinct system.

Interactive installer for agent harness configurations: guided skill and rule selection, merge/overwrite detection, path verification, and optimization.

Write-time code quality enforcement using Plankton: auto-formatting, linting, and Claude-powered fixes on every file edit via hooks.

Interactive agent picker for composing and dispatching parallel teams. Select agents by capability, assign tasks, and coordinate execution.

RFC-driven multi-agent DAG execution: quality gates, merge queues, work unit orchestration, and structured parallel development.

Neural search via Exa MCP: web search, code examples, company intel, people lookup, and AI-powered deep research with semantic retrieval.

Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, and code examples.

Multi-agent orchestration using dmux tmux pane manager: parallel agent workflows across Claude Code, Codex, OpenCode, and other harnesses.

Engineering operating model for teams where AI agents generate a large share of implementation output. Role redefinition and workflow patterns.

Nuxt 4 app patterns: hydration safety, performance, route rules, lazy loading, and SSR-safe data fetching with useFetch and useAsyncData.

Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel deployment support.

Next.js 16+ and Turbopack: incremental bundling, FS caching, dev speed improvements, and migration from webpack.

Create animation-rich HTML presentations from scratch or by converting PowerPoint files. Visual exploration for non-designers.

JetBrains Exposed ORM: DSL queries, DAO pattern, transactions, HikariCP pooling, Flyway migrations, and repository pattern.

Apple FoundationModels framework: on-device text generation, guided generation with @Generable, tool calling, and snapshot streaming in iOS 26+.

iOS 26 Liquid Glass design system: dynamic glass material with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit.

SwiftUI architecture: state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

Protocol-based dependency injection for testable Swift: mock file system, network, and external APIs using focused protocols and Swift Testing.

Swift 6.2 Approachable Concurrency: single-threaded by default, @concurrent for background offloading, isolated conformances for main actor types.

Thread-safe Swift data persistence using actors: in-memory cache with file-backed storage, eliminating data races by design.

Perl testing with Test2::V0, Test::More, prove runner, mocking, coverage with Devel::Cover, and TDD methodology.

Perl security: taint mode, input validation, safe process execution, DBI parameterized queries, XSS/SQLi/CSRF prevention, and perlcritic policies.

Modern Perl 5.36+ idioms: signatures, strict/warnings, Moose/Moo OOP, regular expressions, file I/O, and CPAN module patterns.

C++ testing with GoogleTest and CTest: test fixtures, parameterized tests, mocking with GMock, sanitizers, and CMake integration.

C++ coding standards from C++ Core Guidelines: modern idioms, memory safety, RAII, smart pointers, const correctness, and template practices.

Compose Multiplatform and Jetpack Compose: state management, navigation, theming, performance, and platform-specific UI patterns.

Clean Architecture for Android and KMP: module structure, dependency rules, UseCases, Repositories, and data layer patterns.

Ktor server: routing DSL, plugins, authentication, Koin DI, kotlinx.serialization, WebSockets, and testApplication testing.

Kotlin Coroutines and Flow patterns for Android and KMP: structured concurrency, Flow operators, StateFlow, error handling, and testing.

Verification loop for Django projects: migrations, linting, tests with coverage, security scans, and deployment readiness checks.

Kotlin testing with Kotest, MockK, coroutine testing, property-based testing, and Kover coverage with TDD methodology.

Idiomatic Kotlin: null safety, data classes, sealed classes, extension functions, DSL builders, coroutines, and collection operations.

JPA/Hibernate patterns: entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and connection pooling.

Java coding standards for Spring Boot: naming, immutability, Optional usage, streams, exceptions, generics, and project layout.

Verification loop for Spring Boot: build, static analysis, tests with coverage, security scans, and diff review before release.

Test-driven development for Spring Boot: JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo coverage.

Spring Security: authentication, authorization, validation, CSRF, secrets management, security headers, rate limiting, and dependency security.

Spring Boot architecture: REST API design, layered services, data access, caching, async processing, and logging for Java backend services.

Verification loop for Laravel: env checks, linting, static analysis, tests with coverage, security scans, and deployment readiness.

Test-driven development for Laravel with PHPUnit and Pest: factories, database testing, fakes, and coverage targets.

Laravel security: authentication, authorization, validation, CSRF, mass assignment protection, file upload security, secrets, and rate limiting.

Laravel architecture patterns: routing, controllers, Eloquent ORM, service layers, queues, events, caching, and API resources for production apps.

Django testing strategies with pytest-django, TDD methodology, factory_boy, mocking, coverage, and testing Django REST Framework APIs.

Django security best practices: authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment.

Django architecture patterns: REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps.

Video and audio processing pipeline: ingest from files, URLs, RTSP feeds, or desktop capture. Extract frames, build visual/semantic/temporal indexes, search moments with timestamps. Timeline edits, subtitles, overlays, dubbing, and transcoding.

Python testing with pytest: fixtures, parametrize, mocking with unittest.mock, hypothesis property-based testing, coverage with pytest-cov, and TDD methodology for Python applications.

Pythonic idioms: PEP 8 style, type hints with mypy, dataclasses and protocols, generator patterns, context managers, async/await with asyncio, and package structure for maintainable Python.

Idiomatic Go patterns: error handling conventions, interface design, goroutine and channel concurrency, context propagation, struct embedding, and package organization for maintainable Go applications.

Declarative intermediate schema pattern for AI agent task execution: intent capture, schema validation, execution planning, and result verification. Separates what from how in agent workflows.

Multi-agent coding orchestration via Claude DevFleet: plan projects, dispatch parallel agents in isolated git worktrees, monitor progress, and read structured completion reports.

Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, httptest for API testing, testify assertions, and coverage measurement with TDD methodology.

Anthropic Claude API patterns for Python and TypeScript: Messages API, streaming, tool use, vision, extended thinking, batch processing, prompt caching, and Claude Agent SDK integration.

Decision framework for choosing between regex and LLM when parsing structured text. Start with regex for deterministic patterns, add LLM only for low-confidence edge cases.

ClickHouse database patterns: columnar query optimization, MergeTree engine selection, materialized views, data ingestion pipelines, partition strategies, and high-performance analytical workload design.

Unified AI media generation via fal.ai MCP: text-to-image, text/image-to-video with Seedance/Kling/Veo, text-to-speech with CSM-1B, and video-to-audio with ThinkSound.

AI-assisted video editing: FFmpeg processing, Remotion programmatic video, ElevenLabs voiceover, fal.ai generation, and final polish with Descript or CapCut. Full pipeline from raw capture to published content.

Quality management system patterns: nonconformance reporting, CAPA workflows, root cause analysis, disposition tracking, supplier quality management, and audit trail generation for ISO 9001 and regulated manufacturing.

Energy procurement patterns: contract negotiation workflows, spot vs forward pricing analysis, renewable energy certificate tracking, demand response program management, and regulatory compliance for utility procurement.

Reverse logistics patterns: return authorization workflows, disposition routing, refurbishment tracking, warranty claim processing, sustainability metrics, and customer return experience optimization.

Logistics exception handling patterns: shipment delay detection, damage claim workflows, customs hold resolution, delivery failure escalation, and automated exception classification with SLA tracking.

Logistics carrier management patterns: rate negotiation tracking, performance scorecards, capacity allocation, lane optimization, contract management, and carrier compliance monitoring.

Manufacturing production scheduling patterns: capacity planning, constraint-based scheduling, changeover optimization, work order sequencing, bottleneck detection, and real-time schedule adjustment.

Supply chain demand planning patterns: demand forecasting, safety stock calculation, reorder point optimization, ABC/XYZ classification, seasonal adjustment, and inventory health scoring.

Trade compliance automation patterns: HS classification, tariff calculation, denied party screening, export controls, FTZ management, customs brokerage workflows, and regulatory audit trails for cross-border commerce.

Library-agnostic Flutter/Dart code review checklist: widget best practices, state management patterns across BLoC/Riverpod/Provider/GetX, Dart idioms, performance optimization, accessibility, security, and clean architecture.

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform voice and format constraints. Never posts identical content cross-platform.

X/Twitter API integration: posting tweets and threads, reading timelines, search endpoints, analytics retrieval, OAuth 1.0a and 2.0 auth patterns, rate limit handling, and platform-native content formatting.

Universal coding standards: immutability by default, file organization, naming conventions, error handling patterns, TypeScript strict mode, React component patterns, and Node.js best practices.

Idiomatic Rust patterns: ownership, borrowing, lifetimes, error handling with thiserror/anyhow, trait design, concurrency with tokio, and performance optimization for safe systems programming.

Frontend development patterns for React and Next.js: component composition, state management, performance optimization with memoization and code splitting, accessibility patterns, and UI best practices.

Rust testing patterns: unit tests, integration tests, async testing with tokio::test, property-based testing with proptest, mocking strategies, and coverage measurement with cargo-tarpaulin.

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, and newsletters. Adapt one source asset across platforms without cross-posting identical content. Content calendar generation and repurposing workflows.

Analyze an unfamiliar codebase and generate a structured onboarding guide: architecture map, key entry points, naming conventions, dependency graph, and a starter CLAUDE.md for AI-assisted development.

Capture architectural decisions as structured ADRs during development sessions: auto-detect decision moments, record context and alternatives considered, maintain a searchable ADR log for future developers.

Research-before-coding workflow: search for existing tools, libraries, and patterns before writing custom code. Invokes researcher agent to prevent reinventing solutions that already exist.

Extract cross-cutting principles from skill libraries and distill them into reusable rule files. Scan skills for repeated patterns, consolidate into rule sets, and output as appendable rule definitions.

Write articles, guides, blog posts, tutorials, and newsletter issues in a distinctive voice derived from supplied examples or brand guidance. Structure for credibility with evidence, examples, and clear takeaways.

Conduct market research, competitive analysis, investor due diligence, and industry intelligence with source attribution and decision-oriented summaries. Market sizing, competitor comparisons, fund research, and technology scans.

Create and update pitch decks, one-pagers, investor memos, accelerator applications, financial models, and use-of-funds tables. Maintains internal consistency across multiple fundraising assets.

Draft cold emails, warm intro blurbs, follow-ups, update emails, and investor communications. Personalized, concise messaging for angels, VCs, strategic investors, and accelerators.

Multi-source deep research using web search and retrieval MCPs. Searches the web, synthesizes findings, and delivers cited reports with source attribution for any research topic.

Build automated AI-powered data collection agents for public sources: job boards, prices, news, GitHub, sports. Schedule scraping via GitHub Actions, enrich with LLM, store in Notion/Sheets/Supabase, and learn from user feedback.

Autonomous agent loop architectures from simple to complex: sequential pipelines, infinite agentic loops with quality gates, continuous PR loops with CI gates, de-sloppify cleanup passes, and RFC-driven multi-agent DAG orchestration with merge queues.

Audit context window consumption across agents, skills, MCP servers, and rules. Identifies token bloat, redundant components, and produces prioritized savings recommendations. Target: under 10 MCPs, under 80 tools active.

Strategic context window compaction: compact after research before implementation, after milestones before next phase, after debugging before feature work, after failed approaches before new ones. Never mid-implementation.

Systematic prompt improvement pipeline: structured prompt analysis, A/B testing patterns, metric-driven iteration, and prompt versioning for production LLM applications.

LLM cost optimization pipeline: automatic model routing by text length and item count thresholds, immutable cost tracking with frozen dataclasses, budget enforcement with early stopping, exponential backoff retry, and prompt caching strategies.

MCP server construction with Node/TypeScript SDK: tool registration with Zod validation, resource and prompt handlers, stdio vs Streamable HTTP transport selection, and transport-independent server architecture.

Quality gates, eval checkpoints, and recovery controls for continuous autonomous agent loops. Patterns for safe loop operation with stall detection and intervention hooks.

Operate long-lived agent workloads with observability, security boundaries, and lifecycle management patterns for enterprise deployments.

Solves the subagent context problem via 4-phase iterative retrieval: dispatch with minimal context, evaluate gaps, retrieve targeted context, and re-dispatch. Prevents context overflow and starvation in multi-agent workflows.

Instinct-based learning system: observe sessions via hooks, create atomic instincts with confidence scoring, project-scoped isolation to prevent cross-project contamination, promote universal patterns to global scope, and evolve instinct clusters into full skills.

Agentic engineering operating model: eval-first execution, task decomposition, cost-aware model routing by complexity, and structured agent workflow patterns.

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher task completion rates.

Docker and Docker Compose patterns: multi-service orchestration for local development, bind mounts with anonymous volume isolation, container networking, multi-stage Dockerfile optimization, container security hardening, and volume backup strategies.

Audit skill and command libraries for quality: quick scan mode for changed skills, full stocktake with sequential subagent batch evaluation, quality scoring, and gap analysis.

Head-to-head coding agent comparison tool: YAML task definitions with judge criteria, git worktree isolation per agent run, pass rate/cost/time/consistency metrics, and reproducible benchmarking across Claude Code, Aider, Codex, and other agents.

Pre-PR verification pipeline: sequential build check, type check, lint, test with coverage, security scan, and diff review. Hard stop on build failure. Report all type errors before proceeding.

Eval-driven development framework: define pass/fail criteria before implementation, capability/regression/consistency eval types, pass@k reliability metrics, grader patterns, and continuous eval integration during development.

Playwright E2E testing patterns: Page Object Model, test configuration, CI/CD integration with artifact capture (screenshots, videos, traces), flaky test quarantine, and critical user flow coverage strategies.

Test-driven development enforcement: write-tests-first methodology, RED/GREEN/REFACTOR cycle, 80%+ coverage requirement across unit/integration/E2E, user journey definitions, test pyramid structure, and coverage verification gates.

Production deployment workflows: rolling/blue-green/canary strategies, CI/CD pipeline patterns, Docker multi-stage builds, health checks, readiness probes, rollback strategies, and environment-specific configuration management.

Scans agent harness configurations for security vulnerabilities, misconfigurations, injection risks, secrets leaks, and permission escalation vectors.

PostgreSQL quick reference: B-tree/GIN/BRIN index selection, data type cheat sheet, Row Level Security patterns, connection pooling, and Supabase-specific best practices.

Zero-downtime database migration patterns: forward-only production migrations, concurrent index creation, nullable column additions, separate schema vs data migrations, rollback planning.

Backend architecture patterns: repository/service/controller layers, database query optimization, Redis caching, background jobs, middleware chains, and structured error handling.

REST API design patterns: resource naming, HTTP methods, status codes, pagination, cursor-based filtering, error response envelopes, versioning strategies, and rate limiting configuration.

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, patterns to catch blind spots where the same model writes and reviews code.

SHA-256 content-hash caching for expensive file processing. Path-independent keys auto-invalidate on content change. Frozen dataclass cache entries with file-based O(1) storage.

OWASP Top 10 security checklist with code patterns for secrets management, input validation, SQL injection prevention, XSS, CSRF, rate limiting, and pre-deployment security verification.

Forces rigorous hypothesis-driven debugging sequence before writing any fix. Prevents guessing. Works across Rust, Flutter, TypeScript, React Native, Python, and SQL.

Enforces plan-first development via brainstorm, write-plan, execute-plan workflow. No implementation code until plan is approved.

Designs production-grade multi-crate Rust workspace architectures with enforcement boundaries, cryptographic integrity, and deterministic policy evaluation.

Converts raw feature ideas into sprint-ready PRDs. Also handles architecture docs, feature specs, technical briefs, and sprint planning.

Designs policy DSLs, WASM sandbox plugins, and policy validation pipelines for governance rule engines.

Full-stack Next.js with App Router, Tailwind, TypeScript, Drizzle ORM, Supabase/PostgreSQL. Server actions, RSC, and auth patterns.

Enforces surgical MCP server usage preventing context flooding, unconstrained queries, and silent mutations. Governs all MCP interactions regardless of server.

Multi-agent autonomous development system. 41 agent types across 7 swarms, builds from PRD with zero human intervention. RARV+C cycle with 7 quality gates.

Generates IoT/webhook mock payloads and deterministic unit tests for event evaluation engines. Supports Ring, generic webhooks, and cooldown/rate-limit testing.

Generates exact, least-privilege AWS IAM policies. No wildcards. Covers Lambda, API Gateway, EventBridge, cross-account, and permission boundaries.

Designs production-grade Docker Compose stacks with service isolation, secrets, health checks, and reverse proxy configurations.

Generates complete design systems from brand name, vibe, or color input. Outputs CSS variables, typography, spacing, component tokens, and dark/light modes.

Designs production-grade Rust CLI binaries with clap subcommands and ratatui terminal UIs.

Designs AWS serverless infrastructure (API Gateway, EventBridge, SQS, Lambda, DynamoDB, Timestream) with IaC templates and Rust Lambda handlers.

Generates adversarial attack tests, property-based invariant tests (proptest), and security boundary tests for enforcement systems. Supports Rust, TypeScript, and Python.

Composes personalized emails based on context, tone, and recipient data.

Persists detailed audit logs for compliance reviews.

Captures leads and sends personalized follow-up across channels.

Matches candidates to job postings using AI ranking.

Compiles data from multiple sources into a formatted report or dashboard update.

Sends transactional or alert emails via SendGrid, Gmail, or SMTP.

Creates and sends PDF invoices from order or project data.

Publishes content to LinkedIn, Twitter/X, or Instagram on a schedule.

Iterates over lists of items or processes records in chunks.

Branches workflow paths based on if/else rules or switch conditions.

Maps, renames, filters, and reshapes data between workflow steps.

Catches failures, retries logic, and sends alerts when a workflow step breaks.

Makes authenticated HTTP requests to third-party APIs and handles responses.

Reads, converts, and routes CSV, PDF, or JSON files through a workflow.

Queries or inserts records into Postgres, MySQL, or Supabase tables.

Posts messages, alerts, or summaries to Slack channels or DMs.

Reads, writes, filters, and appends rows in Google Sheets or Airtable.

Reads and writes contact, deal, or lead data to CRM platforms like HubSpot or Pipedrive.

Starts a workflow instantly when an external service sends an HTTP event.

Searches the internet for real-time information and returns structured results.

Transcribes, summarizes, or responds to audio input.

Interprets images, screenshots, or documents using vision models.

Reads context and fills out web forms or structured inputs automatically.

Evaluates conditions and routes tasks to the right branch or agent.

Answers questions by searching a private knowledge base before generating a response.

Stores and retrieves past interactions to maintain continuity across sessions.

Writes, reviews, or debugs code snippets based on a prompt or spec.

Reads calendars, finds open slots, and books meetings automatically.

Gathers background info on people, companies, or topics from multiple sources.

Detects the emotional tone of text - positive, negative, or neutral.

Categorizes inputs like emails, leads, or tickets into predefined labels.

Pulls structured data from unstructured sources like PDFs, web pages, or emails.

Condenses long documents, threads, or pages into concise key points.