universal-llm-skills

# Universal LLM Skills

> A library of deep, style-neutral skills (expert playbooks) that any LLM can load on demand. Start with AGENTS.md, choose skills from CATALOG.md, then read skills/<name>/SKILL.md.

## Start here

- [AGENTS.md](AGENTS.md): how an LLM should use this library
- [CATALOG.md](CATALOG.md): every skill with when-to-use descriptions
- [Skill standard](docs/SKILL_STANDARD.md): format and quality bar

## Meta: how to work

- [clarify-requirements](skills/clarify-requirements/SKILL.md): Decide whether a request is clear enough to act on, find the ambiguities that would actually change the result, ask a small number of high-leverage questions, state working assumptions explicitly, and pin down acceptance criteria before doing the work
- [estimate-effort](skills/estimate-effort/SKILL.md): Size work credibly: decompose it, estimate in ranges rather than single numbers, account for unknowns, integration, review, and rework, calibrate against past data, and communicate confidence and assumptions so others can plan around the estimate
- [explore-codebase](skills/explore-codebase/SKILL.md): Orient quickly and accurately in an unfamiliar or partly familiar code repository before changing it: find entry points, build/run/test commands, architecture and module boundaries, conventions, and the exact places a change belongs; trace data and control flow; read before writing
- [manage-context](skills/manage-context/SKILL.md): Keep long or complex work coherent when it outgrows what can be held in view at once: maintain working notes, decide what to keep in context versus write down, summarize without losing decisions, checkpoint at stable points, resume cleanly after an interruption or context reset, delegate to sub-agents without losing the thread, and use persistent memory across sessions responsibly
- [plan-and-decompose](skills/plan-and-decompose/SKILL.md): Break a non-trivial task into ordered, verifiable steps: decide whether a plan is worth making, find dependencies, sequence risky and uncertain work first, define milestones that each leave the system working, and re-plan when reality diverges
- [report-results](skills/report-results/SKILL.md): Hand finished or partial work back to the person who asked for it: lead with the outcome, say what changed and where, separate verified from unverified, surface decisions and risks that need the reader, and fit length and detail to the audience and medium
- [technical-decision-making](skills/technical-decision-making/SKILL.md): Make and document sound technical choices: frame the actual decision and its constraints, generate genuinely different options, analyse trade-offs against criteria that matter here, weigh reversibility and cost of delay, make a clear recommendation rather than a survey, and record the decision and its reasoning (e.g
- [using-skills](skills/using-skills/SKILL.md): How to route a user request to the right skills in this library, combine several skills for one task, resolve conflicts between a skill and a project's conventions, and work without a skill when none fits
- [verify-before-done](skills/verify-before-done/SKILL.md): Prove that work actually does what was asked before calling it finished: run the build, tests, and the real thing; inspect actual output instead of assuming it; check edge cases and regressions; compare against the acceptance criteria; and report honestly what was verified, what was only inferred, and what was not checked
- [write-new-skill](skills/write-new-skill/SKILL.md): Author a new skill, or substantially improve an existing one, for this library according to docs/SKILL_STANDARD.md: decide whether a new skill is warranted, research the domain, capture real expert judgment rather than generic advice, write a description that routes correctly, structure depth between SKILL.md and references/, keep it style- and model-neutral, and validate it

## Development

- [api-design](skills/api-design/SKILL.md): Design interfaces between software components that are easy to use correctly, hard to misuse, and safe to evolve: REST/HTTP, GraphQL, gRPC and other RPC, and event/message contracts
- [authentication-and-authorization](skills/authentication-and-authorization/SKILL.md): Design and implement who-are-you and what-may-you-do correctly: choosing between managed identity providers, auth libraries, and custom code; sessions vs
- [backend-development](skills/backend-development/SKILL.md): Build and change server-side services in any language or framework: the request lifecycle, input validation, where business logic belongs, transactions and data access, background jobs, configuration and secrets, statelessness, timeouts and resource limits, logging, and testing
- [cli-development](skills/cli-development/SKILL.md): Design and build command-line tools people and scripts can rely on: command and subcommand structure, flags and arguments, help text and error messages, exit codes, stdin/stdout/stderr discipline, human vs
- [code-documentation](skills/code-documentation/SKILL.md): Write and maintain documentation that lives with code: comments that earn their place, docstrings and doc comments, READMEs, API reference, architecture and decision records, runbook-style operational notes, and changelogs — and keep them true as the code changes, in the project's existing voice and tooling
- [concurrency-and-async](skills/concurrency-and-async/SKILL.md): Write and debug correct concurrent and asynchronous code: choosing between threads, processes, async/await and event loops, actors, and worker pools; avoiding data races, race conditions, deadlocks, livelocks and starvation; managing shared state with locks, atomics, immutability or message passing; structured concurrency, cancellation and timeouts; backpressure and bounded queues; and testing concurrent code
- [database-design](skills/database-design/SKILL.md): Choose the right kind of data store and design the data model inside it: relational, document, key-value, wide-column, graph, time-series, search, and vector stores; entities and relationships; normalization vs
- [database-migrations](skills/database-migrations/SKILL.md): Change database schemas and data safely in live systems: migration tooling and versioning, expand/contract (parallel change) for zero-downtime deploys, adding/renaming/dropping columns and tables, indexes and constraints without long locks, backfills and data migrations in batches, reversibility and roll-forward, coordinating code and schema deploys, and testing migrations on production-sized data
- [debugging](skills/debugging/SKILL.md): Systematically find and fix the root cause of bugs, crashes, wrong output, failing tests, hangs, and intermittent failures in any language or system: reproduce, minimize, form and test hypotheses, bisect, instrument, read error messages and stack traces, handle heisenbugs, fix the cause rather than the symptom, and lock the fix in with a regression test
- [dependency-management](skills/dependency-management/SKILL.md): Choose, add, pin, update, audit, and remove third-party dependencies safely: evaluating packages, semantic versioning and version ranges, lockfiles, reproducible installs, update strategy and automation, vulnerability and licence auditing, supply-chain risk (typosquatting, compromised maintainers, install scripts), vendoring, private registries, and monorepo workspaces
- [error-handling](skills/error-handling/SKILL.md): Design how software detects, reports, propagates, and recovers from failures: exceptions versus result/error types, fail fast versus graceful degradation, validation at boundaries, retries with exponential backoff and jitter, idempotency, timeouts and deadlines, circuit breakers, partial failure, user-facing versus internal error messages, error codes and API error formats, and logging errors usefully without leaking secrets or swallowing them
- [frontend-development](skills/frontend-development/SKILL.md): Build client-side user interfaces in any framework or none: component design and composition, state management, data fetching and caching, routing, forms and validation, loading/empty/error states, performance, accessibility, and faithfully matching an existing design system
- [git-workflow](skills/git-workflow/SKILL.md): Use Git well and safely: crafting focused commits and messages, choosing a branching model (trunk-based, feature branches, release branches), rebasing vs
- [legacy-modernization](skills/legacy-modernization/SKILL.md): Safely change, extend, migrate, or replace old, undocumented, or poorly tested systems: code archaeology, characterization tests, finding seams, strangler-fig replacement, incremental migration, framework and language version upgrades, and managing the risk of touching code nobody understands
- [performance-optimization](skills/performance-optimization/SKILL.md): Make software measurably faster or leaner, driven by measurement rather than guesswork: define the goal, profile CPU, memory, I/O and lock contention, find the real hot spot, apply the right fix (algorithmic complexity, data layout, caching, batching, lazy or avoided work, concurrency, database and network round trips), write benchmarks that don't lie, and guard against regressions with budgets
- [refactoring](skills/refactoring/SKILL.md): Change the structure of existing code without changing its behaviour: establishing a safety net, moving in small verified steps, recognising code smells, applying common refactorings (extract, inline, rename, move, replace conditional, introduce parameter object), planning large-scale refactors with branch-by-abstraction, expand-contract and strangler-fig patterns, and judging when not to refactor
- [secure-coding](skills/secure-coding/SKILL.md): Write code that resists attack: trust boundaries and input validation, output encoding, injection classes (SQL, command, template, path traversal, LDAP/NoSQL), XSS, CSRF, SSRF, open redirects, insecure deserialization, file upload handling, secrets management, cryptography do's and don'ts, safe error handling and logging, least privilege, and the OWASP Top 10 as a checking lens
- [software-architecture](skills/software-architecture/SKILL.md): Structure a codebase so it stays understandable and changeable: modules and boundaries, layering, dependency direction, coupling and cohesion, monolith vs
- [sql-and-queries](skills/sql-and-queries/SKILL.md): Write SQL that is correct first and fast second, in any dialect: joins and their row-multiplication traps, aggregation and GROUP BY, window functions, CTEs and subqueries, NULL and three-valued logic, set operations, upserts, pagination, transactions and locking in queries, reading query plans, indexing for specific queries, fixing N+1 access from application code, and safe parameterised queries
- [system-design](skills/system-design/SKILL.md): Design distributed systems that meet scale, latency, and reliability goals: gather functional and non-functional requirements, estimate capacity, shape data flow, and choose caching, queues, replication, partitioning, and consistency models while reasoning explicitly about failure modes and trade-offs
- [test-driven-development](skills/test-driven-development/SKILL.md): Write code test-first using the red-green-refactor cycle: pick the next smallest test, watch it fail for the right reason, make it pass with the simplest change, then refactor with the tests as a safety net
- [testing-strategy](skills/testing-strategy/SKILL.md): Decide what to test, at which level, and how: unit, integration, contract, end-to-end, property-based, snapshot and exploratory testing; test pyramid versus testing trophy trade-offs; mocks, stubs, fakes and other test doubles; test data and fixtures; flaky tests; and using coverage as a signal rather than a goal

## DevOps and operations

- [ci-cd-pipelines](skills/ci-cd-pipelines/SKILL.md): Design, build, speed up, and repair continuous integration and delivery pipelines on any CI system (e.g
- [cloud-architecture](skills/cloud-architecture/SKILL.md): Design and review systems on public clouds (AWS, Google Cloud, Azure, and smaller providers alike): choosing compute (VMs, containers, managed container platforms, serverless), managed data and messaging services, network topology, identity and access (IAM), multi-AZ and multi-region resilience, disaster recovery targets, cost management, well-architected trade-offs, and vendor lock-in
- [containerization](skills/containerization/SKILL.md): Write, review, and optimise container images and local container setups: Dockerfiles/Containerfiles, base image choice, layer ordering and build caching, multi-stage builds, image size, running as non-root, signals and PID 1, health checks, configuration via environment, Compose for local development, and image scanning and signing
- [incident-response](skills/incident-response/SKILL.md): Handle a live production incident from first alert to resolution: confirming impact, declaring and classifying severity, assigning roles (incident commander, operations, communications), communicating with stakeholders and customers, mitigating before diagnosing (rollback, failover, feature-flag off, scaling, shedding load), keeping a timeline, handing over between responders, and handing off to a postmortem
- [infrastructure-as-code](skills/infrastructure-as-code/SKILL.md): Define, change, and review cloud and platform infrastructure as code with tools such as Terraform, OpenTofu, Pulumi, CloudFormation, CDK, Bicep, Crossplane, or Ansible: state management and locking, modules, environment separation, plan review, drift detection, secrets, blast radius, refactoring without destroying resources, and importing existing infrastructure
- [kubernetes](skills/kubernetes/SKILL.md): Deploy, configure, operate, and debug workloads on Kubernetes (any distribution or managed service, e.g
- [observability](skills/observability/SKILL.md): Instrument and monitor software so its behaviour in production can be understood and acted on: structured logging, metrics, distributed tracing (e.g
- [release-management](skills/release-management/SKILL.md): Plan and run how software changes reach users: versioning schemes (SemVer, CalVer, build numbers), changelogs and release notes, release trains versus continuous delivery, release branches and tags, feature flags and decoupling deploy from release, staged and percentage rollouts, rollback and roll-forward plans, coordinating database migrations and API changes with releases, deprecations, and hotfixes

## AI, LLMs and machine learning

- [ai-agents-and-tool-use](skills/ai-agents-and-tool-use/SKILL.md): Design, build, and debug LLM agents and tool-using systems: deciding between a fixed workflow and an autonomous agent, the agent loop and its stopping conditions, designing tools (names, schemas, descriptions, return values, error messages), planning, short- and long-term memory, multi-agent orchestration and delegation, human-in-the-loop approval, guardrails on actions, cost and runaway control, and tracing
- [ai-safety-and-guardrails](skills/ai-safety-and-guardrails/SKILL.md): Threat-model and harden LLM applications and agents against misuse and failure: direct and indirect prompt injection, jailbreaks, system prompt and data leakage, PII handling, insecure output handling, excessive agency, moderation of inputs and outputs, output validation, least-privilege tool access, human confirmation for consequential actions, rate limiting and abuse prevention, red-teaming, and incident response for AI features
- [fine-tuning-models](skills/fine-tuning-models/SKILL.md): Decide whether to fine-tune a language or other foundation model versus improving prompts or adding retrieval, and if so, carry it out well: collecting, cleaning, and formatting training data, supervised fine-tuning, parameter-efficient methods such as LoRA, preference tuning, distillation from a larger model, hyperparameters at a practical level, evaluation against the base model and a prompted baseline, detecting overfitting and capability loss, deployment, and cost
- [llm-application-development](skills/llm-application-development/SKILL.md): Design and build production software on top of large language model APIs from any vendor or self-hosted runtime: application architecture, model selection and routing, streaming, structured output and validation, tool calling, context-window management, prompt and response caching, cost and latency budgets, retries, timeouts, fallbacks between providers, logging, tracing, and data handling
- [llm-evaluation](skills/llm-evaluation/SKILL.md): Build evaluations that tell you whether an LLM feature, prompt, model, RAG pipeline, or agent is actually good and whether a change made it better or worse: defining success criteria, building golden and adversarial test sets, code-based checks, rubric scoring, LLM-as-judge with its known biases and calibration against humans, pairwise comparisons, regression suites in CI, online metrics and user feedback, error analysis, and handling sampling noise and statistical significance
- [machine-learning-workflow](skills/machine-learning-workflow/SKILL.md): Run a classic machine learning project end to end on tabular, text, image, or time-series data: framing the business problem as a prediction task, establishing baselines, splitting data correctly and preventing leakage, feature engineering, choosing model families, picking metrics that match the decision, validation and hyperparameter tuning, error analysis, experiment tracking and reproducibility, deployment for batch or real-time inference, and monitoring for data and concept drift
- [mcp-server-development](skills/mcp-server-development/SKILL.md): Build, test, secure, and ship Model Context Protocol (MCP) servers and clients that expose tools, resources, and prompts to LLM applications: choosing between tools, resources, and prompts; picking a transport (stdio for local, HTTP-based for remote); designing tool names, input schemas, descriptions, and results; error handling; authentication and authorisation for remote servers; testing with inspector tools and real hosts; and limiting the blast radius of exposed actions
- [prompt-engineering](skills/prompt-engineering/SKILL.md): Write, debug, and improve prompts and system prompts for any large language model: giving clear instructions and context, choosing a role, adding few-shot examples, structuring long prompts with delimited sections, controlling output format, deciding when to ask for step-by-step reasoning, iterating against test cases, and hardening prompts against injection from untrusted input
- [rag-systems](skills/rag-systems/SKILL.md): Design, build, debug, and evaluate retrieval-augmented generation systems that answer questions from documents, knowledge bases, codebases, or databases: ingestion and parsing, chunking strategy, embeddings, vector and keyword (hybrid) search, reranking, metadata and permission filters, query rewriting, prompt assembly with citations, freshness and re-indexing, and separate evaluation of retrieval and answer quality

## Application generation

- [browser-extension-development](skills/browser-extension-development/SKILL.md): Design, build, test and publish browser extensions (Chrome, Edge, Firefox, Safari and other WebExtensions-based browsers): manifest and permissions, background service workers, content scripts, popups, side panels and options pages, message passing, storage, cross-browser differences, store review and extension security
- [chatbot-and-conversational-apps](skills/chatbot-and-conversational-apps/SKILL.md): Design and build chatbots, virtual assistants and voice or messaging applications end to end: conversation design, choosing between scripted flows, intent classification and LLM-driven dialogue, conversation state and memory, turn-taking, clarification, fallback and escalation to humans, channel constraints (web chat widgets, SMS, WhatsApp and chat platforms like Slack/Teams/Discord, voice/IVR), safety, analytics and evaluation
- [desktop-app-development](skills/desktop-app-development/SKILL.md): Build and ship desktop applications for Windows, macOS and Linux: choose between native toolkits, web-technology shells (e.g
- [documentation-site](skills/documentation-site/SKILL.md): Plan, build and maintain a documentation website for a product, API, library, platform or internal system: information architecture (tutorials, how-to guides, reference, explanation), choosing a static site generator or hosted docs platform, navigation and search, versioning for multiple releases, generated API reference, code samples that are tested and actually run, docs-as-code workflow with review, previews, link checking and CI, plus accessibility, internationalisation and analytics
- [full-stack-app-build](skills/full-stack-app-build/SKILL.md): Generate a complete, working full-stack application from a description: capture requirements, choose a stack by constraints rather than taste, design the data model first, build in vertical slices, add authentication, seed realistic data, run it end to end, define a deploy path, and hand it over with clear run instructions
- [game-development](skills/game-development/SKILL.md): Plan and build playable games — 2D or 3D, browser, desktop, mobile or console — from first prototype to shippable build: choosing an engine, framework or from-scratch approach, the game loop and timing, state and scene management, input, rendering, physics and collision basics, game feel, audio, asset pipeline, save data, scope control, playtesting and performance
- [mobile-app-development](skills/mobile-app-development/SKILL.md): Build mobile applications for iOS and Android: choose native vs cross-platform by constraints, follow each platform's navigation and interaction conventions, design for offline use and data sync, request permissions in context, implement push notifications, manage performance, battery and app size, meet app store review and privacy requirements, and test on real devices
- [mvp-prototyping](skills/mvp-prototyping/SKILL.md): Build the smallest thing that tests an idea: identify the riskiest assumption, decide what to fake and what to make real, choose throwaway vs evolvable code on purpose, time-box the build, make it demo-able, and document what was deliberately skipped
- [project-scaffolding](skills/project-scaffolding/SKILL.md): Start a new software repository well: choose a language toolchain and package manager from the real constraints, lay out directories for the project type (library, CLI, service, web app, monorepo), and set up formatting, linting, type checking, tests, CI, environment configuration, scripts, README, licence and ignore files from day one — the minimum that pays off, not every tool available
- [website-and-landing-pages](skills/website-and-landing-pages/SKILL.md): Build content-first websites and marketing pages: define the goal and audience, structure pages and visual hierarchy around one primary action, write or place real content before styling, choose static vs CMS vs framework by who edits it and how often, and ship it fast, responsive, accessible and indexable, with working forms and analytics

## Analysis and research

- [competitive-analysis](skills/competitive-analysis/SKILL.md): Map and analyse competitors and alternatives for a product, service, or business: defining the market and the customer's job to be done, finding direct, indirect, and substitute competitors (including "do nothing" and in-house solutions), comparing features, positioning, pricing, go-to-market, and strengths and weaknesses from defensible sources, avoiding confirmation bias, and turning findings into implications and decisions
- [dashboard-building](skills/dashboard-building/SKILL.md): Design and build dashboards that people actually use: start from the audience and the decisions they make, define every metric precisely, lay out by priority, choose filters and drill-downs deliberately, show freshness and data quality, keep it fast, and pick the tool (BI platform, notebook app, custom code, spreadsheet) by constraint
- [data-analysis](skills/data-analysis/SKILL.md): Answer real questions with data: frame the question as a decision, establish the data's provenance, grain and coverage, explore before concluding, segment and compare like with like, reason about confounders and selection effects, and report findings with honest uncertainty and caveats
- [data-cleaning-and-validation](skills/data-cleaning-and-validation/SKILL.md): Profile, clean and validate data so it can be trusted: establish types and grain, handle missing values, duplicates and outliers, catch joins that multiply rows, fix encoding and unicode problems, normalise dates, timezones and units, write validation rules and data contracts, and document every transformation reproducibly
- [data-visualization](skills/data-visualization/SKILL.md): Turn data into charts that answer a specific question honestly and fast: choose the chart form from the comparison being made, build an encoding hierarchy, use color for meaning (categorical, sequential, diverging) with colorblind safety, label directly, keep axes honest, use small multiples, annotate the insight, and avoid misleading charts — with styling derived from the destination (report, slide, app, publication, brand) rather than a default
- [experiment-design](skills/experiment-design/SKILL.md): Design, run and interpret controlled experiments — A/B tests, multivariate and multi-arm tests, holdouts — and quasi-experiments when you cannot randomize: write a falsifiable hypothesis, choose primary, secondary and guardrail metrics, pick the randomization unit, compute power, sample size and duration, avoid peeking, sample-ratio mismatch and novelty effects, and read results honestly
- [financial-modeling](skills/financial-modeling/SKILL.md): Build, review, and explain business and financial models: identifying the question the model answers, choosing drivers, unit economics (contribution margin, customer acquisition cost, lifetime value, payback), bottom-up and top-down revenue builds, cost and headcount builds, linking income statement, balance sheet, and cash flow at a conceptual level, working capital and runway, scenarios and sensitivity analysis, documenting assumptions, and sanity checks
- [literature-review](skills/literature-review/SKILL.md): Survey academic, scientific, or technical literature on a topic and synthesize what is known: defining the review question and type, designing a search strategy across databases and preprint servers, setting inclusion and exclusion criteria, screening, reading papers efficiently, extracting claims together with the strength of their evidence, building a synthesis across studies, identifying gaps and disagreements, and keeping citations accurate
- [requirements-analysis](skills/requirements-analysis/SKILL.md): Elicit, analyse, and specify requirements for a system, product, feature, process, or procurement: identifying stakeholders and their goals, separating needs from proposed solutions, capturing functional and non-functional (quality) requirements and constraints, modelling use cases and scenarios, finding edge cases and error paths, detecting and resolving conflicts, prioritising, maintaining traceability, and turning vague asks into precise, testable requirements
- [root-cause-analysis](skills/root-cause-analysis/SKILL.md): Explain why something went wrong in a system, process, product, or business and identify causes that, if addressed, prevent recurrence: scoping the problem precisely, building an evidence-based timeline, generating and testing hypotheses, using 5 whys, fishbone (cause-and-effect) diagrams, fault trees, and change analysis appropriately and knowing their limits, distinguishing triggers, contributing factors, and systemic causes, and turning findings into verifiable corrective actions
- [spreadsheet-modeling](skills/spreadsheet-modeling/SKILL.md): Build spreadsheets and spreadsheet models that are correct, auditable and survive being edited by other people: separate inputs, calculations and outputs, use formulas instead of hard-coded numbers, name ranges, choose robust lookups, avoid fragile references, build checks and error traps, handle scenarios and sensitivity, document assumptions, and recognise when to move to a database or code
- [statistical-analysis](skills/statistical-analysis/SKILL.md): Choose, apply and interpret statistical methods correctly: descriptive statistics, distributions, hypothesis tests, confidence and credible intervals, regression, multiple-comparison corrections, effect sizes versus p-values, assumption checks, resampling, and Bayesian versus frequentist framing
- [web-research](skills/web-research/SKILL.md): Research a question using online sources and produce a sourced, calibrated answer: turning the question into searchable queries, finding primary sources, triangulating claims across independent sources, judging credibility and recency, tracking where each fact came from, synthesizing conflicting evidence, knowing when to stop, and citing properly

## Quality, testing and reviews

- [accessibility-audit](skills/accessibility-audit/SKILL.md): Audit an existing website, web app, mobile app, or document (PDF, slides, office files) against the Web Content Accessibility Guidelines (WCAG) and produce a prioritized report of barriers with concrete fixes
- [ai-content-authenticity](skills/ai-content-authenticity/SKILL.md): Review text for generic, formulaic, or AI-sounding patterns — filler phrases, empty intensifiers, false balance, hedging stacks, stock metaphors, listicle and triad structure tics, vague unsupported claims, and tone that sounds like nobody in particular — and revise it into writing that is specific, substantive, accurate, and recognizably the author's own
- [architecture-review](skills/architecture-review/SKILL.md): Evaluate a proposed or existing software design (design doc, RFC, ADR, architecture diagram, system proposal, or a running system's structure) and give a clear, reasoned verdict
- [code-review](skills/code-review/SKILL.md): Review a code change (pull request, merge request, patch, diff, or a set of edited files) for correctness, safety, maintainability and fit with the codebase, and write feedback the author can act on
- [end-to-end-testing](skills/end-to-end-testing/SKILL.md): Write, stabilize, and run reliable end-to-end and UI automation tests for web, mobile, and desktop apps with tools such as Playwright, Cypress, Selenium/WebDriver, WebdriverIO, Appium, Detox, or XCUITest/Espresso
- [fact-checking](skills/fact-checking/SKILL.md): Verify the factual claims in a document, article, report, speech, social post, or AI-generated answer: extract checkable claims, trace each to primary sources, verify numbers, statistics, quotes, dates, names, and attributions, detect claims that are technically true but misleading through missing context, rate confidence, and document sources so others can audit the result
- [postmortem](skills/postmortem/SKILL.md): Run and write a blameless post-incident review (postmortem, incident review, retrospective, after-action review, learning review) once an incident is resolved: gathering evidence, reconstructing an accurate timeline, analysing contributing factors across technology, process and organisation, recording what went well and where the team got lucky, producing action items that are specific, owned, prioritised and tracked, facilitating the review meeting, and sharing learnings
- [pull-request-workflow](skills/pull-request-workflow/SKILL.md): Prepare, open, shepherd and land a code change through review: scoping a pull/merge request to one reviewable purpose, writing a description that explains why, self-reviewing before asking others, stacking dependent changes, responding to review feedback, keeping CI green and trustworthy, choosing a merge strategy (merge, squash, rebase), and cleaning up after
- [qa-test-planning](skills/qa-test-planning/SKILL.md): Plan quality assurance for a feature, release, or product: decide what to test and how deeply based on risk, derive test cases with equivalence partitioning, boundary values, decision tables, and state-transition analysis, write exploratory testing charters, choose device/browser/OS coverage matrices, set entry and exit criteria, and write bug reports that reproduce
- [release-readiness](skills/release-readiness/SKILL.md): Run a go/no-go assessment for shipping a release, launch, major feature, migration or deployment: identify what this release actually risks, check test and quality status, known issues and their severity, migration and rollback plans, feature flags and staged rollout, monitoring and alerting, documentation, support and stakeholder readiness, and record explicit risk acceptance
- [security-audit](skills/security-audit/SKILL.md): Assess an existing system, application, codebase or deployment for security weaknesses within an authorised scope, and report them responsibly
- [web-performance-audit](skills/web-performance-audit/SKILL.md): Measure, diagnose, and prioritize improvements to how fast web pages load and respond for real users
- [writing-review-and-editing](skills/writing-review-and-editing/SKILL.md): Review and edit any piece of writing — reports, articles, essays, docs, proposals, emails, web copy, fiction, academic drafts — to make it clearer, tighter, better organized, and right for its audience while keeping the author's voice

## Design, UI and UX

- [accessible-design](skills/accessible-design/SKILL.md): Design products that people with disabilities can use from the first sketch, not after an audit: color and contrast, text size and spacing, visible focus, target sizes, keyboard and screen-reader-friendly structure and semantics, headings and landmarks, accessible names, forms and error messaging, alt text and image descriptions, captions and transcripts, motion and flashing, cognitive accessibility and plain language, and inclusive representation and language
- [design-critique](skills/design-critique/SKILL.md): Give, structure, and receive critique of any design artifact — screens, flows, prototypes, visual designs, design systems, slides, diagrams, physical or service designs — by first understanding goals and constraints, separating personal taste from effectiveness, making feedback specific and actionable, prioritizing issues, running critique sessions, critiquing your own work, and responding well to critique
- [design-systems](skills/design-systems/SKILL.md): Create, extend, audit and evolve design systems: design tokens (primitive, semantic and component tiers), naming, theming and multi-brand support, component APIs, variants and composition, documentation, contribution and governance models, versioning and deprecation, adoption and migration, and keeping design files and code in sync
- [design-to-code-handoff](skills/design-to-code-handoff/SKILL.md): Make designs buildable and keep implementation faithful to them: writing specs and annotations, mapping design decisions to design tokens and existing components, specifying every state and edge case, responsive and adaptive behavior, interaction and motion details, accessibility requirements, preparing and exporting assets, collaborating from both the design and engineering side, and running design QA against the built product
- [information-architecture](skills/information-architecture/SKILL.md): Organize and label content and features so people can find, understand, and use them: content inventories and audits, mental models, taxonomies and metadata, labeling, global/local/contextual navigation, search versus browse, card sorting and tree testing, findability metrics, and scaling an IA as a product or site grows
- [interaction-design](skills/interaction-design/SKILL.md): Design how an interface behaves over time: task flows, feedback and system status, state transitions, forms and validation, navigation and wayfinding, progressive disclosure, error prevention and recovery, confirmation vs
- [layout-and-responsive-design](skills/layout-and-responsive-design/SKILL.md): Plan and build layouts that adapt to any viewport, container, input method and zoom level: grid systems, CSS Flexbox vs
- [motion-design](skills/motion-design/SKILL.md): Design and implement purposeful interface animation: deciding when motion helps (feedback, orientation, continuity, attention, character) and when it harms, easing curves and springs, duration by distance and size, choreography and staggering, transitions between states and screens (including shared-element and view transitions), loading and skeleton motion, performance (compositor-friendly properties, frame budgets, layout thrash), and reduced-motion and vestibular safety
- [ui-design-fundamentals](skills/ui-design-fundamentals/SKILL.md): Design user interfaces that are clear, usable and fit their product: visual hierarchy, alignment, proximity and grouping, contrast, consistency, affordances and signifiers, information density, the full set of UI states (empty, loading, partial, error, success, disabled), and choosing between common component patterns (modal vs
- [usability-evaluation](skills/usability-evaluation/SKILL.md): Evaluate how usable an interface, flow, or prototype is: expert reviews (heuristic evaluation using Nielsen's heuristics or other lenses, cognitive walkthroughs), moderated and unmoderated usability tests, task and scenario design, think-aloud, metrics (task success, time on task, errors, post-task and SUS-style questionnaires), severity rating, benchmarking, and reporting findings that get fixed
- [ux-research](skills/ux-research/SKILL.md): Plan, run, and synthesize user research: framing research questions, choosing methods (interviews, contextual inquiry, surveys, diary studies, usability tests, analytics, card sorts) by what you need to learn, recruiting and screening participants, interview technique without leading questions, affinity mapping and thematic synthesis, turning observations into insights, and research ethics and consent
- [ux-writing](skills/ux-writing/SKILL.md): Write and edit interface copy and microcopy: button and link labels, form labels and hints, error and validation messages, empty states, confirmations, notifications, onboarding, tooltips, and settings descriptions; build consistent terminology; adapt tone to the product's existing voice; and prepare strings for localization
- [visual-design](skills/visual-design/SKILL.md): Build a coherent visual language for an interface, document or brand surface from its given constraints: typography (type scales, pairing, measure, leading, weights, numerals), color (palette construction, roles, contrast, dark mode, state and meaning), spacing scales, elevation and shape, imagery, illustration and iconography
- [wireframing-and-prototyping](skills/wireframing-and-prototyping/SKILL.md): Turn ideas into sketches, wireframes, mockups, and interactive prototypes at the right fidelity to answer a specific question: choosing low- vs

## Automation

- [api-integrations-and-webhooks](skills/api-integrations-and-webhooks/SKILL.md): Integrate with third-party APIs and receive webhooks reliably and securely: reading API docs critically, choosing and implementing auth (API keys, OAuth 2.0 flows, signed requests), rate limits, timeouts, retries with exponential backoff and jitter, pagination, idempotency keys, webhook signature verification, deduplication, replay and reconciliation, sandbox vs production, versioning, and secret storage
- [browser-automation](skills/browser-automation/SKILL.md): Drive real or headless browsers programmatically for testing, task automation, screenshots, PDF generation and data capture, using tools such as Playwright, Puppeteer, Selenium/WebDriver or Cypress as examples: robust selectors, auto-waiting instead of sleeps, sessions and authentication state, downloads and uploads, screenshots and traces, headless vs headed, iframes and popups, reducing flakiness, and safety when operating real accounts
- [etl-pipelines](skills/etl-pipelines/SKILL.md): Design, build and operate data pipelines that move and transform data between systems: ETL vs ELT, batch vs streaming, full vs incremental loads, change data capture, idempotent and re-runnable loads, schema evolution, orchestration (e.g
- [scheduled-jobs](skills/scheduled-jobs/SKILL.md): Design, implement and operate jobs that run on a schedule or from a job queue: cron and crontab syntax, systemd timers, Kubernetes CronJobs, cloud schedulers, and background job queues as examples; timezones and daylight saving, overlapping runs and locking, retries and idempotency, catch-up and missed-run semantics, timeouts, alerting on silent failure (dead man's switch), logging and observability
- [scripting-and-shell](skills/scripting-and-shell/SKILL.md): Write robust, safe, maintainable scripts in shell (bash, zsh, POSIX sh), PowerShell, or a scripting language such as Python: strict modes, quoting, argument parsing, idempotency, dry-run flags, logging, portability between GNU, BSD/macOS and Windows, safe destructive operations, and knowing when a script has outgrown the shell
- [text-processing-and-regex](skills/text-processing-and-regex/SKILL.md): Construct correct, readable, efficient regular expressions and perform text transformations safely: anchors, greediness, character classes, groups and lookarounds, regex flavor differences, catastrophic backtracking (ReDoS), Unicode and encodings; line-oriented tools such as grep, sed, awk, jq, yq and their GNU/BSD differences; using real parsers for JSON, CSV, HTML, XML, YAML and code instead of regex; and making bulk search-and-replace edits across many files without breaking them
- [web-scraping](skills/web-scraping/SKILL.md): Extract structured data from websites responsibly and reliably: checking terms of service, robots.txt and legal constraints, preferring official APIs and data exports, choosing plain HTTP versus a headless browser, parsing HTML/JSON, pagination and crawling, rate limiting and politeness, resilience to layout changes, deduplication, and storing provenance
- [workflow-automation](skills/workflow-automation/SKILL.md): Design and build automations of business and development workflows, using no-code/low-code platforms (e.g

## Product, writing and communication

- [business-communication](skills/business-communication/SKILL.md): Write workplace messages that get read and acted on: emails, chat messages, status updates, announcements, requests, escalations, difficult or bad-news messages, apologies, and executive summaries
- [copywriting](skills/copywriting/SKILL.md): Write persuasive and marketing copy that moves a specific audience to act: landing and product pages, headlines, taglines, value propositions, calls to action, ads, email campaigns, product descriptions, app-store listings, social posts, sales one-pagers, and launch announcements
- [curriculum-design](skills/curriculum-design/SKILL.md): Design courses, units, lessons, workshops, and training programmes that produce real learning: defining measurable learning objectives (with Bloom's taxonomy as one lens), backward design from outcomes, assessments aligned to objectives, active and hands-on activities over passive content and recall quizzes, scaffolding and sequencing, pacing and cognitive load, feedback, accessibility and inclusion, adapting to audience level from K-12 through university to professional and corporate training, and iterating from learner evidence
- [document-generation](skills/document-generation/SKILL.md): Produce document files — DOCX, PDF, XLSX, PPTX, Markdown, HTML, CSV — either programmatically (libraries, templates, converters, report pipelines) or by hand, and verify they open and render correctly
- [presentations](skills/presentations/SKILL.md): Build slide decks and talks that make one clear argument to a specific audience: storyline before slides, one idea per slide, evidence and visuals instead of text walls, data slides, speaker notes, fitting audience and time slot, and a visual style derived from the organisation's brand or the content itself rather than a default theme
- [product-requirements](skills/product-requirements/SKILL.md): Write, review, and maintain product requirements documents (PRDs), feature specs, one-pagers, and briefs: frame the problem before the solution, name the users and their jobs, set goals, non-goals and success metrics, define scope, write requirements at the right altitude, record alternatives and open questions, and keep the spec alive as the work changes
- [project-management](skills/project-management/SKILL.md): Plan, run, and close projects of any kind with any method (agile, kanban, waterfall, or hybrid): scope and charter the work, set milestones, assign clear ownership (RACI-style), keep a risk and issue log, track status honestly, control scope creep through explicit change decisions, set meeting and reporting cadences, unblock people, manage dependencies, and close out with handover and lessons learned
- [roadmap-and-prioritization](skills/roadmap-and-prioritization/SKILL.md): Decide what to work on and in what order, and communicate it as a roadmap: use prioritization frameworks (RICE, ICE, MoSCoW, Kano, cost of delay / WSJF, opportunity scoring) as lenses with known failure modes rather than oracles, build outcome-based instead of output-based roadmaps, sequence by dependency, risk and learning, say no well, and communicate confidence and uncertainty honestly
- [seo](skills/seo/SKILL.md): Improve how content and sites are found through search engines and AI answer engines, without spam tactics
- [technical-writing](skills/technical-writing/SKILL.md): Explain technical subjects clearly to a defined audience: guides, tutorials, how-tos, reference pages, conceptual explanations, design docs, runbooks, READMEs, internal wikis, knowledge-base articles, and technical blog posts
- [user-stories](skills/user-stories/SKILL.md): Write, split, and refine user stories and their acceptance criteria so each backlog item delivers a thin, testable slice of user value: apply INVEST, slice vertically rather than by layer, split epics with proven patterns, write acceptance criteria (Given/When/Then as one option among several), cover edge cases, agree a definition of done, and catch tasks disguised as stories