AI Strategy · Organizational Intelligence

Your Organization Has Source Code (And You Can Finally Read It)

Somewhere in your company there’s a double-approval that exists because of an incident nobody remembers, a Friday report built for an executive who left in 2019, and a threshold a COBOL programmer encoded from a policy meeting nobody minuted. The reasons are all written down — in emails, meeting notes, reports, and the code itself. That record is source code. And the cost of reading it just collapsed.

Two years ago, “let an AI rewrite the legacy system” was heresy. The economics said otherwise, and the economics won: AI agents now read decades-old codebases and recover the specification — the expensive, blocking step that made rewrites rare — for a fraction of what it used to cost. Stripe reports that a codebase-wide migration inside a 50-million-line Ruby codebase, months of engineering by hand, was done in a day.¹ AWS sells mainframe modernization with assessment timelines cut “from several months to days.”² IBM ships a product whose pitch is that generative AI writes natural-language explanations of undocumented COBOL so developers can understand applications nobody alive fully remembers.³

All of that worked for one structural reason: legacy code is an executable specification. Decades of business decisions, frozen in the only medium precise enough to run. The blocker was never writing the new system — it was recovering the spec from the old one, and AI collapsed that cost. That doctrine is published; in our canon it’s called AI Legacy Takeover.

Here is the substitution that matters more than the original: your organization’s exhaust — the emails, the reports, the meeting minutes, the shared-drive sediment — is the source code of the organization. Same property: decisions frozen in a readable medium. Same historical blocker: comprehension was unaffordable. Same collapse.

Legacy code was the first corpus where “the system is its own documentation” became exploitable. The organization is the second — and it was always the bigger one.

The record exists. It was just never readable.

This isn’t a small corpus. IDC measured that 90% of the data organizations generated in 2022 was unstructured — documents, messages, media, the soft layer — against 10% structured.⁴ (The folklore version, “80% of enterprise data is unstructured,” has a fuzzier pedigree: it traces to a 1998 Merrill Lynch estimate whose own sourcing was never clear.⁵ The honest statement is a band, 80–90%, and IDC’s current measurements sit at the top of it.) Gartner has a name for what happens to that layer: dark data — “information assets organizations collect, process and store during regular business activities, but generally fail to use for other purposes.”⁶

Twenty years of “data-driven organization” rhetoric, and the layer where the explanations live has been dark the entire time. The warehouse holds your outcomes — the sale closed, the payment posted, the Q3 dip. The decisions that produced those outcomes — the reasoning, the objections, the trade-offs, the workaround’s justification — happened in emails, meetings and documents, and left their residue there. And that layer is the one that walks out the door: one workplace study found 42% of institutional knowledge is unique to the individual holding it — when they leave, their colleagues simply can’t do that part of the job.⁷

Why did nobody read it? Because until cheap LLMs, reading had no unit price. Storage was affordable, search was affordable — synthesis wasn’t. Enterprise search, content management, eDiscovery: every incumbent in this space stopped at retrieval, because retrieval was what the economics permitted. Nobody concludes. The moment comprehension acquired a per-document price measured in fractions of a cent, “read everything and conclude” became a line item instead of a fantasy.

Organizations run two systems at once

Here’s where the organization turns out to be a richer corpus than code. With software, the source is the truth — the application does exactly what the code says. Organizations run two systems simultaneously: the as-designed (the documented procedure, the policy manual, the process map on the wall) and the as-operated (what the emails reveal people actually do — the double-save workaround, the approval everyone routes around, the step everyone skips).

The exhaust captures both. Which means the compile doesn’t just recover the blueprint — it recovers the deviation report: every place the org-as-documented and the org-as-run disagree, held as two claims with a contested edge between them, each pointing back to its evidence.

The market has already proven it wants half of this. Process mining — reconstructing as-run processes from transactional event logs — built a category on it: Celonis alone reached a valuation near $13 billion and reports more than 5,000 enterprise deployments.⁸ The field even has a name for the as-designed-vs-as-operated comparison: conformance checking — in its founder’s words, “Do we do what was agreed upon?”⁹

But look at what an event log is, by the field’s own definition: each event records an activity, a case, perhaps a resource and a timestamp.¹⁰ Sequence, never justification. The log can tell you step B followed step A a hundred thousand times; it is structurally incapable of telling you why — the workaround’s justification, the exception’s negotiation, the objection that reshaped the process. That story lives in the soft layer.

Process mining found the skeleton. This recovers the reasoning.

The query that was never runnable

Once the exhaust is compiled — into a navigable map of claims with receipts, not a chatbot — every process step can carry a provenance edge: this step exists because of X. The manual re-entry exists because the old system couldn’t integrate. The double-approval exists because of the 2019 incident. The Friday report exists because a departed executive wanted it.

Now run the query that was never runnable before:

That’s dead-code elimination for organizations — and it finally domesticates the oldest blocker in process improvement. G.K. Chesterton’s famous fence: the reformer who says “I don’t see the use of this; let us clear it away” is told to go away and think, and only “when you can come back and tell me that you do see the use of it, I may allow you to destroy it.”¹¹ Chesterton’s actual argument is more precise than the paraphrase everyone quotes — “Some person had some reason for thinking it would be a good thing for somebody. And until we know what the reason was, we really cannot judge whether the reason was reasonable.” He even specifies the win condition: if you know how an institution arose and what purposes it served, you may really be able to say that they are “purposes which are no longer served.”¹¹

That is a provenance lookup, specified in 1929, waiting a century for the read to become affordable. In every organization, “nobody knows why this step exists, so nobody dares remove it” has been a terminal state. It was never a fact about the organization. It was a cost statement — and the cost just collapsed. You don’t tear the fence down blindly and you don’t preserve it superstitiously; you read why it was built and check whether the bull is still alive.

The code knows things nobody minuted

And one more corpus belongs in the same compile — the one this article started with. A business rule implemented in code is an organizational decision, and often the code is the only surviving record of it. The eligibility thresholds, the discount logic, the validation rules some programmer encoded in 1998 from a policy meeting that produced no minutes: ingest the legacy application’s source alongside the emails and the documents — not the data, the connections — and those frozen decisions rejoin the organizational map, cross-linked to the procedures that grew around them. Your legacy estate stops being a liability you pay to keep alive and becomes tuition you already paid — you’re finally collecting the knowledge it holds.

This is what changes the texture of an ordinary meeting. Someone says: “this is the procedure, this is how we’ve always done it.” And someone else says: “Yeah — but what does the wiki say?” The answer comes back with a date, a supersedes-chain and a receipt — and the five-year veteran discovers, without losing face, that the policy changed after they learned it. Authority by seniority becomes authority by receipt. The oracle asks for faith; the navigator offers receipts.

The honesty clause

Now the boundary, stated as plainly as the claim — because this is where the analogy must bend or it becomes consultant hubris.

Organizations are not software, and the “regenerate” step does not transfer. In our own doctrine, the companion move to reading a legacy codebase is Nuke-and-Regenerate: once you hold the spec, deleting the old system and regenerating it is often the economically correct move. You can nuke a codebase because code doesn’t have morale, tenure, or trust. An organization does. A big-bang re-org justified by “the AI read everything” would be the same catastrophe re-orgs have always been, with better paperwork.

The pitch is precise, and it’s three verbs:

• Read the legacy organization with software economics — the whole exhaust, compiled, current, with provenance.
• Model changes against the compiled map’s real dependency edges — what touches this step, who relies on this report, which obligations constrain this process.
• Refactor incrementally, at human pace, with receipts — every removal traceable to a dead constraint, every survivor to a live one.

Blueprint recovery at AI prices; change execution at human pace, de-risked by the first genuinely current map of how the place actually works.

What this displaces

There has always been a way to buy a version of this map. It’s called a discovery engagement: as TechCrunch put it in covering Celonis’s rise, “the kind of work that high-priced consultants have tended to do, camping inside companies for months or years and figuring out how work flows through the organization while collecting fat checks to do it.”¹² Even the process-mining vendors concede the traditional alternative runs on “time-consuming workshops and interviews.”¹³

A discovery engagement is humans hand-reading a sliver of the exhaust — and it’s stale on delivery. The compiled version is complete instead of sampled, current instead of a snapshot, and queryable forever instead of bound into a deck. The interview doesn’t disappear; it gets pointed exclusively at the gaps — the questions the written record genuinely can’t answer. Your experts stop being the retrieval layer and start being the reviewers of a draft compiled from answers they already gave.

The record was always there. Every fence in your organization has a builder, and most of the builders wrote down their reasons — in an email, a memo, a meeting note, a line of COBOL. For the entire history of management, that archive has been dark because reading it cost more than the answers were worth. That era just ended. The only question left is whether you’ll read your organization’s source code before someone quotes you six figures to interview it.