Human-to-Human Communication in the Age of AI

From meetings and documents to reflection loops and deliberate communication

Code Is Truth, But Not the Story

In a meeting recently, a colleague said something that many developers would probably agree with immediately:

“Code is the ultimate truth.”

At first glance, that sounds perfectly reasonable.

The code is what runs.
The code is what the system does.
If you want to understand reality, read the code.

But when he said it, I pushed back.

I told him: yes, the code shows you what the system does now. But it does not show you how it came to be, which alternatives were considered, which constraints existed at the time, or why it looks the way it does.

A few seconds later, he actually agreed.

He thought of a recent example. We had code written in Python that needed to be translated into Kotlin. On paper, the code was there. The “truth” was visible. And yet that did not mean the important part was obvious. You could read the code and still not understand the surrounding framework, the assumptions behind it, or why it had been written that way in the first place.

That is the gap I keep running into in knowledge work.

We often act as if the artifact is enough. The code. The document. The ticket. The email. But the artifact usually only captures the final shape. It rarely captures the reasoning, the trade-offs, the misunderstandings, the dead ends, or the decisions that produced it.

And once I started seeing that gap clearly, I also started seeing why so much work feels harder than it should.

Not because people are incapable.
Not because the systems are too complex.

But because translating thought into shared understanding is still far more difficult, and far more lossy, than most of our work culture admits.

The Invisible Layer of Knowledge Work

Once you start paying attention to that gap, you begin to see it everywhere.

In theory, knowledge work should be straightforward. People think about problems, make decisions, and produce artifacts: code, documents, designs, reports.

But the artifact is only the visible surface.

The real work happens in the layer underneath.

It lives in conversations, assumptions, mental models, trade-offs, constraints, and half-formed ideas that gradually become clearer over time.

Most of that reasoning never makes it into the final artifact.

The code shows what the system does.
The document shows the conclusion.
The ticket shows the task.

But none of them reliably capture the thinking that produced them.

And that missing layer is where much of the friction in knowledge work actually lives.

We spend a surprising amount of time trying to reconstruct context.

Why was this written this way?
What problem was this supposed to solve?
Which alternatives were considered?
What constraints existed at the time?

Often the answers exist only in fragments: a meeting someone half remembers, a chat thread from weeks ago, a decision that seemed obvious in the moment but was never written down.

To compensate for this loss of context, organizations build communication structures around it: meetings, chat threads, status updates, documents.

But these mechanisms come with their own friction.

Meetings force people to think at the same time.
Chat messages fragment complex ideas into small pieces of conversation.
Documents often capture conclusions but not the reasoning behind them.

The result is a strange paradox.

Knowledge work depends on shared understanding, yet the tools we rely on to create that understanding are often inefficient, noisy, and fragile.

The Reflection Layer

For a long time, the friction in knowledge work seemed unavoidable.

Thinking is messy. Communication is imperfect. Misunderstandings happen. Meetings fill the gaps.

That was simply how collaboration worked.

But something interesting has started to change.

Large language models are often described as tools for generating text or writing code. But in practice, their most important function may be something else entirely.

They act as a reflection layer between thinking and communicating.

Instead of translating thoughts directly into messages, many people now go through an intermediate step.

A rough idea becomes a conversation with a system that helps clarify it. The thought is expanded, challenged, reorganized, or compressed before it ever reaches another human.

The loop looks something like this:

thought
→ reflection
→ structured message
→ response
→ reflection again

The AI is not replacing the thinking. The human is still doing the thinking.

But the friction between having an idea and expressing it clearly becomes much lower.

Instead of struggling to find the right formulation, people can explore their own reasoning more freely. Questions can be tested. Arguments can be refined. Assumptions can be challenged.

By the time the idea is shared with others, it often arrives in a much more structured form.

The interesting consequence is that communication itself begins to change.

What used to happen in meetings or long message threads can now happen partly in private reflection loops.

The human conversation that follows becomes less about figuring out what someone meant, and more about engaging with the actual idea.

And when both sides begin to use the same reflection process, something new emerges.

Not AI agents talking to each other.

But humans communicating through a reflection layer.

Human-to-Human Communication Through a Reflection Layer

Once this reflection layer becomes part of the workflow, something subtle begins to change in how people communicate.

Traditionally, collaboration often happens through rapid back-and-forth interaction. Meetings bring people together to think at the same time. Chat systems simulate the same dynamic in written form, creating rapid exchanges that resemble real-time conversation.

This has one major advantage: the reasoning process becomes visible in real time. People can ask questions immediately, challenge assumptions, and explore ideas interactively.

But that interactivity also comes with a cost.

The signal is mixed with noise. Conversations branch into multiple directions. Context gets lost in threads. Important ideas are scattered across dozens of messages.

And because communication happens in short fragments, misunderstandings become more likely. Tone is easy to misread. A message intended as direct or efficient can easily be perceived as abrupt or dismissive. Conversations that begin as technical discussions can slowly drift into friction simply because participants interpret the same words differently.

There is another effect as well.

Synchronous conversations favor the people who are most comfortable speaking in the moment. The ones who respond fastest, speak longest, or dominate the flow of the discussion often shape the direction of the conversation.

This is rarely intentional, but it is a natural dynamic of real-time interaction.

For people who prefer to think through ideas more carefully, this can be limiting. Good ideas sometimes appear only after reflection, not during the rapid exchange of a meeting or chat thread.

The reflection layer changes that dynamic.

Instead of sending raw thoughts into the conversation, a person first reflects on them. The idea is clarified, structured, and sometimes even challenged before it is shared.

The resulting message often carries more of the reasoning that led to it.

This also allows communication to become more asynchronous.

People no longer have to think at the same moment in order to collaborate. Ideas can be written, reflected upon, and revisited when the recipient has the time and focus to engage with them.

For knowledge work in particular, this can be a significant advantage. Deep thinking requires concentration, and constant interruptions or context switching come with a real cost.

Every time attention is pulled away from a problem, it takes time to reconstruct the mental model that was being built.

The reflection loop helps reduce that overhead.

Instead of interrupting each other with partial thoughts, people exchange more complete ideas at moments when they are ready to engage with them.

The interaction becomes less about reconstructing what someone meant, and more about engaging with the substance of the idea itself.

In my own work, I have been experimenting with simple ways to support this kind of communication.

One example is a three-layer structure for messages:

• Overview — for quick scanning
• Summary — for coherent reasoning
• Context — for background thinking

The goal is not to create a rigid system or a new formal process.

It is simply an attempt to preserve more of the reasoning that normally disappears during communication.

And importantly, this is still evolving.

The format itself is not the point.

The real shift is that communication becomes deliberate again.

Not necessarily synchronous.
Not necessarily interactive in real time.

But clearer, more reflective, and easier to build upon.

Why This Is Hard

At this point the idea might sound appealing.

Lower friction.
More deliberate communication.
Reflection before interaction.

But there is an important caveat.

None of this happens automatically.

In fact, working this way requires a shift that is not purely technical. It is cognitive and cultural.

Many people currently approach AI tools in a very different way.

They use them as assistants for small tasks: reformatting a piece of code, generating a test, rewriting a paragraph, or producing a quick snippet. In software development this often looks like delegating work to what is essentially treated as a junior developer.

The interaction becomes transactional.
A request is made. A result is returned. The human evaluates the output and moves on.

There is nothing inherently wrong with this approach. In many situations it is perfectly useful.

But it leaves a large part of the potential untouched.

AI systems are not only tools for producing outputs. They can also act as mirrors for thought. They can help structure reasoning, challenge assumptions, and make implicit ideas explicit.

Using them this way requires a different mindset.

Instead of simply asking for results, the interaction becomes part of a reflection process. Ideas are explored, refined, and sometimes restructured before they are turned into concrete work.

For people who are used to fast task execution, this can feel inefficient at first.

It may even feel excessive.

Why spend time structuring an idea when you could immediately jump into implementation? Why write a structured message when a quick chat response might move things forward faster?

The answer only becomes visible over time.

When reasoning is externalized and structured, the quality of communication improves. Fewer misunderstandings occur. Decisions become easier to revisit. The path that led to an implementation remains visible instead of disappearing.

But reaching that point requires something else: metacognition.

Metacognition simply means thinking about how we think. It is the ability to observe our own reasoning processes and intentionally adjust them.

For many people this is not something they actively practice in their daily work. Not because they lack the ability, but because traditional workflows rarely reward it.

In my own case, this shift was not planned.

When I started experimenting with AI tools several months ago, I did not set out to build a reflection loop or develop a new communication model. I simply began using these tools for a wide range of tasks: coding, writing, exploring ideas, and sometimes even working through personal questions.

Over time something changed.

The interaction itself started to shape how I thought about problems. Instead of jumping directly to solutions, I began exploring the reasoning behind them. Questions led to more questions. Ideas became easier to articulate.

Only later did I realize that what had emerged was a form of metacognition.

That realization also explains why this model does not spread automatically.

It requires curiosity.
It requires experimentation.
And most importantly, it requires people to see value in reflecting before acting.

Some people will naturally gravitate toward this way of working. Others may find it unnecessary or overly elaborate.

Both reactions are understandable.

But as AI tools continue to reduce the friction of expressing and structuring thoughts, the barrier to experimenting with this kind of reflection becomes lower and lower.

The real challenge is not technical.

It is cultural.

And cultural shifts rarely happen instantly.

They emerge gradually, as individuals begin experimenting with new ways of thinking and communicating.

Beyond Software Development

Although many of the examples in this essay come from software development, the underlying pattern is not limited to writing code.

Software simply makes the dynamics easier to see.

Developers work with complex systems, abstract models, and evolving designs. Decisions made early in a project can influence the behavior of a system months or even years later. Because of this, the reasoning behind decisions matters almost as much as the decisions themselves.

But the same structure appears in many forms of knowledge work.

Architects design buildings that will only exist months later.
Product teams define features that shape how thousands of users interact with a system.
Researchers develop hypotheses that evolve over time as new evidence appears.
Writers construct arguments that depend on layers of reasoning built across multiple drafts.

In all of these cases, the visible output is only the final layer of a much larger thinking process.

Traditionally, much of that thinking remains invisible.

Meetings capture fragments of it.
Documents often preserve conclusions but not the exploration that led to them.
Chat conversations scatter the reasoning across dozens of messages.

The result is that teams repeatedly reconstruct the same context.

Someone joins a project and asks why a decision was made.
A colleague tries to explain the reasoning from memory.
Pieces of the story reappear, but rarely in full.

This is not a failure of documentation.

It is simply a reflection of how difficult it has been to externalize complex thinking in a way that is both natural and efficient.

AI-assisted reflection changes that equation.

Because expressing ideas has become easier, people can capture more of their reasoning while it is still fresh. Thoughts that might previously have remained internal can now be structured, clarified, and shared with relatively little friction.

The reflection loop described earlier is one way to support that process.

Instead of communicating only conclusions, people begin sharing parts of the reasoning that led to them. Instead of reconstructing context repeatedly, teams can build on a visible trail of thought.

This dynamic is not limited to professional environments.

Any situation where people try to understand each other can benefit from clearer reflection before communication.

Personal relationships, collaborative hobbies, and shared decision-making all involve the same underlying challenge: translating complex internal thoughts into something another person can understand.

Sometimes that translation benefits from a moment of reflection before speaking. A thought that is difficult to express in the heat of a conversation may become much clearer when it is written, structured, and revisited.

In that sense, the reflection loop is not just a professional tool. It is a way of slowing down the translation between thinking and communicating.

This does not eliminate meetings, chats, or spontaneous conversations. Those forms of interaction remain important.

But their role shifts.

Meetings become moments for alignment rather than discovery.
Chats become coordination rather than exploration.
Documents become living reflections of evolving reasoning instead of static artifacts written after the fact.

In that sense, AI does not simply accelerate existing workflows.

It enables a different relationship between thinking, communication, and collaboration.

The boundary between individual reflection and collective reasoning becomes more fluid.

And when that happens, knowledge work itself begins to change.

The Cultural Shift

If the reflection model described so far seems compelling, an obvious question follows:

Why is this not already the dominant way knowledge work is organized?

The answer has less to do with technology than with habit.

Most organizations were built around synchronous coordination. Meetings, quick conversations, and rapid exchanges became the default mechanisms for making progress. In many environments, the ability to respond quickly is even seen as a sign of productivity.

But speed and clarity are not always the same thing.

When communication is driven primarily by immediacy, the goal often becomes moving the conversation forward rather than developing the idea fully. Decisions emerge from interaction, not necessarily from reflection.

Over time this creates a familiar pattern.

People gather in meetings to explore ideas that are still forming.
Discussions branch into multiple directions.
Context has to be reconstructed repeatedly.
And once the meeting ends, much of the reasoning disappears with it.

The result is a cycle where the same ideas need to be rediscovered again and again.

This is not because people are careless or unwilling to document their work. It is simply the path of least resistance in environments where communication tools were historically optimized for immediacy rather than reflection.

Chat systems accelerated this dynamic.

They reduced the friction of sending messages, but they also encouraged faster interaction cycles. Conversations that might once have been carefully written emails became streams of short fragments sent back and forth in rapid succession.

In earlier days, writing an email often meant taking a moment to structure a thought. The message had to carry enough context for the recipient to understand it later, sometimes hours or even days after it was sent.

Instant messaging changed that rhythm.

Instead of a single deliberate message, communication turned into a sequence of small exchanges. Context moved from the message itself into the surrounding conversation.

From the outside this often looks efficient.

But for complex work it can create a hidden cost: the constant reconstruction of context.

Every participant must repeatedly rebuild the mental model behind a discussion. Ideas are clarified incrementally, but the reasoning behind them remains distributed across many interactions.

The reflection loop described earlier challenges that default.

Instead of relying primarily on synchronous interaction, it introduces a deliberate step where thinking is structured before it enters the conversation.

That shift changes several things at once.

Communication becomes slower at the point of writing, but clearer when it is received.
Meetings become less about discovering ideas and more about aligning around them.
And reasoning that would normally disappear in conversation becomes part of the shared context.

This is where the cultural shift appears.

For people used to rapid interaction, this approach can initially feel unfamiliar. Writing structured thoughts takes effort. Reading them requires attention. The pace of conversation changes.

But over time the balance shifts.

Less time is spent reconstructing what someone meant.
Fewer meetings are needed to clarify ideas that were never fully expressed.
And the shared understanding of a system or decision becomes easier to maintain.

The technology that enables this shift is relatively new.

The cultural habits surrounding communication, however, are decades old.

Changing them will not happen overnight.

It will happen gradually, as individuals and teams experiment with new ways of thinking, writing, and collaborating.

And like most cultural shifts, it will likely start with small local experiments rather than formal mandates.

An Ongoing Experiment

Everything described in this essay should be understood for what it is: an experiment.

There is no framework here. No formal methodology. No claim that this is the one correct way to organize thinking or communication.

What exists so far is simply a set of observations.

AI tools have dramatically lowered the friction of expressing thoughts.
That change makes it possible to externalize reasoning more easily than before.
And once reasoning becomes visible, the way people communicate and collaborate can begin to shift.

The reflection loop described earlier is one attempt to explore that possibility.

Instead of treating AI only as a generator of answers, it can become a partner in the thinking process. A tool for clarifying ideas, structuring reasoning, and translating complex internal thoughts into something others can understand.

The consequences of that shift are still unfolding.

Some people will use AI primarily as a fast assistant for small tasks. Others will explore it as a way to augment their thinking and communication. Most workflows will likely fall somewhere in between.

What matters is not which specific format people adopt.

The three-layer message structure described earlier, for example, is not a prescription. It is simply a practical experiment that emerged while trying to make reasoning more visible during collaboration.

It will likely evolve. It may even disappear if better patterns emerge.

What seems more durable is the underlying idea.

If expressing thoughts becomes easier, reflection can become part of everyday work again. Communication can carry more of the reasoning behind decisions. And collaboration can gradually move from reconstructing context toward building on shared understanding.

None of this requires organizations to adopt a new process overnight.

Most cultural shifts begin much smaller.

Someone writes a more deliberate message.
A colleague responds with a more thoughtful reply.
A team experiments with capturing reasoning before jumping into implementation.

Small changes accumulate.

Over time, the way people think together begins to evolve.

And perhaps that is the most interesting part of the shift we are currently witnessing.

For the first time, tools exist that make structured reflection almost frictionless. Thoughts that once remained internal can now be explored, refined, and shared with far less effort than before.

What people choose to do with that capability is still an open question.