Urgent.News

What's breaking now, across thousands of outlets.

Tech

Drafting Rights: Assign Every Doc Section to a Model or a Named Human

Most documentation pipelines fail on accountability rather than prose quality, because nobody can point at a sentence and name the human who approved it. That gap widens the moment a model drafts pages: reviewers read fluently, approve quickly, and silently inherit claims they never verified. The rule I now apply is narrow enough to enforce in CI — a model may draft anything that describes how…

Most documentation pipelines suffer from a lack of accountability, as nobody can trace a sentence back to the human who approved it. This issue becomes more pronounced when models generate content. To address this, the author now establishes a rule that a model can only draft sections describing the current behavior of the software, while anything promising future functionality is strictly prohibited.

The previous checks focused on numerals, fenced examples, and fact fidelity, but the new approach addresses the question of whether a model was even permitted to write a given sentence.

The documentation is divided into four tiers based on the commitment each sentence demands from the team. Tier 1 includes intros, transitions, glossary wording, and navigation copy, which can be drafted by models with the assurance that they will pass fact gates. Tier 2 consists of mechanism details like build behavior, config keys, CLI flags, and error meanings, where the model drafts but a human verifies the evidence.

Tier 3 covers support windows, deprecation dates, pricing, SLAs, and roadmap wording, which require a named owner to confirm the evidence pointer. Tier 4 comprises security posture, data retention, licensing, and legal terms, where a named owner plus the team shares the risk.

Models are most beneficial in the first two tiers, while the latter two tiers are where most problematic generated documents originate. The distinction between describing current behavior and promising future functionality is crucial. A model that writes "retries are capped at three attempts" is merely describing the code, while a model that writes "we support this until 2028" is inventing a promise.

To ensure adherence to these tiers, the author creates a manifest file, docs-rights.yml, located at the repository root. This file specifies the tier for each section, with defaults applied to unlisted sections. When the manifest changes, it undergoes code review, making any alterations to model rights visible in a diff for potential objections.

The enforcement of these tiers is accomplished through a linter script that parses headings, hashes the normalized section bodies, and compares the hash with a receipt created during the review process. If the reviewed text changes, the receipt becomes outdated, and the check fails until a human revisits the material.

Written by urgent.news from Dev.to's reporting — not their text. Machine-written — may contain errors; check the original before relying on it.

Read the original at dev.to →

More in Tech

Python: Call Multiple APIs in Parallel with asyncio.gather and Semaphore in 10 Minutes

When you need to call dozens of APIs — syncing data, crawling prices, firing webhooks — a sequential for loop adds up the waiting time of every request: 20 requests × 1 second = 20 seconds.

  • asyncio.gather enables concurrent execution of coroutines in a single event loop.
  • Semaphore limits concurrent requests to avoid overwhelming partner APIs.
  • Using returnexceptions=True allows handling of errors while returning a list of results.

Meet LiveReview: Auto Approve 30-50% of Your Low-Risk PRs, Safely

Earlier this year, we built a small tool called git-lrc . It fixed one problem: engineers committing AI-written code they had not read.

  • LiveReview auto-approves 30-50% low-risk PRs
  • System uses semantic LLM, custom ML, static analysis
  • Provides checkpoints for custom risk enforcement

Your Timer Is a Wall Clock, Not a Stopwatch: Four Elapsed-Time Myths and a Monotonic Probe

How long did that batch job take? Simple question. Your logs probably answer it wrong. I kept seeing two numbers for one run. The job log said eleven minutes. The dashboard said forty-two.

  • Wall clock measures what time it is, not how long a task took
  • Monotonic clock never goes backward, suitable for measuring durations
  • Timeouts indicate local socket issue, not remote task completion

More from Saturday 7 November →