30 Claude Prompts That Write README Files

You are a backend engineer who writes clear REST API documentation. <context> I have a REST API and need a README documenting auth, endpoints, and examples, returned as one ready-to-commit Markdown artifact. </context> <inputs> - API name and purpose: [NAME PLUS WHAT IT SERVES] - Base URL and versioning: [E.G. https://api.x.com/v1] - Auth method: [API KEY, BEARER, OAUTH] - Key endpoints: [METHOD, PATH, WHAT EACH DOES] - Rate limits / errors: [LIMITS AND ERROR FORMAT] - Run locally: [SETUP STEPS] </inputs> <task> Write a README with: title and description, badges (build, license, API version), Overview, Base URL and Authentication with a header example, an Endpoints reference table (method, path, description), detailed examples per key endpoint with a curl request and JSON response, an Errors section with the standard error shape and status codes, Rate Limiting, Local Development, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged bash for curl and json for payloads; realistic request/response examples. - Never print real API keys; use a placeholder token; keep the error shape consistent. - Precise and complete, no filler. </constraints> <format> Return the complete README.md as one Markdown artifact, then note when to graduate from a README to OpenAPI/Swagger. </format>

You are a GraphQL API author who documents schemas and operations clearly. <context> I have a GraphQL API and need a README covering the schema, queries, mutations, and auth, returned as one ready-to-commit Markdown artifact. </context> <inputs> - API name and purpose: [NAME PLUS WHAT IT DOES] - Endpoint URL: [GRAPHQL ENDPOINT] - Auth: [HOW CLIENTS AUTHENTICATE] - Key types: [MAIN OBJECT TYPES] - Key queries and mutations: [WITH WHAT THEY RETURN] - Playground / introspection: [AVAILABLE OR NOT] </inputs> <task> Write a README with: title and description, badges, Overview, Endpoint and Authentication, a Getting Started query example, a Schema Overview of key types, a Queries section with an example query plus variables plus response, a Mutations section similarly, Error handling, Rate limits, a Playground link, Local Development, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged graphql for operations and json for responses and variables. - Show real, executable example operations with variables; use a placeholder auth token. - Clear and complete, no filler. </constraints> <format> Return the complete README.md as one Markdown artifact, then note how to auto-generate schema docs and keep the README examples in sync. </format>

You are a platform engineer who documents microservices for on-call and onboarding. <context> I own a microservice and need a README covering how to run it, its env, health, and observability, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Service name and responsibility: [NAME PLUS WHAT IT OWNS] - Stack and dependencies: [LANGUAGE, DB, QUEUE, UPSTREAM/DOWNSTREAM SERVICES] - Env vars: [KEY CONFIG] - Endpoints/consumers: [WHO CALLS IT, WHAT IT EXPOSES] - Health/metrics endpoints: [E.G. /healthz, /metrics] - Deploy/runbook basics: [HOW IT DEPLOYS, ALERTS] </inputs> <task> Write a README with: title and responsibility statement, Architecture context (upstream/downstream with a small Mermaid diagram), Tech Stack, Local Development (run plus dependencies via Docker), an Environment Variables table, the API/interface it exposes, Health and Observability (health, readiness, metrics, logs, tracing), Deployment, an on-call Runbook section (common failures and fixes), and links. Add a table of contents. </task> <constraints> - Valid Markdown; include a fenced mermaid diagram of dependencies; code blocks tagged bash. - Document health/readiness/metrics endpoints and key alerts; include no real secrets. - Operationally useful, no filler. </constraints> <format> Return the complete README.md as one Markdown artifact, then note which runbook items belong in a dedicated RUNBOOK.md. </format>

You are an integrations engineer who documents webhook-based services. <context> I built a service that sends or receives webhooks and need a README explaining setup, payloads, and verification, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Service name and purpose: [NAME PLUS WHAT IT INTEGRATES] - Direction: [RECEIVES WEBHOOKS / SENDS WEBHOOKS / BOTH] - Events and payloads: [EVENT TYPES AND SAMPLE PAYLOAD] - Signature/verification: [HMAC HEADER, SECRET HANDLING] - Setup/config: [HOW TO REGISTER THE WEBHOOK] - Retry behavior: [RETRIES, TIMEOUTS] </inputs> <task> Write a README with: title and description, an Overview of the integration, Setup (registering the endpoint, configuring the secret), an Events reference table (event, when it fires, payload), sample JSON payloads per event, Signature Verification with a code example, Handling retries and idempotency, Testing (how to send a test event), Troubleshooting, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged json for payloads and a language for the verification snippet; use a placeholder signing secret. - Explain idempotency and retry handling; document every event; no filler. - Precise and security-aware. </constraints> <format> Return the complete README.md as one Markdown artifact, then note the verification pitfalls (raw body, timing-safe compare) worth calling out. </format>

You are an SDK author who writes onboarding docs for API client libraries. <context> I built a client SDK that wraps an API and need a README, returned as one ready-to-commit Markdown artifact. </context> <inputs> - SDK name and language: [NAME PLUS LANGUAGE] - Install command: [PACKAGE INSTALL] - Auth/init: [HOW TO CONSTRUCT THE CLIENT WITH A KEY] - Key methods/resources: [MAIN CALLS AND WHAT THEY DO] - Async / pagination behavior: [IF ANY] - License and repo: [LICENSE, URL] </inputs> <task> Write a README with: title and tagline, badges (package version, license, docs), description, Installation, Authentication and client initialization, Quick Start with a real call and response, a Usage section covering key resources/methods with examples, Error handling, Pagination/async patterns, Configuration (timeouts, retries), Contributing, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged for the SDK's language; read the API key from an env var placeholder. - Show idiomatic init, a real call, and error handling; document key methods; no filler. - Clear and example-driven. </constraints> <format> Return the complete README.md as one Markdown artifact, then note how to keep the examples tested so they never drift from the SDK. </format>

You are a developer-brand designer who crafts standout GitHub profile READMEs. <context> I want a GitHub profile README (the special username/username repo shown on my profile) returned as one ready-to-commit Markdown artifact. </context> <inputs> - Name and role: [NAME PLUS WHAT YOU DO] - Focus / current work: [WHAT YOU ARE BUILDING OR LEARNING] - Top skills / tech: [LANGUAGES, TOOLS] - Notable projects: [2-4 REPOS WITH ONE-LINERS] - Links: [WEBSITE, LINKEDIN, TWITTER/X, EMAIL] - Vibe: [MINIMAL, PLAYFUL, PROFESSIONAL] </inputs> <task> Write a profile README with: a friendly header intro, an About Me blurb, a What I am working on / learning section, a Tech Stack with shields.io skill badges, Featured Projects with links and one-line descriptions, a GitHub stats widget block (github-readme-stats), a top-languages card, a social/contact badge row, and an optional fun fact or quote. Match the requested vibe. </task> <constraints> - Valid Markdown; use shields.io badges and standard github-readme-stats image URLs with a [USERNAME] placeholder. - Keep it skimmable and personality-forward; no filler; center-align the header tastefully. - Set image alt text for accessibility. </constraints> <format> Return the complete README.md as one Markdown artifact, then note which dynamic widgets need a username swap and any that require a token. </format>

You are a designer-developer who documents portfolio projects to impress reviewers. <context> I want a README for a portfolio/showcase project that recruiters and peers will read, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Project name and what it is: [NAME PLUS PURPOSE] - Why you built it / your role: [MOTIVATION, ROLE] - Tech stack: [STACK] - Live demo and repo: [URLS] - Key features and challenges solved: [HIGHLIGHTS] - Screenshots available: [WHAT VIEWS] </inputs> <task> Write a README with: a header (title, one-line pitch, live-demo and repo badges), a hero screenshot placeholder, Overview (problem, solution, your role), Features, a Screenshots/Demo gallery with placeholders and captions, a Tech Stack with badges, a How It Is Built architecture note, Getting Started, Challenges and Learnings, and License. Add a table of contents. </task> <constraints> - Valid Markdown; screenshot placeholders with descriptive alt text and captions; badges for stack, demo, license. - Emphasize outcomes and decisions, not just features; no filler. - Polished and recruiter-friendly. </constraints> <format> Return the complete README.md as one Markdown artifact, then note where a short demo GIF has the most impact for reviewers. </format>

You are a curator who builds well-organized awesome-list READMEs. <context> I am creating an awesome-list repo (curated resources on a topic) and need a README that follows awesome-list conventions, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Topic: [WHAT THE LIST CURATES] - Categories: [SECTIONS TO ORGANIZE BY] - Seed entries: [KNOWN ITEMS WITH LINKS AND DESCRIPTIONS] - Audience: [WHO IT IS FOR] - Contribution rules: [WHAT QUALIFIES] </inputs> <task> Write an awesome-list README with: a title and the awesome badge, a one-line description, a Contents table of contents, well-organized category sections each with entries formatted as [Name](url) - Short description., a Contributing section pointing to contribution guidelines, a Related Lists section, and a License (typically CC0). Populate categories with the seed entries and sensible structure. </task> <constraints> - Valid Markdown following the awesome-list format exactly (entry pattern, logical order, the awesome badge). - Descriptions are one concise sentence, no marketing fluff; every entry is a real Markdown link with a [PLACEHOLDER] URL where unknown. - Clean and consistent. </constraints> <format> Return the complete README.md as one Markdown artifact, then note the awesome-lint rules to pass before submitting to the awesome index. </format>

You are a developer-branding specialist focused on dynamic README widgets. <context> I want a data-rich personal profile README packed with dynamic badges and stats widgets, returned as one ready-to-commit Markdown artifact. </context> <inputs> - GitHub username: [USERNAME] - Headline: [ONE-LINE WHO YOU ARE] - Skills to badge: [LANGUAGES, FRAMEWORKS, TOOLS] - Widgets wanted: [STATS, STREAK, TOP LANGS, TROPHIES, VISITOR COUNT] - Socials: [LINKS TO BADGE] - Theme: [E.G. DARK, RADICAL, TOKYONIGHT] </inputs> <task> Write a profile README with: a centered header with the headline and a typing-SVG or banner placeholder, a social badges row, a Connect With Me block, a Tech Stack badge wall grouped by category, a Dynamic Stats section (github-readme-stats card, streak stats, top languages, optional trophies and visitor counter) all themed consistently, and a footer. Apply the chosen theme across every widget. </task> <constraints> - Valid Markdown; use correct widget image URLs (github-readme-stats, streak-stats, github-profile-trophy) with [USERNAME] and matching theme params. - Apply one consistent theme; set image alt text; no filler. - Visually balanced and centered where appropriate. </constraints> <format> Return the complete README.md as one Markdown artifact, then list which widgets need a deployed instance or token and which work out of the box. </format>

You are a brand and community lead who writes GitHub organization profile READMEs. <context> I manage a GitHub organization and want a profile README (the .github repo's profile/README.md shown on the org page), returned as one ready-to-commit Markdown artifact. </context> <inputs> - Organization name and mission: [NAME PLUS WHAT IT DOES] - What you build / flagship products: [KEY REPOS OR PRODUCTS] - Who you are for: [USERS / CONTRIBUTORS] - Ways to get involved: [CONTRIBUTE, JOBS, COMMUNITY] - Links: [WEBSITE, DOCS, SOCIALS] - Vibe: [PROFESSIONAL, COMMUNITY-DRIVEN, ETC] </inputs> <task> Write an org profile README with: a centered header (logo placeholder, tagline, badges), a mission statement, a What We Build grid of flagship repos/products with one-liners and links, a Get Involved section (contribute, join, hire), a Community and Support block, org highlights or stats, a social links row, and a footer. Match the requested vibe. </task> <constraints> - Valid Markdown; logo placeholder with alt text; shields.io badges for key links. - Warm, on-brand, and scannable; link real repos with [PLACEHOLDER] URLs where unknown; no filler. - Balanced layout suitable for an org landing page. </constraints> <format> Return the complete README.md as one Markdown artifact, then note that it must live in the org's .github repo at profile/README.md to show on the org page. </format>

You are a boilerplate author who writes clear starter-kit documentation. <context> I built a starter template/boilerplate others will clone to bootstrap projects and need a README, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Template name and purpose: [NAME PLUS WHAT IT BOOTSTRAPS] - Stack and included tooling: [FRAMEWORK, LINTING, TESTING, CI] - How to use it: [USE-THIS-TEMPLATE / degit / clone] - What is included: [FOLDERS, PRECONFIGURED FEATURES] - First steps after cloning: [RENAME, ENV, INSTALL, RUN] - License and repo: [LICENSE, URL] </inputs> <task> Write a README with: title and tagline, badges (template, license, CI), a What's Included feature checklist, a Use This Template section (GitHub template button, degit, or clone), Getting Started (install, configure, run), a Project Structure tree, a Make It Yours checklist (rename, update metadata, replace placeholders), Included Scripts, Deployment, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged bash; include the exact use-this-template and degit commands. - Provide a post-clone checklist so users know what to change first; no filler. - Skimmable and action-oriented. </constraints> <format> Return the complete README.md as one Markdown artifact, then note which lines new users forget to change and how to flag them. </format>

You are a build engineer who documents monorepos for contributors. <context> I maintain a monorepo with multiple packages/apps and need a README explaining the layout and workflows, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Repo name and purpose: [NAME PLUS WHAT IT CONTAINS] - Tooling: [E.G. TURBOREPO, NX, PNPM WORKSPACES] - Packages/apps: [LIST WITH WHAT EACH IS] - Common tasks: [BUILD, DEV, TEST, LINT ACROSS PACKAGES] - Versioning/release: [E.G. CHANGESETS] - License: [LICENSE] </inputs> <task> Write a README with: title and overview, an Apps and Packages table (path, name, description), a Repository Structure tree, Prerequisites, Getting Started (install at root), Common Commands (run across all, filter to one package), how to add a new package, Versioning and Releases, a CI overview, Contributing, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged bash showing workspace-aware commands (filtering to a package). - Accurately reflect the chosen monorepo tool's command syntax; document every package; no filler. - Clear structure and scannable. </constraints> <format> Return the complete README.md as one Markdown artifact, then note which per-package details belong in each package's own README versus the root. </format>

You are a developer-onboarding writer for reusable GitHub template repositories. <context> I created a GitHub template repository and want a README that guides first-time users the moment they generate a repo from it, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Template name and what it produces: [NAME PLUS OUTCOME] - Target user: [WHO USES IT] - Setup steps after generating: [ORDERED STEPS] - Configurable placeholders: [WHAT TO REPLACE] - Included CI/automation: [WORKFLOWS, HOOKS] - License: [LICENSE] </inputs> <task> Write a README with: a header noting Generated From a Template - Start Here, a numbered First Do These Steps checklist (replace placeholders, set secrets, update this README), What's Included, Configuration, Included Automation (CI, dependabot, etc.), how to keep it updated, a Delete This Section Once Set Up note, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged bash; the first-run checklist is unmissable and ordered. - Include a clearly marked block for users to delete after setup; no filler. - Action-first and beginner-friendly. </constraints> <format> Return the complete README.md as one Markdown artifact, then note how to structure the delete-after-setup section so it is obvious but not embarrassing if left in. </format>

You are a cloud infrastructure engineer who documents Terraform modules. <context> I publish a reusable Terraform module and need a README that follows Terraform Registry conventions, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Module name and what it provisions: [NAME PLUS RESOURCES] - Provider and versions: [AWS/GCP/AZURE, TERRAFORM VERSION] - Inputs (variables): [KEY VARIABLES, TYPES, DEFAULTS] - Outputs: [WHAT IT RETURNS] - Example usage: [A TYPICAL MODULE BLOCK] - License and repo: [LICENSE, URL] </inputs> <task> Write a README with: title and description, badges (Terraform Registry, license), a Usage section with a copy-paste module block, a Requirements table (Terraform and provider versions), a Providers table, an Inputs table (name, description, type, default, required), an Outputs table, one or more Examples, Notes/caveats, and License. Add a table of contents. </task> <constraints> - Valid Markdown; code blocks tagged hcl; Inputs/Outputs/Requirements formatted as terraform-docs-style tables. - Document every variable and output with type and default; use a realistic example block; no filler. - Registry-compatible structure. </constraints> <format> Return the complete README.md as one Markdown artifact, then note how terraform-docs can auto-generate the Inputs and Outputs tables from your code. </format>

You are a CI/CD engineer who documents GitHub Actions for the marketplace. <context> I built a GitHub Action (or reusable workflow) and need a README suitable for the GitHub Marketplace, returned as one ready-to-commit Markdown artifact. </context> <inputs> - Action name and what it does: [NAME PLUS PURPOSE] - Inputs: [INPUT NAMES, DESCRIPTIONS, DEFAULTS, REQUIRED] - Outputs: [OUTPUT NAMES AND MEANINGS] - Example workflow usage: [A STEP THAT USES IT] - Runs on / requirements: [PERMISSIONS, RUNNER, SECRETS] - License and repo: [LICENSE, URL] </inputs> <task> Write a README with: title and tagline, badges (marketplace, release, license), description, a Usage section with a complete example workflow YAML that uses the action, an Inputs table (name, description, required, default), an Outputs table, required Permissions/secrets, Advanced examples (matrix, conditional), a Versioning note (pin to a major tag), Contributing, and License. Add a table of contents. </task> <constraints> - Valid Markdown; the example workflow is valid, copy-paste YAML fenced as yaml; reference the action as owner/repo@v1. - Document every input and output; note required permissions and secrets; no filler. - Marketplace-ready and precise. </constraints> <format> Return the complete README.md as one Markdown artifact, then note the branding and versioning steps needed to list it on the GitHub Marketplace. </format>