Docs updates

Docs that don't fall behind the code.

When a release adds something your docs don't cover, DevRelay drafts the missing section as a Markdown diff: a heading, a short explanation and the code example from the change. You review it and apply it.

Start free See pricing
fluxdb/go-sdk · Release v2.8.0GroundingRelease statusBrand
docs/go/stream.mdx
@@ -0,0 +1,21 @@
+## Add Stream() for incremental query results
+
+Go SDK v2.8.0 adds Stream() for incremental query results. Stream() returns *Rows backed by a server-side cursor.
+
+```go
+rows, err := db.Stream(ctx, "SELECT * FROM events")
+if err != nil {
+ return err
+}
+defer rows.Close()
+for rows.Next() {
+ var e Event
+ if err := rows.Scan(&e.ID, &e.Payload); err != nil {
+ return err
+ }
+}
+return rows.Err()
+```
+
+Rows are yielded as the server produces them, so large result sets no longer need to be buffered in memory.
+Reads pause when the consumer is slower than the network (backpressure).
Unedited draft · FluxDB demo workspace
Only when needed
no patch if a guide exists
Real examples
code from the pull request
Markdown diff
you review and apply
Why docs drift

The code changed on Tuesday. The docs still describe last quarter.

Docs rarely go wrong in one big mistake. They fall behind one release at a time.

Docs aren't in the pull request

The change gets reviewed, merged and released. The docs page that should mention it isn't part of the diff, so nobody notices it's missing.

Users ask for what exists

Issues and support threads ask for features you shipped months ago, because the docs never said so.

Examples stop working

A signature changes, the guide still shows the old call, and the first thing a new user runs is an error.

How it works

From release to the docs section it needs.

DevRelay only drafts a docs update when the docs are actually missing something.

01

Reads your docs

Add your docs site as a knowledge source and DevRelay crawls it, splits it into passages and indexes them. That index is what it checks each release against, and what it quotes when it writes.
Docs already contain a guide        → no patch
Docs lack a section for Stream()    → docs_patch
02

Asks whether the docs already cover it

For every released change, the classifier checks the change against your docs. If a guide already covers it, there's no patch. If the change adds public API your docs don't mention, a docs update goes on the plan.
03

Drafts the missing section

A heading, a short explanation written from the change, and the code example from the pull request when it has one. It comes as a Markdown diff against a proposed file, so you can see exactly what would be added.
04

Checks it like any other draft

API names, versions and claims have to appear in the evidence, and nothing about a beta feature gets called GA. Go examples are also parsed, so a snippet with broken syntax fails before you see it.
05

Adds a tutorial when there's material for one

For a high-priority new capability your docs don't cover, DevRelay also drafts a step-by-step tutorial, but only when the pull request has enough to work from: an example or real detail. Otherwise it says so and skips it.
06

You apply it

Approve the patch and export it as Markdown. Adjust the path to match your docs repo and commit it. DevRelay doesn't open pull requests on your docs repository yet.
Knowledge

Grounded in your docs, your site and your brand.

The brain holds what DevRelay knows about your company: the sources it crawled, your product facts and your voice. Docs drafts quote it; they don't guess.

app.devrelay.so/brain
DevRelay brain page showing the company profile and knowledge sources
FAQ

Questions about docs updates.

01Does it open a pull request on our docs repo?

Not yet. Docs updates come as a Markdown diff you export and apply. Export is on the DevRelay plan; on the free plan you can see and review every draft.

02Which docs platforms does it work with?

Any public docs site that serves its pages as HTML, which most static-site and hosted docs tools do. DevRelay doesn't run JavaScript when it crawls, so pages that only render in the browser can't be read. The output is Markdown.

03Can it read private or internal docs?

No. The crawler only fetches public http and https pages and refuses private, loopback and link-local addresses.

04How does it decide the docs are missing something?

A classifier compares the released change with what it found in your docs. When it's confident a guide already exists, no patch is drafted. When the change adds public API that isn't documented, one is.

05Where does the code example come from?

From the pull request that shipped the change, when it has one. The writer takes code from the evidence rather than making it up, and Go examples are parsed as part of the checks.

06Will it rewrite pages that already exist?

No. It drafts the missing section for a new change. Rewriting or restructuring existing pages is up to you.

GuideDocs drift: how to keep documentation in sync with your codeRead more ProductChangelog: an entry for every release, grouped the way readers scanRead more ProductLaunch posts: X and LinkedIn posts for every releaseRead more

Ship the feature and the docs for it in the same week.

Connect a repo and your docs site. The next release that outgrows your docs comes with the missing section, drafted and checked.

Start free See pricing

No credit card · Nothing posts without your approval