AI and documentation: the end of the excuse, not the end of the problem

In the previous article, I said that documentation is uncomfortable because it reduces ambiguity and makes decisions binding. This is not a tooling issue. It is a cultural one.

AI does not change that. It changes something else: it removes part of the excuses. And it will force many teams to face the issue sooner than they imagine.

Let me be clear right away about what I mean, because there is a frequent misunderstanding. I am not talking about technical documentation (the kind often dumped on developers), nor user documentation (the kind produced at the end of the chain because “you need a guide”). I am talking about project documentation, in the broad sense: decisions, trade-offs, assumptions, renunciations, the reasons why this choice was made, at that moment.

The trace will become a by-product

We already have the technology in front of us. Many companies use Teams, Meet, or Zoom every day. These tools increasingly integrate transcription, summarization, and action-item extraction features. On the Microsoft side, Copilot is making its way into Teams and the 365 ecosystem. On the Google side, Gemini is being pushed into Workspace and Meet. Zoom has its AI Companion. And if a company does not want to enable these features in “corporate” tools, there is a whole galaxy of dedicated note-taking tools like Otter.ai, Fireflies.ai, Fathom, or tl;dv.

The result is simple: documentation will no longer be just a voluntary effort. It will become a flow. A capturable background noise.

Today, we document when we have the courage, when we have the time, or when we are forced by necessity. Tomorrow, we will have a meeting trace almost by default. A summary. A timeline. A list of supposed “decisions”. Sometimes even a draft report ready to be pasted into Notion or Confluence.

This is good news on one specific point: we will no longer be able to say “we didn’t have time to write”.

But it opens another, much more delicate question: what do we agree to record?

The end of comfortable orality

In many organizations, oral communication is a refuge. We “frame” things in meetings, we “align” in video calls, we “decide” half-explicitly. Then everyone leaves with their own version. Ambiguity protects. It helps manage tensions. It avoids crystallizing disagreement. It provides an exit when a decision turns out to be wrong.

Automatic transcription and summarization shine a spotlight on this.

It is not so much that the tool records word for word. It is that it makes the conversation consultable. A month later, you can find the moment when someone said “ok, we’ll do it this way”. You can see that the risk was mentioned. You can note that the assumption was fragile. You can go back to the moment when a trade-off was made under constraint.

And this is where we touch the nerve: enforceability.

This is exactly what already made people uneasy about “classic” documentation. Except this time, the trace does not wait for us to decide to write it. It appears on its own.

I expect to see a fairly predictable reaction in teams: at first, everyone finds it convenient. Then they realize it changes the balance of power. That it puts sentences in the light. That it removes some room for maneuver from after-the-fact narratives.

The real leap is not “summarizing a meeting”, it is “finding the why”

The most interesting point, in my view, is not even note-taking. It is search.

When you combine transcripts, documents, tickets, Slack messages, emails, PRs, you no longer just have an archive. You have a knowledge base that can be queried.

And this is where things get serious, because AI is very good at traversing a corpus and reconstructing a thread. Notion AI already does this on a well-maintained workspace. Confluence is pushing its “intelligence” features into the Atlassian ecosystem. Slack AI promises to surface discussion summaries. Copilot and Gemini aim to become the natural interfaces to everything lying around in a Drive or a SharePoint.

The questions “who, what, when, why” suddenly become accessible.

Not in the sense of “I read twenty documents”. In the sense of “I ask a question”.

Why did we choose this solution over another?
When did we decide to postpone this security requirement?
Who validated this workaround, and in what context?
Which options were discarded, and for what reason?

That is project documentation. And it is exactly the kind that is most often missing.

Not because no one knows how to write it. But because many organizations prefer these answers to remain diffuse, fragmented, debatable.

AI makes that blur harder to maintain.

New risk: abundant but fragile documentation

There is a trap: AI can produce very convincing documentation… even when it is wrong, or too clean.

An automatic summary can smooth over a real disagreement. It can turn a hypothesis into a certainty. It can act “as if” a decision was made because an ambiguous sentence was interpreted that way. And because it is written, the organization can cling to it.

This risk seems underestimated to me. We tend to think: “it’s better than nothing”. Yes, sometimes. But an incorrect and widely distributed trace can do more damage than the absence of a trace, because it turns into operational truth.

From the moment documentation is generated continuously, rules are also needed: how it is corrected, how it is invalidated, how a meeting note is distinguished from an official decision.

Otherwise, the documentation problem is not solved. It is displaced. We replace a lack of documentation with abundant documentation, but without status.

What is coming: the politics of the trace

We are therefore moving from a world where documentation is rare, costly, and intermittent, to a world where the trace is easy, almost permanent, and queryable.

This will relieve teams on one obvious point: fewer context losses, fewer “let’s redo the discussion”, fewer phantom decisions. But it will also force a more mature conversation about the governance of that trace.

What do we record? What do we not record?
Who has access, and at what level of detail?
How long do we keep it?
And above all: what is binding, and what is not?

The topic will no longer be “who writes the documentation”.
It will be: what are we willing to make visible about how we actually make decisions.

And I am not sure organizations are ready. Not technically. Culturally.