编写有效的使用示例

Developers learn a component fastest by seeing it used. A great usage example often replaces paragraphs of prose.

This lesson focuses on writing examples that teach, not just decorate, your documentation.

Lead with the example 90% of users need - the simplest, most typical usage.

Edge cases and advanced configurations come later. If the first example is complex, you scare people away before they start.

Examples should be copy-paste runnable, not pseudo-code with ... placeholders.

A developer should be able to drop your snippet in and see it work. The example below is complete and self-contained.

The gold standard is a live playground where users edit props and see results instantly.

Tools like Storybook controls let people experiment without leaving the docs. Interactivity turns reading into understanding.

Show correct usage beside incorrect usage. A side-by-side Do / Don't teaches judgment, not just syntax.

• Do: use one primary button per view.
• Don't: stack three primary buttons competing for attention.

These pairs prevent the most common misuses.

An example shows how; a short note explains why. Pair each guideline with its reasoning.

When people understand the rationale, they apply the rule correctly in situations you never documented.

Use realistic content, not Lorem ipsum and foo. Show a real form, a real error message, a real card with an actual product.

Realistic examples reveal spacing, overflow, and wrapping issues that placeholder text hides.

Components have states: default, hover, disabled, loading, error. Document each with an example.

If you only show the default state, users will not know the disabled style exists or how to trigger the loading spinner.

Stale examples are worse than none - they teach outdated patterns. Tie examples to the live component so they break when the API changes.

Auto-generated examples from the source code stay accurate by definition.

Model good behavior. If your examples skip labels or use poor contrast, people copy those mistakes.

Every example should be the accessible version, so copy-pasting spreads good practice instead of bugs.

When examples are complete, current, and realistic, developers trust the documentation and stop pinging you with questions.

Well-crafted examples are the highest-leverage documentation you can write.

You learned to write usage examples that teach:

• Show the common case first, then edge cases.
• Make snippets copy-ready and ideally live/editable.
• Use do/don't pairs and explain the why.
• Use realistic content, cover states, and keep examples in sync.

Great examples are the most-used part of any design system doc.