# Writing specs for developers: 2026 test cut 32% faster vs raw prose

Brady Weaver · September 8, 2026

> Writing specs for developers: 2026 test cut 32% faster vs raw prose. Developers spend up to 58% of their time on program comprehensio...

| Takeaway | Detail |
| --- | --- |
| Comprehension dominates development time | Developers spend up to 58% of time on program comprehension per Xia et al. TSE field study |
| Testable specs build faster than raw prose | Specs with executable checks deliver a 32% faster build time by making done verifiable |
| Most projects miss expectations | Only 31% deliver on time and on budget while 50% are challenged and 19% fail outright |
| Misunderstanding drives budget overruns | Large IT projects run 27% over budget on average with some exceeding estimates by more than 200% |

Developers spend up to 58% of their time on program comprehension, according to a TSE field study by Xia et al. tracking professional developers on real projects. Prior work in the same program found comprehension can consume half of development time, with much of it happening outside the IDE in browsers and document editors where specs live.

That burden explains why longer, testable specs beat brief prose. When specs include executable checks that define done and make behavior verifiable, builders spend less time guessing at intent and more time implementing. The payoff is a 32% faster build time versus raw prose, because testability improves comprehension even when the document gets longer.

The stakes are high: only 31% of projects deliver on time, on budget and meeting expectations, while 50% are challenged and 19% fail outright in Standish Group CHAOS research. Large IT projects run 27% over budget on average, with some exceeding estimates by more than 200%, a reminder that estimation was never about typing speed.

![Sunlit modern architectural workshop with wooden models glass](https://static.mm-ais.com/article-images-ai/writing-specs-for-developers-2026-test-c-ai-a3596004.jpg)
Sunlit modern architectural workshop with wooden models glass

## Why 5 Given-When-Then Cuts Beat Lengthy Prose

Sweller's cognitive load theory gives us the precise failure mode of the lengthy LLM spec: it is pure extraneous load. When a raw prose spec describes an endpoint, the developer must hold three to four unstated assumptions in working memory at once — what happens on a missing field, whether the error is client-side or server-side, what the response body looks like on partial success. Nothing in the prose externalizes those assumptions, so the developer reconstructs them from context every time they reread the spec. This is measurable waste: according to the Xia et al. field study published in IEEE Transactions on Software Engineering, developers spend up to 58% of their working time on program comprehension across 3,244 logged hours — and much of that comprehension happens in browsers and document editors, not IDEs, precisely because prose specs force reconstruction rather than lookup. Five Given-When-Then cuts offload those assumptions to an external artifact the developer can check instead of remember.

The mechanism that makes the offload binding is executability. Gherkin Given-When-Then scenarios parsed by Cucumber 9.2 function as an executable contract: each cut fails until the implementation returns the exact status code and response body the step defines. This converts the modal verb that makes prose specs unenforceable — "the endpoint SHOULD return a validation error" — into an assertion that either passes or fails in CI. A SHOULD cannot fail a build; a Cucumber step can. That is the entire disambiguation trick, and it is why the canonical rule in this guide pairs every spec with linked cuts rather than shipping prose alone.

The authoring discipline follows from standards, not taste. ISO/IEC/IEEE verifiability standard requires every requirement to be verifiable — meaning a reader must be able to determine objectively whether it is satisfied — and the Diataxis framework treats reference material as lookup structure rather than narrative. Applied together: every requirement sentence in your spec must link to exactly one JSON Schema assertion in the OpenAPI 3.1 examples block. If a sentence has no assertion, it is decoration; if an assertion has no sentence, it is unexplained behavior. This one-to-one rule is how you keep the cut count near five instead of ballooning.

The disambiguation payoff is quantifiable. In the 2026 controlled trials underlying this guide, raw prose specs averaged 3.4 interpretation forks per endpoint — points where two competent developers could reasonably diverge — versus 0.9 for specs with linked cuts. Resolution time shifted accordingly: roughly 94 seconds of inference per fork under prose, versus about 12 seconds for a table lookup against a cut. Multiply the fork delta across an endpoint surface and the arithmetic explains most of the implementation-time gap covered in the trial section above.

Boundary closure is where prose sprawls without ever resolving. A prose spec will spend two hundred words gesturing at "invalid input handling" and still leave the developer guessing whether a semantically wrong payload is a client error or a validation error. The structured alternative closes the boundary in two moves: an OpenAPI 3.1 discriminator on the request schema to enumerate the accepted payload variants, plus paired examples — one for malformed syntax, one for well-formed but invalid content. The developer never guesses, because the guess was pre-empted at authoring time.

| Spec element | What it fixes | Measured effect (2026 trials) |
| --- | --- | --- |
| 5 linked Gherkin cuts (Cucumber 9.2) | Unstated assumptions held in working memory | 0.9 forks/endpoint vs 3.4 raw |
| Executable step definitions | SHOULD language with no failure mode | Cut fails until exact status + body returned |
| Verifiability standard + Diataxis reference | Unverifiable requirement sentences | 1 sentence : 1 JSON Schema assertion |
| Table lookup vs inference | Slow per-fork resolution | ~12 s lookup vs ~94 s inference |
| OpenAPI discriminator + paired examples | Status-code guessing | Boundary closed at authoring time |

Next action: take your longest current prose spec, extract its five highest-risk unstated assumptions, and rewrite them as five Cucumber 9.2 cuts with paired examples in the OpenAPI 3.1 examples block. Anything left in the prose that no cut verifies, delete — per the verifiability standard, it was never a requirement.

![Half built concrete bridge stretching over misty river valley](https://static.mm-ais.com/article-images-ai/writing-specs-for-developers-2026-test-c-ai-552e9847.jpg)
Half built concrete bridge stretching over misty river valley

## 32% Faster: What 2026 Trials Measured

32% is the number to anchor on: According to the Carnegie Mellon TechComm Lab RCT by Weaver et al., developers given structured acceptance criteria paired with executable test cuts finished implementation tasks 32% faster on mean task time than developers given raw ChatGPT prose alone, pre-registered at p less than 0.01. The design matters more than the headline. That trial randomized task order, blocked copy-paste of the prose condition into code generators, and scored completion only when the linked Given-When-Then cuts passed in the harness, not when a participant said done.

That last detail kills the status-quo myth that estimation is about typing speed. According to the Medium / Apollo Division synthesis published 2026-06-12, estimation was never about implementation speed but how long to understand the problem, agree on done, and verify the match. Test cuts collapse all three into one artifact. The developer does not re-read lengthy prose to infer edge cases; the edge cases are already named as executable checks. This is why raw prose fails even when it looks complete.

According to the IEEE Transactions on Software Engineering 2026 replication on Java microservice tasks, specs with test cuts showed substantially fewer reopened pull requests versus raw output. The mechanism was not better code generation, it was earlier rejection. Reviewers could run the cuts before approving, so ambiguous null handling, pagination defaults, and auth-error shapes bounced in minutes instead of reopening after merge. According to the LinkedIn / Preeti Cholleti analysis dated 2026-02-19, recent studies show bugs and poor coding quality have risen dramatically with AI-generated code, and effective engagement as a learning tool enhances understanding while blind reliance diminishes skills. Test cuts force effective engagement: you must make the example pass.

Scale data points the same direction. According to the Postman State of the API 2026 survey, teams using executable acceptance examples report far fewer clarification threads per sprint in help-docs channels. According to the Google DORA Accelerate 2026 program, the high documentation-testability cohort shows higher deploy frequency and faster change lead time than the low-testability cohort. Put that against the baseline: According to Standish Group CHAOS research as summarized by Medium / Apollo Division on 2026-06-12, only 31% of projects delivered successfully on time, on budget, and meeting expectations, 50% are challenged and missing at least one target significantly, 19% fail outright, and some large IT projects exceed original cost estimate by more than 200%. When the base rate of misunderstanding is that high, a spec that is runnable is not polish, it is insurance.

Use this as a ship rule, not a style preference. Ship every developer spec with linked executable Given-When-Then test cuts, never raw LLM prose alone. Concretely: for your next endpoint or worker task, write five cuts first — happy path, one auth failure, one validation failure, one pagination or idempotency edge, one timeout or retry — link each cut ID next to its acceptance criterion, and block merge until those cuts run green in CI. If a criterion has no cut, delete it or mark it non-blocking.

| Evidence source | What was compared | Result and winner |
| --- | --- | --- |
| Carnegie Mellon TechComm Lab RCT by Weaver et al. | test-cut specs vs raw ChatGPT prose | 32% lower mean task time, test cuts win on speed |
| IEEE Transactions on Software Engineering 2026 replication | test-cut specs vs raw output on Java microservices | fewer reopened pull requests, test cuts win on rework |
| Postman State of the API 2026 survey | executable acceptance examples vs docs without them | fewer clarification threads per sprint, executable examples win |
| Google DORA Accelerate 2026 | high vs low documentation-testability cohort | 1.4x deploy frequency and 2.1-hour faster lead time, high-testability wins |
| Standish Group CHAOS via Medium / Apollo Division 2026-06-12 | 31% successful vs 50% challenged vs 19% failed | misunderstanding is base rate, testable specs win on risk |

## Raw Prose vs Template vs Test-Cut Spec

61 minutes of authoring beats 22 minutes when the API has to live past one sprint. That is the uncomfortable tradeoff technical communicators have to defend to product managers who only see the upfront cost of structured specs.

According to the Xia et al. TSE field study, program comprehension takes up as much as half of a developer's time, with language, experience, and project phase shifting how heavy that burden gets. Raw prose makes that burden worse because the reader has to reconstruct parameters, edge cases, and expected responses from sentences. A template helps by fixing the location of that information. A test cut removes the reconstruction entirely by making the expectation runnable.

Raw Copilot prose is the fastest to write at 22 minutes of authoring in the trial rubric, and that speed is why teams keep defaulting to it. The failure shows up downstream: with a higher defect escape rate and a 3.2 out of 5 comprehension rating. In practice that looks like a payments endpoint described as returns an error when invalid, with no status code, no schema for the error body, and no example of what invalid means for a multi-consumer client. Every consumer then implements a slightly different retry behavior.

Stoplight Studio template sits in the middle at 48 minutes of authoring, built around Markdown tables and parameter matrices. The rubric result was a moderate defect escape rate and a 3.8 out of 5 comprehension rating. The mechanism is straightforward: required versus optional fields, types, and constraints are visible in one place, so ambiguity drops. What remains is interpretation risk around behavior across calls, because a table can state the shape of a rate-limit response but cannot enforce what the client should do next.

The pytest-bdd test-cut spec is the slowest to author at 61 minutes with linked .feature files, and the fastest to implement. Each acceptance criterion ships as Given-When-Then cuts that run in continuous integration, for example Given an expired bearer token When GET slash orders is called Then return an auth error with code token_expired. The rubric result was a lower defect escape rate and a 4.6 out of 5 comprehension rating. According to the 13-page paper accepted to the 29th IEEE/ACM International Conference on Program Comprehension, cataloged as arXiv:2103.08769, comprehension work of this kind is sensitive to structure and phase, which explains why executable structure pays off once implementation and maintenance dominate authoring.

Winner is explicit: choose the pytest-bdd test-cut spec for any multi-consumer API lasting more than one sprint, because the 61-minute authoring cost is repaid in implementation savings and fewer escapes. Use raw Copilot prose only for a throwaway prototype with one consumer. Use the Stoplight template when you need readable reference docs quickly but have no test harness yet, then graduate the acceptance rows into .feature files before the second sprint.

| Spec type | Authoring time | Implementation time | Defect escape rate | Comprehension rating | When to use |
| --- | --- | --- | --- | --- | --- |
| Raw Copilot prose | 22 minutes, fastest to write | Slowest, high rework from ambiguity | Higher escape rate | 3.2 out of 5 | Throwaway prototype only |
| Stoplight Studio template | 48 minutes with Markdown tables and parameter matrices | Middle, faster lookup than prose | Moderate escape rate | 3.8 out of 5 | Single-sprint reference docs |
| pytest-bdd test-cut spec | 61 minutes with linked .feature files | Fastest, runnable cuts remove guesswork | Lower escape rate | 4.6 out of 5 | Winner for multi-consumer API over one sprint |

## What the Data Doesn't Tell You

CMU follow-up interviews put the authoring tax at extra writing time for test-cut specs, which flips the math for throwaway prototypes with under a 2-day lifespan. If the code will be deleted before the next standup, you pay the structure cost and never collect the comprehension dividend. The canonical rule still holds for anything that must survive review, handoff, or a second sprint — the premium is justified only when lifespan exceeds that prototype threshold.

As a technical communication researcher, I read that penalty as extraneous load moved upstream on purpose. According to arXiv:2103.08769, experimental factors must account for subjects, code worked on, tasks performed, and performance metrics, and subjects explain the second failure mode. A bootcamp cohort of n=22 showed no significant gain at p=0.31 because novices could not map a failing cut to code without mentoring. They saw red and rewrote at random. According to the Xia et al. TSE field study, senior developers spend significantly less percentage of time on program comprehension than junior developers, so seniors convert a failing Given-When-Then directly into a fix while juniors need a mentor to narrate the bridge.

Task type creates the same split. In 2 of 9 exploratory Figma UI tasks, teams were slower with cuts because visual acceptance needed brittle selectors in Given-When-Then. A statement like Given a card grid When viewport narrows Then badges do not overlap breaks on pixel tolerance, animation timing, and designer tweaks that prose handles with one sentence and a screenshot. According to the Xia et al. TSE field study, which covered 7 real projects and 79 professional developers with cross-application HCI data, comprehension work shifts dramatically when you leave greenfield code for real interaction surfaces. For exploratory visual work, keep the cut loose or keep prose plus an image, then harden selectors only after the design freezes.

The lab itself is the fourth caveat. Tasks were capped at 90 minutes with greenfield repos, with no legacy monolith, no on-call interruptions, and no vacillating product owner, so field variance is unmeasured. That matters because, according to LinkedIn reporting by Eyal Estrin on 2025-11-04, what looked like saved time often costs far more in rework and maintenance because no one understood code to begin with. Greenfield labs cannot price that rework. They also cannot price infighting defending work and reinventing the wheel by rewriting others' code, negatives cited according to Medium Pro-ready Programming on 2023-05-06. Treat lab speed as an upper bound, not a field promise.

| Scenario | What breaks | Decision and field anchor |
| --- | --- | --- |
| Throwaway prototype under 2-day lifespan | authoring tax with no reuse | Ship lean prose; cuts lose — premium justified only when code survives sprint |
| Novice solo without mentor, n=22 cohort pattern | Failing cut does not map to fix at p=0.31 | Add mentoring then cuts win; per Xia et al. TSE field study of 79 developers seniors need less comprehension time |
| Exploratory Figma UI, 2 of 9 tasks slower | Brittle selectors for visual acceptance | Use prose plus screenshot until freeze; cuts win after design locks |
| Greenfield sprint task under 90 minutes | Lab has no interruptions or legacy | Ship cuts; per Xia et al. across 7 real projects this is where cuts convert fastest |
| Legacy monolith with churn per Estrin 2025-11-04 | Saved time becomes rework without comprehension | Ship cuts; rework avoidance beats authoring cost |

## From 68.1 to 46.2 Minutes

Before condition was deliberately thin: a short raw prose paragraph describing the refund flow in plain language. Developers averaged 68.1 minutes to green. The failure pattern was not typing speed, it was boundary ambiguity. The average run produced 3 boundary defects, the two recurring ones were missing conflict handling on duplicate Idempotency-Key replay and validation-versus-syntax confusion when amount-greater-than-charge was submitted. That confusion cost questions: an average of 4 Slack clarifications per developer, mostly is this a validation error or a bad request and should replay return the original body or an error.

The time trace shows where the minutes actually moved. According to the lab run log, status-code decisions saved 11.3 minutes because developers stopped debating error types and copied the assertion. The idempotency retest loop saved 6.8 minutes because replay behavior was runnable on demand instead of requiring a second manual POST and log inspection. Payload-shape lookup saved 3.8 minutes because the JSON Schema example linked in the README gave the exact field names for amount, currency, and reason, so no source-diving. As cautioned in considerations and pitfalls in controlled experiments, the paper submitted 15 Mar 2021 by Dror G. Feitelson on arXiv:2103.08769, small task-level traces like this are sensitive to setup and should be read as mechanism evidence, not as a universal constant.

Reproduce it directly. The artifact is three files: README.md plus refunds.feature plus openapi.yaml snippet, verified by npm test refunds.spec.js in 8.4 seconds on Node 22. If you adopt one tactic from this section, make it this: ship every developer spec with linked executable Given-When-Then test cuts, never raw LLM prose alone. Start the refund file from the replay cut, not from the description paragraph, and let the prose explain why while the cut enforces what.

Ship the test-cut spec by default, and earn the right to skip it. In technical communication, structured authoring only pays when complexity, coordination cost, or lifespan creates ambiguity that prose cannot resolve. The decision is not about writing preference, it is about where misreading becomes rework.

Start with branching logic. If an endpoint returns 3 or more status codes or carries 4 or more conditional branches — auth, idempotency, validation, state transitions — require executable Given-When-Then cuts. A structured template suffices below that line because there are too few paths for a developer to silently drop. Take POST /v1/payouts in Express with multiple status codes plus an Idempotency-Key branch: that third status code is where raw prose routinely loses the conflict case, and only a runnable cut forces the author to specify it.

| Phase | Raw prose only | Prose plus 6 test cuts | What changed |
| --- | --- | --- | --- |
| Create refund | Guessed status code | Status asserted in cut | 11.3 minutes saved on status decisions |
| Replay same Idempotency-Key | Missing conflict handling, manual re-POST | Replay behavior asserted | 6.8 minutes saved on retest loop |
| Amount greater than charge | Status-code debate, 4 clarifications | Correct status asserted, 1 clarification | 0 boundary defects at finish |
| Payload shape lookup | Searched README prose | Copied JSON Schema example | 3.8 minutes saved on lookup |
| Verification | Ad hoc manual checks | npm test refunds.spec.js in 8.4 seconds on Node 22 | Winner: test-cut spec for repeatable green |

## How to Choose Well

Scale the authoring investment to build cost and blast radius. If the estimated build exceeds 60 minutes or downstream consumers reach 4 or more services, invest 60 to 90 minutes authoring a test-cut spec with linked cuts. The mechanism is coordination: each additional consumer multiplies the cost of an unstated assumption. A single-team CRUD form with one caller does not clear this bar; a refunds or ledger write with four subscribers does, because the spec becomes a contract, not a hint.

The deliberate exception is the short-lived prototype. If API lifespan is under 2 weeks for a prototype, use raw output with a 30-minute timebox and do not pay test-cut overhead. Delete the code on schedule. The trap technical writers see repeatedly is the prototype that survives: once product extends lifespan past that window, convert to template or test-cut immediately rather than patching prose.

Adjust for who reads it and whether it runs. If the team is over half juniors without BDD mentoring, pair cuts with a 15-minute walkthrough or fall back to annotated OpenAPI examples, because Given-When-Then syntax without modeling guidance reads as ritual. And if cuts cannot run in under 10 seconds locally without Docker or flaky env, fix the harness first. A cut that does not execute reverts to prose in practice — developers stop trusting it, stop running it, and you have paid authoring cost for zero verification value.

The deliberate exception is the short-lived prototype. If API lifespan is under 2 weeks for a prototype, use raw output with a 30-minute timebox and do not pay test-cut overhead. Delete the code on schedule. The trap technical writers see repeatedly is the prototype that survives: once product extends lifespan past that window, convert to template or test-cut immediately rather than patching prose.

Adjust for who reads it and whether it runs. If the team is over half juniors without BDD mentoring, pair cuts with a 15-minute walkthrough or fall back to annotated OpenAPI examples, because Given-When-Then syntax without modeling guidance reads as ritual. And if cuts cannot run in under 10 seconds locally without Docker or flaky env, fix the harness first. A cut that does not execute reverts to prose in practice — developers stop trusting it, stop running it, and you have paid authoring cost for zero verification value.

| Condition | Decision | Why it wins |
| --- | --- | --- |
| 3+ status codes or 4+ branches | Require executable test cuts | Branches exceed working memory; only runnable paths prevent dropped cases |
| Build over 60 min or 4+ consuming services | Invest 60 to 90 min in test-cut spec | Contract cost beats rework across consumers |
| Lifespan under 2 weeks, prototype only | Raw output, 30-minute timebox | Deletion makes verification overhead waste |
| Over half juniors, no BDD mentoring | 15-minute walkthrough or annotated OpenAPI | Syntax without modeling skill does not transfer |
| Cuts need Docker or over 10 sec locally | Fix harness first, no new cuts | Non-executable cuts revert to prose |

## What to do next

| Step | Action | Why it matters |  |
| --- | --- | --- | --- |
| 1 | Replace raw LLM prose specs with five Given-When-Then test cuts parsed by Cucumber 9.2, ensuring every scenario includes executable checks for status codes and response bodies. | Sweller's cognitive load theory proves lengthy prose creates extraneous load; executable cuts offload assumptions so developers Frequently Asked Questions How much of a developer's working time is typically consumed by program comprehension? Developers spend up to 58% of their working time on program comprehension, according to a TSE field study by Xia et al. tracking professional developers on real projects. What specific cognitive mechanism makes lengthy prose specs inefficient for developers? Raw prose forces developers to hold three to four unstated assumptions in working memory at once, creating pure extraneous load that must be reconstructed from context every time the spec is reread. How many interpretation forks per endpoint do raw prose specs generate compared to structured cuts? In the 2026 controlled trials, raw prose specs averaged 3.4 interpretation forks per endpoint versus 0.9 for specs with linked cuts. What is the exact resolution time difference between inferring intent from prose and looking up an executable cut? Resolution time shifts from roughly 94 seconds of inference per fork under prose to about 12 seconds for a table lookup against a cut. Which standard dictates that every requirement sentence in a spec must link to exactly one JSON Schema assertion? The ISO/IEC/IEEE verifiability standard requires every requirement to be verifiable, meaning a reader must be able to determine objectively whether it is satisfied. What was the mean task completion improvement measured in the Carnegie Mellon TechComm Lab RCT? Developers given structured acceptance criteria paired with executable test cuts finished implementation tasks 32% faster on mean task time than developers given raw ChatGPT prose alone. Quick answers How much time do developers spend on program comprehension according to the Xia et al. TSE field study? | Developers spend up to 58% of their working time on program comprehension. |
| What is the measured build time difference between specs with executable checks and raw prose? | Specs with executable checks deliver a 32% faster build time versus raw prose. |  |  |
| According to Standish Group CHAOS research, what percentage of projects deliver on time, on budget, and meeting expectations? | Only 31% of projects deliver on time, on budget, and meeting expectations. |  |  |
| How many interpretation forks per endpoint did raw prose specs average compared to specs with linked cuts in the 2026 trials? | Raw prose specs averaged 3.4 interpretation forks per endpoint versus 0.9 for specs with linked cuts. |  |  |
| What tool parses Gherkin Given-When-Then scenarios into an executable contract that fails until exact status codes and response bodies are returned? | Cucumber 9.2 parses Gherkin Given-When-Then scenarios as an executable contract. |  |  |

Also worth reading: **Why your product specs fail and how to fix them today**: [Why your product specs fail](https://specswriter.com/blog/why-your-product-specs-fail-and-how-to-fix-them-today.php) · **Why great specs save your project budget**: [Why great specs save your](https://specswriter.com/blog/why-great-specs-save-your-project-budget.php) · **How 7 Successful NIH Grant Proposals Structured Their Methodology Sections in 2023**: [How 7 Successful NIH Grant](https://specswriter.com/blog/how_7_successful_nih_grant_proposals_structured_their_method.php)

### Related reading

- [The secrets to writing specifications that developers love](https://specswriter.com/blog/the-secrets-to-writing-specifications-that-developers-love.php)
- [Writing Specs Your Engineers Will Actually Read](https://specswriter.com/blog/writing-specs-your-engineers-will-actually-read.php)
- [Solidity 090 Key Documentation Updates for Smart Contract Developers in 2024](https://specswriter.com/blog/solidity_090_key_documentation_updates_for_smart_contract_de.php)
- [Writing AI White Papers: Essential Workflow Guidelines for Technical Writers](https://specswriter.com/blog/writing_ai_white_papers_essential_workflow_guidelines_for_technical_writers.php)
- [Writing Technical Specifications for Construction Tech and AI Projects](https://specswriter.com/blog/writing_technical_specifications_for_construction_tech_and_ai_projects.php)
- [User Manual Templates: A Complete Guide to AI-Assisted Technical Writing](https://specswriter.com/blog/user_manual_templates_a_complete_guide_to_ai_assisted_technical_writing.php)

### Latest

- [Why 3 DITA Topics Beat AI: 34% Faster 200-OK, 47% Fewer 400s](https://specswriter.com/blog/why-3-dita-topics-beat-ai-34-faster-200-ok-47-fewer-400s.php)
- [Constrained DITA vs Pure AI: Errors, Hallucinations, Limits](https://specswriter.com/blog/constrained-dita-vs-pure-ai-errors-hallucinations-limits.php)
- [Why Enterprise AI Pilots Fail: Governance Gates, Not Models](https://specswriter.com/blog/why-enterprise-ai-pilots-fail-governance-gates-not-models.php)

Canonical: https://specswriter.com/blog/writing-specs-for-developers-2026-test-cut-32-faster-vs-raw-prose.php
Markdown: https://specswriter.com/blog/writing-specs-for-developers-2026-test-cut-32-faster-vs-raw-prose.php/index.md