89 Development Agent Skills

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

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.

Runs CEO, design, and engineering reviews sequentially with auto-decisions using 6 built-in principles. Surfaces only the taste decisions that need your input. One command, fully reviewed plan.

Establishes baselines for page load times, Core Web Vitals, and resource sizes. Compares before/after on every PR and tracks performance trends over time.

Gives Claude a real Chromium browser. Navigate URLs, click elements, verify page state, take annotated screenshots, test forms, check responsive layouts — 100ms per command.

Watches the live app after a deploy for console errors, performance regressions, and page failures. Takes periodic screenshots, compares against pre-deploy baselines, and alerts on anomalies.

Warns before running rm -rf, DROP TABLE, force-push, git reset --hard, kubectl delete, and similar destructive operations. You can override each warning. Scoped to the current session.

Independent code review from OpenAI Codex CLI — a completely different AI reviewing the same diff. Three modes: code review with pass/fail gate, adversarial challenge, or open consultation.

Launches your actual Chrome browser controlled by gstack, with a Side Panel extension showing a live activity feed of every action. Watch Claude navigate in real time.

Infrastructure-first security audit: secrets archaeology, dependency supply chain, CI/CD security, OWASP Top 10, and STRIDE threat modelling. Zero noise — 8/10 confidence gate, 17 false positive exclusions. Every finding includes a concrete exploit scenario.

Generates production-quality HTML where text actually reflows on resize and heights compute dynamically. Accepts mockups, CEO plans, or design reviews as input. Zero dependencies.

Restricts all file edits to a single directory for the session. Blocks Edit and Write operations outside the allowed path — prevents accidentally changing unrelated code while debugging.

Combines /careful (warns before destructive commands) and /freeze (locks edits to one directory) in a single command. Maximum safety for production work or high-stakes debugging.

Wraps your existing project tools — type checker, linter, test runner, dead code detector, shell linter — into a weighted composite 0–10 health score with trend tracking over time.

Systematic root-cause debugging with four phases: investigate, analyze, hypothesize, implement. Iron Law: no fixes without root cause. Stops after 3 failed hypotheses and escalates.

Merges the PR, waits for CI to pass, deploys to production, and verifies production health via canary checks. One command from approved PR to verified live deploy.

Eng manager-mode plan review. Locks in architecture, data flow diagrams, edge cases, test coverage, and failure modes before any code is written.

Opens a real Chromium browser and tests your app the way a user would. Finds bugs, fixes them with atomic commits, generates regression tests for every fix, and gives you a before/after health score.

Same real-browser methodology as /qa but produces a structured bug report with health score and repro steps without making any code changes. Pure signal, no side effects.

Weekly engineering retro with persistent history and trend tracking. Per-person breakdowns, commit analysis, test health trends, shipping streaks, and growth opportunities. Works across all your projects.

Staff engineer-level PR review. Finds bugs that pass CI but blow up in production — SQL safety, LLM trust boundaries, conditional side effects, race conditions. Auto-fixes the obvious ones.

Imports cookies from your real Chrome, Arc, Brave, or Edge browser into the headless browse session. Lets Claude test authenticated pages without you having to log in again.

One-time setup for /land-and-deploy. Detects your deploy platform (Fly.io, Render, Vercel, Netlify, Heroku, GitHub Actions, custom), production URL, and health check endpoints.

Syncs main, runs tests, audits coverage, bumps VERSION, updates CHANGELOG, pushes the branch, and opens the PR. One command from ready code to open pull request.

Clears the directory restriction set by /freeze, allowing edits across all directories again without ending the session.

Upgrades gstack to the latest version. Detects whether you have a global or vendored install, syncs both, and shows you what changed.

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.

Anthropic's official Claude Code skill for building with the Claude API — usage patterns, tool use, streaming, and API integration examples.

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.

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

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.

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

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 Claude Code skill for building web artifacts — interactive HTML, React components, data visualizations, and browser-ready frontend outputs.

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