AI Readme

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:

1. State each reader belief as a numbered decision.
2. Give two to four mutually exclusive lettered choices with concrete effects.
3. Recommend one choice for each decision.
4. 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:

1. 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.
2. 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.
3. 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:

1. Read the current README and linked documentation without assuming either is current.
2. Inspect build and dependency manifests, public interfaces, CLI help, examples, tests, configuration, release metadata, and recent relevant history.
3. Identify the project's real status: proposal, prototype, experimental, supported, production-used, deprecated, or unknown.
4. Find the shortest safe first-success path. Run it when reasonably cheap.
5. Capture the actual prerequisite, command, output, duration, environment, and cleanup needed to reproduce it.
6. 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:

1. What is this project?
2. Who is it for, and what can they do with it?
3. What is its current status or most important limitation?
4. 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.