90 skills for coding agents such as Claude Code and Cursor. Each listing states what the skill may read, write, run and send (summarised from its SKILL.md) and its install command.
Asks one question at a time to learn what the user actually wants and why, then writes a design doc they approve before anything is built.
Turns a spec or requirements into an implementation plan of bite-sized TDD tasks, each naming exact files, interfaces and tests.
Executes a plan by dispatching a fresh implementer subagent per task, a task review after each, and a whole-branch review at the end.
Dispatches a code reviewer subagent with crafted context and a git commit range to check completed work against its requirements.
Works through bugs in four phases, root cause investigation, pattern analysis, hypothesis testing and implementation, fixing causes, not symptoms.
Runs a relentless interview to sharpen a plan or design, by handing off to the grilling skill from the same repo.
Provides a shared vocabulary and principles for deep modules: lots of behaviour behind a small interface, at a clean seam, tested through it.
Breaks a plan, spec or conversation into tracer-bullet tickets with blocking edges and publishes them to the configured tracker.
Sets up a Husky pre-commit hook in the current repo that runs Prettier via lint-staged, plus typecheck and tests.
Implements work from a spec or tickets, using the tdd skill where possible, running typechecks and tests, then reviewing and committing.
Reviews changes since a fixed point on two axes, the repo's coding standards and the originating spec, using parallel sub-agents.
Builds features and fixes bugs test-first in a red-to-green loop, testing behavior only at public seams agreed with the user.
Sets up a Claude Code PreToolUse hook that blocks dangerous git commands such as push, reset --hard, clean and branch -D before they run.
Finds refactors that turn shallow modules into deep ones, shows them in a visual HTML report, then grills through the one you pick.
Turns ambiguous or high-impact changes into scoped, verifiable acceptance criteria before or alongside implementation.
Sets a product-specific design direction before building production UI, then checks accessibility, responsiveness and content states as rendered.
Designs, implements and refactors Ports & Adapters systems so business logic stays independent of frameworks, transport and persistence.
Reads a plan document, splits it into steps, classifies each and emits a ready-to-paste ECC slash command carrying the step's scope.
Gives baseline cross-project coding conventions for naming, readability, immutability, error handling and code-smell review.
Orchestrates a brand-new feature end to end (research, plan, TDD, review, gated commit), delegating each phase to the matching ECC agent.
Playwright E2E testing patterns covering Page Object Model, configuration, CI/CD integration, artifact management and flaky test strategies.
A security checklist with code patterns for secrets, input validation, SQL injection, auth, XSS, CSRF, rate limiting, sensitive data and dependencies.
Hardens the boundaries where an agent turns untrusted data into filesystem, network, memory or tool actions, producing concrete controls and tests.
Turns speed-up requests into a bounded, measured loop: baseline first, one-hypothesis variants, a correctness gate, and the fastest safe variant wins.
Orchestrates a behavior-preserving refactor: confirm tests are green, restructure in small steps, keep tests green, review, and commit behind gates.
Maps the impact surface from real dependencies before a change, then compares the actual diff with the plan afterwards.
Covers rolling, blue-green and canary strategies, multi-stage Dockerfiles, CI/CD, health checks, rollback and a production readiness checklist.
Watches a deployed URL for regressions in HTTP status, console errors, network failures, performance, content, APIs, static assets and SSE streams.
Guides distinctive visual design for new or reworked UI, making deliberate palette, typography and layout choices grounded in the subject matter.
Tests local web applications with native Python Playwright scripts, capturing screenshots and browser logs, with a helper that manages servers.
Reviews a change for correctness, safety, behavior under load, tests, speed and leanness, reading connected code, not only the diff.
One-shot quality audit of a whole repo for bugs, security holes, load problems, untested risky code, slow paths and code to delete, merge or split.
Collects every shortcut: comment (and older ponytail: ones) in the repo into a one-shot technical debt ledger without changing anything.
Searches a local database of styles, palettes, font pairings, UX guidelines, icons, charts and stack notes to guide UI design and implementation.
Interrogates a vague request over five phases and turns it into a precise spec, filed as a GitHub issue and archived locally.
Audits a live site with a designer's eye for inconsistency, spacing, hierarchy, AI slop and slow interactions, then fixes and re-checks each finding.
Reviews a plan, branch diff or code path as an engineering manager would, covering architecture, code quality, tests and performance in a report.
Reads the CEO, design, DX and eng review skills from disk and runs them in sequence, auto-deciding intermediate questions with 6 decision principles.
While coding, runs the repo's declared checks and the tests /ship would pick, fixes and repeats until green.
Reviews a PR's diff against the base branch for structural issues tests miss, auto-fixing mechanical findings and asking before others.
Tests a site, API or CLI, then fixes the bugs it finds in severity order, each with a regression test and its own commit.
Evidence-first security audit via the gstack-cso helper that reports supported findings; comprehensive mode adds reproduction and repair candidates.
Turns on destructive-command warnings and a directory-scoped edit boundary together, combining /careful and /freeze in one command.
Measures live page metrics from performance.getEntries() in a browser and compares them with a saved baseline to detect web performance regressions.
Finds worthwhile shared-code extractions in recent work and recommends the three that delete the most code net.
Picks up the GitHub PR from /ship: checks CI and readiness, merges after approval, monitors the deploy, verifies production and writes a report.
After a deploy, drives a browser over live pages and compares screenshots, console errors, load times and broken links to a baseline.
Builds a feature as a complete, narrow path that fits the system, reusing existing seams and adding nothing acceptance does not need.
Compressed code review: one line per finding with location, problem and fix, with no throat-clearing.
Diagnoses ambiguous failures by gathering evidence and ranking hypotheses before any product code is changed.
Restructures code while preserving behavior, bracketing structural edits with the same verification before and after.
Interviews the user one question at a time, each with a guess attached, until it can state their real intent with about 95% confidence.
Builds accessible, responsive, production-quality UIs that follow the project's design system and avoid the generic AI-generated look.
Guides stable, hard-to-misuse APIs and module interfaces: contract first, consistent errors, validation at boundaries and additive changes.
Breaks work into small, ordered tasks with acceptance criteria and verification steps, saved as a plan document and task list.
Writes a project's quality bar down as a CONSTRAINTS.md contract and watches diffs for a quietly weakened bar.
Delivers changes in thin, verifiable slices: implement one piece, test it, verify it, commit, then move to the next.
Reviews code changes across five axes, correctness, readability, architecture, security and performance, labeling each finding by severity.
Hardens web app code against vulnerabilities, starting from a threat model and covering input, auth, sessions, dependencies, privacy and LLM features.
Optimizes frontend, backend and database performance via a measure, identify, fix, verify and guard loop, keeping only changes that measure better.
Reduces code complexity while preserving exact behavior, aiming for code that is easier to read, modify and debug rather than fewer lines.
Guides removing old systems, APIs or features, moving consumers safely to a replacement, and changing database schemas via expand/contract.
Prepares production launches with a pre-launch checklist, feature flags, staged rollout thresholds, monitoring, an error-budget gate and rollback.
Instruments code with structured logs, RED/USE metrics, OpenTelemetry tracing, and symptom-based alerts with runbooks so production is diagnosable.
Web art direction distilled from a study of 247 curated sites: deals design directions, checks pages in a real browser and runs a look-and-fix loop.
Builds checked standalone HTML diagrams in ten types, like architecture or ERD, from requirements, Mermaid or repo evidence, or a one-page explainer.
Analyzes a codebase into knowledge-graph.json under .ua/, with files, symbols, edges, layers and a guided tour for an interactive dashboard.
Checks for and implements a strict Content Security Policy, combined with HTML sanitization and Trusted Types against XSS and injection.
Sets bundle-size and Lighthouse thresholds in CI and fails builds over budget, so regressions surface at PR time.
White-box security review with Strix: reads source for data flow and authorization, then attempts exploitation in a sandbox with a PoC.
Defensive, source-first security review that finds vulnerabilities crossing a real trust boundary, with evidence, safe reproduction, priority and fix.
Diagnoses why web animations drop frames and keeps them within the frame budget using composite-only properties and off-main-thread motion.
Applies Clean Architecture, Hexagonal Architecture and DDD to give a service layered structure, dependency rules, interfaces and test boundaries.
Covers Python linting and formatting setup with ruff and mypy, PEP 8 naming, import order, type hints and Google-style docstrings.
Uses STRIDE to identify threats: spoofing, tampering, repudiation, information disclosure, denial of service and elevation of privilege.
Implements defense-in-depth for Kubernetes clusters with NetworkPolicy, Pod Security Standards, RBAC, OPA Gatekeeper and Istio mTLS.
Profiles Python code with cProfile, line_profiler, memory_profiler and py-spy, then optimizes bottlenecks using documented performance patterns.
Reference for microservice decomposition, sync and async communication, database-per-service, sagas, and resilience patterns like circuit breakers.
Designs multi-stage CI/CD pipelines with approval gates and security checks: pipeline config, rollout strategy, health checks, gates and rollback.
Defines SLIs, SLOs and error budget policy, and implements them with Prometheus recording rules, burn-rate alerts and Grafana dashboards.
Vercel's React and Next.js performance guide: 70 rules in 8 categories, ordered by impact, for writing and refactoring code.
Deploys an app to Vercel, choosing the method from link status, git remote and CLI auth, and returns the deployment URL.
Supports architecture decisions and design reviews, with scripts for dependency analysis, project assessment and architecture diagrams.
Generates CI/CD pipelines, Terraform modules and deployment manifests with rollback runbooks across AWS, GCP and Azure.
Classifies production incident severity, rebuilds the timeline and drafts the post-incident review, with communication templates and runbooks.
Uses the sentry CLI to read Sentry issues and events, summarize recent production errors and pull basic health data, read-only.
Manages multi-step agent work in task_plan.md, findings.md and progress.md on disk so it can be recovered after interruptions.
Writes a lean, decision-ready PRD from an 8-section template with market segments and a 6-part JTBD value proposition, about one to two pages.
Refines code for clarity, consistency and maintainability while preserving all functionality, applying project-specific standards.
Generates and maintains Terraform HCL code following HashiCorp's official style conventions and best practices.
No matching skills. Adjust your keywords or switch category.