AI README
Write a repository-native explanation that earns trust by working. Lead with
what the project is, who it helps, and the shortest verified path to an
observable result. Then reveal the mechanism, tradeoffs, diagnostics, and
internals at the reader's pace.
Combine two complementary habits:
- use an executable, progressive spine: one stable example, working commands,
expected results, controlled variants, visible failure modes, and a reference
path when correctness or quality can vary;
- write like a public technical notebook: begin from a real task or curiosity,
show the decisive artifact near the claim, explain what happened in ordinary
language, preserve surprise and uncertainty, and stop when the reader's job
is complete.
Apply swyx-writing as the shared voice and editing layer. For substantial
public README work, read its
technical-writer influences.
Apply research-grounded-writing when external claims or comparisons need
support beyond the repository.
Choose the README's job
Identify the primary job before choosing sections:
- Project landing page: help a newcomer understand, evaluate, and try the
project.
- CLI or library guide: get an adopter from installation to one useful call,
then document common recipes, errors, and the deeper reference.
- Experiment or research repository: state the question, setup, runnable
experiment, observed result, uncertainty, and reproduction boundary.
- Executable engineering notebook: preserve a working reference path,
controlled optimizations, benchmarks, diagnostics, and failed trials beside
the code they describe.
- Contributor guide: explain architecture, invariants, ownership, tests,
development commands, and safe extension points after the user path is clear.
A README may serve several jobs, but choose one primary reader path. Split a
large implementation ledger, benchmark history, API reference, or contributor
manual into linked documents when keeping it inline would bury first use.
Keep the front door small
Default to a focused project README of roughly 600–1,500 words. Treat that
range as an editing signal, not a quota. A new evaluator usually needs one
plain definition, honest status, one verified first result, the minimum model,
the limitations that affect adoption, and a short route into deeper material.
Do not draft complete evaluator, operator, researcher, and contributor paths in
the same file. When the chosen reader is an evaluator or adopter, route adapter
catalogs, backup and recovery recipes, full protocol status, security details,
crate maps, and contributor commands to linked documentation unless one of
them changes the adoption decision.
Allow a longer README when its primary job is genuinely an executable
engineering notebook and the reader must compare modes, reproduce experiments,
or diagnose observable failures beside the code. Length is earned by a
progressive recurring example, not by the number of facts available.
Align with the reader
Before a substantial creation or rewrite, determine what the skill user expects
the reader to be, know, and want. If those expectations are not
already explicit, ask one compact batch using the align-me shape:
- State each reader belief as a numbered decision.
- Give two to four mutually exclusive lettered choices with concrete effects.
- Recommend one choice for each decision.
- End with
Reply approve all to accept 1A, 2B, 3A, or give changes such as 2C. Then wait.
Tailor the choices to the repository. A useful default is:
- Who is the primary reader?
- A. New evaluator or adopter — optimize for understanding and first success.
- B. Operator or integrator — optimize for setup, behavior, and failure recovery.
- C. Contributor or researcher — optimize for internals and extension.
- What may they already know?
- A. General software concepts only — define the domain and every project noun.
- B. The domain, but not this project — explain the project's distinctive model.
- C. This ecosystem — move faster, but still define repository-specific terms.
- What should they accomplish?
- A. Decide whether the project fits and obtain one visible result.
- B. Reproduce or integrate a real workflow.
- C. Understand, debug, benchmark, or extend the implementation.
Recommend the new evaluator, domain-but-not-project, and first-visible-result
path unless the repository clearly serves specialists. Do not ask questions the
user has already answered. For a small correction, state the inferred reader
briefly and proceed.
Establish the truth
Inspect before writing:
- Read the current README and linked documentation without assuming either is
current.
- Inspect build and dependency manifests, public interfaces, CLI help, examples, tests,
configuration, release metadata, and recent relevant history.
- Identify the project's real status: proposal, prototype, experimental,
supported, production-used, deprecated, or unknown.
- Find the shortest safe first-success path. Run it when reasonably cheap.
- Capture the actual prerequisite, command, output, duration, environment, and
cleanup needed to reproduce it.
- Identify the reference or oracle path when faster, approximate, cached, or
aggressive modes can change correctness, quality, or behavior.
Do not invent commands, output, support promises, performance, compatibility,
or project intent. Mark a path as unverified when it cannot be run. Preserve
useful failed attempts and reversals when they prevent readers from repeating a
mistake.
Address the elephant in the first screen
The opening viewport must answer, in ordinary language:
- What is this project?
- Who is it for, and what can they do with it?
- What is its current status or most important limitation?
- What is the shortest path to seeing it work?
Name the central thing directly. If the repository is a Program Database, say
Program Database; do not hide it behind a slogan such as Record every thread. A memorable line may sharpen the explanation, but it cannot replace
the subject, status, or reader promise.
Do not put badge walls, architecture inventories, project history, generated
hero art, or a table of contents ahead of the definition and first useful path.
Build an executable progression
Prefer this sequence, adapting it to the reader's job:
- Inspect or install. State prerequisites and provide the smallest safe
setup.
- Produce one visible result. Use one canonical fixture, request, file,
prompt, or input that can recur through the README.
- Interpret it. Tell the reader what happened and what to notice.
- Explain the minimum model. Reduce the mechanism to the fewest concrete
parts that predict the observed behavior.
- Change one control at a time. Add realistic recipes or variants and state
their consequence.
- Show the boundary. Describe limitations and failures through observable
symptoms rather than
quality regressed or may not work.
- Go deeper only on demand. Move into architecture, API details,
performance, diagnostics, and contribution after successful use is clear.
Stop when the primary reader can make the next decision. Link the secondary
path instead of completing it inline.
Before every command or code excerpt, state the question it answers. After it,
show or summarize the expected result and explain why it matters. Do not make a
reader reverse-engineer a tutorial from a command inventory.
When tradeoffs matter, use consistent language such as reference,
validated default, and aggressive/experimental. State what may change,
the measured benefit, the test boundary, and how to restore the reference path.
Introduce a second fixture only to test whether the lesson generalizes.
Use visuals only when they teach
Use an authentic screenshot, compact diagram, measured comparison, or short
annotated output when it lets the reader understand or verify something faster.
Keep the first success available as text and commands. Never use generated
pixels as evidence or let a decorative image displace the definition and
quickstart.
Review in three passes
Run the three passes in swyx-writing. During the developmental pass, also
confirm one primary reader path, an explicit project definition, progressive
order, and a clear cut line between README material and linked detail. During
the explanatory pass, check prerequisites, expected results, commands, and
whether one example carries the mechanism. Justify a front-door README that
grows beyond roughly 1,500 words.
Then run a context-isolated cold-reader review for every substantial README.
Give a fresh subagent only the approved reader beliefs and the rendered or
source README—not the repository, task thread, intended answers, suspected
problems, or this diagnosis. Ask it to:
- identify the project, intended reader, status, and first useful outcome;
- predict what the first command will do;
- explain the central mechanism in plain language;
- list undefined terms, missing prerequisites, causal gaps, and promises it
could not verify;
- name the point where it would stop reading or become lost.
Revise until the cold reader's account matches the intended reader contract.
Do not coach the reviewer toward the desired answer.
Verify the repository handoff
- Run the documented first-success path and representative tests when safe and
reasonably cheap.
- Check commands, expected output, links, anchors, code wrapping, narrow-screen
rendering, and copied snippets.
- Keep installation, usage, reference behavior, and contribution commands
consistent with the code at the inspected revision.
- Report which paths were executed, which were read from existing evidence,
and which remain unverified.
- Edit only repository documentation and supporting assets unless the user also
asked to change product behavior.
1---2name: ai-readme3description: Create or substantially revise repository README files that help a specific reader understand a technical project, reach a verified first result, and progress into realistic use, evaluation, debugging, or contribution. Use for project landing READMEs, CLI and library quickstarts, experimental or research repositories, executable engineering notebooks, and contributor-facing repository guides when an agent should reconstruct behavior from code, tests, commands, examples, and history rather than write generic documentation.4metadata:5 source: https://skillmd.com/skills/swyxio/ai-readme6---78# AI README910Write a repository-native explanation that earns trust by working. Lead with11what the project is, who it helps, and the shortest verified path to an12observable result. Then reveal the mechanism, tradeoffs, diagnostics, and13internals at the reader's pace.1415Combine two complementary habits:1617- use an executable, progressive spine: one stable example, working commands,18 expected results, controlled variants, visible failure modes, and a reference19 path when correctness or quality can vary;20- write like a public technical notebook: begin from a real task or curiosity,21 show the decisive artifact near the claim, explain what happened in ordinary22 language, preserve surprise and uncertainty, and stop when the reader's job23 is complete.2425Apply `swyx-writing` as the shared voice and editing layer. For substantial26public README work, read its27[technical-writer influences](../swyx-writing/references/technical-writer-influences.md).28Apply `research-grounded-writing` when external claims or comparisons need29support beyond the repository.3031## Choose the README's job3233Identify the primary job before choosing sections:3435- **Project landing page:** help a newcomer understand, evaluate, and try the36 project.37- **CLI or library guide:** get an adopter from installation to one useful call,38 then document common recipes, errors, and the deeper reference.39- **Experiment or research repository:** state the question, setup, runnable40 experiment, observed result, uncertainty, and reproduction boundary.41- **Executable engineering notebook:** preserve a working reference path,42 controlled optimizations, benchmarks, diagnostics, and failed trials beside43 the code they describe.44- **Contributor guide:** explain architecture, invariants, ownership, tests,45 development commands, and safe extension points after the user path is clear.4647A README may serve several jobs, but choose one primary reader path. Split a48large implementation ledger, benchmark history, API reference, or contributor49manual into linked documents when keeping it inline would bury first use.5051## Keep the front door small5253Default to a focused project README of roughly 600–1,500 words. Treat that54range as an editing signal, not a quota. A new evaluator usually needs one55plain definition, honest status, one verified first result, the minimum model,56the limitations that affect adoption, and a short route into deeper material.5758Do not draft complete evaluator, operator, researcher, and contributor paths in59the same file. When the chosen reader is an evaluator or adopter, route adapter60catalogs, backup and recovery recipes, full protocol status, security details,61crate maps, and contributor commands to linked documentation unless one of62them changes the adoption decision.6364Allow a longer README when its primary job is genuinely an executable65engineering notebook and the reader must compare modes, reproduce experiments,66or diagnose observable failures beside the code. Length is earned by a67progressive recurring example, not by the number of facts available.6869## Align with the reader7071Before a substantial creation or rewrite, determine what the skill user expects72the reader to **be**, **know**, and **want**. If those expectations are not73already explicit, ask one compact batch using the `align-me` shape:74751. State each reader belief as a numbered decision.762. Give two to four mutually exclusive lettered choices with concrete effects.773. Recommend one choice for each decision.784. End with `Reply approve all to accept 1A, 2B, 3A, or give changes such as79 2C.` Then wait.8081Tailor the choices to the repository. A useful default is:82831. **Who is the primary reader?**84 - A. New evaluator or adopter — optimize for understanding and first success.85 - B. Operator or integrator — optimize for setup, behavior, and failure recovery.86 - C. Contributor or researcher — optimize for internals and extension.872. **What may they already know?**88 - A. General software concepts only — define the domain and every project noun.89 - B. The domain, but not this project — explain the project's distinctive model.90 - C. This ecosystem — move faster, but still define repository-specific terms.913. **What should they accomplish?**92 - A. Decide whether the project fits and obtain one visible result.93 - B. Reproduce or integrate a real workflow.94 - C. Understand, debug, benchmark, or extend the implementation.9596Recommend the new evaluator, domain-but-not-project, and first-visible-result97path unless the repository clearly serves specialists. Do not ask questions the98user has already answered. For a small correction, state the inferred reader99briefly and proceed.100101## Establish the truth102103Inspect before writing:1041051. Read the current README and linked documentation without assuming either is106 current.1072. Inspect build and dependency manifests, public interfaces, CLI help, examples, tests,108 configuration, release metadata, and recent relevant history.1093. Identify the project's real status: proposal, prototype, experimental,110 supported, production-used, deprecated, or unknown.1114. Find the shortest safe first-success path. Run it when reasonably cheap.1125. Capture the actual prerequisite, command, output, duration, environment, and113 cleanup needed to reproduce it.1146. Identify the reference or oracle path when faster, approximate, cached, or115 aggressive modes can change correctness, quality, or behavior.116117Do not invent commands, output, support promises, performance, compatibility,118or project intent. Mark a path as unverified when it cannot be run. Preserve119useful failed attempts and reversals when they prevent readers from repeating a120mistake.121122## Address the elephant in the first screen123124The opening viewport must answer, in ordinary language:1251261. What is this project?1272. Who is it for, and what can they do with it?1283. What is its current status or most important limitation?1294. What is the shortest path to seeing it work?130131Name the central thing directly. If the repository is a Program Database, say132`Program Database`; do not hide it behind a slogan such as `Record every133thread`. A memorable line may sharpen the explanation, but it cannot replace134the subject, status, or reader promise.135136Do not put badge walls, architecture inventories, project history, generated137hero art, or a table of contents ahead of the definition and first useful path.138139## Build an executable progression140141Prefer this sequence, adapting it to the reader's job:1421431. **Inspect or install.** State prerequisites and provide the smallest safe144 setup.1452. **Produce one visible result.** Use one canonical fixture, request, file,146 prompt, or input that can recur through the README.1473. **Interpret it.** Tell the reader what happened and what to notice.1484. **Explain the minimum model.** Reduce the mechanism to the fewest concrete149 parts that predict the observed behavior.1505. **Change one control at a time.** Add realistic recipes or variants and state151 their consequence.1526. **Show the boundary.** Describe limitations and failures through observable153 symptoms rather than `quality regressed` or `may not work`.1547. **Go deeper only on demand.** Move into architecture, API details,155 performance, diagnostics, and contribution after successful use is clear.156157Stop when the primary reader can make the next decision. Link the secondary158path instead of completing it inline.159160Before every command or code excerpt, state the question it answers. After it,161show or summarize the expected result and explain why it matters. Do not make a162reader reverse-engineer a tutorial from a command inventory.163164When tradeoffs matter, use consistent language such as **reference**,165**validated default**, and **aggressive/experimental**. State what may change,166the measured benefit, the test boundary, and how to restore the reference path.167Introduce a second fixture only to test whether the lesson generalizes.168169## Use visuals only when they teach170171Use an authentic screenshot, compact diagram, measured comparison, or short172annotated output when it lets the reader understand or verify something faster.173Keep the first success available as text and commands. Never use generated174pixels as evidence or let a decorative image displace the definition and175quickstart.176177## Review in three passes178179Run the three passes in `swyx-writing`. During the developmental pass, also180confirm one primary reader path, an explicit project definition, progressive181order, and a clear cut line between README material and linked detail. During182the explanatory pass, check prerequisites, expected results, commands, and183whether one example carries the mechanism. Justify a front-door README that184grows beyond roughly 1,500 words.185186Then run a context-isolated cold-reader review for every substantial README.187Give a fresh subagent only the approved reader beliefs and the rendered or188source README—not the repository, task thread, intended answers, suspected189problems, or this diagnosis. Ask it to:190191- identify the project, intended reader, status, and first useful outcome;192- predict what the first command will do;193- explain the central mechanism in plain language;194- list undefined terms, missing prerequisites, causal gaps, and promises it195 could not verify;196- name the point where it would stop reading or become lost.197198Revise until the cold reader's account matches the intended reader contract.199Do not coach the reviewer toward the desired answer.200201## Verify the repository handoff202203- Run the documented first-success path and representative tests when safe and204 reasonably cheap.205- Check commands, expected output, links, anchors, code wrapping, narrow-screen206 rendering, and copied snippets.207- Keep installation, usage, reference behavior, and contribution commands208 consistent with the code at the inspected revision.209- Report which paths were executed, which were read from existing evidence,210 and which remain unverified.211- Edit only repository documentation and supporting assets unless the user also212 asked to change product behavior.