Why Nobody Will Touch That Process

Every company has a process nobody will touch. The person who understood it left, the workarounds piled up, and better documentation never fixes it. A forty-year-old essay about software explains why, and what it actually takes to keep a process alive.

Eric Pelz

Founder & CEO · Malleable

4 min read

Every company has a version of this story. The person who really understood how purchase approvals worked, or claims intake, or vendor onboarding, leaves. The process keeps running. But nobody will touch it. New situations get handled with workarounds instead of fixes. A year later there's a proposal to "rebuild it properly," which mostly means rediscovering, expensively, what the person who left already knew.

We treat this as a documentation problem. Write more wikis, record more Looms. It never works. A forty-year-old essay about software explains why.

In 1985, Peter Naur argued that the real product of programming isn't the code. It's the theory, held by people, of how the software maps to the world: why it's built this way, and what will break if you change it. The code and the docs are artifacts produced by people who hold the theory. You can read every line of both and still not understand the theory.

When the people who hold the theory leave, the software still runs, but nobody can safely change it. Naur says it dies. Each change degrades it further, because no one fully understands it. Eventually someone calls it legacy and proposes a rewrite.

If you've operated software, you've watched this happen. I spent ten years building workflow software, and saw this over and over. The reason it's hard to change workflows is almost never the tooling.

No one understands the full process

Nothing in Naur's argument is really about code. A business process starts as a theory in one or two heads. Then it grows: across teams, across tools, through a hundred exceptions the owner learned one new situation at a time.

When many people are involved, the theory doesn't grow in a single person. It fragments, disguised as "tribal knowledge." The finance lead knows why anything over $5,000 gets a second look. The ops manager knows why the Airtable has that weird column. Soon no one can explain the process end to end.

If no one can explain it, no one can safely change it. So changes route through the one or two people trusted to touch it, and bigger overhauls never happen. The process still runs, but can't evolve.

The tools we reach for make it worse

Automation tools take the theory that was in someone's head and bury it in the wiring of six connected apps. A zap chain tells you what happens. It can't tell you why. When it breaks, figuring out the fix takes hours, and the fix is usually another patch on top.

Vibe-coded internal tools are the same mistake, faster. The code gets written, the theory-building never happens. It ships, it runs, and from day one nobody can explain how it works.

AI agents, on their own, keep even less. They use judgment, yes, but it happens fresh each run and is kept nowhere. A skill file or a memory doesn't fix that. It's a pile of text sitting next to the process, not part of it. You can read that a rule exists. You can't ask which run put it there, who decided, or what it was protecting against.

All three share a blind spot. They ship the process and throw away the why.

Keep the theory where the team can read it

If you and a coworker built a process together over a year and worked through the exceptions, the theory is held by both of you. That works until one of you leaves.

So the theory needs a home that doesn't leave: the plan itself, written down where anyone on the team can read it. Every change to it is a draft someone reviewed and published, and the conversation that led to it is kept. When someone new wants to change a step, they can see when it was added and why.

Take the purchase approvals from the top of this post. Anything over $5,000 goes to the finance lead. She leaves. A year later someone wants to raise the limit to $10,000 and has no idea where $5,000 came from. Today that's a coin flip: leave it alone, or change it and find out. Instead they look up the change that set it, and learn it was tied to a budget cycle that ended two quarters ago. So they raise it, knowing what they're doing.

A better way to run a process

With Malleable, your process, its documentation, and the memory of every session that shaped it are one plan your team owns. An agent runs the plan and proposes changes. People correct it, in feedback and in review, and nothing changes until someone publishes it. The theory stays current instead of frozen at rollout, and it keeps getting built by the people who own the process, with the AI that runs it.

It's also why we don't build an AI employee:

An AI employeeA Malleable plan
Works fromA job descriptionHow your team does the work, written down
Decides the stepsFresh, on each runYour team, ahead of time
When a person should decideDepends on how you briefed itNames who decides, and the run waits for them
What the team can seeIts instructions and a logThe plan, and every run
When the work changesBrief it again and hope it sticksSay what changed, then the team reviews the draft and publishes it
Where the know-how livesIn its instructions and memoryIn a plan anyone on the team can read

No rebuild proposal a year later. Someone leaving is just someone leaving.


Thanks to Steve Krouse, who first pointed me to Naur's essay.

Malleable

AI agents that run your team's operations, with your team in charge.

Start free