Development

Design and orchestrate multi-agent AI systems — define agent roles, communication protocols, tool use patterns, and failure recovery strategies.

Anthropic's official skill for working with the Claude API, examples, and API-oriented workflows.

Scaffold production-ready Next.js/React landing pages with Tailwind CSS, copywriting frameworks (PAS, AIDA, BAB), and SEO-optimized structure.

Anthropic's official skill for building or reasoning about Model Context Protocol tooling and integrations.

Design and build Retrieval-Augmented Generation systems — chunking strategies, embedding selection, vector store setup, and query pipeline optimization.

Generate production-ready SaaS boilerplate with Next.js, TypeScript, authentication, payments (Stripe), and Docker — skip months of setup work.

Anthropic's official skill for testing web applications with a more repeatable, explicit QA workflow.

Design agentic workflows for automation — map task sequences, define tool use patterns, set human-in-the-loop checkpoints, and optimize for reliability.

Review REST and GraphQL API designs for consistency, developer experience, versioning strategy, and adherence to industry standards.

Build comprehensive API test suites — contract tests, integration tests, load tests, and automated regression for REST and GraphQL APIs.

A Composio community skill for building richer Claude artifacts with modern frontend patterns and UI components.

AWS Bedrock AgentCore skill for deploying, managing, and scaling agent infrastructure across Gateway, Runtime, Memory, Identity, and related services.

AWS CDK expert skill for building cloud infrastructure with TypeScript or Python using best-practice CDK patterns.

AWS documentation and MCP setup skill for configuring AWS knowledge tools, credentials, and connectivity in Claude workflows.

AWS serverless and event-driven architecture skill for Lambda, API Gateway, DynamoDB, Step Functions, EventBridge, SQS, and SNS systems.

Cloud infrastructure design and optimization on AWS — VPCs, IAM, compute, databases, serverless, and cost optimization from a certified architect perspective.

Build production CI/CD pipelines for GitHub Actions, GitLab CI, and CircleCI — from lint and test to deploy with environment promotion and rollbacks.

Deep code review for TypeScript, JavaScript, Python, and Go — anti-pattern detection, security issues, performance bottlenecks, and quality metrics.

Get up to speed on any codebase fast — architecture overview, key entry points, data flow diagrams, and a curated reading order for new contributors.

Customize a Claude Code plugin for a specific organization's tools and workflows.

Guide users through creating a new plugin from scratch in a cowork session.

Design production-grade databases — schema modeling, normalization, indexing strategy, query optimization, and choosing between SQL and NoSQL.

Audit project dependencies for vulnerabilities, outdated packages, license risks, and bloat — with a prioritized remediation plan.

Build production-ready HTML email templates — responsive design, dark mode support, email client compatibility, and reusable component libraries.

Create or evaluate an architecture decision record (ADR). Use when choosing between technologies (e.g., Kafka vs SQS), documenting a design decision with trade-offs and consequences, reviewing a system design proposal, or designing a new component from requirements and constraints.

Review code changes for security, performance, and correctness. Trigger with a PR URL or diff, "review this before I merge", "is this code safe?", or when checking a change for N+1 queries, injection risks, missing edge cases, or error handling gaps.

Structured debugging session — reproduce, isolate, diagnose, and fix. Trigger with an error message or stack trace, "this works in staging but not prod", "something broke after the deploy", or when behavior diverges from expected and the cause isn't obvious.

Pre-deployment verification checklist. Use when about to ship a release, deploying a change with database migrations or feature flags, verifying CI status and approvals before going to production, or documenting rollback triggers ahead of time.

Write and maintain technical documentation. Trigger with "write docs for", "document this", "create a README", "write a runbook", "onboarding guide", or when the user needs help with any form of technical writing — API docs, architecture docs, or operational runbooks.

Run an incident response workflow — triage, communicate, and write postmortem. Trigger with "we have an incident", "production is down", an alert that needs severity assessment, a status update mid-incident, or when writing a blameless postmortem after resolution.

Generate a standup update from recent activity. Use when preparing for daily standup, summarizing yesterday's commits and PRs and ticket moves, formatting work into yesterday/today/blockers, or structuring a few rough notes into a shareable update.

Design systems, services, and architectures. Trigger with "design a system for", "how should we architect", "system design for", "what's the right architecture for", or when the user needs help with API design, data modeling, or service boundaries.

Identify, categorize, and prioritize technical debt. Trigger with "tech debt", "technical debt audit", "what should we refactor", "code health", or when the user asks about code quality, refactoring priorities, or maintenance backlog.

Design test strategies and test plans. Trigger with "how should we test", "test strategy for", "write tests for", "test plan", "what tests do we need", or when the user needs help with testing approaches, coverage, or test architecture.

Design secure secrets management workflows — vaults, rotation policies, environment variable hygiene, and developer-friendly secret distribution.

Master Git worktrees — manage multiple branches simultaneously, set up parallel development workflows, and avoid branch-switching friction.

Lead incident response from detection to resolution — coordinate teams, run war rooms, draft status updates, and produce postmortems.

A Composio community skill for pulling LangSmith traces into Claude workflows for debugging and inspection.

Create Model Context Protocol servers from scratch — define tools, resources, and prompts, then wire up to external APIs or local services.

Plan and execute code and system migrations — database migrations, framework upgrades, cloud migrations, and monolith-to-microservices transitions.

Navigate and manage monorepos — understand Nx/Turborepo setups, optimize build caching, manage affected dependencies, and enforce workspace boundaries.

Design comprehensive observability for distributed systems — metrics, logs, traces, alerting rules, and dashboards that surface real problems fast.

Profile and optimize application performance — CPU, memory, network, and database bottlenecks identified and fixed with measurable improvements.

Production-grade Playwright test suites — test generation, flaky test diagnosis, migration from Cypress, and E2E coverage strategy.

Expert pull request reviews — code quality, architectural impact, test coverage, security implications, and developer-friendly feedback.

Manage software releases end to end — release checklists, versioning strategy, changelog generation, rollback plans, and stakeholder communication.

Generate clear operational runbooks — step-by-step procedures for deployments, incident response, disaster recovery, and routine maintenance tasks.

Design system architecture with C4 and sequence diagrams, write Architecture Decision Records, evaluate tech stacks, and guide architectural trade-offs.

REST and GraphQL API development, database schema optimization, authentication patterns, and backend architecture decisions from a senior engineer.

Object detection, image segmentation, visual AI model implementation, and computer vision pipeline design from a senior engineer perspective.

ETL/ELT pipeline design, data warehouse architecture, dbt transformations, and data infrastructure at scale from a senior data engineer.

CI/CD pipeline design, Infrastructure as Code, containerization with Docker and Kubernetes, and deployment automation from a senior DevOps perspective.

React and Next.js component development, bundle optimization, performance tuning, and accessibility best practices from a senior engineer perspective.

End-to-end project scaffolding with Next.js, FastAPI, MERN, and Django — full-stack code quality analysis and frontend-backend integration.

Machine learning model implementation, training pipelines, evaluation frameworks, and MLOps — production ML engineering from an expert perspective.

LLM prompt design, chain-of-thought optimization, few-shot example selection, and systematic prompt testing — get the most out of any AI model.

Jest and React Testing Library test authoring, test coverage analysis, and Playwright E2E test scaffolding from a senior QA engineer perspective.

SAST/DAST scanning automation, CVE triage and remediation, GDPR and SOC2 compliance workflows, and security operations from a senior SecOps perspective.

Threat modeling, penetration testing guidance, zero-trust architecture design, and security code review from a senior security engineering perspective.

Anthropic's official meta-skill for designing and packaging new skills more systematically.

Stripe payments, subscriptions, webhooks, and billing workflows — from checkout to dunning, built correctly the first time.

A step-by-step guide and live coding partner for test-driven development — write failing tests first, then implement just enough code to pass.

Scan a codebase for technical debt, categorize by severity and effort, and produce a prioritized remediation roadmap with business impact estimates.

Systematic technology selection — compare stacks on TCO, team fit, scalability, and ecosystem maturity, then get a clear recommendation with rationale.

Anthropic's official skill for creating web-facing artifacts and structured frontend outputs.