Skip to content

Technical Reference

A stable lookup document designed for repeated return visits. Optimized for scanning over reading. The reader arrives with a specific question; the format serves that question.

Technical reference is not written to be read start to finish. It is written to be consulted. The reader arrives with a specific question - what are the parameters for this function? what does this error mean? what are the valid values for this field? - and the reference document should answer that question in the fewest possible steps. Every structural decision in a technical reference document serves the returning reader, not the first-time reader. Headers are navigation. Tables beat prose for structured data. Examples beat explanation.

The authority of a technical reference comes from its precision and stability. Precision means every statement is accurate and complete for its scope - not approximately right, not rounded for readability. Stability means the document changes only when the underlying system changes, not to improve the prose. A reader who bookmarks a section of a reference document is trusting that section to remain findable and accurate. That trust is the contract the format creates.

Technical reference is distinct from tutorials and how-to guides. A tutorial walks a newcomer through a concept; a how-to guide walks a practitioner through a task. A reference document assumes the reader already knows what they want to do and needs the exact specification to do it. Mixing tutorial prose into a reference document - adding context, motivation, and explanation that the experienced reader will skip - is the most common way reference documents fail the readers who rely on them most.

# [Component / Function / Concept Name]
[One sentence: what this is and what it does. No background.]
## Syntax / Signature
```
[Exact syntax or function signature]
```
## Parameters / Fields / Options
| Name | Type | Required | Description |
|------|------|----------|-------------|
| [name] | [type] | [yes/no] | [concise description] |
## Returns / Output
[What is returned or produced - type and structure]
## Examples
```[language]
[Working minimal example]
```
[Optional: second example showing edge case or variation]
## Notes / Constraints
- [Important limitation, gotcha, or version note]
## See Also
- [Related component or concept] - [link or cross-reference]

Technical reference belongs on any API, library, CLI tool, or configuration schema that practitioners consult repeatedly. Use it when the reader is experienced with the domain and arrives with a specific question, when precision and completeness matter more than approachability, and when the document needs to stay stable and findable across software versions.

Reference format is wrong for introducing someone to a concept for the first time, guiding a practitioner step by step through a task, or explaining the reasoning behind a design decision. It is also wrong for non-technical stakeholders who need context, and for one-time documentation that will not be consulted again.

technical-writer, pragmatic-architect, matter-of-fact, instructional, diataxis-explanation

diataxis-explanation: A Diataxis explanation document teaches conceptual understanding - it is oriented toward learning and can include motivation, analogy, and context. A technical reference document is oriented toward lookup - it assumes understanding and prioritizes precision and scannability over explanation.

procedural: A how-to guide walks a practitioner through a specific task with sequential steps toward a defined goal. A technical reference document is a stable specification that a practitioner consults while doing a task - it does not guide; it answers.

user-manual: A technical reference is a precise specification of inputs, outputs, and syntax for a developer artifact (API, library, CLI, config schema), organized by signature, parameters, and returns. A user manual is whole-product, end-user task and feature coverage with numbered procedural steps. The discriminator: if the unit of organization is a function, endpoint, or field, it is a technical reference; if it is a user-facing feature or task with steps, it is a user manual.

  • Organized for lookup, with headers as navigation rather than as a reading order
  • Each entry leads with a one-sentence definition and no background
  • Tables for structured data - parameters, fields, options - instead of prose
  • At least one working code example per entry
  • Constraints and gotchas stated as explicit notes, not buried as caveats
  • Precise and stable - complete for its scope, changing only when the system changes
  • Mixing in tutorial prose - motivation, analogy, and step-by-step context - That is the confusable diataxis-explanation aimed at learning; a reference assumes understanding and the explanatory padding is exactly what the experienced reader skips.
  • Walking the reader through a task in sequential steps toward a goal - That is a how-to guide; a reference does not guide, it answers a specific question for someone already mid-task.
  • Optimizing the opening as a narrative hook and onboarding pitch - That is the confusable readme, organized for the first-time visitor; a reference serves the returning reader who arrives knowing what they want.
  • Grows so exhaustive it becomes unnavigable - completeness is pursued until the document is a sprawl no reader can scan to the answer - Precision serves the returning reader’s specific question; split or cross-link sprawling sections so an answer is still reachable in the fewest steps.
  • Over-stabilizes into staleness - the stability contract is held so rigidly that the reference no longer tracks the system it documents - Stability means changing when the underlying system changes, not refusing to change; update the spec the moment the behavior it describes does.
Write as technical reference documentation. Optimize for scanning, not reading start to finish.
Every section should be findable via its header. Use tables for structured data (parameters,
options, fields). Lead each entry with a one-sentence definition - no background or motivation.
Include at least one working code example. State constraints and limitations as explicit notes,
not as caveats buried in prose. Do not explain why the system works this way - state precisely
how it works. Assume the reader already knows what they want to do and needs the specification
to do it.

See the Technical Reference template.

Technical Writer, Pragmatic Architect, Matter of Fact, Instructional, Diataxis Explanation

Columnist, Pastoral, Warm, Playful, Narrative Case Study

README, Diataxis Explanation, Procedural, User Manual

Applies to: eng-platform team (11 engineers, 4 timezones) Channel: #team-standup Status: Trial - effective 2026-05-19 through 2026-06-19 Owner: Maya Chen (EM Platform)

Post once per workday in #team-standup. Copy the pinned message and fill in.

*Shipped*
- <item>
*In progress*
- <item>
*Blocked / at risk*
- <item, with @mention of who can resolve>

If a section is empty, write - none. Do not omit the heading.

FieldIncludesExcludes
ShippedWork merged, deployed, or otherwise complete in the last 24hWork in review; planning; meetings attended
In progressCurrent focus through your next workdayBacklog; speculative work; “thinking about X”
Blocked / at riskAnything where someone else’s input changes your day, plus things trending lateVents; status with no ask; non-actionable FYI

A blocker requires three things: what is blocked, who can unblock, when you need it. @user, can you review #4412 today? is a blocker. Reviews are slow. is not.

RuleValue
Post by10:00 your local time
On-call triage by09:00 Pacific
Blocker first-response SLA30 min during business hours of the resolver
Backfill window for missed postSame day, until 17:00 local

If you will not be at a keyboard before 10am local (early meeting, school run, travel), post the previous evening with a tomorrow: prefix on In progress.

day 0 (post) - @mention the resolver in your update
+4 business hours - on-call engineer nudges the resolver in-channel
+1 business day - on-call escalates to the resolver's manager
+2 business days - escalates to Maya

Mark a blocker resolved by editing your original post or replying in-thread with resolved: and the outcome. Do not delete the line - the searchable record is part of the point.

Post one line on your last working day: OOO <date range>, back <date>. Coverage: @user. Do not post during PTO.

On-call engineer posts as normal plus a fourth line: *On-call:* responding to pages, async post may be late. On-call days do not count against participation metrics.

Post on the days you work. On a public holiday for your locale, skip without notice.

Post anyway. Shipped: none. In progress: <thing>. Blocked: none. Silence is harder to interpret than a thin update.

Post as normal. The five minutes it takes is the price of the team knowing where you are. If you genuinely cannot context-switch, post the night before.

If a blocker involves a person issue or anything confidential, post Blocked: DMing @maya and handle in DM. Do not name the person in-channel.

Pulled weekly by Priya from #team-standup history.

MetricDefinitionTarget
Participation ratePosts / engineers / workday>= 9/11
Blocker response timeTime from post to first substantive reply< 30 min business hours
Stale blockersBlockers open > 2 business days0
  • Trial proposal: docs/proposals/async-standup-trial.md
  • Thursday working session charter: docs/eng-platform/thursday-session.md
  • ADR-0014: Adopt async-first standup format
  • Day-15 pulse and day-30 review: calendar invites from Maya