133 Agent Skills for Developers

Plan, design, and implement A/B tests and experiments — hypothesis framing, variant definition, sample size calculation, statistical significance, and test analysis.

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

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

Backlog management, INVEST-compliant user story writing, sprint capacity planning, and epic breakdown for agile product teams.

Implement and audit analytics tracking — GA4, Google Tag Manager, event tracking, conversion tracking, UTM parameters, and measurement plans.

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.

Administer Jira and Confluence at scale — user management, permission schemes, SSO integration, security configuration, and disaster recovery planning.

Create and manage Jira and Confluence templates — sprint retrospectives, project charters, risk registers, and 15+ reusable blueprints for common workflows.

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 cost optimization and operations skill for pricing analysis, CloudWatch monitoring, budget review, and operational excellence.

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.

A Composio community skill for turning release notes, commits, and updates into a cleaner changelog draft.

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.

Design and manage Confluence knowledge bases — space architecture, page templates, documentation strategy, and making Confluence actually useful for teams.

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.

Write correct, performant SQL across all major data warehouse dialects (Snowflake, BigQuery, Databricks, PostgreSQL, etc.). Use when writing queries, optimizing slow SQL, translating between dialects, or building complex analytical queries with CTEs, window functions, or aggregations.

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.

A Composio skill for analyzing developer-facing growth patterns, signals, and performance context.

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.

Optimize lead capture, contact, demo request, and application forms — reduce friction, improve completion rates, and increase qualified submissions.

Plan, evaluate, and build free tools for marketing — calculators, generators, graders, and interactive tools that generate leads, earn backlinks, and build brand authority.

Anthropic's official frontend-focused skill for UI exploration, interface thinking, and design execution support.

Navigate EU GDPR and German DSGVO compliance — data processing agreements, DPIAs, privacy policies, consent management, and data subject rights workflows.

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

Automate Google Workspace administration with gws CLI — user provisioning, group management, Drive policies, and security audit workflows.

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.

Saves your current git state, decisions made, and remaining work so you can resume exactly where you left off — even across sessions or workspace handoffs.

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.

Builds a complete design system from scratch — aesthetic direction, typography, color palette, layout, spacing, and motion. Researches your product space, proposes creative risks, and writes DESIGN.md.

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.

Finds visual inconsistency, spacing issues, hierarchy problems, and AI slop patterns on a live site — then fixes them. Commits each fix atomically with before/after screenshots.

Generates multiple visual design variants, opens a browser comparison board, collects structured feedback, and iterates toward an approved direction. Taste memory biases future variants toward your preferences.

Reads every doc file in your project, cross-references the diff, and updates README, ARCHITECTURE, CONTRIBUTING, CLAUDE.md, and CHANGELOG to match what just shipped.

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.

Manages what gstack has learned across sessions — project-specific patterns, pitfalls, and preferences. Review, search, prune, and export learnings. Compounds over time.

YC-style forcing questions before you write a line of code. Pushes back on your framing, challenges premises, explores alternatives, and writes a design doc that feeds every downstream skill.

Founder-mode plan review. Finds the 10-star product hiding in your request, challenges scope, and pushes the plan toward maximum ambition or maximum focus — your choice.

Designer's eye review of a plan before implementation. Rates each design dimension 0–10, explains what a 10 looks like, then edits the plan to get there.

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.

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

Design structured technical and behavioral interview processes — question banks, evaluation rubrics, calibration guides, and fair assessment frameworks.

JQL query writing, custom workflow design, automation rules, dashboard configuration, and Jira best practices for software and project teams.

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.

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

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.

Optimize post-signup onboarding and user activation — first-run experience, empty states, activation checklists, and time-to-value improvements.

Create and optimize in-app paywalls, upgrade modals, and feature gates — convert free users to paid with the right message at the right moment.

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.

Plan a sprint — scope work, estimate capacity, set goals, and draft a sprint plan. Use when kicking off a new sprint, sizing a backlog against team availability (accounting for PTO and meetings), deciding what's P0 vs. stretch, or handling carryover from the last sprint.

Write a feature spec or PRD from a problem statement or feature idea. Use when turning a vague idea or user request into a structured document, scoping a feature with goals and non-goals, defining success metrics and acceptance criteria, or breaking a big ask into a phased spec.

Build SEO-driven pages at scale using templates and data — location pages, comparison pages, integration pages, and other high-volume keyword strategies.

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

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.

Add, fix, and optimize schema markup and structured data — JSON-LD implementation for FAQ, Product, Article, BreadcrumbList, and other schema types that unlock rich snippets in Google.

Sprint planning, agile ceremonies facilitation, backlog management, and velocity tracking — an expert Scrum Master in your workflow.

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.

Audit, review, and diagnose SEO issues — technical SEO, on-page optimization, meta tags, Core Web Vitals, crawl errors, indexing issues, and ranking drops.

Optimize signup, registration, and trial activation flows — reduce friction, improve step completion, and increase activation from first visit.

Plan, map, and restructure website information architecture — page hierarchy, navigation, URL structure, internal linking strategy, and visual sitemaps.

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

A Composio community skill for packaging, sharing, and distributing skills more cleanly across teams or communities.

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.

Generate design tokens, typography scales, spacing grids, and responsive breakpoints — build or document a production-ready design system.

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.