Enterprise Context Layer - Automating Documentation (2)
As product velocity increases, documentation quickly falls out of sync with reality. Andy Chen and Sara Faradji are building a Claude Code–powered documentation layer that automatically updates knowledge bases, reconciles conflicting sources, and ships customer-facing updates within minutes of code changes.
March 13, 2026
Velocity Can Muddy Documentation
As Abnormal ships faster, documentation sometimes struggles to keep up.
Feature details live in Jira tickets, Slack threads, code comments, release announcements, and internal docs. Each source may be accurate in isolation, but together they create contradictions. A roadmap date might say May in one place and July in another. Slack may contain the freshest update, but it’s buried in conversation. AI bots that try to synthesize answers across all sources often surface citations that conflict or chain back to other incomplete threads.
This fragmentation creates a compounding problem. The more sources of truth exist, the harder it becomes for both humans and AI to determine what’s actually correct.
Andy Chen, who has been building the Feature Question Bot and help.abnormal.ai, began to see that answering questions wasn’t enough. The deeper issue wasn’t response quality, but rather documentation governance.
Documentation as a Governed AI Layer
Instead of treating documentation as static files written by humans, Andy and Sara began experimenting with what they call “Claude Code for documentation.”
The idea is simple but powerful: documentation becomes a unified context layer that is maximally AI-readable, AI-retrievable, and AI-editable. Rather than manually updating scattered docs, both humans and AI can propose changes into a single version-controlled repository.
In practice, this means:
Asking questions directly in Slack (e.g., “What languages are on the roadmap for AI Phishing Coach?”)
Receiving answers grounded in structured documentation
Generating pull requests to update outdated content
Reviewing changes side-by-side in GitHub
Publishing updates directly to customer-facing help pages
Instead of writing content in isolation, documentation becomes collaborative, iterative, and managed with the same rigor as code.
What It Looks Like in Action
Sara demonstrated how this system works in real workflows.
If a product manager asks what languages are supported or on the roadmap, the bot synthesizes the current state and surfaces source references. If a guide is outdated (say, a PowerShell integration changed in code), the bot can propose updates automatically. A PR is opened, showing exactly what needs to change, and reviewers can approve or modify it directly.

From there, a simple “publish” command pushes the updated content live to the help site within minutes.

The result is a docs-as-code workflow where Slack becomes an entry point for documentation changes. GitHub becomes the version-controlled source of truth, and the help site becomes an automatically updated reflection of product reality.
Even more powerful, the same documentation layer can power Slack bots, help centers, customer portals, and internal tools simultaneously.
AI Governs the Knowledge Layer
The most important shift here is governance.
Instead of AI trying to reconcile conflicting sources at query time, this system continuously normalizes and updates documentation itself. Humans can prompt changes. AI can propose corrections when code or Slack announcements diverge from current documentation. Over time, the knowledge base becomes cleaner, more structured, and more reliable.
This transforms documentation from a reactive task into an active, living system.
With this approach, the lag between feature shipment and customer-facing documentation shrinks from weeks to minutes. Coordination overhead disappears. Teams no longer need to chase down “is the guide updated?” before making announcements.
Internally, it reduces context-switching across tools. Externally, it ensures customers always see accurate, up-to-date information. Most importantly, it lays the groundwork for a company-wide AI-readable context layer, where product knowledge is not scattered but unified.
What’s Next
The team is exploring confidence scoring, truth prioritization, and automated weekly summaries of major changes. They’re also thinking about how this governance layer can integrate more deeply with roadmap planning and release workflows.
The broader vision is clear: the fastest-moving AI-native companies won’t treat documentation as an afterthought. They’ll treat it as infrastructure. Andy and Sara are building exactly that.
Problem
Product knowledge lived across Slack, Jira, docs, and code, often conflicting and quickly becoming outdated as features shipped.
Solution
A unified, AI-governed documentation layer that treats docs as code by keeping it continuously updated, reviewable, and publishable through Slack commands.
Why it's cool
It collapses fragmented knowledge systems into a single AI-readable, AI-editable layer that keeps pace with product velocity.
Technologies used:
- Claude Code