Your documentation is wrong the moment you ship
Ship a feature on Tuesday and something in your documentation becomes false on Tuesday: a renamed field, a changed default, a new setting the setup guide doesn't mention yet. Nobody decides to let the docs go stale. It happens because the person who changed the code and the person who owns the docs were never the same person, and the space between a merged pull request and an updated help page is where the rot sets in.
That space is what Promptless is built to close.
Promptless is an AI teammate that keeps customer-facing documentation current on its own. It watches the places where product changes actually surface, a pull request, a resolved support ticket, a message in Slack, and when something changes that the docs should reflect, it drafts the update and opens it as a pull request for a human to review and merge. The founders put it plainly: an AI teammate that updates your customer docs before you even ask.
Writing was never the real problem
Most teams treat documentation as a writing chore. You block off an afternoon, you write the guide, you move on. That framing is the reason the problem never gets solved, because the writing was rarely the hard part. The hard part is knowing that a specific paragraph on a specific page is now wrong, and knowing it before a customer hits it. Promptless's argument is that doc drift is a detection problem first and a writing problem second.
Watch how a single change propagates. An engineer merges a pull request that renames an API parameter. The change is correct, tested, shipped. Three weeks later a support agent answers a confused ticket, notices the docs still reference the old name, and files it in a backlog that a technical writer will get to eventually. By then the same confusion has reached other customers who never wrote in. Everything needed to fix the page existed the moment the pull request merged. It just never reached the page.
That is the quiet liability sitting inside every product company. The docs are a snapshot of how the software worked on the day someone last looked. The software keeps moving. The snapshot does not.
What Promptless actually does
Promptless installs at the points where change originates rather than the point where someone finally notices the damage. A pull request in GitHub, GitLab, or Bitbucket kicks off an analysis when a feature or fix lands. A resolved Zendesk or Intercom ticket signals that customers keep hitting the same gap. Tagging @Promptless in Slack or Microsoft Teams tells it to look into a specific change. Under all of these triggers the same loop runs: read the code diff, the existing docs, and the relevant tickets and conversations, decide which pages are affected, write the proposed edit, and show its work by citing the sources behind the change.
The part that makes those edits usable is the context it builds before it writes a word. On setup, Promptless crawls the entire documentation site and builds a model of how the product is described, what lives where, and which pages lean on which concepts. The company calls this a product ontology. It is the difference between an autocomplete that rewrites one sentence and a system that understands a single parameter rename touches the quickstart, two API reference pages, and a troubleshooting note nobody would have thought to check.
Take the parameter rename from earlier. In a Promptless workflow, the pull request that renames it is itself the trigger. The agent reads the diff, checks the ontology for every page that references the old name, and drafts edits to each one, the quickstart, the reference pages, the troubleshooting note, in a single proposed change. It attaches the reasoning too, pointing back to the exact lines of code and prior docs it drew from, so a reviewer can see why each edit was made instead of trusting a black box. The gap that used to run three weeks and a support ticket collapses into a review that lands the same afternoon the code does.
Drafts arrive as pull requests in whatever system already holds the docs, or as edits inside a CMS. Docs kept in a Git repo get a normal pull request. Teams on ReadMe, Mintlify, Zendesk, Intercom, or Webflow get the change pushed to where they publish. Nothing goes live on its own. A person reviews, adjusts, and merges using the tools they already use, which keeps a human accountable for what customers eventually read. The agent proposes; the team still decides.
For larger organizations that review step doubles as a safety boundary. Promptless applies fine-grained permissions so internal detail from a private Slack channel or an engineering ticket cannot leak into a public help page, and SOC 2 compliance is on the roadmap. For a tool that reads across a company's code, tickets, and internal chatter, that boundary matters as much as the writing. The value would evaporate the first time a confidential note showed up on a public page.
Two founders who hit the problem from opposite sides
Promptless comes from two people who lived this pain in different roles.
Frances Liu was Head of Data Science at OneSignal, a YC company itself. Digging into customer data, she found that how much a new customer engaged with documentation in their first 24 hours was among the strongest predictors of that customer's long-term value. In her numbers, docs behaved like an activation surface, an early signal of which customers would stick and how much they would spend.
Prithvi Ramakrishnan was VP of Product and Engineering at Bond, later acquired by FIS. He lived the other half of the story. Keeping customer docs good took a coordinated effort across several teams, and he ended up writing many of the guides himself. He watched how much senior time went into keeping pages accurate, and how fast they slid out of date anyway.
Put those two experiences together and the thesis writes itself. Documentation measurably drives adoption and retention, and the work of keeping it accurate is expensive, thankless, and always the first thing to slip when a team is busy. That is precisely the shape of problem worth handing to software.
Why this is buildable now
Two things changed to make Promptless possible. Language models got good enough to read a code diff, work out what a change means for a reader, and write a clear explanation of it in a product's existing voice. And the pace of shipping went up, partly because those same models now write more of the code. More changes per week means more documentation debt piling up per week. The old manual model, where a writer trails engineering and patches pages after the fact, falls further behind the faster a team moves.
The company frames the cost in dollars. It estimates that documentation debt runs mid-sized engineering teams somewhere between $500,000 and $2 million a year once you count support load, churn from confused users, and the senior engineering hours spent writing and rewriting pages. A given team's real number will vary, but the direction is hard to argue with. Stale docs still cost money. The bill just arrives indirectly, through support tickets and quiet churn rather than a line item anyone tracks.
Not a doc generator
There is a crowded field of tools that generate documentation, and it would be easy to file Promptless next to them. That misreads what it does. A generator helps you write a page faster once you have sat down to write it. Promptless is built for the moment you never sit down, the change you didn't realize created a documentation problem in the first place. Its unit of work is not a blank page. It is a diff against reality.
That is also why it sits alongside the docs stack instead of replacing it. Teams keep Mintlify, ReadMe, or their Git repo. Promptless is the layer that notices when the content in those systems has drifted from the product and proposes the correction. Seen that way, it reads less like a writing tool and more like an accuracy monitor for everything a company has already published.
The traction backs the framing. Promptless went through Y Combinator's Winter 2025 batch and was among the top companies in it by revenue, which is a strange thing to be able to say about a documentation product. It is backed at pre-seed by Scale Asia Ventures and Orange Collective, and the company says its customers already span fast-growing startups and Fortune 500 enterprises. Its Promptless 1.0 release aimed squarely at the hardest parts of docs automation, the detection and precision problems that make naive approaches produce confident, wrong edits.
The synchronization job
The bet underneath all of this is that documentation stopped being a writing job and became a synchronization job. Products change too often, across too many surfaces, for a human to catch every downstream page by hand. Promptless treats docs the way a build system treats code, as something that should be continuously reconciled against the source of truth, with a person signing off on the result.
If that framing holds, the teams that win on developer and customer experience will not be the ones with the best writers on staff. They will be the ones whose docs were quietly right the whole time, because a teammate was watching every change and fixing the page before anyone thought to ask.