What stale documentation costs, and why it can be worse than none
A missing page sends a reader off to ask someone. A wrong page looks like an answer, so they follow it. That is the real cost of outdated documentation, and it is hard to price. This page sets out what studies have measured, keeps the vendor surveys separate, and labels the dollar figures as models.
Why wrong can be worse than missing
When a page doesn't exist, the reader knows they don't know. They search the code, ask in a channel, or try things and watch what happens. When a page exists and is out of date, they have no reason to doubt it. It has the company's logo, the same layout as the pages that are right, and often a confident step-by-step list. They run the old command, look for the button that moved, and lose time before they suspect the page.
Research on how people judge websites explains why. B.J. Fogg's Stanford Guidelines for Web Credibility (2002) are based on three years of studies with over 4,500 people. Guideline 8 is "Update your site's content often (at least show it's been reviewed recently)", because people give more credibility to sites that look recently updated or reviewed. Guideline 6 says people judge a site quickly by its visual design.
Those are findings about how credible a page seems, not whether it is accurate. A stale page with a clean design and a recent date passes both tests. That is the problem. Nothing on the page tells the reader it describes last year's product.
We haven't found a study that puts wrong docs and missing docs head to head and measures the difference. The claim in this page's title is an argument from the evidence below, not a result anyone has measured.
What has been measured
Two peer-reviewed studies and one analyst survey, each with its own sample.
| Study | What it looked at | What it found |
|---|---|---|
| Tan, Wagner and Treude, 2024 (peer-reviewed) | READMEs and wikis of more than 3,000 GitHub projects | 82.3% of the top projects had a reference to deleted code in their docs at some point |
| Silva, Unterkalmsteiner and Wnuk, 2023 (peer-reviewed) | 318 documentation bug reports for an Ericsson cloud product | 40% were reported by the product's users, not the team that wrote it |
| Gartner, 2024 (analyst survey) | 5,728 customers surveyed (December 2023) | Only 14% of issues were fully resolved in self-service |
Outdated references stayed wrong for years
Tan, Wagner and Treude, in Empirical Software Engineering, wrote a tool that finds names of variables, functions and classes in a project's documentation that no longer exist in its code. They ran it over GitHub's 1,000 most-starred projects and Google's 2,279 projects on GitHub, with full histories for 800 of the popular ones.
- At the time of analysis, 28.9% (265 of 918) of the most popular projects had at least one outdated reference. For Google's projects, which are mostly smaller, it was 5.4%.
- Over their full history, 82.3% (658 of 800) of the popular projects had been outdated at some point.
- The references that were still wrong had been wrong for 4.7 years on average in the popular projects and 4.2 years in Google's.
The authors then opened GitHub issues on 15 actively maintained Google projects, covering 19 outdated references. Maintainers fixed 5. Four projects responded positively, four said the reports were false positives, and seven did not reply by the time of writing. That's a small sample, and it shows the tool is not perfect. It also shows that a real error can sit in a busy project until someone outside points at it.
Readers report the errors
Silva, Unterkalmsteiner and Wnuk, at the 2023 ACM/IEEE International Conference on Technical Debt, studied the customer-facing documentation of one cloud product at Ericsson. From 1,663 resolved bug reports filed between March 2019 and September 2022, 318 were about the documentation alone. Deployment guides drew the most, 129.
In a sample of 101 of those reports, the largest defect types were missing documentation (35), erroneous code examples (23) and outdated content (19). Those are the counts in the paper's abstract. Its body reports the outdated count slightly differently in different sections, so treat the exact split loosely.
The authors had no cost data, so they used a stand-in. A defect found by a customer costs more than one found inside the company, and it costs confidence in the product. The system's users, not the company, filed 126 of the 318 reports (40%). The authors' conclusion is careful. Documentation debt can raise maintenance costs, and it "can easily go undetected".
Self-service fails when the content isn't there
Gartner's August 2024 press release reports a December 2023 survey of 5,728 customers. 73% used self-service at some point, but only 14% of issues are fully resolved in self-service. Even issues customers called "very simple" resolved there only 36% of the time. The most common reason for failure, in 43% of cases, was that the customer couldn't find content relevant to their issue.
Read that 43% carefully. It is a share of "cases", not of all users, and the release doesn't say whether that means every self-service attempt or only the failed ones. And "couldn't find relevant content" covers missing pages, unfindable pages and pages that describe a screen that no longer exists. Gartner doesn't split them, so it doesn't tell you how much of the failure is staleness.
Documentation drift: why docs go out of date
Documentation drift is the gap that opens between the docs and the product as the product changes and the docs don't. Tan and colleagues name the mechanism. Unlike code, documentation goes out of date "silently". Nothing crashes, and no test fails. A pull request renames a function or moves a setting, every check passes, and the page that described the old behaviour is now wrong.
Their explanation is that developers don't know when a code change has made the docs obsolete. They state this as the reason they built the tool, not as something they measured, and we report it that way. It fits the rest of their data, though. If people knew, a reference wouldn't stay wrong for four years.
The same thing happens to pictures. A study of VS Code's docs found that in 24 of 44 sampled fixes to outdated screenshots, the text around the picture changed too. The VS Code screenshot study has the detail, including why a screenshot's age is a poor test of whether it is wrong. For the wider picture of how common outdated docs are, see the statistics page.
Who finds the errors
If the writers don't know the docs broke, someone else finds out. The evidence points the same way in three settings:
- In the VS Code study (ACM TOSEM, 2026), 36 of 44 sampled reports of outdated screenshots came from people outside the docs team. The documentation writers filed the other 8.
- In the Ericsson study, the system's users, not the company, filed 126 of 318 documentation bug reports (40%).
- In Tan et al.'s study of GitHub projects, the researchers reported 19 suspected outdated references to 15 Google projects. Maintainers fixed 5, and four projects called the reports false positives.
Each report is a reader who followed the page, failed, worked out that the page was the problem, and then took the trouble to say so. Our guess is that most readers stop well before the last step. The reports you get are the visible part of the cost.
When the reader is an AI tool
AI agents reading your docs have the same blind spot as people, with less chance of noticing. An assistant that retrieves an old page doesn't know it is old. It repeats the steps in the same confident tone as a correct answer.
The only numbers we found here come from a vendor. Slite, which sells a knowledge base, asked 143 founders, operators and engineers for their worst stories about stale documentation (published June 2026). 76% said an AI tool had surfaced a stale document and produced a wrong answer. Of those, 41% said the wrong information had reached a customer, and 1 in 5 cases involved a direct financial loss. The article does not say how respondents were recruited or what they were asked, and Slite sells the fix. Treat these as a vendor's tally of stories, not a measurement.
The dollar figures are models
None of the studies above puts a dollar figure on stale docs. The Ericsson authors said so directly. The product had no way to estimate defect cost, so they used counts and severity instead.
The dollar figures you'll see elsewhere are models. Someone takes an hourly rate and multiplies it by hours they assume were lost. Slite's article, for example, quotes single incidents its respondents described, such as $47,000 lost in one week, and a Gartner figure for the yearly cost of poor data quality that it links only to Gartner's homepage. That figure is about data in general, not documentation. Single stories show a cost can be large. They don't tell you what it usually is.
If you need a number, build your own model from your own data and call it a model. Count the support tickets that cite a wrong page, and multiply by what a ticket costs you. Count the docs bug reports from users, and add the hours to fix each one.
That gives you a floor, because it only counts the people who told you. In Tan et al.'s study, references that were still wrong had gone four years without anyone fixing them, so silence is not evidence that a page is fine.
What to do about it
If wrong docs cost more than missing ones, two rules follow. Check docs when the product changes, not when the calendar says so. And delete a page nobody will maintain, because a gap is the cheaper failure.
- Make drift fail a build. Tan and colleagues' tool checks code names in docs against the code. The Ericsson authors propose generating docs from one source of truth and testing them like code. Either way, a stale page fails a check instead of waiting for a reader.
- Take screenshots from the build. If your end-to-end tests capture the screens your docs show, each build makes new ones from the current app. Screenery publishes each at an @latest URL that a push on the default branch moves, so the docs follow the product. See How to keep documentation screenshots up to date.
- Make reporting cheap. Readers find most of the errors. A "this page is wrong" link that opens an issue costs little and catches what checks miss.
For the evidence on screenshots in particular, see what the research says about product screenshots.
Sources
We opened every page below on 15 November 2026 and checked each number on this page against it.
- Tan, Wagner and Treude, "Detecting outdated code element references in software repository documentation", Empirical Software Engineering 29, article 5, 2024 (open access)
- Silva, Unterkalmsteiner and Wnuk, "Towards identifying and minimizing customer-facing documentation debt", 2023 ACM/IEEE International Conference on Technical Debt (TechDebt), pp. 72-81
- The same paper, authors' copy on arXiv
- Gartner, "Gartner Survey Finds Only 14% of Customer Service Issues Are Fully Resolved in Self-Service", 19 August 2024
- Fogg, B.J., "Stanford Guidelines for Web Credibility", Stanford Persuasive Technology Lab, May 2002
- Tang, Yan, Liu, Meng and Zhong, "Detecting Outdated Screenshot from GUI Document", ACM TOSEM 35(5), article 133, April 2026
- Slite, "The Hidden Dangers of Stale Documentation in 2026", 23 June 2026 (vendor survey)