Connect your sources. Docs appear.

GitHub.
Fabric reads your merged pull requests, code changes, and repository activity, then produces engineering documentation that reflects what your team has actually built. No manual authoring required.

Slack.
Decisions, discussions, and context that would otherwise disappear into chat scroll are captured and filed as documentation. Fabric monitors the channels you choose and identifies what matters.

Discord.
For teams using Discord as internal comms or community platforms, Fabric captures decisions and knowledge the same way. Turn a chaotic server into a searchable knowledge base.

Meetings.
Decisions, action items, and context from meetings are extracted and filed where they belong. Meeting content stops being something you have to remember and becomes part of your documentation.

Your existing workspace.
Your team already has months of scattered notes, files, and recordings across Fabric. Point the docs feature at your existing spaces and Fabric synthesizes it all into organized documentation. No external connections needed.

Always current. Never stale.

Continuous updates.
Fabric keeps watching your connected tools after the initial docs are produced. When your team merges new PRs, makes decisions in Slack, or holds meetings, the relevant documentation is updated to reflect the latest state.

Setup in minutes.
A setup wizard guides you through connecting your sources and choosing what to watch. This is a configuration that takes minutes, not a documentation project that takes weeks. Fabric handles structure, organization, and maintenance from there.

Knowledge gaps filled.
As more content flows through your connected tools, Fabric identifies areas where documentation is missing or thin. Gaps get filled automatically as your team works, without anyone being assigned to write docs.

The documentation problem nobody solves.

Every team has the same problem with documentation. It either does not exist, or it exists but is outdated. The reason is straightforward: documentation requires someone to write it, and then someone to keep it updated. Both of those tasks compete with actual work, and actual work always wins. The result is knowledge trapped in people's heads, buried in Slack threads, scattered across PR descriptions, and locked inside meetings that nobody transcribed.

The cost of this is real. New hires take months to ramp up because there is nothing accurate to read. Decisions get re-debated because nobody remembers what was already resolved. Engineers spend hours answering the same questions because the answer was never written down. Teams duplicate work because they cannot find what already exists. For startups growing fast, agencies managing multiple projects, and research teams building on previous findings, the absence of documentation is one of the most expensive hidden costs in the organization.

Fabric writes it. You review it.

Self-writing docs works differently from every documentation tool that came before it. Traditional wikis like Confluence or Notion require someone to sit down and write. Even AI writing assistants still need a person to prompt, review, and organize the output. Fabric does not wait for someone to start writing. It connects to the tools your team already uses, watches the activity flowing through them, and produces documentation from that activity. Connect your sources, and docs begin appearing within 24 hours.

The output is real, structured documentation. Engineering docs assembled from merged PRs and code changes. Decision logs compiled from Slack and Discord conversations. Project documentation built from meeting notes and file activity. Onboarding guides synthesized from your existing knowledge base. Each doc type is assembled from the relevant sources and organized into your workspace where it can be searched, annotated, and discussed with your AI assistant.

Not an agent. A product capability.

Fabric has background agents that you can configure, schedule, and dispatch on specific tasks. Self-writing docs is something different. It is a product-level capability that operates at the system level. You do not write a prompt or define a schedule. You connect your sources, tell Fabric what to watch, and documentation appears. The distinction matters because it means you do not need to think about how to get docs written. Fabric just does it. You and your team can then read, edit, annotate, and build on the docs, but the initial creation and ongoing maintenance is handled automatically.

It compounds.

Every merged PR, every Slack decision, every meeting, every note saved to your workspace makes the documentation richer. The system becomes more valuable over time without anyone maintaining it. After a month, you have a documentation set that would have taken weeks of dedicated authoring to produce manually. After six months, you have a comprehensive knowledge base that reflects the full history of your team's work, decisions, and thinking. For consultancies managing client work across multiple engagements, or startups scaling fast with new hires joining regularly, this compounding effect means documentation gets better precisely when you need it most.

What gets produced.

Engineering docs
Architecture decisions, API docs, migration notes, dependency changes, and system overviews. Assembled from PRs, Slack discussions, and technical meetings. The engineering wiki that updates with every deploy.

Product docs
Roadmap context, feature decisions, user feedback synthesis, and spec evolution. Assembled from meetings, Slack, and product spaces. The living product bible nobody has to maintain.

Decision logs
What was decided, when, by whom, and why. Assembled from meetings, Slack, and Discord. The queryable record of every important call that stops teams from re-debating resolved questions.

Onboarding guides
Everything a new hire needs: processes, tools, team context, and project history. Assembled from all sources. Always current because it updates as the company evolves. See how Fabric supports onboarding.

Client relationship tracker
Per-client pages with deal history, meeting summaries, decisions, deliverables, and open items. Assembled from client calls, emails, and Slack channels. Full context before every client conversation without anyone updating a CRM. See how Fabric supports CRM.

User research repository
Interview summaries, synthesized findings, recurring themes, and participant insights. Assembled from recorded interviews, notes, and team discussions. The research repository that builds itself with every session.

Sales knowledge base
Objection handling, competitive intel, pricing precedents, and win/loss context. Assembled from sales calls, Slack, and deal notes. New reps ramp faster because the playbook writes itself from real conversations.

Company changelog
A running record of what changed across the company each week. Assembled from all sources. The weekly digest nobody has to write. New hires read the last month and they are caught up.

Use cases

Team wikis
Stop manually building and maintaining your internal wiki. Connect your sources and let Fabric produce documentation that stays current as your team works. See how Fabric supports team wikis.

New hire onboarding
Give new team members documentation they can trust. Self-writing docs produce onboarding materials that reflect the current state of your company, not a snapshot from when someone last had time to update the wiki. See how Fabric supports onboarding.

Project documentation
Keep project docs current without assigning someone to maintain them. Engineering decisions, product context, and project history are documented as they happen across your connected tools. See how Fabric supports project docs.

Sales and client context
Build a client relationship tracker and sales knowledge base from meetings, messages, and team activity. New account managers can get up to speed from docs that wrote themselves. See how Fabric supports sales collateral.

Perfect for

Startups
Growing teams need documentation to scale, but nobody has time to write it. Self-writing docs give you a knowledge base that grows with your company without anyone being assigned to documentation duty. Learn more about Fabric for startups.

Agencies
Manage knowledge across multiple clients and projects without documentation falling through the cracks. Client context, decision history, and project status are documented automatically for every engagement. Learn more about Fabric for agencies.

Research teams
Capture decisions, methodologies, and findings from meetings, messages, and research activity. Build a user research repository and institutional knowledge base that makes previous work discoverable for future projects. Learn more about Fabric for research teams.

Engineering teams
Technical documentation assembled from your actual development workflow. PRs become docs. Architecture discussions become decision records. The documentation reflects what was built, not what someone remembered to write down.

Works seamlessly with other features.

AI assistant
Your AI assistant can search, reference, and answer questions from all self-written docs. Ask it about a past decision, a system's architecture, or a client relationship and it draws from documentation that is always current.

Smart search
All produced docs are fully searchable alongside your other content. Find decisions, engineering context, and project information through natural language queries.

Collaboration
Self-written docs are editable and collaborative. Your team can review, annotate, discuss, and build on any document that Fabric produces. Comments, @mentions, and threaded discussions work the same way as any other content.

Connections
Self-writing docs are powered by your connections to external tools. The more sources you connect, the richer and more comprehensive the documentation becomes.

FAQ

How long does it take to get started?
A setup wizard walks you through connecting your sources and choosing what to watch. Most teams are configured in minutes. Documentation begins appearing within 24 hours of connecting your sources.

What sources can Fabric connect to?
Currently supported sources include GitHub, Slack, Discord, meeting recordings, and your existing Fabric workspace including notes, files, and saved content. Additional sources are being added. For existing integrations, see the connections marketplace.

What types of docs does Fabric produce?
Engineering docs, product docs, client relationship trackers, user research repositories, sales knowledge bases, onboarding guides, decision logs, and company changelogs. Each doc type is assembled from the relevant sources automatically.

How does Fabric decide what to document?
Fabric analyzes the activity flowing through your connected tools and identifies content that belongs in documentation: decisions, technical changes, project updates, and knowledge that would otherwise be lost. You can configure what to watch and what to ignore during setup.

Can I edit the docs Fabric produces?
Yes. Self-written docs are full Fabric documents that you can edit, annotate, reorganize, and collaborate on. Fabric produces the initial content and keeps it updated, but you have full control over the final output.

What happens if Fabric updates a doc I have edited?
Fabric is aware of manual edits and incorporates them into its ongoing updates. Your changes are preserved and new information is added around them rather than overwriting your work.

How is this different from background agents?
Background agents are user-configured AI workflows that you write prompts for, schedule, and manage. Self-writing docs is a product-level capability that works at the system level. You do not need to write prompts or define schedules. Connect your sources and documentation appears. Agents can then work with the docs Fabric produces, building on them or using them as context for other tasks.

How is this different from Scribe or similar tools?
Scribe documents how you click through software. Fabric documents what your company knows. Scribe produces process documentation showing step-by-step instructions for using tools. Fabric produces knowledge documentation covering decisions, engineering context, project history, and institutional knowledge. Both create docs automatically, but for fundamentally different content.

Can I control what gets documented?
Yes. During setup you choose which sources to connect and what activity to watch. You can adjust these settings at any time to expand or narrow what Fabric documents.

Does the documentation improve over time?
Yes. Every PR, message, meeting, and saved note adds to the documentation. The system compounds, getting richer and more comprehensive as your team works. Knowledge gaps are identified and filled automatically as relevant activity occurs.

Which plans include self-writing docs?
Self-writing docs is available on Team plans. See team pricing for details.