Skill Composition
Each skill is designed for a specific kind of caller — some only fire when you name them, others load automatically when the model judges them relevant. The split below summarises both modes at a glance.
These skills only fire when you call them by name. The agent will not load them on its own — they stay inert until invoked.
These skills are loaded automatically by the agent when it judges the context relevant. You usually don't need to call them yourself.
Skill List
Implement WCAG 2.2 compliant interfaces with mobile accessibility, inclusive design patterns, and assistive technology support. Provides semantic HTML, ARIA patterns, keyboard navigation, and testing guidance. Value: builds inclusive UX, passes audits, reduces legal risk.
AI Debt Detector audits AI-generated code for hidden debt patterns agents miss: missing error handling, orphaned resources, edge cases, hallucinated dependencies, and architectural drift. It provides a 5-step scan process and red-flag checklist used after code generation or before merge. Value: catches AI blind spots, prevents production incidents from unverified code.
Build production Apache Airflow DAGs with best-practice operators, sensors, testing, and deployment. Provides DAG design principles, dependency patterns, and ready templates via TaskFlow API. Delivers reliable, idempotent, observable data pipelines that are easy to test and run in production.
Guides migration from AngularJS to Angular via hybrid mode, incremental component rewriting, and DI updates. Uses ngUpgrade, code templates for components/services/routing, and strategy selection. Value: safely modernize legacy apps with minimal downtime and clear step-by-step paths.
Understands anti-reversing, obfuscation, and protection techniques in software analysis. Provides identification of debug/timing/virtualization checks, bypass strategies via patches or scripts, and detection code for CTF or research. Value: enables legitimate analysts to neutralize protections and complete authorized reverse engineering safely.
Master REST and GraphQL API design principles to build intuitive, scalable, maintainable APIs. Provides resource-oriented REST patterns, schema-first GraphQL guidance, versioning strategies, and best-practice checklists. Value: helps teams design developer-friendly APIs with consistent conventions and reduced integration friction.
Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Provides multiple templates (MADR, lightweight, Y-statement, deprecation, RFC) and lifecycle guidance. Helps teams capture context, decisions, and consequences, improving traceability and onboarding.
Implements proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and DDD. Provides layered structures, dependency rules, interface boundaries, and troubleshooting for dependency cycles. Produces maintainable, testable, scalable services with in-memory test adapters free of framework coupling.
Master Python asyncio, concurrent programming, and async/await patterns for high-performance non-blocking apps. Provides decision guides, core concepts, and code patterns for gather, tasks, error/timeout handling. Helps build fast async APIs and I/O-bound systems with fewer pitfalls.
Builds comprehensive attack trees to visualize threat paths from attacker goals to atomic steps. Uses OR/AND node structures with cost, time, skill, and detection attributes. Helps identify defense gaps, prioritize investments, and communicate security risks to stakeholders.
Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control. Provides strategy comparison, best practices, and pitfall avoidance via reference docs. Value: helps developers implement hardened auth systems and debug security issues efficiently.
Builds robust trading backtesting systems that avoid look-ahead, survivorship, and overfitting biases via train/validation/test splits and walk-forward analysis. Delivers reliable strategy performance estimates with realistic transaction costs and bias control for confident algorithmic trading.
Master defensive Bash programming for production-grade scripts. Uses strict mode, quoting, error traps, input validation, and safe temp handling to build fault-tolerant, idempotent, portable shell scripts. Delivers reliable CI/CD and system utilities with structured logging and fewer runtime failures.
Master Bats (Bash Automated Testing System) to write comprehensive unit tests for shell scripts. Provides patterns for error handling, dependencies, shell compatibility, parallel runs, and CI/CD integration. Delivers maintainable, portable test suites that catch regressions early across bash/sh/dash.
Optimizes Bazel builds for large-scale monorepos by providing architecture patterns, core concepts, and best practices for remote caching/execution and build performance. Delivers faster, reproducible enterprise builds with better caching and enforced architecture boundaries.
A pre-build risk review skill for founders, PMs, and AI builders. It runs a compact pre-mortem across demand, positioning, monetization, retention, trust, distribution, and adoption risk before implementation. Method: 7-dimension checklist plus decision-oriented output. Value: surfaces top risk assumption and smallest validation step to avoid wasted build effort.
Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Provides billing cycle models, proration and tax patterns, dunning flows, and Python starter code. Value: faster, reliable SaaS billing with fewer payment failures.
Master binary analysis patterns covering disassembly, decompilation, control flow and code pattern recognition. Use Ghidra/IDA/Binary Ninja workflows and reference assembly snippets to reverse-engineer executables, recover structs and types, and document program logic from compiled binaries.
Configures a PreToolUse hook for Claude Code to block AI agents from using git bypass flags like --no-verify and --no-gpg-sign. By adding a JSON hook to .claude/settings.json that inspects Bash calls, it enforces commit quality gates, ensuring pre-commit hooks, linting, tests, and signing always run. Value: prevents unsafe commits and policy violations.
Guides developers through a brand interview, translates answers into Stitch design-system params, generates and iteratively refines landing-page screens, and delivers a deployment-ready bundle. Uses Stitch SDK for visual generation and saves state in .stitch/metadata.json. Value: turns a built product into an on-brand marketing page without design expertise.
Automates changelog generation from commits, PRs, and releases using Keep a Changelog and Conventional Commits. Provides templates, commit examples, and best practices to standardize release notes and versioning. Value: less manual effort, consistent history, CI-ready releases.
Gates fine-tuned model checkpoints before promotion using a four-stage workflow: data-quality, capability-drift suite, paired arena, and canary. It applies drift budgets, paired comparison, and forgetting checks to produce a PROMOTE/REJECT verdict with evidence, preventing unsafe models from shipping and guiding remediation.
Master effective code review practices to give constructive feedback, catch bugs early, and foster knowledge sharing while keeping team morale. Uses four-phase review process, checklists, and language-specific patterns. Produces clear decisions and improves code quality and collaboration.
Analyzes competition and market positioning for startups using Porter's Five Forces, Blue Ocean Strategy, and positioning maps. Provides frameworks, templates, and scorecards to identify differentiation opportunities and sustainable advantages. Outputs a structured competitive landscape report that supports strategy and investor pitch decisions.
Guides managing project context as a versioned artifact alongside code in Conductor projects. Uses structured docs and best practices to keep AI sessions and teams aligned. Produces consistent, traceable context that reduces drift and improves onboarding and decision quality.
Optimize cloud costs across AWS, Azure, GCP, and OCI via rightsizing, tagging, reserved instances, and spend analysis. Provides frameworks, cloud-specific patterns, HCL examples, and checklists. Value: systematic cost governance and 30-90% savings while maintaining performance.
Implements CQRS to separate read and write models for scalable architectures. Provides architecture diagrams, component tables, and best practices for commands, queries, events, and projectors. Delivers independently scalable systems with optimized query performance and clear separation of concerns.
Implements data quality validation using Great Expectations, dbt tests, and data contracts. Provides quality dimensions, testing pyramid, and CI/CD integration patterns. Delivers reliable pipelines with automated checks and enforceable contracts.
Transforms raw data into compelling narratives for stakeholders using story structure, narrative arc, and three pillars (Data, Narrative, Visuals). Provides best practices to curate insights and drive decisions. Value: clear, persuasive executive presentations and data reports that inspire action.
Execute database migrations across ORMs (Sequelize, TypeORM, Prisma) with zero-downtime strategies, data transformation, and rollback procedures. Provides code templates, schema change patterns, and safe rollback methods. Value: enables confident, zero-downtime database upgrades with reversible migrations.
Prepares, formats, and validates datasets for supervised fine-tuning and preference training. Methods: format selection by target method, chat template application with loss masking, sequence packing, synthetic data mixing with ≥25% real floor, and dataset card authoring. Produces a validated JSONL dataset and Phase 2 card that gates the training run.
Master dbt for analytics engineering with model layering (staging/intermediate/marts), testing, documentation, and incremental strategies. Provides project structure, naming conventions, and best practices. Helps build maintainable, tested, documented data transformation pipelines with clear lineage.
Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or stack. Uses scientific method and phased workflow (reproduce, gather, hypothesize, verify) with language-specific tools like pdb, Delve, DevTools. Delivers faster root-cause isolation and reduced guesswork.
Provides production-ready Solidity templates for common DeFi protocols including staking, AMMs, governance, and flash loans. Uses OpenZeppelin-based secure contract patterns and references extended examples. Accelerates safe DeFi smart contract development with auditable, reusable code scaffolds.
Manages major dependency version upgrades via compatibility analysis, staged rollout, and comprehensive testing. Uses semantic versioning review, dependency audits, codemods, and automated update tools. Delivers safe, validated upgrades with rollback plans and minimal breaking changes.
Designs multi-stage CI/CD pipelines with approval gates, security checks, and deployment orchestration. Uses stage organization, progressive delivery (canary/blue-green), and automated quality gates. Produces pipeline configs, rollback plans, and health checks that enable zero-downtime, reliable production deployments.
Build scalable design systems via design tokens, theming infrastructure, and component architecture patterns. Provides token hierarchies, CSS-variable theming, and Figma-to-code pipelines. Value: consistent, maintainable UI foundations across web and mobile.
Implements distributed tracing with Jaeger and Tempo to track requests across microservices and find performance bottlenecks. Provides sampling, context propagation, and tagging best practices plus correlated logging. Delivers request-flow visibility and faster root-cause analysis for distributed systems.
Master C#/.NET backend patterns for robust APIs, MCP servers, and enterprise apps. Covers async/await, DI, EF Core, Dapper, config, caching, xUnit testing. Delivers production-grade code templates and architecture guidance to accelerate development and improve quality.
Master end-to-end testing with Playwright and Cypress to build reliable test suites that catch bugs and enable fast deployment. Provides testing pyramid guidance, stable selector strategies (data-testid), page objects, and debugging techniques for flaky tests. Delivers confident, regression-free shipping via maintainable E2E standards.
Selects and optimizes embedding models for semantic search and RAG. Provides a 2026 model comparison table, chunking/preprocessing pipeline, and best practices. Helps users pick domain-matched models, improve retrieval quality, and reduce cost via batching and caching.
Creates employment contracts, offer letters, and HR policy documents following legal best practices. Provides document-type templates, key legal considerations, and best-practice do's/don'ts. Outputs standardized, jurisdiction-aware employment documentation that reduces risk and speeds HR paperwork preparation.
Master cross-language error handling patterns including exceptions, Result types, propagation, and graceful degradation to build resilient apps. Provides philosophies, categories, best practices, and code examples. Value: improves reliability, debugging, and API design.
Builds the evaluation harness that gates every fine-tuning run by creating golden sets from traces, per-failure-mode graders, calibrated judges, and base-model baselines. Method: error analysis, deterministic grading, judge calibration, baseline generation. Value: provides training data and a regression gate for checkpoints.
PluginEval quality methodology skill explaining three evaluation layers (static, LLM judge, Monte Carlo), ten scoring dimensions, composite formula, badge thresholds, and anti-pattern flags. It helps users measure plugin quality, interpret low scores, improve skills, and calibrate marketplace thresholds with statistical rigor.
Design and implement event stores for event-sourced systems. Provides architecture patterns, technology comparison, and best practices for append-only immutable event storage. Helps teams choose technologies, set up schemas, and avoid common pitfalls, enabling scalable and reliable event sourcing infrastructure.
Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Provides recommended project structure, DI examples, and async test scaffolding. Value: accelerates backend API setup with best-practice layout and reduces boilerplate.
Converts files across 999 routes (images, video, audio, docs, data, fonts, ebooks, archives) via the free ChangeThisFile service. Methods: MCP tools if available, bundled convert.sh script, or curl to hosted MCP endpoint. Value: no API key/signup, server-side conversion, files deleted in 24h, simple local or remote file format change.
A router skill for the fine-tuning lifecycle that decides whether to fine-tune and selects the right method (SFT, DPO/ORPO/KTO, GRPO/RLVR, CPT) and base-model size class. It uses off-ramp checks, a decision tree by data shape, and catalog references to route efficiently. Value: prevents wasted training runs by matching task to cheapest effective approach before any model work begins.
Implements GDPR-compliant data handling covering consent management, data subject rights, and privacy by design. Provides data classification, legal bases, and DSAR workflows plus best practices. Value: reduces regulatory risk and builds compliant EU data systems.
Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Provides command patterns, best practices, and recovery commands for complex histories and collaboration. Value: clean PRs, multi-feature parallelism, and confident mistake recovery.
Create production-ready GitHub Actions workflows for automated testing, building, and deploying apps. Provides YAML patterns (test, Docker, K8s, matrix, security scan) and reusable workflows with best practices. Value: fast, secure CI/CD setup across tech stacks.
Build GitLab CI/CD pipelines with multi-stage workflows, caching, and distributed runners for scalable automation. Provides YAML templates for build/test/deploy, Docker, Terraform, security scanning, and dynamic child pipelines. Delivers reliable, optimized CI/CD reducing setup time and operational risk.
Implements GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Provides install commands, YAML templates for apps/sync/secrets, and progressive delivery patterns. Value: Git as single source of truth, auto-sync, self-heal, less manual errors.
Master Go concurrency with goroutines, channels, sync primitives, and context. Provides quick-start worker pool code, core concept tables, and Do/Don't best practices. Helps build concurrent apps, implement pipelines, debug race conditions, and avoid goroutine leaks with production-ready patterns.
Master Godot 4 GDScript patterns covering architecture, signals, scenes, and optimization. Provides code examples and best practices for building game systems. Helps developers write clean, performant GodScript code and learn Godot conventions efficiently.
Create and manage production Grafana dashboards for real-time visualization of system, application, and business metrics. Uses RED/USE methods, JSON panel templates, variables, alerts, and dashboard-as-code (Terraform/Ansible). Delivers observable, provisioned dashboards that improve monitoring and incident response.
Train reasoning and verifiable-task behavior using GRPO and RLVR. Provides a TRL GRPOTrainer recipe, composite reward design, a mandatory reward-inspection gate, and variant selection. Produces validated GRPO configs that reduce reward-hacking and sharpen models on algorithmically checkable tasks.
HADS skill defines the Human-AI Document Standard for writing Markdown docs readable by both humans and AI. It uses four block types (SPEC/NOTE/BUG/?) with an AI manifest to mark what models should read. Key methods: structured blocks, versioned headers, validation rules. Value: token-efficient docs, clear fact/context separation, better AI consumption.
Guides creation, organization, and management of Helm charts for templating and packaging Kubernetes apps with reusable configs. Uses scaffolding steps, templates, and validation scripts to produce production-ready charts that enable consistent multi-environment deployments and distribution.
Hermes Tweet adds an X/Twitter toolset to Hermes Agent for social listening, account research, launch monitoring, and gated publishing. It uses tweet_explore/tweet_read/tweet_action tools with read-first, approval-gated operation. Value: safe, explicit X data access and controlled account actions via Hermes runtime.
Configure secure, high-performance connectivity between on-premises and cloud (AWS, Azure, GCP, OCI) via VPN and dedicated links. Provides HCL examples, hybrid patterns, BGP routing, security and HA best practices. Value: compliant, reliable cross-premises networking with cost optimization.
Combines vector similarity and keyword search to improve retrieval recall and precision for RAG and search engines. Provides fusion methods (RRF, linear, cross-encoder, cascade), architecture patterns, and best practices. Delivers a hybrid retrieval pipeline that handles exact-match and semantic queries better than either approach alone.
Create structured incident response runbooks with step-by-step procedures, escalation paths, and recovery actions for outages and database incidents. Uses severity models, checklists, and communication templates to help on-call engineers resolve issues fast and standardize response across teams.
Design and implement microinteractions, motion, transitions, and feedback patterns for UI. Provides timing/easing principles, Framer Motion and CSS code patterns, accessibility and performance guidance. Delivers delightful, accessible, 60fps user experiences with consistent motion language.
Configure Istio traffic management covering routing, load balancing, circuit breakers, and canary deployments via YAML templates and istioctl. Provides copy-ready manifests and best practices for progressive delivery and resilience. Value: safe, observable service mesh traffic control in production.
A skill for implementing robust JS/TS testing strategies using Jest, Vitest, and Testing Library. It provides config templates, unit/integration/async test patterns, and mocking via module mock or DI. Value: accelerates test setup, improves coverage, and supports TDD/CI workflows.
Generates production-ready Kubernetes manifests (Deployments, Services, ConfigMaps, Secrets) following best practices and security standards. Uses templates and reference specs to guide step-by-step creation with resource limits, health checks, and security contexts. Outputs secure, validated YAML for Git-based CI/CD and GitOps workflows.
Implements Kubernetes security via NetworkPolicy, PodSecurityPolicy, RBAC and Pod Security Standards with ready YAML templates and best practices. Provides network isolation, least-privilege access, and compliance mapping (CIS/NIST) to harden clusters and meet production security requirements.
Designs effective KPI dashboards via metric selection, SMART framework, and visualization best practices. Provides troubleshooting patterns for contradictory metrics, DB load, and alert fatigue using SQL/Python. Delivers governed, real-time monitoring dashboards that drive accurate business decisions.
Design LLM apps with LangChain 1.x and LangGraph for agents, memory, and tool use. Provides package structure, StateGraph patterns, ReAct agents, memory systems, and document pipelines with code examples. Delivers production-grade, modular LLM architectures with durable execution and observability.
Implement Linkerd service mesh patterns for lightweight, security-focused Kubernetes deployments. Provides install, injection, mTLS, traffic split, service profile, and multi-cluster templates plus monitoring commands. Value: minimal-overhead zero-trust networking and observable microservice communication.
Implements comprehensive evaluation strategies for LLM apps via automated metrics, human feedback, and LLM-as-Judge. Provides Python suite to score outputs on test cases. Helps detect regressions, compare models, and build production confidence.
Configures LoRA and QLoRA supervised fine-tuning with current best-practice hyperparameters. Provides target modules, rank/alpha/LR sizing, Unsloth defaults, and LoRA vs QLoRA guidance. Outputs a validated adapter config that downstream training consumes, reducing config errors and training failures.
Calculates TAM/SAM/SOM for market opportunities using top-down, bottom-up, and value theory methodologies. Provides a three-tier framework and methodology selection guidance to size markets and estimate addressable revenue. Outputs investor-ready market analysis that validates opportunity and supports startup strategy and fundraising.
Master memory forensics: acquire RAM from live systems (WinPmem/LiME/osxpmem) and analyze dumps with Volatility 3 for process, network, injection, and credential artifacts. Delivers incident response and malware analysis via workflows, YARA, and string extraction.
Provides cross-language memory-safe programming patterns (RAII, ownership, smart pointers) for Rust, C++, and C to prevent use-after-free, leaks, and races. Delivers bug taxonomies, best practices, and debugging tool commands, enabling developers to write safe systems code and catch memory bugs early.
Guides design of microservices architectures with service boundaries, event-driven communication, and resilience patterns. Uses decomposition strategies, sync/async communication, and fault-tolerant patterns. Delivers clear, resilient distributed system designs from monoliths or scratch.
Builds end-to-end MLOps pipelines covering data prep, training, validation, and deployment. Uses DAG orchestration patterns and provides templates and best practices. Delivers reproducible, automated, production-ready ML workflows with monitoring.
Master Material Design 3 and Jetpack Compose patterns for native Android apps. Provides theming, component, and navigation references plus Kotlin code samples and best practices. Helps developers build adaptive, accessible, ecosystem-aligned UIs faster with fewer bugs.
Master iOS Human Interface Guidelines and SwiftUI patterns to build native, polished iOS apps. Provides layout, navigation, SF Symbols, Dynamic Type, and visual design code samples plus best practices. Value: helps developers create accessible, adaptive, Apple-compliant UIs faster with fewer design violations.
Master ES6+ JavaScript features (async/await, destructuring, spread, arrow functions, modules, generators) and functional programming patterns to write clean, efficient code. Provides best practices and pitfall references for refactoring legacy code, optimizing apps, and modernizing async flows. Value: cleaner, maintainable, performant JavaScript.
Master monorepo management with Turborepo, Nx, and pnpm workspaces to build efficient multi-package repos. Provides setup commands, config templates, and best practices for shared deps and optimized builds. Value: scalable code sharing, atomic changes, and faster CI.
Configures mutual TLS (mTLS) for zero-trust service-to-service communication. Provides mTLS handshake flow, certificate hierarchy, and best practices for cert rotation and compliance. Delivers secure internal communication, encrypted channels, and PCI-DSS/HIPAA readiness via gradual STRICT migration.
Design multi-cloud architectures via a decision framework that compares AWS, Azure, GCP, and OCI services. Provides patterns, cloud-agnostic stacks, migration phases, and cost tactics. Value: avoid vendor lock-in and leverage best-of-breed services with structured, portable plans.
Coordinates parallel code reviews across security, performance, architecture, testing, and accessibility dimensions. Provides dimension allocation, finding deduplication, severity calibration, and a consolidated report template. Produces unified, prioritized review output with consistent severity and clear remediation actions.
Master Next.js 14+ App Router with Server Components, streaming, parallel routes, and advanced data fetching. Provides rendering-mode tables, file conventions, quick-start code, and best-practice do's/don'ts. Helps developers build efficient, full-stack React apps with SSR/SSG and optimized RSC.
Implement NFT standards (ERC-721, ERC-1155) with metadata handling, minting strategies, and marketplace integration. Provides Solidity templates, royalty (EIP-2981) patterns, and on/off-chain metadata specs. Value: accelerates compliant NFT contract development and digital asset systems.
Build production-ready Node.js backends with Express/Fastify covering middleware, error handling, auth, DB integration, and API design. Uses TypeScript, validation, DI, and testing best practices. Delivers scalable, secure, maintainable services and microservices.
Configure and optimize Nx monorepo workspaces with standard structure, library types, and module boundaries. Uses tags and caching to enforce rules and speed CI. Delivers scalable, low-tech-debt monorepos with efficient affected builds.
Master on-call shift handoffs with context transfer, escalation, and documentation patterns. Provides handoff components, timing overlap, templates, and troubleshooting to ensure incoming responders have full situational awareness. Value: reduces context loss, smooths incident continuity, and improves cross-team handoff quality.
Generate and maintain OpenAPI 3.1 specs from code or design-first. Provides structure templates, approach comparison, and validation patterns. Produces API docs, SDK-ready contracts, and compliance assurance.
Debug complex bugs via competing hypotheses with parallel agent investigation, evidence collection, and root cause arbitration. Method: generate 6-category hypotheses, assign parallel investigators, cite file:line evidence with confidence, then arbitrate to confirm root cause and validate fix. Value: systematic, bias-free RCA that avoids missed causes and produces defensible conclusions.
Coordinates parallel feature development for multi-agent teams using file ownership, conflict-avoidance rules, and integration patterns. Provides strategies for decomposing features into independent streams, designing interface contracts, and choosing vertical/horizontal/hybrid integration. Value: enables safe concurrent implementation with minimal merge conflicts and clear integration points.
Integrates PayPal payments with express checkout, subscriptions, and refund management via JS SDK and REST API. Provides frontend/backend code patterns, IPN handling, and sandbox testing. Value: fast, secure e-commerce payment flows with recurring billing support.
PCI Compliance skill helps implement PCI DSS requirements for secure payment card data handling. It provides 12 core requirements, compliance levels, and Python code for data minimization, tokenization, and encryption. Value: achieve compliance, reduce scope, and protect cardholder data.
A style guide for designing and reviewing PostgreSQL schemas. Provides best-practice rules, data type selection, indexing, constraints, and partitioning patterns. Helps engineers build performant, maintainable tables and avoid PostgreSQL-specific pitfalls.
Guides writing effective blameless postmortems with root cause analysis, timelines, and action items after incidents. Uses templates (standard, 5 Whys, quick), facilitation guides, and anti-pattern lists to drive systemic learning. Value: improves incident response and prevents recurrence.
Prepares narrative, source lineage, and design context for a new editable PPTX deck before slide authoring. Uses a decision sequence to confirm audience, pick narrative framework, assign source IDs, and lock design direction. Produces a recorded deck context that guides downstream slide specification and ensures consistent, sourced, brand-aligned presentations.
Validates and repairs editable PPTX decks for geometry, accessibility, native editability, source lineage, and OOXML integrity. Uses an audit checklist and package validator to detect collisions, overflows, and hidden slides, then repairs specs/builders and reruns checks. Delivers error-free, natively editable decks with full audit trails.
Analyzes reference PPTX decks read-only to extract structure, theme, typography, layout rhythm, and diagnostics via bundled OOXML scripts. Produces design-evidence reports and template catalogs that inform independent deck authoring without copying or mutating source files.
Author or repair coordinate-explicit JSON specs for editable PPTX decks. Enforces a strict layout contract: absolute inch bboxes, native objects, accessibility order, and no renderer inference. Produces deterministic, editable, accessible slides with explicit layout and source lineage.
Helps select and place approved icons, images, SVGs, diagrams, or infographics into editable PPTX decks. It verifies rights, alt text, and placement bbox, preserves native editable content, and records sources. Value: visually richer decks without sacrificing editability or accessibility.
Aligns fine-tuned models with preference data via DPO, ORPO, KTO, or SimPO. Provides a data-shape method table, iterative on-policy DPO pattern, and μ−2σ pair construction. Outputs a validated method choice and TRL config for direct training use, improving model alignment efficiently.
Build read models and projections from event streams for CQRS and event-sourced systems. Provides projection architecture, types (Live/Catchup/Persistent/Inline), and best practices like idempotency and checkpoints. Delivers optimized query performance, real-time dashboards, and rebuildable materialized views.
Set up Prometheus for metric collection, storage, and monitoring of infra and apps. Provides scrape config, recording/alert rules, relabeling, HA, federation, and long-term storage guidance plus troubleshooting via HTTP API. Delivers a reliable monitoring and alerting foundation.
A skill for mastering advanced prompt engineering: few-shot learning, chain-of-thought, structured outputs, optimization, templates, and system prompts. Provides patterns, references, and a Python optimizer script to build reliable, controllable LLM prompts that improve accuracy, consistency, and parsing success.
Configures Cedar policy enforcement and Ed25519 signed receipts for Claude Code tool calls. Uses PreToolUse/PostToolUse hooks with protect-mcp CLI and Cedar policies to gate execution and emit hash-chained receipts. Delivers tamper-evident, offline-verifiable audit trails and compliance-ready evidence of agent actions.
Master network protocol reverse engineering: capture traffic with Wireshark/tcpdump/mitmproxy, analyze via tshark/Scapy, identify binary/encrypted protocols, and document specs with Lua dissectors. Delivers protocol understanding for security research and debugging.
A reference checklist of common Python anti-patterns across infrastructure, architecture, error handling, resources, type safety, and testing. It uses BAD/GOOD code contrasts and a quick review checklist to help reviewers catch bad practices early. Value: improves code quality and team standards before merge.
Provides Python background job patterns using task queues (e.g., Celery), workers, and event-driven design to decouple long-running work from request/response. Key methods: return job ID immediately, persist job state, ensure idempotency, configure retries/timeouts. Value: responsive APIs, safe async processing, observable and fault-tolerant job execution.
Python Code Style skill provides linting, formatting, naming, and docstring standards using ruff/mypy/pyright. It delivers pyproject configs, PEP 8 naming rules, and Google-style docstring templates. Value: consistent, maintainable, auto-enforced codebase with clear documentation and type safety.
Python configuration management skill for externalizing config via environment variables and typed pydantic-settings. Provides patterns for fail-fast validation, secrets handling, and environment-specific behavior. Value: clean, portable, secure apps that run unchanged across environments.
Provides Python design principles (KISS, SRP, composition over inheritance, Rule of Three) to build maintainable, testable code. Methods include code examples, refactoring guidance, and troubleshooting for layering violations. Value: reduces coupling, eases testing, and improves code review quality.
Python error handling skill covering input validation, exception hierarchies, and partial failure handling. Uses fail-fast patterns, Pydantic models, and standard exceptions with context. Produces robust APIs and batch processes that are reliable, debuggable, and degrade gracefully.
Python observability skill provides patterns for structured logging, metrics, and distributed tracing using structlog and correlation IDs. It helps instrument apps to debug production issues fast via the four golden signals and bounded cardinality, delivering traceable, queryable observability.
A skill for creating distributable Python packages with proper project structure, pyproject.toml config, and PyPI publishing. It covers source/flat layouts, build backends (setuptools, hatchling, flit, poetry), metadata, and wheel/sdist building. Value: enables developers to package libraries and CLI tools correctly and publish them reliably.
Profile and optimize Python code using cProfile, memory profilers, and best practices to find and fix CPU, memory, and I/O bottlenecks. Delivers faster, leaner applications via measurement-driven optimization.
A skill for organizing Python projects with clear module boundaries, explicit public APIs via `__all__`, and maintainable flat directory structures. It provides patterns for file focus, naming, imports, and layered/domain-driven layouts. Value: makes code discoverable and changes predictable.
Python resilience skill provides patterns for automatic retries, exponential backoff, timeouts, and fault-tolerant decorators using tenacity. It helps build services that survive transient failures via bounded retries and jitter. Value: robust, observable, gracefully degrading Python apps.
A Python skill for deterministic resource management via context managers, cleanup patterns, and streaming with state. It provides sync/async context manager protocols, decorator shortcuts, and unconditional release patterns. Value: prevents leaks, ensures reliable cleanup on exceptions, and improves code robustness.
A skill for building robust Python tests with pytest, fixtures, mocking, and TDD. It provides AAA structure, naming/organization conventions, markers, coverage config, and time-freeze patterns. Value: improves test reliability, isolation, and CI integration while reducing debugging time.
Python type safety skill guides adding type hints, generics, protocols, and strict checking with mypy/pyright. It provides patterns for annotation, narrowing, and generics to catch errors at static analysis time. Value: fewer runtime bugs and enforceable documentation.
Export promoted fine-tuned models into deployment-ready formats (merged safetensors, LoRA-only, GGUF+imatrix, FP8) matched to target hardware and workload. Provides a format map, workload overrides, and a mandatory smoke test using golden prompts. Value: prevents silent export bugs and ensures quantized models work correctly in production runtimes.
Build Retrieval-Augmented Generation (RAG) systems for LLM apps using vector databases and semantic search. Provides vector DB selection, embedding strategies, retrieval (dense/sparse/hybrid), reranking, and LangGraph code. Enables grounded, citation-backed answers that reduce hallucinations and connect LLMs to external knowledge.
Upgrades React apps to latest versions, migrates class components to hooks, and adopts concurrent features. Uses version path guides, code transformation examples, and codemod references. Delivers modern, performant, maintainable React codebases with improved rendering and state management.
Guides building production React Native apps with Expo: project structure, navigation, native modules, offline sync, and cross-platform patterns. Provides quick-start commands, architecture comparisons, and best practices. Value: faster mobile development with OTA updates, performant UI, and fewer crashes.
Master React Native styling, React Navigation, and Reanimated 3 animations for cross-platform mobile apps. Provides TypeScript examples, best practices (memoization, UI-thread animation, SafeArea), and common issue fixes. Value: build performant native-quality apps with smooth navigation and 60fps animations.
Master modern React state management with Redux Toolkit, Zustand, Jotai, and React Query. Provides categorization, selection criteria, quick-start code, best practices, and migration guides. Helps developers choose right solutions, reduce re-renders, and build maintainable React apps.
Designs composable recommendation, ranking, and feed pipelines via the six-stage Source→Hydrator→Filter→Scorer→Selector→SideEffect framework from xAI's For You algorithm. Method: 8-step guided workflow to clarify use case, identify sources, list hydrations/filters, design scorer chain, and generate runnable scaffold. Value: produces maintainable, trade-off-aware pipeline code for feeds, RAG rerankers, task prioritizers with no silent defaults.
Implement modern responsive layouts via container queries, fluid typography, CSS Grid, and mobile-first breakpoints. Provides patterns, best practices, and references for adaptive interfaces. Value: seamless cross-device UI with fewer overflow and touch-target issues.
Configures human-in-the-loop gating for AI agent review actions in Claude Code. Uses Cedar policies and Ed25519-signed receipts to gate PR reviews, merges, and CI edits. Produces a cryptographically auditable approval trail, ensuring no agent action bypasses human review.
Calculates portfolio risk metrics including VaR, CVaR, Sharpe, Sortino, and drawdown analysis. Uses categorized metric frameworks and multi-horizon methods with reference examples. Helps quantify risk, set limits, and build monitoring systems for safer portfolio management.
Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Provides execution model, quick-start code, and best practices for building resilient async services. Delivers production-ready patterns that avoid deadlocks and improve observability.
Implement saga patterns for distributed transactions and cross-aggregate workflows without 2PC. Provides step-by-step guidance to define ordered steps, action/compensation commands, orchestrator/choreography implementation, and monitoring. Delivers resilient async compensation flows that replace fragile distributed locks and ensure atomic rollback across microservices.
Configures SAST tools (Semgrep, SonarQube, CodeQL) for automated vulnerability detection in code. Provides setup, custom rule creation, CI/CD integration, and false-positive tuning. Delivers early security scanning, compliance gates, and reduced risk in DevSecOps workflows.
Scans the codebase to generate project-doc.md and AGENTS.md for agent-driven repos. Uses optional understand-anything + context-mode plugins or native tools. Runs full scan first, then smart delta scans via git diff. Detects architectural changes with human confirmation. Value: keeps agent docs accurate and flags drift.
A practical guide to testing web apps with screen readers (VoiceOver, NVDA, JAWS, TalkBack). Provides setup, commands, checklists, and HTML/JS fixes for ARIA, forms, modals, and live regions. Helps teams validate assistive tech support and fix accessibility issues efficiently.
Secure CI/CD secrets management using Vault, AWS Secrets Manager, and native tools. Provides integration patterns, rotation scripts, and scanning hooks to avoid hardcoding. Value: leak-proof pipelines with automated rotation and least-privilege access.
Derives actionable security requirements from threat models and business context. Uses categorized templates (functional/non-functional/constraint) with traceability and testability attributes. Outputs security user stories, test cases, and compliance mappings that bridge threats to technical controls.
Implements comprehensive observability for service meshes (Istio, Linkerd) via distributed tracing, metrics, and visualization. Uses three-pillar and golden-signal methods to debug latency, set SLOs, and map dependencies. Delivers monitoring setups that cut MTTR and boost reliability.
Session Guard prevents silent context corruption in long AI agent sessions via behavioral self-enforcement. It monitors tool-call counts and drift signals, anchors critical rules in files to survive compaction, and splits sessions before damage. Value: keeps conventions and decisions intact across compactions with zero packages or setup.
Master ShellCheck static analysis configuration and usage to improve shell script quality. Provides setup for CI/CD linting, error code interpretation, rule-set configuration, and false-positive suppression. Delivers portable, bug-free scripts and consistent code quality standards via automated gates.
A step-by-step cookbook for setting up cryptographically signed audit trails on Claude Code tool calls. It covers Cedar policy evaluation, Ed25519 receipt signing, offline verification, tamper detection, CI/CD integration, and SLSA composition. Value: provides tamper-evident, regulator-verifiable evidence of agent behavior without trusting the operator.
Provides patterns for efficient similarity search with vector databases, covering distance metrics, index types (Flat/HNSW/IVF+PQ), and best practices for hybrid search and tuning. Helps build semantic search, RAG retrieval, and recommendation systems with optimized latency and recall at scale.
Defines and implements SLIs, SLOs, and error budgets with Prometheus recording/alerting rules and Grafana dashboards. Provides target tables, YAML configs, and burn-rate alerts to establish reliability targets. Value: balances reliability with dev velocity via measurable SRE practices.
Agent-first social media publishing via SocialClaw. Uses one workspace API key to publish, schedule, and analyze posts across 13 platforms without per-platform OAuth. Key methods: campaign definition, platform-native copy generation, media reuse, schedule validation, and analytics retrieval. Value: streamlined multi-platform campaigns with minimal setup.
Master Solidity smart contract security to prevent reentrancy, overflow, and access control flaws via secure patterns and Hardhat tests. Delivers audit-ready code and reduced exploit risk for blockchain apps.
Set up a working ML training/inference environment on NVIDIA DGX Spark (GB10, aarch64, CUDA 13). Provides container-first rule, pinned pip sequences, and ABI-matching guidance to avoid libcudart/wheel errors. Delivers a verified GPU-visible environment for PyTorch/Unsloth/TRL/vLLM on Spark.
Manages unified memory and thermals for long ML jobs on NVIDIA DGX Spark GB10. Provides UMA memory planning via free -g, an ordered OOM ladder (flush, batch/pack, method downgrade), and thermal sampling scripts. Value: prevents OOM mid-run and distinguishes thermal throttling from config bugs.
Optimizes Apache Spark jobs via partitioning, caching, shuffle optimization, and memory tuning. Uses AQE, Kryo, broadcast joins, and skew handling to debug slow jobs and scale pipelines. Delivers faster, lower-cost data processing with right-sized resources.
Preflight and diagnose ten known ML training failure modes on NVIDIA DGX Spark (GB10). Method: numbered G1–G10 gotchas with symptoms, causes, checks, and fixes, plus an automated preflight.sh. Value: prevents wasted multi-hour runs by catching CUDA ABI, OOM, thermal, and parallelism issues before launch.
Master SQL query optimization, indexing strategies, and EXPLAIN analysis to eliminate slow queries and improve database performance. Uses systematic methods: EXPLAIN plan reading, selective indexing (B-Tree/GIN/partial/covering), and query rewrite patterns. Delivers faster responses, lower DB cost, and scalable schemas.
Builds comprehensive 3-5 year financial models for early-stage startups using cohort-based revenue, detailed cost structures, and three-scenario planning. Provides templates for SaaS, marketplace, e-commerce, and services models plus fundraising integration. Output is investor-ready projections with burn, runway, and milestone-based funding plans.
A comprehensive framework for tracking, calculating, and optimizing key startup metrics (MRR, CAC, LTV, burn multiple, NDR) across SaaS, marketplace, consumer, and B2B models from seed to Series A. It provides formulas, benchmarks, and stage-based tracking practices. Value: benchmark business health, improve unit economics, and prepare investor-ready metric dashboards.
Apply STRIDE methodology to systematically identify security threats across Spoofing, Tampering, Repudiation, Info Disclosure, DoS, and Elevation categories. Uses a threat matrix and templates to analyze system architecture and produce categorized threat documentation that supports mitigation and compliance.
Implements Stripe payment processing for PCI-compliant flows: checkout, subscriptions, webhooks, refunds. Provides Python SDK patterns, core concepts, and test cards. Value: fast, secure, maintainable payment integration.
Build scalable design systems with Tailwind CSS v4 using CSS-first config, design tokens, component libraries, and responsive patterns. Provides token hierarchy, component architecture, dark mode, and accessibility guidance. Value: consistent, maintainable, accessible UI standardization across codebases.
Decomposes complex tasks into parallelizable units, designs dependency graphs, and coordinates multi-agent work with clear task descriptions and workload balancing. Uses layered/component/file-ownership decomposition and blockedBy/blocks patterns. Produces structured task specs and balanced agent teams for faster delivery.
Provides structured messaging protocols for agent teams: message type selection, plan approval, shutdown, and anti-patterns. Methods include JSON message templates and workflows. Value: clean coordination, approved plans, graceful teardown.
Designs optimal team structures, hiring plans, compensation, and equity allocation for early-stage startups (pre-seed to Series A). Uses stage-based role definitions, US salary benchmarks, equity pool sizing, and budget formulas. Delivers a hiring plan with org chart, comp/equity ranges, and funded headcount budget aligned to milestones.
Designs optimal multi-agent team compositions for Claude Code's Agent Teams. Provides sizing heuristics, preset teams (review/debug/feature/security etc.), agent-type-to-tool mapping, and display mode config. Output is a right-sized, correctly-typed team plan that reduces coordination overhead and improves task outcomes.
A skill for testing Temporal Python workflows using pytest with time-skipping, activity mocking, and replay strategies. It covers unit, integration, and replay testing plus local setup. Value: enables fast, deterministic, high-coverage tests that catch bugs before production deployment.
Builds reusable Terraform modules for AWS, Azure, GCP, OCI following IaC best practices. Provides standard module structure, HCL examples, and testing patterns via Terratest. Produces consistent, versioned, multi-cloud compatible modules that standardize provisioning and reduce effort.
Maps identified threats to appropriate security controls and mitigations using control categories, layers, and defense-in-depth. Provides templates for remediation roadmaps and gap analysis. Helps prioritize security investments and validate control effectiveness.
Converts graded evaluation traces and production logs into SFT examples and DPO preference pairs for LLM fine-tuning. Uses reward ranking, expert-correction routing, step-level masking, and same-task pair building with μ−2σ rejection. Outputs hygiene-checked JSONL that feeds directly into dataset-curation, closing the eval-to-training flywheel.
Track Management guides creation and lifecycle operations of Conductor tracks—logical units for features, bugs, and refactors. It provides conventions for spec.md, plan.md, status markers, and tracks.md registry. Value: keeps work focused, phased, verifiable, and traceable via archived history and commit SHAs.
Configure Turborepo for efficient monorepo builds with local and remote caching. Provides turbo.json templates, remote cache setup (Vercel/self-hosted), filtering syntax, and debugging commands. Reduces CI time and enables cross-environment cache sharing for faster, reliable builds.
Master TypeScript's advanced type system (generics, conditional/mapped/template-literal types, utility types) via example-driven guidance. Use it to build type-safe libraries, API clients, and reusable type utilities. Delivers compile-time safety, fewer runtime errors, and documented patterns for robust TS projects.
Master Unity ECS (Entity Component System) with DOTS, Jobs, and Burst for high-performance game development. Provides ECS vs OOP comparison, DOTS concepts, and best practices like ISystem, Burst compile, ECB batching. Enables data-oriented design, linear scaling, and CPU optimization for games with large entity counts.
Master uv, a Rust-based ultra-fast Python package manager for dependency management, virtual environments, and project workflows. Key methods: uv init/venv/add/sync/lock and Python version control. Value: 10-100x faster than pip, reproducible builds, simplified migration from pip/poetry, and optimized CI/CD.
Optimizes vector index performance for latency, recall, and memory in production. Provides index-type selection by data size, HNSW parameter tuning, and quantization strategy guidance. Delivers balanced, scalable vector search configs and benchmarking practices for RAG and semantic search systems.
Fine-tunes vision-language models (VLMs) with supervised learning on image+text data. Provides consensus recipe (frozen vision tower + LLM LoRA), escalation rules for visual domain shift, and two silent-killer checks. Produces a validated adapter config that prevents non-learning runs and feeds directly into training script generation.
Apply typography, color theory, spacing systems, and iconography to build cohesive visual designs. Provides modular scales, tokens, and WCAG checks via code examples. Delivers consistent, accessible UI foundations and style guides.
Visual Edit Precision guides agents to make targeted, minimal UI edits when visual context (selections, annotations, screenshots) accompanies a request. It uses a 5-step process: identify, scope, preserve, targeted, verify. Value: prevents over-refactoring, keeps behavior and accessibility intact, delivers exact visual changes safely.
Conducts WCAG 2.2 accessibility audits using automated testing, manual verification, and remediation guidance. Provides conformance levels, POUR principles, and violation impact tiers. Helps teams find and fix accessibility blockers, meet ADA/Section 508 and VPAT compliance with actionable patterns.
Master React, Vue, and Svelte component patterns including CSS-in-JS, composition strategies, and reusable component architecture. Provides code templates, API design principles, and framework-specific patterns to build accessible, maintainable UI component libraries and design systems efficiently.
Test smart contracts comprehensively via Hardhat and Foundry with unit, integration, fuzz, and mainnet-fork tests. Provides configs, test templates, and advanced patterns (snapshot, impersonation). Value: high coverage, caught edge cases, audited-ready DeFi protocols.
Design durable workflows with Temporal for distributed systems, covering workflow/activity separation, saga patterns, state management, and determinism. Provides best practices and pitfalls to build reliable long-running processes and microservice orchestration with automatic failure recovery.
A coding skill that guides task implementation inside Conductor's TDD workflow. It enforces red-green-refactor, phase checkpoints, git commit discipline, and verification protocols. Value: traceable commits, updated plans, passed quality gates, and review-ready code.
