GitHub collection
spencerpauly/awesome-cursor-skills
Imported from GitHub — is this yours?
65 skills imported from this repository.
accessibility-auditing
Use Cursor's browser aria snapshots to audit a page for accessibility issues — missing labels, broken tab order, contrast, and ARIA misuse.
adding-analytics
Add PostHog analytics to a web application, including event tracking, page views, feature flags, and session replay.
adding-api-docs
Generate OpenAPI/Swagger documentation for an API, including endpoint schemas, request/response types, and interactive docs UI.
adding-auth
Add authentication to a web application using NextAuth.js (Auth.js), including OAuth providers, session management, and protected routes.
adding-docker
Dockerize an application with a production-ready Dockerfile, docker-compose setup, and .dockerignore.
adding-e2e-tests
Set up Playwright end-to-end testing in a project, including test configuration, example tests, and CI integration.
adding-error-tracking
Add Sentry error tracking, performance monitoring, and source maps to a web application.
adding-feature-flags
Add feature flags to an application for gradual rollouts, A/B testing, and kill switches using PostHog, LaunchDarkly, or a simple local implementation.
adding-stripe
Integrate Stripe payments into a web application, including checkout sessions, webhooks, and customer portal.
api-smoke-testing
Start the dev server, discover API routes from the codebase, hit every endpoint, and report which ones return errors.
architecture-decision-records
Document technical decisions as Architecture Decision Records (ADRs) with context, options considered, and rationale.
auditing-performance
Audit and optimize application performance, including bundle size, rendering, database queries, and Core Web Vitals.
auditing-security
Perform a systematic security audit of a codebase, checking for OWASP Top 10 vulnerabilities, secrets exposure, and insecure patterns.
auto-type-checking
Run TypeScript type checking after file edits and immediately flag type errors before moving on. Uses Cursor hooks for automatic enforcement.
babysitting-pr
Monitor a pull request for CI failures, review comments, and merge conflicts — then fix them automatically. Use when a PR is open and you want the agent to keep it merge-ready.
best-of-n-solving
Solve a hard problem by trying multiple approaches in parallel using isolated git worktrees. Each attempt runs in its own branch, and the best solution is selected. Use for complex refactors, tricky bugs, or architectural decisions where multiple strategies could work.
building-skills-from-patterns
When the same multi-step workflow repeats in Cursor (user corrections or agent redos), capture it as a new SKILL.md under .cursor/skills/ so future sessions load it automatically.
codebase-onboarding
Launch multiple explore subagents in parallel to investigate architecture, data models, auth, APIs, and deployment. Synthesize into an onboarding document.
comparing-branches-visually
Check out two branches in separate worktrees, start both dev servers on different ports, screenshot the same pages, and produce a visual diff.
converting-css-modules-to-tailwind
Migrate CSS Modules (.module.css/.module.scss) to Tailwind utility classes. Handles styles object removal, className interpolation, composition, and global overrides.
converting-css-to-tailwind
Convert plain CSS stylesheets to Tailwind CSS utility classes. Handles selectors, media queries, pseudo-classes, custom properties, and animations.
creating-pr
Create a clean, review-ready pull request with a good title, structured description, linked issues, and appropriate reviewers.
dark-mode-testing
Toggle between light and dark mode in Cursor's browser, screenshot both states, and flag missing token mappings or contrast issues.
database-design
Design database schemas — tables, relationships, indexes, constraints, and ORM setup. Covers relational design, normalization, and common patterns.
detecting-port-conflicts
Detect EADDRINUSE and port conflicts, find what's using the port, and resolve it by killing the process or suggesting an alternative port.
exporting-to-png
Export code, terminal output, diagrams, or UI components to PNG images using headless browser rendering or CLI tools.
finding-dev-server-url
Scan running terminals for dev server URLs (localhost ports), report them, and optionally open the app in Cursor's built-in browser.
fixing-broken-links
Crawl all links in a file or project, test each for a valid HTTP response, report broken ones, and fix or remove them.
form-testing
Use Cursor's browser to fill and submit every form in the app with valid and invalid data, verifying validation, error states, and success flows.
generating-images
Generate or edit images using the OpenAI Image API (gpt-image-2). Use when the user asks to generate, create, draw, render, illustrate, mock up, or edit an image, icon, logo, mockup, illustration, OG image, blog hero, marketing asset, or similar visual. Also use when the user sup
grinding-until-pass
Keep iterating on code changes until the tests pass, the build succeeds, or linting is clean. Runs in a tight loop of fix → run → check → repeat. Use when you want the agent to autonomously grind through test failures or build errors.
incident-response
Handle production incidents — triage, mitigate, communicate, and write postmortems.
kubernetes-deploying
Deploy applications to Kubernetes — Deployments, Services, Ingress, ConfigMaps, Secrets, health checks, and scaling.
monitoring-terminal-errors
Watch running terminal processes for crashes and stack traces. When an error appears, navigate to the failing file and line, diagnose, and fix it automatically.
network-request-auditing
After navigating and interacting in Cursor's built-in browser, use browser_network_requests to audit every fetch/XHR for failures, slowness, duplicate calls, and suspicious payloads. Use for API-heavy pages and after backend or client networking changes.
parallel-ci-triage
When GitHub Actions fails, fetch failing job logs and assign each failing job to a separate subagent that fixes its slice of the problem in parallel. Use for multi-job CI failures where jobs are independent.
parallel-code-review
Run four parallel read-only subagents that each review the same diff from a different lens — security, performance, correctness, and readability — then merge findings into one report. Use before merging large or risky PRs.
parallel-exploring
Explore a large codebase in parallel by launching multiple explore subagents that each investigate a different area simultaneously. Use when onboarding onto a new project, understanding architecture, or investigating a cross-cutting concern.
parallel-test-fixing
When multiple tests fail, assign each failing test file to a separate subagent that fixes it independently in parallel.
profiling-performance
Profile a running web application's CPU performance using Cursor's built-in browser profiler. Captures call stacks, identifies slow functions, and suggests optimizations. Use when a page feels slow or janky.
prompt-engineering
Write effective prompts for LLMs — structure, few-shot examples, chain-of-thought, system prompts, and output parsing.
python-tdd-with-uv
Test-driven development in Python using uv as the package manager. Covers the red-green-refactor cycle, vertical slicing, and uv project setup.
react-native-patterns
Build mobile apps with React Native and Expo — navigation, platform-specific code, performance, and native modules.
recording-browser-flow-as-test
Execute a user flow step-by-step in Cursor's built-in browser while documenting each action, then emit a Playwright test that replays the same flow using stable selectors derived from the accessibility tree.
responsive-testing
Open the app in Cursor's browser at multiple viewport sizes, screenshot each, and report any layout breakage.
reviewing-code
Perform a thorough code review focused on correctness, maintainability, performance, and best practices.
saving-workspace-context
Automatically persist useful context — research, decisions, learnings, templates — to workspace files so knowledge survives across conversations.
screenshotting-changelog
Generate a visual changelog or PR description by taking before/after screenshots of UI changes using Cursor's built-in browser. Use when preparing a PR with visual changes.
seo-auditing
Audit technical SEO — meta tags, structured data, Open Graph, sitemaps, robots.txt, performance, and accessibility signals.
setting-up-ci
Set up a GitHub Actions CI/CD pipeline with linting, testing, type-checking, and deployment steps.
setting-up-terraform
Set up Terraform infrastructure-as-code for cloud resources, including provider configuration, modules, state management, and CI integration.
suggesting-cursor-hooks
When the user keeps asking for the same check to run (lint, tests, type-check), suggest a Cursor hook to automate it.
suggesting-cursor-rules
When the user repeats the same correction or convention multiple times, suggest a Cursor rule to encode it permanently.
suggesting-skills
When the user struggles with a task that a known skill could handle, suggest installing it.
switching-projects
Switch the current Cursor workspace to a different project directory using the cursor-app-control MCP. Use when the user asks to switch projects, open another repo, jump to a different codebase, or move to a worktree.
systematic-debugging
Structured debugging methodology — reproduce, isolate, hypothesize, verify. Covers git bisect, binary search, logging, and minimal reproduction.
tailing-build-output
Monitor a build process (webpack, turbo, docker) for warnings and errors as they stream. Summarize issues and fix them before the build finishes.
updating-npm-package
Safely update an npm package by checking npmjs.com for the latest version, reading release notes, and handling minor vs major upgrades differently. For minor updates, just do it. For major updates, find the upgrade guide, validate breaking changes, and produce a detailed migratio
using-ui-stack
Enforce a configuration-driven design system when generating UI. Ensures consistent spacing, colors, typography, dark mode, interactions, and accessibility across all AI-generated components.
verifying-in-browser
After making code changes, start the dev server, open the app in Cursor's built-in browser, and verify everything works — check rendering, console errors, and network health. Use proactively after any UI or API change.
verifying-markdown-formatting
Verify that a Markdown file has correct formatting — headings, lists, links, code blocks, spacing, and consistent style.
visual-qa-testing
Visually QA a web application by launching it in Cursor's built-in browser, taking screenshots, checking console errors, and auditing network requests. Use after making UI changes to verify they look correct.
writing-commit-messages
Write clear, conventional commit messages with proper type prefixes, scopes, and body content.
writing-copy
Write marketing copy for landing pages, product descriptions, CTAs, emails, and app UI text.
writing-tests
Analyze existing code and write comprehensive unit and integration tests for it. Detects the test framework, identifies untested code paths, and generates tests with proper mocking, edge cases, and assertions. Use when the user asks to add tests, improve coverage, or test a speci