Can ChatGPT write error code documentation?

For table structure after you paste real codes from your API spec, logged examples, and fixes that worked in support tickets. Do not let the model invent codes, statuses, or retry rules your server does not implement.

What belongs in every error code entry?

Code string, HTTP status, plain-language cause, copy-paste fix (curl or SDK snippet), and when to contact support. Adjectives do not replace the fix.

Should I humanize JSON error response bodies?

No. Humanize cause and fix prose. Response JSON must match what your server returns today—same rule as API docs.

How is this different from general API documentation?

API docs teach happy path. Error docs are the contract when things fail. Start with our API docs guide for auth and first working call.

Humanize Error Code Docs (Fix Steps, Not Essays)

Integrators live in failure mode. ChatGPT error documentation gives them literary definitions: three paragraphs on what "unauthorized" means philosophically, no curl that reproduces the 401, and retry advice that contradicts your rate limiter.

Support tickets follow. Churn follows. The fix is not prettier prose—it is code → cause → copy-paste fix on one screen.

Human Writes is the voice pass after engineering locks codes and fixes. It does not invent ERR_PAYMENT_402 or tell users to retry when your API returns non-retryable 400.

What AI error docs get wrong

Failure	Integrator pays
Invented error codes	Wrong grep in logs
Wrong HTTP status	Bad client handling
"Contact support" with no fix path	Ticket flood
Essay definitions	Skim past, still broken
Retry advice that ignores idempotency	Double charges

Users forgive overview fluff on the happy path. They do not forgive wrong fixes on the error path.

Error entry fact block (lock first)

For each code, fill from server source and a real log line:

Field	Example (your real values)
Code	`humanize/quota_exceeded`
HTTP status	429
When it happens	Daily word cap hit mid-request
Cause (one sentence)	Account over daily limit
Fix (copy-paste)	curl or SDK snippet that succeeds
Do not	Retry without backoff / wrong key
Support?	When to open ticket + required IDs

Prompt: "Build error table rows from this data only. Each row: code, status, cause, fix. No new codes."

Error docs vs API overview vs runbook

Artifact	Reader state	Success test
Error code doc	Broken integration	Fix works in 5 min
API overview	Learning product	First 200 OK
Runbook	On-call engineer	Incident resolved
Changelog	Returning integrator	Knows what changed

Cross-link from API auth page to error table—see API docs guide for the auth + one working call baseline.

Row template integrators scan

Column	Humanize?	Notes
Code	No	Exact string
Status	No	Numeric
Cause	Yes	Plain language
Fix	Light	Keep commands exact
Example response	No	From real server
Related	Light	Link other codes

Humanize cause paragraphs. Never humanize JSON keys or status numbers.

Before and after

AI error entry:

The unauthorized error indicates that authentication credentials provided with the request may be invalid or insufficient. Users should ensure they are following best practices for secure API access and verify their configuration meets our documentation standards.

After fact block + one humanize pass:

humanize/unauthorized — HTTP 401
Cause: Missing or wrong API key in the Authorization header.
Fix:
curl -sS -X POST "https://api.humanwrites.example/v1/humanize" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"test","purpose":"General"}'
Do not retry with the same rejected key—rotate in the dashboard first. If the key is correct and you still see 401, open a ticket with request id from the response body.

Second version has code, status, cause, and copy-paste fix.

Workflow

Export codes from OpenAPI / proto / server enum—single source of truth.
Pull three real support tickets per top code; extract fixes that worked.
Build the table; no model until every fix was tested in staging.
One ChatGPT pass for consistent row order if helpful; diff against export.
One Human Writes pass on cause prose only.
Link each error from the API auth page and from SDK exception docs.
Changelog any new code the day it ships—pair with developer changelog.

For incident narrative after codes fire in production, see incident postmortems—different artifact, same rule: facts before polish.

What not to do

Publish codes the server never returns.
Humanize until curl flags or header names change.
Tell users to "retry aggressively" on non-idempotent POSTs.
Write essay intros before the fix table.
Paste production logs with customer keys into a consumer chatbot.

Bottom line

Error code docs win when integrators can grep the code and run the fix. Lock codes and copy-paste steps from engineering, humanize cause prose once, and keep JSON honest.

Paste stiff error copy on Human Writes after every command matches a curl that succeeded in staging—not from memory.