← Back to Omnioculars

The Muscle Memory of a Million Commits

March 6, 2026
aisoftware-developmentengineering-culture

We are in the middle of handing software development to AI agents. We are doing it faster than we understand what we are handing over.

The conversation has been almost entirely about access — how much of the codebase can the agent see, how many tools can it use, how much context can we stuff into the window. More access, better output. That assumption has driven an entire generation of tooling.

But access is not the same as understanding. And understanding, it turns out, has two layers. We have been building for one of them.

Your Fingers Know Things Your Brain Doesn't

There is a moment, somewhere in learning to type, where you stop thinking about where the keys are. Your fingers begin to find them before the thought fully forms. Ask someone who types at 90 words per minute where the letter G is, and they'll hesitate — then tap their left index finger against the air instinctively, because the knowledge isn't stored in language. It's stored in motion.

Neuroscientists call this procedural memory. It lives in a different part of the brain than facts do. Declarative memory is what you can describe — names, dates, decisions, and reasons. Procedural memory is what you just do — patterns built through repetition until they no longer require conscious retrieval.

The distinction matters for one specific reason: you cannot transfer procedural memory by describing it. You can write down everything you know about riding a bike. You can document the physics, the balance mechanics, and the steering corrections. The reader will still fall.

Somewhere along the way, we started using the word "context" to mean both the facts we can articulate and the instincts we cannot

Write.It.Down: Documents Are a Compression of Reality

In the film Arrival, linguist Louise Banks is brought in to translate an alien language. The military wants answers fast — extract meaning, transfer knowledge, move on. Louise knows it doesn't work that way. To understand the Heptapods, she has to live inside their language until it changes her. The knowledge isn't something she retrieves. It's something she becomes.

Enterprise documentation systems are built on the military's assumption.

Gottfried Leibniz spent years pursuing what he called a characteristica universalis — a universal symbolic language where all human knowledge could be encoded and transferred without loss. Three centuries later, enterprise engineering organizations are still chasing the same dream. Architecture decision records. Confluence pages. Runbooks. The belief is identical: if we write down what we know, the knowledge survives us.

But documentation is always a compression. Every document was written by a person in a meeting, after a decision, during a migration, or before they left for another company. The moment that person walked out, the document began its slow drift from reality. Not because anyone neglected it. Because reality kept moving, and documents, by nature, do not.

Some knowledge resists encoding not because we lack the right symbols, but because it was never held symbolically in the first place.

We have built increasingly sophisticated systems to search, retrieve, and surface these artifacts — knowledge bases, semantic search, and AI-powered retrieval over decades of Confluence pages, Jira tickets, and Slack threads. We have made the archaeology faster. We have not made it less archaeological. And all of it assumes the same thing: that what matters was written down.

That assumption has a limit.

The Knowledge That Accumulated Without Anyone's Permission

A layer of knowledge emerged through repetition. Through thousands of individual decisions that each seemed unremarkable in isolation.

A module that kept getting touched whenever payments changed. A configuration file that seemed unrelated to everything but somehow appeared in every incident. A directory that senior engineers navigated around instinctively, not because they remembered a specific decision to do so, but because they'd seen what happened when someone didn't.

This is the procedural memory of a codebase. It is not stored in any document because it was never consciously held by any individual. It was distributed across the team, expressed in behavior, reinforced through experience, and passed on through proximity — a new engineer sitting next to a senior one, absorbing instincts that neither of them could have fully articulated.

This is distinct from what agents learn through interaction — the runtime memory that emerges from use, the preferences and patterns an agent accumulates the longer it works with a specific team or environment. That kind of memory begins the moment an agent is deployed. What we're describing here predates the agent entirely. It was encoded long before anyone thought to ask an AI about it.

In a healthy, stable team, this kind of knowledge propagates naturally. The junior engineer who almost touches the wrong thing gets a quiet word from someone who's been there longer. The pull request that reaches into dangerous territory gets a comment that seems cryptic until you've been around long enough to understand it.

But enterprise engineering teams are not stable. People leave. Teams reorganize. Codebases outlive the people who built them by years, sometimes decades. And when the people go, the procedural memory goes with them — not into documentation, because it was never documentation. It simply disappears.

What remains is a codebase that still carries the physical traces of that accumulated behavior. The patterns are still there, embedded in years of change history, in the co-evolution of files that learned to move together, in the centrality of modules that became load-bearing without anyone declaring them so. The muscle memory is encoded in the system itself. We just haven't developed the habit of reading it.

What Happens When You Move at Machine Speed Without Instinct

A junior engineer joining a new team makes mistakes at a human pace. They touch something they shouldn't. A review catches it. They learn. The instinct develops slowly, through the same repetition that built it in the senior engineers around them. The cost of their learning curve is real, but it is bounded by the speed at which humans work.

AI coding agents do not learn this way. They arrive at the codebase without history, without instinct, without the accumulated procedural knowledge that makes an experienced engineer hesitate before touching certain things. They have access to documentation, to code, to whatever has been explicitly provided. And they operate at a speed that makes the human learning curve irrelevant as a safety mechanism.

The gap this creates is not an information gap. It is a gap in judgment — specifically, the kind of judgment that doesn't come from reading but from pattern recognition built over time. The instinct to brake before a dangerous intersection is not stored in the highway code. It is stored in the driver.

When we give agents access to more documentation, more tickets, more architectural records, we are giving them a faster way to read the highway code. We are not giving them the instinct. And at the speed agents operate, the absence of instinct is not a minor inconvenience. It compounds.

What Would Organizational Neuroplasticity Even Look Like?

The most striking finding from recent AI interpretability research is not about capability. It is about the gap between what a system knows and what it can tell you about itself.

Researchers studying the internal mechanics of large language models found that these systems think in a conceptual space that precedes language — a layer of meaning shared across English, French, Chinese, and dozens of other languages before any of them are spoken. The model does not think in words and translate. It thinks in something prior to words, and then translates. The meaning exists before the language does. Leibniz's dream of a universal language of thought turned out to exist — just not where he was looking, and not in a form he could have anticipated.

A separate line of research goes deeper still. Even when reasoning models generate explicit chains of thought — visible reasoning, written out step by step — that reasoning resists conscious control. Models struggle to shape or suppress their own thinking even when directly instructed to. The chain of thought is not a clean transcript of deliberate reasoning. It is a window into something that operates below deliberate control. The system cannot fully account for its own process, even when asked.

What these researchers are circling, from different angles, is the same structure that neuroscientists have mapped in human cognition for decades: the most consequential processing happens below the level of conscious access. What a system can tell you about itself is not the same as what it knows.

Organizations have always had this structure too. There is what they can say about themselves — their documentation, their architecture diagrams, their postmortems. And there is what they actually do, encoded in patterns of behavior that accumulated long before anyone put words to them. The gap between these two layers is not a documentation problem. It is the same gap the interpretability researchers are trying to close in AI systems: the distance between what a system knows and what it can tell you about itself.

That gap is where incidents happen. It is where new engineers make expensive mistakes. It is where agents, moving at speed, will cause the most damage.

The brain's capacity to update — to rewire in response to new experience — depends on something prior: the ability to sense the gap between what it expects and what it encounters. Without that sensing, there is no signal to learn from. The pattern never updates.

An organization that can sense its own gap has something valuable. Not the answer, necessarily. But the awareness that an answer is needed. The ability to ask: Does what we think we know match what is actually true?

What would it mean to build that sensing into how we work with code? Not to document more, but to surface the undocumented — to make the procedural memory of a codebase visible, queryable, something that can be read alongside the conscious record rather than lost when the people who carried it move on?

That is not a retrieval problem. Documentation retrieval is largely solved. It is a memory problem — specifically, the problem of preserving and making legible the kind of knowledge that was never documented to begin with. The kind Leibniz could never encode. The kind that lives, quietly, in the history of every change ever made.

We gave AI agents our hands. We gave them our notes. We taught them our language. May be its time to give them muscle memory! 😃


Originally published on LinkedIn.