Agent skills

More skills

20 categories 5 each 100 skills

100 common agent skills in 20 topics, ordered roughly as: prompts & agents → code & collaboration → testing → security & compliance → APIs & full-stack → architecture → continuous delivery & infra → process & docs → observability & troubleshooting. Pair with entries in the case hub.

Curated from public references and common delivery cases—for example SkillsCursor on review, frontend, branding, and agent-dev skills, and Cursor’s official docs on the Skills workflow. New here? Start from code review, Cursor rules, or prompt engineering, save outputs in-repo, then add testing, security, and release skills.

Prompt engineering

Prompt engineering

Constraints, few-shot, reproducible templates.

RAG retrieval

Chunking, rerank, citation boundaries.

Context window

Compression, summaries, priority trimming.

SKILL authoring

Structured skill docs and triggers.

MCP server

Tool exposure and auth model.

Agent engineering

Agent orchestration

Multi-step tasks and handoffs.

Tool use design

Schemas, idempotency, errors.

Eval harness

Cases and regression metrics.

Guardrails

Refusal and privilege boundaries.

Multimodal input

Image, audio, structured payloads.

Code review

Code review checklist

Security, performance, testability.

Review automation

CI + agent review.

Pair programming

Roles and incremental commits.

Rubber duck debugging

Voice assumptions and minimal repro.

Safe refactoring

Small steps, behavior preserved.

Collaboration & tooling

Legacy modernization

Strangler and compat layers.

Cursor rules

Bootstrap .cursor/rules.

Dependency upgrades

Breaking changes and lockfiles.

Static analysis

Quality gates and rule sets.

Lint & format

Formatting and team conventions.

Testing

Unit tests

Boundaries and test doubles.

Integration tests

Containers and isolation.

E2E tests

Critical paths and stability.

Coverage strategy

Thresholds and exceptions.

Mutation testing

Test effectiveness.

Security

Security audit

Threat modeling checklist.

Secret scanning

False positives and rotation.

SBOM

Supply-chain transparency.

SQL injection

Parameterization and least privilege.

XSS prevention

Encoding and CSP.

Compliance & privacy

License compliance

Dependency obligations.

Privacy & GDPR

Processing and consent.

CSRF protection

Tokens and same-site cookies.

CORS

Preflight and credentials.

PII redaction

Logs and prompts.

Identity & API

AuthN / AuthZ

Identity and capability boundaries.

OAuth / OIDC

Code flow and token lifecycle.

API contract draft

OpenAPI and errors.

OpenAPI design

Versioning and compatibility.

GraphQL schema

Pagination, N+1, depth limits.

Frontend & UI

Frontend components

API surface and composition.

Design system

Tokens and variants.

Responsive layout

Breakpoints and container queries.

CSS architecture

BEM and scoping.

React patterns

Hooks and state boundaries.

UX & internationalization

Vue patterns

Composition and reuse.

Accessibility (a11y)

Semantics and keyboard paths.

i18n & l10n

Strings and plural rules.

Diagrams as code

Mermaid and versioned diagrams.

Markdown lint

Style and link checks.

Server-side development

API documentation

Examples synced with changes.

API rate limiting

Fairness and backoff.

WebSocket realtime

Heartbeats and reconnect.

Node.js backend

Middleware and errors.

Python FastAPI

DI and schema validation.

Languages, data & caching

Go microservices

Concurrency and boundaries.

Rust CLI

Error chains and shipping.

Database migrations

Forward compatible rollbacks.

SQL optimization

Indexes and plans.

Caching strategy

Invalidation and consistency.

Distributed systems & architecture

Message queues

Delivery semantics and idempotency.

Event-driven design

Contracts and ordering.

Microservice boundaries

Bounded contexts.

Monorepo tooling

Task graphs and caching.

Database backup

RPO/RTO and verification.

CI/CD & quality gates

CI/CD pipeline

Stages and artifacts.

GitHub Actions

Workflows and secrets.

Performance profiling

Sampling and flame graphs.

Frontend bundle size

Splitting and dependency audit.

SEO & metadata

Titles, snippets, structured data.

Containers & infrastructure

Dockerfile best practices

Multi-stage, minimal images.

Kubernetes manifests

Resources and probes.

Helm charts

Values and upgrades.

Terraform IaC

State and modules.

Cloud cost optimization

Rightsizing and cleanup.

Release & change

Release & rollback

Steps and health checks.

Blue/green

Traffic switch and verification.

Canary release

Metric gates and rollback.

Feature flags

Audience and lifecycle.

Disaster recovery

Drills and postmortems.

Git & delivery workflow

Long-form docs

RFC-style sections and risks.

Git workflow

Branching and merge rules.

Conventional Commits

Types and scopes.

Changelog generation

Versions and breaking notes.

PR description

Motivation, tests, rollback.

Docs & knowledge

Issue triage

Priority and labels.

Incident postmortem

Timeline and actions.

Runbook authoring

Steps and contacts.

README onboarding

Local setup and FAQ.

Knowledge base / wiki

Structure, search, ownership.

Observability

Monitoring dashboards

SLOs and alert noise.

Logging & tracing

Structured logs and traces.

Alerting & on-call

Severity and escalation.

Bug reproduction

Minimal cases and redaction.

Stack trace analysis

Async and wrapped errors.

Troubleshooting & root cause

Memory leak

Heap snapshots and refs.

Race conditions

Ordering and locks.

Concurrency patterns

Queues and backpressure.

ADR

Context and consequences.

Controlled codegen

Templates, review, tests.