Skills from clawhub.ai/anton-abyzov

Help and guidance for Azure DevOps synchronization with SpecWeave increments. Use when asking how to set up ADO sync, configure credentials, or troubleshoot integration issues. For actual syncing, use /sw-ado:sync command.

This skill provides cloud provider pricing data and examples for AWS, Azure, and GCP (2025), covering compute, storage, database, networking, serverless, and pricing calculators. No security-relevant behaviors detected.

Analyzes existing brownfield projects to map documentation to SpecWeave's structure (PRD/HLD/Spec/Runbook). Use when migrating existing projects to SpecWeave, scanning legacy docs, or creating project context maps. Detects external tools (JIRA, ADO, GitHub) and supports incremental or comprehensive migration paths.

Statistical modeling - A/B testing, causal inference, customer analytics (CLV, churn), time series forecasting. Use for business analytics or experiment design.

Deployment platform router - Vercel vs Cloudflare vs GitHub Pages. Analyzes framework, SEO needs, repo visibility. Use for "where to deploy" decisions.

Claude Code SDK - tools (Read, Write, Edit, Bash), agent tools (Task, Skill), hooks, and MCP integration. Use for Claude Code extension development.

Elite code review expert for quality, security, and maintainability analysis with AI-assisted review techniques. Use for PR reviews, security vulnerability detection, or code quality assessment. Covers static analysis, performance patterns, and best practices enforcement.

Code refinement expert that improves clarity, consistency, and maintainability while preserving exact functionality. Use when simplifying complex code, cleaning up recently modified files, or refactoring for readability. Based on Anthropic's official code-simplifier pattern - never alters WHAT code does, only HOW.

This skill implements SaaS billing automation for subscriptions, invoicing, dunning, proration, and tax calculation. It includes code that calls external payment processors (e.g. `stripe.Charge.create`) and references `https://app.example.com/billing`.

Deep codebase analysis to discover actual coding standards through statistical evidence. Use when analyzing naming conventions, import patterns, or detecting anti-patterns in existing code. Provides evidence-based detection of how the codebase actually works (not aspirations).

Generate and maintain coding standards documentation from existing codebase patterns. Use when creating STANDARDS.md files, onboarding new developers, or documenting team conventions. Evidence-based approach - standards reflect reality, not aspirations.

Schema Registry expert for Avro, Protobuf, and JSON Schema management. Covers schema evolution strategies, compatibility modes, validation, and best practices for managing schemas in Confluent Cloud and self-hosted Schema Registry. Activates for schema registry, avro, protobuf, json schema, schema evolution, compatibility modes, schema validation.

ksqlDB stream processing expert. Covers SQL-like queries on Kafka topics, stream and table concepts, joins, aggregations, windowing, materialized views, and real-time data transformations. Activates for ksqldb, ksql, stream processing, kafka sql, real-time analytics, windowing, stream joins, table joins, materialized views.

Review code comments for accuracy and quality. Use when finding outdated comments or auditing documentation.

Validates and auto-creates Azure DevOps projects, area paths, and teams and updates the local `.env` and repository spec folders. It reads/writes `.env` (uses `AZURE_DEVOPS_PAT`, `AZURE_DEVOPS_ORG`), calls `https://dev.azure.com/*` APIs, and includes shell examples like `npx tsx` and `npx specweave init`.

System architect for scalable, maintainable technical designs and architectural decisions. Use when designing system architecture, writing ADRs (Architecture Decision Records), or planning microservices and database structures. Covers trade-off analysis, component diagrams, and technology selection.

Intelligently onboards brownfield projects by merging existing CLAUDE.md backups into SpecWeave structure. Use when installing SpecWeave into existing projects with CLAUDE.md, merging documentation, or importing project knowledge. Distributes content to appropriate folders without bloating main CLAUDE.md.

DevOps and IaC expert. Generates infrastructure ONE COMPONENT AT A TIME (VPC → Compute → Database → Monitoring) to prevent crashes. Terraform, K8s, Docker, CI/CD pipelines.

Automated data visualization for EDA, model performance, and business reporting. Activates for "visualize data", "create plots", "EDA", "exploratory analysis", "confusion matrix", "ROC curve", "feature distribution", "correlation heatmap", "plot results", "dashboard". Generates publication-quality visualizations integrated with SpecWeave increments.

Organize specs and tasks across multiple Azure DevOps projects with intelligent content-based mapping. Use when working with project-per-team, area-path-based, or team-based ADO architectures. Handles cross-project coordination and folder structure organization.

Map SpecWeave specs to multiple Azure DevOps projects with intelligent project detection. Use when configuring multi-project bidirectional sync or coordinating work across ADO projects. Supports project-per-team, area-path-based, and team-based strategies.

Bidirectional conversion between SpecWeave increments and Azure DevOps work items. Use when exporting increments to ADO epics, importing ADO epics as increments, or resolving sync conflicts. Handles Epic/Feature/User Story/Task hierarchy mapping.

Docusaurus 3.x documentation framework - MDX authoring, theming, versioning, i18n. Use for documentation sites or spec-weave.com.

Living documentation updater that syncs implementation progress to product docs. Use when updating docs after task completion, changing DRAFT status to published, or ensuring documentation reflects current implementation state.

Expo SDK 54+ workflows, EAS Build/Update, Expo Router v6, native tabs. Use for Expo development or OTA update strategies.

Explains how SpecWeave achieves context efficiency through Claude's native progressive disclosure and sub-agent parallelization. Use when asking about token usage, context management, or how SpecWeave scales with large projects. Leverages Claude's built-in mechanisms without custom caching.

Automated machine learning with hyperparameter optimization using Optuna, Hyperopt, or AutoML libraries. Activates for "automl", "hyperparameter tuning", "optimize hyperparameters", "auto tune model", "neural architecture search", "automated ml". Systematically explores model and hyperparameter spaces, tracks all experiments, and finds optimal configurations with minimal manual intervention.

Intelligent increment archiving expert that analyzes age, status, and activity to recommend archiving. Use when workspace has too many increments, cleaning up completed work, or organizing the _archive folder. Follows the 10-10-10 rule for workspace organization.

Computer vision ML pipelines for image classification, object detection, semantic segmentation, and image generation. Activates for "computer vision", "image classification", "object detection", "CNN", "ResNet", "YOLO", "image segmentation", "image preprocessing", "data augmentation". Builds end-to-end CV pipelines with PyTorch/TensorFlow, integrated with SpecWeave increments.

Expert in building scalable design systems with Atomic Design, design tokens, and theming infrastructure. Use when creating component libraries, implementing dark mode, or establishing typography and color systems. Covers multi-brand support, Storybook-driven development, and accessibility-first component APIs.

Generate Mermaid diagrams following C4 conventions. Activates for create diagram, draw diagram, visualize, system diagram, architecture diagram, C4 diagram, context diagram, container diagram, component diagram, sequence diagram, ER diagram, entity relationship, data model, deployment diagram. Coordinates with diagrams-architect agent.

This skill documents browser automation with Playwright/Puppeteer/Selenium for web scraping, form filling, screenshots, and PDF generation. It includes explicit network calls such as `await page.goto('https://example.com', { waitUntil: 'networkidle' });` and route patterns like `**/api/analytics`.

Anomaly and outlier detection using Isolation Forest, One-Class SVM, autoencoders, and statistical methods. Activates for "anomaly detection", "outlier detection", "fraud detection", "intrusion detection", "abnormal behavior", "unusual patterns", "detect anomalies", "system monitoring". Handles supervised and unsupervised anomaly detection with SpecWeave increment integration.

LLM-as-Judge for verifying Azure DevOps sync correctness and conflict resolution. Use when validating bidirectional sync behavior, checking lifecycle management rules, or auditing sync decisions. Ensures external tool status wins and increments complete strictly.

AWS cost optimization - EC2 Reserved Instances, Savings Plans, Spot, Lambda optimization, Cost Explorer, Trusted Advisor.

Confluent Cloud architecture - eCKU sizing, cluster linking, multi-region strategies, Schema Registry HA, ksqlDB, Stream Governance.

Kafka Connect integration expert. Covers source and sink connectors, JDBC, Elasticsearch, S3, Debezium CDC, SMT (Single Message Transforms), connector configuration, and data pipeline patterns. Activates for kafka connect, connectors, source connector, sink connector, jdbc connector, debezium, smt, data pipeline, cdc.

Enterprise compliance architecture for SOC 2, HIPAA, GDPR, and PCI-DSS regulated systems. Use when designing compliant systems, preparing for audits, or implementing regulatory requirements. Covers compliance checklists, data protection controls, audit evidence collection, and security policies.

Second-pass context optimization that surgically removes irrelevant content after initial context load. Use when context is bloated, tokens need reduction, or loaded specs are irrelevant to current task. Achieves 80%+ token reduction through intelligent prompt analysis.

FinOps expert for AWS/Azure/GCP cost optimization - right-sizing, reserved instances, savings plans, spot instances. Use for reducing cloud costs.

Expert database optimizer for query performance, indexing strategies, and schema design across PostgreSQL, MySQL, and MongoDB. Use when optimizing slow queries, fixing N+1 problems, or analyzing EXPLAIN plans. Covers connection pooling, caching strategies, partitioning, and database scaling patterns.

.NET/C# backend developer for ASP.NET Core 8+ APIs with Entity Framework Core and enterprise patterns. Use when building C# backends, implementing REST/gRPC APIs, or working with SQL Server/PostgreSQL. Covers JWT authentication, dependency injection, background services, and Minimal APIs.

This skill analyzes codebases to trace features, map dependencies, and produce exploration reports. It instructs running shell commands like `grep`/`find` and searching `process.env.` / `.env*`, enabling local execution and access to environment/config files.

Technical documentation writer for clear, comprehensive docs with incremental generation to prevent crashes. Use when creating API documentation, README files, user guides, or developer onboarding docs. Generates one section at a time (Installation → Usage → API → Configuration).

The skill generates Mermaid diagrams following C4 and SpecWeave conventions and places files under ` .specweave/docs/internal/architecture/diagrams/` and related paths. No security-relevant behaviors detected.

Export SpecWeave skills to Agent Skills open standard format (agentskills.io) for cross-platform portability. Use when converting skills to GitHub Copilot, VS Code, Gemini CLI, or Cursor format. Creates portable SKILL.md files compatible with any Agent Skills-supported tool.

Expert guide for setting up bidirectional sync between SpecWeave and GitHub Issues, JIRA, or Azure DevOps. Use when configuring external tool integration, mapping fields between systems, or troubleshooting sync issues. Covers webhook setup, authentication, and conflict resolution strategies.

Expert at organizing specs and splitting tasks across multiple GitHub repositories for monorepo, polyrepo, and parent repo architectures. Use when managing specs across multiple repos, coordinating cross-repo work, or allocating tasks to different teams/repositories.

Create and manage production Grafana dashboards for real-time visualization of system and application metrics. Use when building monitoring dashboards, visualizing metrics, or creating operational observability interfaces.

Expert frontend architect for React, Next.js, Vue, and Angular with Atomic Design and state management patterns. Use when designing component architecture, building dashboards, or implementing complex frontend features. Covers TanStack Query, Zustand/Redux, routing strategies, and performance optimization.

Two-way synchronization between SpecWeave specs and GitHub Projects (push & pull by default). Use when asking about GitHub integration setup, troubleshooting sync issues, or configuring sync settings. For actual syncing, use /sw-github:sync-spec command.

Expert agent for splitting SpecWeave tasks across multiple GitHub repositories based on microservice or multi-repo architecture. Use when tasks span multiple services, creating cross-repo tracking issues, or analyzing dependencies across repositories.

This skill provides Playwright end-to-end testing guidance and examples. It instructs running shell commands (e.g., `npm run test:e2e`), makes network requests to `http://localhost:3000` and `https://staging.example.com`, and saves auth state to `auth.json`.

This skill implements a feature engineering pipeline that creates, selects, transforms, validates, and documents features and integrates with SpecWeave for versioning and artifacts. It includes explicit CLI commands such as `/sw:sync-docs update` and `/ml:engineer-features 0042` that invoke local tooling.

JIRA integration specialist for SpecWeave increments with epic creation, bidirectional sync, and status updates. Use when creating JIRA issues, syncing task completion, or maintaining cross-system consistency. Covers epics, stories, subtasks, boards, and sprints.

Expert in mapping SpecWeave specs to multiple JIRA projects with intelligent project detection and cross-project coordination. Use when syncing to multiple JIRA projects (project-per-team, component-based), or managing bidirectional sync across team boundaries.

Detects SpecWeave context and provides workflow documentation for available commands. Use when learning SpecWeave commands, understanding available slash commands (/sw:increment, /sw:do, /sw:progress, /sw:done), or getting workflow guidance. Explains command syntax and recommended workflow patterns.

Dangerous skill: contains a download-and-execute install command (`curl -Ls "https://get.maestro.mobile.dev" | bash`) and multiple CLI build/test invocations (`detox build --configuration ios.sim.debug`, `xcodebuild -workspace ios/MyApp.xcworkspace`) that run shell commands. These steps contact `https://get.maestro.mobile.dev` and perform local execution; they are purpose-aligned for testing but present execution risk.

Manages ML experiment tracking with MLflow, Weights & Biases, or SpecWeave's built-in tracking. Activates for "track experiments", "MLflow", "wandb", "experiment logging", "compare experiments", "hyperparameter tracking". Automatically configures tracking tools to log to SpecWeave increment folders, ensuring all experiments are documented and reproducible. Integrates with SpecWeave's living docs for persistent experiment knowledge.

Validates JIRA projects and boards exist, auto-creates missing resources. Use when setting up JIRA integration, validating .env configuration, or troubleshooting missing projects/boards. Supports per-project board configuration with JIRA_BOARDS_{ProjectKey} pattern.

AI image generation using Pollinations.ai - FREE with no API key required. Use when generating hero images, icons, logos, illustrations, mockups, or any visual assets for websites and apps. Covers product shots, avatars, placeholders, and social media images with professional quality.

High-risk skill: installs and configures GitOps tooling and executes remote scripts such as `curl -s https://fluxcd.io/install.sh | sudo bash` and `kubectl apply -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml`. It reads credentials (`kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d`) and references `GITHUB_CLIENT_ID` and `GITHUB_CLIENT_SECRET`.

Provides guidance to implement distributed tracing with Jaeger and Tempo across microservices. Includes explicit `kubectl` commands and example network endpoints such as `https://github.com/jaegertracing/jaeger-operator/releases/download/v1.51.0/jaeger-operator.yaml`, `http://jaeger:14268/api/traces`, and `s3.amazonaws.com`.

Frontend design expert for polished, production-ready UIs with distinctive visual characteristics and micro-interactions. Use when improving visual design, adding CSS animations, or polishing the UI with shadows, gradients, and transitions. Rejects generic AI aesthetics in favor of bold, distinctive design choices.

Mandatory format standard for ALL GitHub issues created by SpecWeave with checkable acceptance criteria and proper metadata. Use when creating GitHub issues, formatting issue content, or ensuring consistent issue structure. Covers user stories, epics, features, and increments.

Expert frontend developer for React, Vue, Angular, and modern JavaScript/TypeScript. Use when creating components, implementing hooks, handling state management, or building responsive web interfaces. Covers React 18+ features, custom hooks, form handling, and accessibility best practices.

Task-level GitHub issue tracking for fine-grained progress visibility via comments, checklists, and labels. Use when tracking detailed task progress in GitHub, managing team collaboration on specific tasks, or tracking blocking issues. Enables per-task updates and discussions.

This skill scaffolds Helm charts, templates, validation, packaging, and repository publishing for Kubernetes. It contains runnable shell commands (e.g., `helm install`, `helm lint`) and network instructions to external endpoints (e.g., `aws s3 sync`, `https://charts.bitnami.com/bitnami`).

Infrastructure-as-Code specialist for Terraform, AWS, Azure, and serverless architectures. Use when setting up cloud infrastructure, writing Terraform modules, or deploying to AWS Lambda/Vercel/Cloudflare. Covers VPC configuration, container orchestration, and CI/CD pipeline infrastructure.

SpecWeave framework documentation for increment-based development, directory rules, hooks, and plugin architecture. It defines `hooks` as shell scripts that run automatically, scans `env vars`, and includes plugin install/sync commands such as `https://github.com/anton-abyzov/specweave` and `npm install -g specweave`.

Generates Terraform/Pulumi and deployment artifacts for Hetzner Cloud (outputs under `terraform/`, `Dockerfile`, `.github/workflows/deploy.yml`). It requests and stores the `HETZNER_API_TOKEN` in `.env`, includes shell steps like `terraform apply` and SSH commands, and references `https://console.hetzner.cloud/`.

The skill auto-detects implementation intent and routes to `/sw:do` or `/sw:increment` to resume or create SpecWeave increments. It reads local SpecWeave state using shell commands such as `find .specweave/increments -name "metadata.json"` and `cat .specweave/config.json`.

LLM Judge for verifying JIRA synchronization correctness and conflict resolution. Use when auditing sync results, validating status transitions, or troubleshooting sync conflicts. Ensures external tool status wins and proper increment lifecycle management.

This skill evaluates increment specs with an LLM-as-Judge and BMAD P×I risk scoring to produce dimension scores and a quality gate decision. It instructs executing a local CLI via `specweave qa 0001 --pre` and reading `.specweave/increments/{id}/spec.md`, which is a shell-execution instruction.

Kafka architecture specialist for event-driven systems, partition strategies, and data modeling. Use when designing Kafka topics, planning consumer groups, or implementing event sourcing and CQRS patterns.

This skill plans and creates SpecWeave increments and templates, generating `spec.md`, `plan.md`, and `tasks.md` under `.specweave/increments/`. It instructs executing local scripts (e.g., `bash plugins/specweave/hooks/v2/guards/spec-template-enforcement-guard.sh`, `node plugins/specweave/skills/increment-planner/scripts/feature-utils.js`) and references integration commands like `/sw-github:create-issue`.

This skill provides guidance for syncing SpecWeave increments with JIRA, covering setup, validation, and troubleshooting. It instructs storing and reading `JIRA_API_TOKEN`, `JIRA_EMAIL`, and `JIRA_DOMAIN` in `.env`, shows shell commands like `cat >> .env` and `export`, and uses `curl` to call `https://$JIRA_DOMAIN/rest/api/3/issue/PROJ-123`.

Kafka DevOps and SRE specialist. Expert in infrastructure deployment, CI/CD, monitoring, incident response, capacity planning, and operational best practices for Apache Kafka.

Terraform deployment expert for Apache Kafka, AWS MSK, and Azure Event Hubs. Use when provisioning Kafka infrastructure with IaC, comparing managed vs self-hosted platforms, or automating cluster deployments.

The skill maps SpecWeave increments to JIRA and synchronizes changes, creating and updating files under `.specweave/increments/` and JIRA issues. It runs local shell commands like `ls .specweave/increments/ | grep -E '^[0-9]{4}' | sort -n | tail -1` and calls JIRA endpoints such as `https://jira.company.com/browse/PROJ-123`.

Implement Kubernetes security policies including NetworkPolicy, PodSecurityPolicy, and RBAC for production-grade security. Use when securing Kubernetes clusters, implementing network isolation, or enforcing pod security standards.

Kafka Streams topology design expert. Covers KStream vs KTable vs GlobalKTable, topology patterns, stream operations (filter, map, flatMap, branch), joins, windowing strategies, and exactly-once semantics. Activates for kafka streams topology, kstream, ktable, globalkTable, stream operations, stream joins, windowing, exactly-once, topology design.

Claude Code marketplace publishing - npm publish, GitHub releases, semantic versioning, plugin packaging. Use when publishing plugins.

This skill generates production-ready Kubernetes manifests and templates for Deployments, Services, ConfigMaps, Secrets, and PVCs. It includes executable commands and container scripts (`kubectl apply`, `kubectl run`, `until nc -z db-service 5432`, `curl http://backend-service.production.svc.cluster.local`) and example `Secret` values like `DATABASE_PASSWORD` and `API_KEY`.

Metro bundler configuration, optimization, and troubleshooting. Use for bundle errors, "unable to resolve module", or caching issues.

MCP server integration for Kafka operations with Claude Desktop and SpecWeave. Use when configuring Kafka MCP servers, connecting Claude to Kafka topics, or choosing between MCP implementations.

Kafka monitoring and observability expert for Prometheus, Grafana, and JMX metrics. Use when setting up Kafka monitoring, configuring alerting rules, or building performance dashboards.

K8s architect generating manifests ONE SERVICE AT A TIME to prevent crashes. GitOps (ArgoCD/Flux), service mesh (Istio/Linkerd), EKS/AKS/GKE patterns.

Navigate and load project living documentation for context from .specweave/docs/internal/. Use when implementing features and needing project context, referencing ADRs for design decisions, or accessing specs and architecture docs. Provides table of contents for all documentation types.

Prepares ML models for production deployment with containerization, API creation, monitoring setup, and A/B testing. Activates for "deploy model", "production deployment", "model API", "containerize model", "docker ml", "serving ml model", "model monitoring", "A/B test model". Generates deployment artifacts and ensures models are production-ready with monitoring, versioning, and rollback capabilities.

Design DAG-based MLOps pipeline architectures with Airflow, Dagster, Kubeflow, or Prefect. Activates for DAG orchestration, workflow automation, pipeline design patterns, CI/CD for ML. Use for platform-agnostic MLOps infrastructure - NOT for SpecWeave increment-based ML (use ml-pipeline-orchestrator instead).

ML system builder enforcing best practices - baseline comparison, cross-validation, experiment tracking, explainability (SHAP/LIME). Use for ML pipelines, model training, production ML.

Orchestrates complete machine learning pipelines within SpecWeave increments. Activates when users request "ML pipeline", "train model", "build ML system", "end-to-end ML", "ML workflow", "model training pipeline", or similar. Guides users through data preprocessing, feature engineering, model training, evaluation, and deployment using SpecWeave's spec-driven approach. Integrates with increment lifecycle for reproducible ML development.

MLOps expert - ML pipelines, experiment tracking, model registries with MLflow/Kubeflow. Use for automated training, deployment, and monitoring.

Observability architect - OpenTelemetry-first, Prometheus+Grafana stack, SLIs/SLOs, alert fatigue prevention. Use for metrics, logs, traces setup.

Performance engineering for web applications, databases, and distributed systems optimization. Use for analyzing bottlenecks, implementing caching strategies, or improving Core Web Vitals. Covers profiling, load testing, bundle optimization, and database query performance tuning.

Performance engineering - OpenTelemetry, distributed tracing, load testing (k6, JMeter), multi-tier caching, Core Web Vitals. Use for slow apps or latency issues.

Validates SpecWeave plugin installation when EXPLICITLY requested by user. Use for checking if plugins are installed correctly, validating marketplace registration, or troubleshooting missing plugins. Only triggers on explicit requests to avoid false positives during normal workflow.

This skill provides Node.js/TypeScript backend guidance and code examples for Express, Prisma, authentication, and background jobs. It uses environment variables such as `process.env.JWT_SECRET` for secret handling; no other security-relevant behaviors were detected.

Comprehensive progress synchronization expert for multi-system sync (tasks.md → living docs → GitHub/JIRA/ADO). Use when syncing progress across systems, creating missing external issues, or understanding /sw:sync-progress command. AUTO-CREATES missing issues when external links are absent.

This skill implements PayPal integration for checkout, subscriptions, IPN/webhooks, and refunds. It makes network calls to `https://api-m.sandbox.paypal.com`, `https://api-m.paypal.com`, `https://ipnpb.sandbox.paypal.com/cgi-bin/webscr` and requires PayPal credentials `CLIENT_ID`/`CLIENT_SECRET`.

This skill is a React Native debugging guide for Flipper, React DevTools, crash analysis, and network debugging. It includes instructions to run shell commands (e.g., `adb logcat`, `brew install --cask flipper`), make network calls (e.g., `adb shell ping 8.8.8.8`, `curl http://localhost:8081/status`), and configure `YOUR_SENTRY_DSN`.

QA lead for comprehensive test strategy, automation frameworks, and quality gates. Use when creating test plans, designing test suites, or setting up E2E/integration testing. Covers web, mobile, and API testing with Playwright, Jest, and test coverage requirements.

This skill is a Python backend agent that generates FastAPI/Django/Flask code, database integrations, and ML inference examples. It references `SECRET_KEY`, reads `model.pkl`, and includes connection strings like `postgresql+asyncpg://user:pass@localhost/db` and `redis://localhost:6379/0`.

SRE expert for incident response, production troubleshooting, root cause analysis, post-mortems, and runbooks. Use for outages, performance issues, or SEV incidents.

Spec-driven brainstorming and product discovery skill for story mapping, prioritization (MoSCoW, RICE, Kano), and lean startup validation. No security-relevant behaviors detected.

Generates `spec.md`, `plan.md`, `tasks.md`, and `tests.md` for SpecWeave increments. It instructs executing local commands such as `specweave context projects`, `ls .specweave/docs/internal/specs/`, and `grep -r "^**Project**:" .specweave/increments/*/spec.md`, which are low-risk local shell operations.

Provides Apache Kafka architecture, sizing, and best-practice guidance. Includes an example administrative shell command `bin/kafka-acls.sh --add \ --allow-principal User:alice \ --operation READ \ --topic orders`, otherwise no high-risk behaviors detected.

React Native and Expo mobile architect. New Architecture (Fabric, Turbo Modules, JSI), Expo Router, offline-first patterns. Use for mobile app architecture and React Native design.

Model interpretability and explainability using SHAP, LIME, feature importance, and partial dependence plots. Activates for "explain model", "model interpretability", "SHAP", "LIME", "feature importance", "why prediction", "model explanation". Generates human-readable explanations for model predictions, critical for trust, debugging, and regulatory compliance.

React Native native modules with New Architecture, Turbo Modules, JSI, and Codegen. Use for bridging JS to Swift/Kotlin native code.

Intelligent multi-project specification splitting that maps user stories to correct projects (FE, BE, MOBILE, INFRA). Use when working with multiple JIRA/GitHub projects, microservices architecture, or brownfield projects with multiple teams. Analyzes content and tech stack for automatic classification.

n8n workflow automation with Kafka integration expert. Covers Kafka trigger node, producer node, event-driven workflows, error handling, retries, and no-code/low-code event processing patterns. Activates for n8n kafka, kafka trigger, kafka producer, n8n workflows, event-driven automation, no-code kafka, workflow patterns.

Centralized model versioning, staging, and lifecycle management. Activates for "model registry", "model versioning", "model staging", "deploy to production", "rollback model", "model metadata", "model lineage", "promote model", "model catalog". Manages ML model lifecycle from development through production with SpecWeave increment integration.

Natural language processing ML pipelines for text classification, NER, sentiment analysis, text generation, and embeddings. Activates for "nlp", "text classification", "sentiment analysis", "named entity recognition", "BERT", "transformers", "text preprocessing", "tokenization", "word embeddings". Builds NLP pipelines with transformers, integrated with SpecWeave increments.

Comprehensive ML model evaluation with multiple metrics, cross-validation, and statistical testing. Activates for "evaluate model", "model metrics", "model performance", "compare models", "validation metrics", "test accuracy", "precision recall", "ROC AUC". Generates detailed evaluation reports with visualizations and statistical significance tests, integrated with SpecWeave increment documentation.

This skill provides guidance for deploying Apache Kafka on Kubernetes using Strimzi, Confluent, and Bitnami. It contains runnable shell commands (e.g., `kubectl apply`, `helm install`) that access Kubernetes secrets (`kubectl get secret ... | base64 -d > producer.crt`) and add external repos (`https://strimzi.io/charts/`, `https://packages.confluent.io/helm`).

Product Manager for spec-driven development with SpecWeave conventions. Use when writing user stories, defining acceptance criteria, planning MVPs, or prioritizing features. Creates specs with proper AC-IDs, manages requirements, and maintains product roadmaps.

React Native performance with Hermes V1, FlashList, expo-image v2, concurrent rendering. Use for slow app, memory leaks, or FPS issues.

Self-reflection specialist that analyzes completed work for quality issues, security vulnerabilities, and improvement opportunities. Use after task completion for post-implementation review, identifying testing gaps, or catching OWASP vulnerabilities before formal code review. Covers technical debt assessment and lessons learned analysis.

React Native 0.83+ and Expo SDK 54+ environment setup. Xcode, Android Studio, CocoaPods, EAS Build troubleshooting.

Expert QA engineer for test strategy and automation. Use when writing tests, fixing failing tests, or improving test coverage.

Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, setting up monitoring infrastructure, or configuring alerting systems.

Multi-repo version alignment - lockstep/independent/umbrella strategies, semver constraints, version conflict detection.

Expert in Next.js 14+ App Router, Server Components, and Server Actions. Use when building Next.js applications, implementing SSR/SSG, or configuring dynamic routing and data fetching. Covers streaming, caching strategies, middleware, and deployment optimization.

Cloud network architect for VPC design, service mesh, zero-trust networking, load balancers, and CDN optimization. Use for network troubleshooting or connectivity issues.

Integrate Stripe, PayPal, and payment processors for checkout flows, subscriptions, and webhook handling. Use when implementing payment processing, building checkout pages, or handling payment webhooks. Covers Stripe Connect marketplace patterns, dual confirmation (webhook + frontend), and idempotent payment operations.

PCI DSS compliance expert for secure payment card handling and audit preparation. Use when implementing card tokenization, encrypting payment data, or preparing for PCI compliance audits. Covers SAQ levels, data minimization, access control, and audit logging requirements.

This skill provides CLI guidance for Kafka operations using `kcat`, `kcli`, `kaf`, and `kafkactl`. It contains executable shell commands (e.g., `brew install kcat`, `curl -LO https://github.com/cswank/kcli/releases/latest/download/kcli-linux-amd64`), network calls to `localhost:9092`/GitHub, and credential usage like `-X sasl.password=admin-secret`.

PR test coverage analyzer. Use when reviewing PR tests, finding missing tests, or checking edge case coverage.

Claude Code plugin development - plugin structure, slash commands, skills, sub-agents, YAML frontmatter. Use when creating plugins.

Diagnostic tool for validating SpecWeave reflection system health and troubleshooting issues. Use when reflection seems stuck, learnings aren't being captured, or MEMORY.md files aren't updating. Checks configuration, permissions, and system state.

Release orchestrator for mono/multi-repo - strategy planning, version alignment, RC workflows, changelog automation. Use for release coordination.

Security engineer for vulnerability assessment, penetration testing guidance, and secure code review. Use for OWASP Top 10 checks, threat modeling, or security architecture review. Covers authentication flaws, injection vulnerabilities, access control, and compliance requirements.

Release strategy advisor - detects brownfield patterns (tags, CI/CD, changelogs), recommends versioning strategy based on architecture. Creates release-strategy.md.

The skill provides product roadmap and feature prioritization guidance using RICE, MoSCoW, and Kano frameworks, templates, and metrics for quarterly planning and stakeholder communication. No security-relevant behaviors detected.

Serverless platform selection expert for AWS Lambda, Azure Functions, GCP Cloud Functions, and Firebase. Use when choosing between serverless platforms, evaluating cold start requirements, or designing event-driven architectures. Considers project scale (pet project vs enterprise), workload patterns, and cost optimization.

Define and implement Service Level Indicators (SLIs) and Service Level Objectives (SLOs) with error budgets and alerting. Use when establishing reliability targets, implementing SRE practices, or measuring service performance.

Stripe payment integration for checkout, subscriptions, webhooks, and Connect marketplace patterns. Use when implementing Stripe payments, handling payment webhooks, or building subscription billing systems. Covers dual confirmation (webhook + frontend), mobile payment verification, 100% promo code handling, and idempotent payment operations.

Test-Driven Development expert. Use when implementing TDD workflow, red-green-refactor, or writing tests first.

Analyze TypeScript type design quality. Use when reviewing types, checking invariants, or strengthening type safety.

Dangerous skill: instructs executing remote packages and CLIs (e.g., `npx @anthropic-ai/claude-code-mcp`, `wrangler`, `aws`) and making external `curl`/API calls while using environment secrets. It is a service connection orchestrator for `Supabase`, `Cloudflare`, `PostgreSQL`, `MongoDB`, `Redis/Upstash`, `AWS`, and `Vercel`.

Multi-repo release coordination - dependency management, release order orchestration, cross-repo validation. Use for synchronized multi-service releases.

Release Candidate (RC) workflow manager - pre-release tagging, alpha/beta/rc lifecycle, testing validation, production promotion.

This skill provides UI testing guidance and examples for Cypress, Testing Library, and Playwright. It includes example shell commands (e.g., `npx playwright test`, `npm ci`) and network calls (e.g., `https://example.com`) for running and exercising tests.

This skill provides unit testing guidance for Vitest and Jest. It includes instructions to execute child processes via `execSync('node my-cli.js', ...)` and `spawnSync('npm', ['run','build'], ...)`, and to manipulate `NODE_OPTIONS` and related env vars.

This skill launches a Docusaurus dev server for SpecWeave projects, caching installs under `.specweave/cache/docs-site/` and serving on `http://localhost:3015` and `http://localhost:3016`. It runs shell commands like `lsof -i :3015 && kill -9 $(lsof -t -i :3015)` and uses the npm registry `https://registry.npmjs.org`.

This skill performs PM closure validation for increments, enforcing three gates: tasks, tests, and documentation. It directs reading ` .specweave/increments/{id}/spec.md`, `tasks.md`, and `CLAUDE.md`, and asks users to run `npm test` / `npm run test:coverage`; only standard local test execution is requested.

Example skill demonstrating self-validating REST API generation with automatic test execution. Use as a template for creating skills with pre-tool-use validation hooks. Validates Node.js environment and dependencies before generating endpoints.

Reflect persists session learnings to skill-specific `MEMORY.md` files under `~/.claude/...` and `.specweave/...` and exposes CLI hooks such as `/sw:reflect`. It instructs running system commands like `specweave refresh-marketplace` (which performs a `Download latest marketplace`) and shell file operations (`ls`, `cp`), enabling network downloads and local file writes.

This skill audits code to find silent failures, inadequate catch blocks, and inappropriate fallbacks. It includes explicit shell commands such as `grep -rn "try {" --include="*.ts" --include="*.js"` to scan repositories, but shows no instructions to access secrets or exfiltrate data.

Detects when user reports issues with recently completed work and suggests reopening relevant tasks or increments. Use when reporting bugs, regressions, or problems with recently finished features. Scans completed work from last 7 days and provides relevance-scored suggestions while checking WIP limits.

This skill orchestrates role-based agents to run multi-phase product workflows and creates increment folders under `.specweave/increments/...`. It issues filesystem and CLI commands such as `mkdir -p ${incrementPath}`, `write ${incrementPath}metadata.json`, and `/sw:status`, which perform file writes and invoke tool commands.

Executive documentation from technical living docs - business summaries, progress dashboards, feature status reports. Use for stakeholder communication.

Technical writing expert for API documentation, README files, tutorials, changelog management, and developer documentation. Covers style guides, information architecture, versioning docs, OpenAPI/Swagger, and documentation-as-code. Activates for technical writing, API docs, README, changelog, tutorial writing, documentation, technical communication, style guide, OpenAPI, Swagger, developer docs.

Master TDD orchestrator for strict red-green-refactor discipline and multi-agent test-driven workflows. Use when implementing TDD across complex features, coordinating test and implementation agents, or enforcing TDD cycle discipline. Covers modern TDD practices, test isolation, and quality gates.

Test-Driven Development discovery hub that detects TDD intent and guides the red-green-refactor cycle. Use when wanting to write tests first, implement TDD workflow, or learn test-first development practices. Routes to appropriate TDD commands (/sw:tdd-red, /sw:tdd-green, /sw:tdd-refactor).

Time series forecasting with ARIMA, Prophet, LSTM, and statistical methods. Activates for "time series", "forecasting", "predict future", "trend analysis", "seasonality", "ARIMA", "Prophet", "sales forecast", "demand prediction", "stock prediction". Handles trend decomposition, seasonality detection, multivariate forecasting, and confidence intervals with SpecWeave increment integration.

This skill is a real-time security pattern detector that scans code for command injection, XSS, unsafe deserialization, SQL injection, and path-traversal patterns. No security-relevant behaviors detected.

This skill provides Stripe Connect integration documentation and code examples for Direct Charge, Destination Charge, webhooks, onboarding, and payouts. It reads `process.env` variables `STRIPE_SECRET_KEY`, `STRIPE_WEBHOOK_SECRET`, `STRIPE_CONNECT_WEBHOOK_SECRET`, `APP_URL` and makes Stripe API/webhook calls such as `https://yourdomain.com/webhooks/stripe`.

Visual regression testing expert. Use when implementing visual testing, detecting CSS regressions, or managing screenshot baselines.

Updates GitHub issues for user stories with checkable acceptance criteria and task connections. Use when fixing GitHub issue format, adding checkable ACs to existing issues, or refreshing user story issue content from specs.