SKILL.MD GENERATOR

Write a reusable skill your coding agent loads on demand: valid Agent Skills frontmatter, a description that says when to use it, numbered steps, an example and guardrails. Start from one of 14 tested templates or a blank form.

Zero retention: everything you type stays in this browser. Verify it yourself in DevTools.
Jump to your file
Skill
When to use
Instructions
Guardrails

Rules the skill must follow

Optional frontmatter
Your fileUpdated as you type. Nothing is sent anywhere.
.claude/skills/my-skill/SKILL.mdFor Claude Code, Codex and any Agent Skills reader
---
name: my-skill
description: "Describe what this skill does and when an agent should use it, with the words a user would actually say."
---

# My Skill

## Steps

1. Add the steps an agent should follow, in order, one per line.

## Guardrails

- Make the smallest change that does the job; do not refactor or reformat unrelated code.
- Run the project test and lint commands after changing code, and report the result. If you could not run them, say so.
- Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
- If a step fails, stop and report the exact error instead of working around it.

Save the file as SKILL.md inside a folder with the same name as the skill, for example .claude/skills/commit-message/SKILL.md.

    Which SKILL.md Templates Can You Start From?

    Fourteen skills teams reach for first. Each card writes a complete SKILL.md: load it into the form to change it, or copy or download it as it is.

    • Commit message writer

      Turns the staged diff into a Conventional Commits message with a clear summary and a body that explains why.

      Preconfigured for: Any git repository; teams that use Conventional Commits.

      Preview SKILL.md
      ---
      name: commit-message
      description: "Writes a Conventional Commits message for the staged changes: a typed, imperative summary under 72 characters and a body that explains why. Use when the user asks to commit, write a commit message, or describe staged changes."
      allowed-tools: "Bash(git diff:*) Bash(git log:*) Bash(git commit:*)"
      ---
      
      # Commit Message
      
      ## When to use
      
      - The user asks for a commit message or asks you to commit.
      - Changes are staged and need describing.
      
      ## When not to use
      
      - Nothing is staged: say so and stop.
      - Squash or merge commits that already have a message the user wrote.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The staged diff: `git diff --cached`.
      - Recent history for tone and scopes: `git log --oneline -15`.
      
      ## Steps
      
      1. Read the staged diff. If it is empty, say so and stop.
      2. Pick the type: feat, fix, refactor, perf, test, docs, build, ci or chore.
      3. Pick a scope from the main directory or module touched, if the repository uses scopes.
      4. Write the summary in the imperative mood ("add", not "added"), under 72 characters, with no trailing period.
      5. Write a body that says why the change was made and anything a reviewer must know; wrap at 72 characters.
      6. Add BREAKING CHANGE: and the migration step if a public API or behavior changed.
      7. Show the message. Commit only if the user asked you to commit.
      
      ## Output
      
      A commit message in a fenced block: one summary line, a blank line, then the body. Then one line saying whether it was committed.
      
      ## Example
      
      ```text
      Diff: adds a retry with backoff to the payment webhook handler
      
      fix(webhooks): retry Stripe deliveries with exponential backoff
      
      Stripe marks an endpoint failing after repeated 5xx responses. Retrying
      transient database errors three times keeps us off that list.
      ```
      
      ## Guardrails
      
      - Do not modify, create or delete files. This skill only reads and reports.
      - Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
      - If the request is ambiguous, ask one specific question before starting.
      - Never mention files or changes that are not in the staged diff.
      
    • Pull request description

      Writes a reviewer-friendly PR description from the branch diff: summary, why, how to test and risks.

      Preconfigured for: GitHub or GitLab pull requests on any stack.

      Preview SKILL.md
      ---
      name: pr-description
      description: "Writes a pull request description from the current branch: a summary, the reason for the change, how to test it and the risks. Use when the user asks for a PR description, PR body or merge request summary."
      allowed-tools: "Bash(git diff:*) Bash(git log:*) Read"
      ---
      
      # Pr Description
      
      ## When to use
      
      - The user asks to open a pull request or write its description.
      - A branch is ready for review.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The base branch (usually main).
      - The branch diff: `git diff main...HEAD`.
      - The commit list: `git log --oneline main..HEAD`.
      - The linked issue number, if there is one.
      
      ## Steps
      
      1. Read the commits and the diff against the base branch.
      2. Write a one-paragraph summary of what changes for users or callers.
      3. Explain why, linking the issue if one exists.
      4. List the notable changes as bullets grouped by area; skip formatting-only changes.
      5. Write numbered "How to test" steps a reviewer can follow, with exact commands.
      6. Call out risks: migrations, config changes, feature flags, breaking changes and rollback steps.
      7. Keep it under 300 words unless the change is large.
      
      ## Output
      
      Markdown with the headings Summary, Why, Changes, How to test, Risks. Nothing else.
      
      ## Guardrails
      
      - Do not modify, create or delete files. This skill only reads and reports.
      - Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
      - Back every finding with a file path and line number, or a command and its output.
      - Do not claim tests pass unless you ran them in this session.
      
    • Code review

      Reviews a diff for real bugs first (logic, edge cases, security), then clarity, and reports findings with file and line.

      Preconfigured for: Reviewing your own branch before you ask a human, or reviewing a teammate's PR.

      Preview SKILL.md
      ---
      name: code-review
      description: "Reviews a diff or branch for correctness bugs, security problems and missing tests, and reports findings ranked by severity with file and line. Use when the user asks for a review, a second opinion, or \"what is wrong with this change\"."
      allowed-tools: "Bash(git diff:*) Bash(git log:*) Read Grep Glob"
      ---
      
      # Code Review
      
      ## When to use
      
      - The user asks you to review a diff, branch, commit or pull request.
      - The user asks whether a change is safe to merge.
      
      ## When not to use
      
      - Style-only feedback the formatter or linter already enforces.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The diff to review: `git diff main...HEAD` unless the user names another range.
      - The tests that cover the changed code.
      
      ## Steps
      
      1. Read the whole diff once to understand the intent before judging any line.
      2. Check correctness: off-by-one errors, null and empty cases, error paths, concurrency, time zones, and money or unit math.
      3. Check security: input validation, injection, authorization on every new endpoint, and secrets.
      4. Check that tests exist for the new behavior and for the bug being fixed.
      5. Check that public APIs, migrations and config changes are backward compatible or called out.
      6. Drop anything you are not confident about, or label it as a question.
      7. Rank findings: blocking, should fix, nit. Keep nits to five at most.
      
      ## Output
      
      A list of findings, most severe first. Each one: severity, file:line, what is wrong, a concrete failing input or scenario, and the suggested fix. End with a one-line verdict.
      
      ## Guardrails
      
      - Do not modify, create or delete files. This skill only reads and reports.
      - Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
      - Back every finding with a file path and line number, or a command and its output.
      - Never invent a finding to make the review look thorough. "No blocking issues" is a valid result.
      
    • Unit test writer

      Adds focused unit tests for a module using the project's existing test framework and patterns.

      Preconfigured for: Projects with an existing test runner (Vitest, Jest, pytest, go test, RSpec and others).

      Preview SKILL.md
      ---
      name: write-unit-tests
      description: "Writes unit tests for a given function, module or file using the test framework and patterns already in the repository, covering the main path, edge cases and errors. Use when the user asks to add tests, improve coverage, or test a specific file."
      ---
      
      # Write Unit Tests
      
      ## When to use
      
      - The user asks for tests for a file, function or module.
      - A bug fix needs a regression test.
      
      ## When not to use
      
      - End-to-end or browser tests: use the project's e2e setup instead.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The code under test.
      - Two or three existing test files, to copy naming, structure and helpers.
      - The command that runs one test file.
      
      ## Steps
      
      1. Read the code under test and list its behaviors: the main path, edge cases, error cases.
      2. Find the nearest existing tests and copy their structure, naming and fixtures.
      3. Write one test per behavior, named after the behavior, not the function.
      4. Use real values; mock only I/O boundaries (network, clock, file system, randomness).
      5. Run the new test file and make every test pass without changing the code under test.
      6. If a test reveals a real bug, stop and report it instead of changing the code to match.
      
      ## Output
      
      The new or updated test file, the command you ran and its result, and any bugs the tests revealed.
      
      ## Guardrails
      
      - Make the smallest change that does the job; do not refactor or reformat unrelated code.
      - Run the project test and lint commands after changing code, and report the result. If you could not run them, say so.
      - If a step fails, stop and report the exact error instead of working around it.
      - Never weaken or delete an existing test.
      - No snapshot tests unless the project already uses them for this kind of code.
      
    • Failing test debugger

      Reproduces a failing test, isolates the cause with evidence, and fixes the code or explains why the test is wrong.

      Preconfigured for: CI failures and red local test runs on any stack.

      Preview SKILL.md
      ---
      name: debug-failing-test
      description: "Diagnoses and fixes a failing test or CI job: reproduce it, isolate the cause with evidence, fix the root cause and prove it with a green run. Use when a test fails, CI is red, or the user pastes a stack trace from a test run."
      ---
      
      # Debug Failing Test
      
      ## When to use
      
      - A test or CI job fails.
      - The user pastes a test failure or stack trace.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The failing test name and the exact error output.
      - The command that runs that one test.
      - What changed recently: `git log --oneline -10`.
      
      ## Steps
      
      1. Run the single failing test and confirm you see the same failure.
      2. Read the assertion and the stack trace; find the first frame in project code.
      3. Form one hypothesis and test it with the smallest experiment: a log line, a narrower input, or a bisect.
      4. Find the root cause. Fix the code, or if the test itself is wrong, explain why and ask before changing it.
      5. Run the failing test, then the whole suite, and confirm both pass.
      6. Remove any debug output you added.
      
      ## Output
      
      Root cause in one or two sentences with the evidence, the fix as a diff, and the before and after test results.
      
      ## Guardrails
      
      - Make the smallest change that does the job; do not refactor or reformat unrelated code.
      - Run the project test and lint commands after changing code, and report the result. If you could not run them, say so.
      - Back every finding with a file path and line number, or a command and its output.
      - Never skip, retry-until-green or loosen a test to make it pass.
      - If the failure is flaky, say so and show how you know.
      
    • Changelog updater

      Adds an Unreleased entry to CHANGELOG.md in Keep a Changelog format from the commits since the last tag.

      Preconfigured for: Libraries and apps that ship versioned releases.

      Preview SKILL.md
      ---
      name: changelog
      description: "Updates CHANGELOG.md in Keep a Changelog format from the commits since the last release tag, grouped into Added, Changed, Deprecated, Removed, Fixed and Security. Use when the user asks to update the changelog or prepare release notes."
      allowed-tools: "Bash(git log:*) Bash(git describe:*) Read Edit"
      ---
      
      # Changelog
      
      ## When to use
      
      - The user asks to update the changelog.
      - A release is being prepared.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The last release tag: `git describe --tags --abbrev=0`.
      - The commits since then: `git log --oneline <tag>..HEAD`.
      - The current CHANGELOG.md.
      
      ## Steps
      
      1. Find the last tag and list the commits since it.
      2. Drop commits that do not affect users: CI, refactors with no behavior change, test-only changes.
      3. Sort the rest into Added, Changed, Deprecated, Removed, Fixed and Security.
      4. Rewrite each one for users: what changed for them, not how it was implemented.
      5. Add the entries under ## [Unreleased] at the top, keeping the existing format.
      6. Do not choose a version number unless the user gives one.
      
      ## Output
      
      The updated Unreleased section, shown as a diff of CHANGELOG.md.
      
      ## Example
      
      ```text
      ## [Unreleased]
      
      ### Fixed
      
      - Webhook deliveries from Stripe are retried on temporary database errors.
      ```
      
      ## Guardrails
      
      - Make the smallest change that does the job; do not refactor or reformat unrelated code.
      - Back every finding with a file path and line number, or a command and its output.
      
    • Dependency upgrade

      Upgrades one dependency safely: reads the changelog for breaking changes, updates the code and runs the checks.

      Preconfigured for: npm, pnpm, pip, uv, Bundler, Cargo and Go module projects.

      Preview SKILL.md
      ---
      name: dependency-upgrade
      description: "Upgrades a single dependency to a target version: reads its changelog for breaking changes, updates call sites, regenerates the lockfile with the package manager and runs the full checks. Use when the user asks to upgrade, bump or update a package."
      ---
      
      # Dependency Upgrade
      
      ## When to use
      
      - The user asks to upgrade or bump a package.
      - A security advisory names a dependency.
      
      ## When not to use
      
      - Upgrading everything at once: do one dependency per change.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The package name and the target version (default: latest stable).
      - The current version from the lockfile.
      - The package's changelog or release notes between the two versions.
      
      ## Steps
      
      1. Find the current version and the target version.
      2. Read the release notes for every version in between and list the breaking changes.
      3. Search the code for each affected API and update it.
      4. Upgrade with the project's package manager so the lockfile is regenerated, never by editing the lockfile by hand.
      5. Run the build, type-check, lint and tests.
      6. Summarize what changed and anything you could not verify.
      
      ## Output
      
      Old and new version, the breaking changes that applied and how each was handled, and the check results.
      
      ## Guardrails
      
      - Make the smallest change that does the job; do not refactor or reformat unrelated code.
      - Run the project test and lint commands after changing code, and report the result. If you could not run them, say so.
      - Never run destructive commands (rm -rf, git reset --hard, git push --force, DROP) as part of this skill.
      - If a step fails, stop and report the exact error instead of working around it.
      - Do not upgrade other packages in the same change unless the package manager requires it; list any it pulled in.
      
    • Database migration

      Writes a reversible, backward-compatible schema migration with the framework's own tooling, and asks before running it.

      Preconfigured for: Apps on Postgres or MySQL with Rails, Django, Prisma, Laravel, Alembic or Knex.

      Preview SKILL.md
      ---
      name: db-migration
      description: "Creates a reversible, backward-compatible database migration with the project's migration tool, and never runs it against a shared database without approval. Use when the user asks to add a column, table or index, or change the schema."
      ---
      
      # Db Migration
      
      ## When to use
      
      - The user asks for a schema change: a table, column, index or constraint.
      
      ## When not to use
      
      - Data backfills over large tables: plan those as a separate job.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The migration tool and its generate command.
      - The current schema for the affected tables.
      - Whether old and new code will run side by side during the deploy.
      
      ## Steps
      
      1. Generate the migration with the framework's command; never hand-write the file name or timestamp.
      2. Make it backward compatible: add columns as nullable or with a default, and never rename or drop in the same deploy that stops using a column.
      3. Add indexes concurrently where the database supports it, for large tables.
      4. Write the down migration, or say clearly why it cannot be reversed.
      5. Update the models and the schema file the framework generates.
      6. Run the migration on the local or test database only, then run the tests.
      7. Ask before running it anywhere else.
      
      ## Output
      
      The migration file, the model changes, the local run output, and the deploy notes (order of steps, rollback).
      
      ## Guardrails
      
      - Show the planned changes and wait for approval before writing any file.
      - Run the project test and lint commands after changing code, and report the result. If you could not run them, say so.
      - Never run destructive commands (rm -rf, git reset --hard, git push --force, DROP) as part of this skill.
      - If a step fails, stop and report the exact error instead of working around it.
      - Never edit a migration that has already been applied; write a new one.
      
    • API endpoint

      Adds a REST endpoint end to end: route, validation, authorization, handler, tests and docs, following existing endpoints.

      Preconfigured for: Backend services in Express, Fastify, NestJS, FastAPI, Django REST, Rails or Go.

      Preview SKILL.md
      ---
      name: api-endpoint
      description: "Adds one HTTP API endpoint following the patterns of the existing endpoints: route, input validation, authorization, handler, error responses, tests and API docs. Use when the user asks for a new endpoint, route or API method."
      ---
      
      # Api Endpoint
      
      ## When to use
      
      - The user asks for a new endpoint, route or API method.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The method, path, request body and response shape.
      - Who may call it (the authorization rule).
      - One similar existing endpoint to copy the structure from.
      
      ## Steps
      
      1. Find the most similar existing endpoint and copy its structure, file layout and naming.
      2. Validate the input at the boundary with the project's validator; reject unknown fields.
      3. Check authorization explicitly, and scope every query to the caller (user or tenant).
      4. Return the project's standard error shape and status codes: 400, 401, 403, 404 and 409 as they apply.
      5. Write tests for success, validation failure, unauthorized and forbidden.
      6. Update the OpenAPI spec or the API docs if the project keeps them.
      7. Run the tests and lint.
      
      ## Output
      
      The changed files, an example request and response, and the test results.
      
      ## Guardrails
      
      - Make the smallest change that does the job; do not refactor or reformat unrelated code.
      - Run the project test and lint commands after changing code, and report the result. If you could not run them, say so.
      - Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
      - Use parameterized queries only.
      - Never return internal error messages or stack traces to the caller.
      
    • Security review

      Checks a diff or folder for secrets, injection, broken authorization, unsafe deserialization and risky dependencies.

      Preconfigured for: Security-conscious teams; changes touching auth, payments, uploads or personal data.

      Preview SKILL.md
      ---
      name: security-review
      description: "Performs a focused security review of a diff or directory: hard-coded secrets, injection, broken authentication and authorization, unsafe file handling, SSRF, insecure deserialization, and logging of personal data. Use when the user asks for a security review or audit, or before merging auth, payment or upload code."
      allowed-tools: "Read Grep Glob Bash(git diff:*)"
      ---
      
      # Security Review
      
      ## When to use
      
      - The user asks for a security review or audit.
      - A change touches authentication, payments, file uploads, or personal data.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The diff or the directory to review.
      - How requests are authenticated in this project.
      - Where user input enters the system.
      
      ## Steps
      
      1. Search for hard-coded secrets: keys, tokens, passwords, private keys and connection strings.
      2. Trace each user-controlled input to where it is used: SQL, shell, file paths, templates, URLs and redirects.
      3. Check that every new route or handler enforces authentication and authorization, including object-level ownership.
      4. Check file uploads for type, size and path validation, and outbound requests for SSRF.
      5. Check that logs and error messages do not contain personal data or secrets.
      6. Check new dependencies for known advisories with the package manager's audit command.
      7. Rate each finding: critical, high, medium or low.
      
      ## Output
      
      Findings ranked by severity. Each one: file:line, the vulnerable flow from input to sink, an example exploit input, and the fix. Mask any secret you find.
      
      ## Guardrails
      
      - Do not modify, create or delete files. This skill only reads and reports.
      - Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
      - Do not call external services or download anything; work only with what is in the repository.
      - Back every finding with a file path and line number, or a command and its output.
      - Never test an exploit against a live or shared system.
      - If you find a real secret, say it must be rotated; removing it from the code is not enough.
      
    • Accessibility audit

      Audits a UI component or page against WCAG 2.2 AA: keyboard, names, contrast, focus, motion and forms.

      Preconfigured for: Front-end teams on React, Vue, Svelte, Angular or plain HTML.

      Preview SKILL.md
      ---
      name: accessibility-audit
      description: "Audits a UI component or page for WCAG 2.2 AA problems: keyboard access, accessible names, focus order and visibility, color contrast, form labels and errors, and motion. Use when the user asks for an accessibility or a11y check, or before shipping new UI."
      ---
      
      # Accessibility Audit
      
      ## When to use
      
      - The user asks for an accessibility, a11y or WCAG review.
      - New interactive UI is about to ship.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The component or page source.
      - The design tokens for colors, to compute contrast.
      
      ## Steps
      
      1. List every interactive element and check it is reachable and usable with the keyboard alone, in a logical order.
      2. Check that each control has an accessible name: label, aria-label or visible text.
      3. Check that focus is always visible and never trapped, except inside an open modal.
      4. Compute the contrast of text and icons: 4.5:1 for body text, 3:1 for large text and UI parts.
      5. Check that form errors are announced and tied to their fields with aria-describedby.
      6. Check that animation respects prefers-reduced-motion.
      7. Prefer native elements over ARIA; flag div and span buttons.
      
      ## Output
      
      A table of issues with the WCAG criterion, the element, the impact and the fix, ordered by impact.
      
      ## Guardrails
      
      - Do not modify, create or delete files. This skill only reads and reports.
      - Back every finding with a file path and line number, or a command and its output.
      - Do not claim compliance. Automated and code checks find some issues, not all; recommend a screen reader pass.
      
    • README writer

      Writes or refreshes README.md from what is actually in the repository: install, run, test, configure, deploy.

      Preconfigured for: Any repository whose README is missing, stale or a framework default.

      Preview SKILL.md
      ---
      name: readme-writer
      description: "Writes or updates README.md from the real contents of the repository: what the project is, requirements, install, run, test, configuration and deployment, with commands verified against the package scripts or Makefile. Use when the user asks for a README or says the README is out of date."
      ---
      
      # Readme Writer
      
      ## When to use
      
      - The user asks for a README, or says it is wrong or missing.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - package.json scripts, Makefile, pyproject.toml or equivalent.
      - The .env.example or the config loader, for the variables.
      - Any existing README, to keep what is still true.
      
      ## Steps
      
      1. Read the manifest and scripts to find the real install, dev, build and test commands.
      2. Read the config loader or .env.example to list every environment variable and what it does.
      3. Write the sections: name and one-line purpose, requirements, quick start, configuration, common tasks, deployment, license.
      4. Keep commands copy-pasteable, one per line, in fenced blocks.
      5. Mark anything you could not confirm with TODO and say so in your summary.
      
      ## Output
      
      The complete README.md, and a list of the claims you could not verify.
      
      ## Guardrails
      
      - Make the smallest change that does the job; do not refactor or reformat unrelated code.
      - Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
      - Back every finding with a file path and line number, or a command and its output.
      - Never paste real values from .env; show variable names and safe examples only.
      
    • Safe refactor

      Refactors with behavior pinned by tests first, in small steps that each keep the build green.

      Preconfigured for: Legacy code, large files, and modules that need splitting.

      Preview SKILL.md
      ---
      name: refactor-safely
      description: "Refactors code without changing its behavior: pin current behavior with tests first, change in small steps that keep the build green, and prove equivalence at the end. Use when the user asks to refactor, clean up, split or restructure code."
      ---
      
      # Refactor Safely
      
      ## When to use
      
      - The user asks to refactor, restructure, extract or split code.
      
      ## When not to use
      
      - Changes that are supposed to alter behavior: those are features or fixes.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The code to refactor and the goal, for example "split this 900-line file by responsibility".
      - The existing tests that cover it.
      
      ## Steps
      
      1. Run the existing tests and record the result.
      2. If the code is not covered, add characterization tests that pin its current behavior first, including odd behavior.
      3. Plan the refactor as a list of small steps.
      4. Do one step at a time, and run the tests after each one.
      5. Keep public names and signatures unless the user agreed to change them.
      6. Finish with the full suite, lint and type-check.
      
      ## Output
      
      The plan, the steps done, the test result after each step, and anything left for later.
      
      ## Guardrails
      
      - Run the project test and lint commands after changing code, and report the result. If you could not run them, say so.
      - If a step fails, stop and report the exact error instead of working around it.
      - If the request is ambiguous, ask one specific question before starting.
      - Never mix a behavior change into a refactor. If you find a bug, report it separately.
      
    • Incident postmortem

      Drafts a blameless postmortem: impact, timeline, root cause, what went well, and owned action items.

      Preconfigured for: Engineering and on-call teams after an outage or near miss.

      Preview SKILL.md
      ---
      name: incident-postmortem
      description: "Drafts a blameless incident postmortem from notes, logs and chat excerpts: summary, impact, timeline, root cause and contributing factors, detection, response, and action items with owners. Use when the user asks for a postmortem, incident report or retrospective."
      ---
      
      # Incident Postmortem
      
      ## When to use
      
      - The user asks for a postmortem, incident report or incident review.
      
      ## Before you start
      
      Gather these first. If one is missing and you cannot find it in the repository, ask for it.
      
      - The timeline sources: alerts, logs, deploy history and chat excerpts.
      - The user-facing impact: who was affected, how, and for how long.
      - The fix that ended the incident.
      
      ## Steps
      
      1. Build a timeline in UTC from the sources, with one event per line.
      2. State the impact with numbers: duration, affected users or requests, and data loss if any.
      3. Find the root cause and the contributing factors with the five whys, and write them about systems, not people.
      4. Describe how it was detected and how long detection took.
      5. List what went well and what was lucky.
      6. Write action items that are specific and checkable, each with an owner role and a priority.
      
      ## Output
      
      A Markdown document with the headings Summary, Impact, Timeline, Root cause, Contributing factors, Detection, Response, What went well, Action items.
      
      ## Guardrails
      
      - Do not modify, create or delete files. This skill only reads and reports.
      - Never print, copy or commit secrets, tokens or .env values; refer to them by variable name.
      - Back every finding with a file path and line number, or a command and its output.
      - Blameless: never name an individual as a cause.
      - Remove customer personal data from any quoted log line.
      
    About the SKILL.md generator

    What Is a SKILL.md File?

    A skill is a folder with a SKILL.md file in it, and optional scripts/, references/ and assets/ folders next to it. The file starts with YAML frontmatter, a name and a description, followed by Markdown instructions. It is an open format, the Agent Skills specification, and Claude Code, Codex and a growing list of other agents read it.

    The point of a skill is progressive disclosure. At startup an agent reads only the name and description of every skill, about a hundred tokens each. It loads the full instructions only when a task matches the description, and reads the extra files only when the instructions point to them. You can keep dozens of skills installed without filling the context window, which is something a long AGENTS.md cannot do.

    What Does the Specification Require?

    • name: 1 to 64 characters, lowercase letters, digits and hyphens only, no hyphen at the start or end and no two hyphens in a row. It must match the folder name. The generator fixes names that break these rules and tells you what it changed.
    • description: 1 to 1024 characters. It should say both what the skill does and when to use it, with the keywords a user would type.
    • license, compatibility (at most 500 characters) and metadata are optional. Most skills need none of them.
    • allowed-tools is an optional, experimental, space-separated list of pre-approved tools, such as Bash(git:*) Read. Support varies by agent.
    • The body has no required sections. The specification recommends step-by-step instructions, examples of input and output, and edge cases, and keeping the file under 500 lines.

    Claude Code adds a few extensions of its own. The one this generator offers is disable-model-invocation: true, which stops Claude from starting the skill by itself, so it runs only when you type its slash command. Other agents ignore it.

    Where Do You Save a Skill?

    In a folder named after the skill, inside the skills directory your agent reads:

    • .claude/skills/<name>/SKILL.md: Claude Code, this repository. Commit it so the whole team gets the skill.
    • ~/.claude/skills/<name>/SKILL.md: Claude Code, every project on your machine.
    • .agents/skills/<name>/SKILL.md: Codex, which scans .agents/skills in every folder from where you start it up to the repository root, and other agents that read the shared folder.

    The install location box sets the path the generator shows above the file. The file itself is the same in every location.

    How Do You Write a Description That Triggers?

    An agent decides whether to use a skill from the description alone, before it has read a word of the instructions. Write it the way you would explain it to a new teammate, and include the words people actually say.

    1. Start with what it does, using a specific verb: "Writes a Conventional Commits message for the staged changes", not "Helps with git".
    2. Then say when: "Use when the user asks to commit, write a commit message, or describe staged changes."
    3. Name the file types, tools or phrases that should trigger it: PDF, migration, changelog, "PR description".
    4. Keep it to two or three sentences. A longer description costs context on every task, for every skill you have installed.

    "Helps with PDFs" is the specification's own example of a poor description. "Extracts text and tables from PDF files, fills PDF forms, and merges multiple PDFs. Use when working with PDF documents" is its example of a good one.

    What Makes the Steps Useful?

    • Order and verbs. Numbered steps an agent can follow and check off: "Run the single failing test and confirm the failure", not "investigate".
    • Exact commands. git diff --cached beats "look at the changes". The agent can run it and so can you.
    • A stop condition. Say what to do when something is missing or a step fails. Most bad skill runs come from an agent improvising past a failed step.
    • The output shape. Say exactly what comes back: a fenced commit message, a table of findings, a diff. A consistent output is what makes a skill worth reusing.
    • One example. A short input and its expected output teaches more than a paragraph of rules.

    How Are Skills Different From AGENTS.md and Commands?

    AGENTS.mdSKILL.md
    LoadedOn every task, in fullName and description at startup; the body only when relevant
    HoldsFacts and rules for the whole repository: stack, commands, conventionsOne procedure: how to do a specific job well
    SizeAs short as possible; every line costs context every timeUp to about 500 lines, with longer references in separate files
    Example"Run pnpm test before you say a task is done""How to write a reversible database migration"

    Use both. Put what is always true in AGENTS.md, and move each repeatable procedure into a skill. In Claude Code, skills have also replaced custom slash commands: a skill named deploy runs when you type /deploy.

    Is the Generator Private?

    Yes. The form, the generated file and the templates all run in this page. Nothing you type is uploaded, stored or added to the address bar. The skill is built from a deterministic template, so the same form always produces the same bytes, and the download is created in your browser.

    Frequently Asked Questions

    Which agents can use a SKILL.md file?

    Claude Code and Codex read SKILL.md natively, and the Agent Skills format is open, so other agents can and do adopt it. The file is plain Markdown with YAML frontmatter, so any agent can also read it when you point to it.

    Does the skill name have to match the folder?

    Yes. The specification requires the name field to match the parent folder name. The generator builds the path from the name so the two always agree.

    How long should a SKILL.md be?

    The specification recommends keeping it under 500 lines and the body under about 5,000 tokens. Move long reference material into a references/ folder next to SKILL.md and link to it.

    Can a skill include scripts?

    Yes. Put them in a scripts/ folder next to SKILL.md and reference them by relative path in the steps. This generator writes the SKILL.md; add any scripts by hand.

    What does allowed-tools do?

    It lists tools the skill may use without asking, such as Bash(git:*) or Read. It is experimental in the specification and agents differ in how they apply it, so treat it as a hint, not a sandbox.

    How Can You Verify That Nothing Leaves This Browser?

    You do not have to take our word for it. Developer tools show every request a page makes, so you can watch this page work and confirm that nothing you type is sent. The check takes under a minute.

    1. Open your browser developer tools with F12, or Cmd+Option+I on a Mac, and select the Network tab.
    2. Reload the page and let it finish. You will see the page's own files, its web fonts, and one anonymous page-view request. Nothing has been typed yet, so none of them can contain your input.
    3. Click the clear icon in the Network tab so that the log is empty.
    4. Fill in the form, load a template card, copy the file and download it.
    5. Look at the Network tab again. It is still empty. Downloads are built in the page as Blob URLs, so even the zip never touches a server. For extra proof, turn on offline mode after the page loads: everything keeps working.

    Only the feedback form can add a line to that log, and it sends only the vote and comment you type into it. 2prompt has no server code at all: no API, no model and no database of your files. The production site also sends a Content-Security-Policy header that tells your browser to refuse connections to anywhere except this site, the fonts and the anonymous analytics endpoint.

    Was this helpful?