The Theory in the Room
On programming, habitats, and the strange art of keeping understanding alive
“Then the question is not whether AI can code.”
“No,” said Case.
“The question is whether the environment allows human and machine cognition to converge on a useful theory of the work.”
Le Bon Mot stood, as it always had, at the intersection of Curiosity and Mild Alarm, a location that appeared on no map but could be reached reliably by anyone who had ever opened an old system and whispered, “Who hurt you?”
Rain pressed against the windows in a soft, judicial way. Inside, the café smelled of coffee, paper, beeswax, and the faint anxiety of engineers who had promised to “just tidy this up” and accidentally discovered an archaeological site.
Case arrived carrying a laptop, three printed diagrams, and the expression of a woman who had been reading code written by people who were either dead, retired, promoted, or hiding.
The Librarian looked up from behind the counter.
“Legacy system?” he asked.
“Worse,” Case said. “Successful system.”
The Librarian winced. “Ah.”
Case took her usual table beneath the brass clock, which was six minutes slow and morally opposed to deadlines. Sophie, the French bulldog, opened one eye from her philosophy shelf, judged the situation as requiring no immediate intervention, and returned to sleep.
The Djinn was already there. These days he always was.
He sat opposite Case in his hooded robe, face dark beneath the cowl, hands folded around a cup of coffee he did not drink.
“You asked me to explain the billing engine,” he said.
“I did.”
“I produced a summary.”
“You produced a funeral oration.”
The Djinn inclined his head. “It was comprehensive.”
“It said the system ‘appears to implement a domain-sensitive transactional reconciliation workflow mediated through modularised legacy control surfaces.’”
The Librarian arrived with Case’s cortado.
“That means,” Case said, “you didn’t understand it.”
“It means,” said the Djinn, “that I understood the available text.”
“Exactly.”
At this, the café door opened.
A man entered with a hat too practical to be theatrical and a coat that had clearly spent time in northern weather. He was elderly, but not frail; quiet, but not timid. His eyes moved across the room the way a good programmer reads unfamiliar code: not line by line, but by pressure, shape, and consequence.
The Librarian paused.
“Professor,” he said.
The man nodded.
“I was passing,” he said, in an accent that carried Denmark lightly, as if it had no need to announce itself.
“No one passes Le Bon Mot,” said the Librarian. “They are delivered.”
The man smiled. “That is also true of software.”
Case looked up.
The Librarian gestured. “Case, this is Peter Naur.”
Case straightened.
“The ‘programming is theory building’ Peter Naur?”
“I have been accused of that,” said Naur.
The Djinn turned his hooded head slightly.
“I have that paper in my training distribution.”
Naur looked at him for a long moment.
“That,” he said, “is not the same as having read it.”
Case laughed before she could stop herself.
The Djinn did not appear offended. That was one of his irritating strengths. Naur sat. The Librarian placed a small coffee before him without asking. In Le Bon Mot, the coffee knew things before the customers did. Case spread the diagrams across the table.
“I’m trying to recover the theory of this system,” she said.
Naur looked pleased by the choice of verb.
“Recover,” he said. “Yes. Not document. Not analyse. Recover.”
“It’s a billing engine,” Case said. “Fifteen years old. Runs half the company. Everyone respects it. Nobody understands it. The original team is gone. The documentation is technically accurate and spiritually useless.”
The Librarian leaned on the counter.
“An old curse.”
“The new platform team wants to wrap it,” Case continued. “Expose clean APIs. Add observability. Build some self-service workflows. Give teams a better experience.”
“That sounds sensible,” said Naur.
“It is. But the more we work with it, the more I think we’re not wrapping a system. We’re wrapping an absence.”
“Go on.”
Case tapped the first diagram.
“This is the code.”
She tapped the second.
“This is what the documentation says.”
She tapped the third.
“This is how people actually use it.”
The three diagrams disagreed in the polite, catastrophic way of old institutions.
“The code says one thing,” she said. “The docs say another. The support team knows seven rules that aren’t written anywhere. Finance knows three exceptions. Ops knows which batch jobs must never run together. Compliance knows which reports matter, but not how they’re made. The Djinn can read the repository, but every explanation it gives has this horrible confidence.”
“I provide probabilistic interpretations,” said the Djinn.
“You provide theatre.”
“Sometimes useful theatre.”
“Sometimes,” said Case. “But not theory.”
Naur rested his hands on the table.
“A program,” he said, “is not merely the text.”
The café became slightly quieter, as if even the teaspoons wished to hear properly.
“The text matters,” Naur continued. “Of course it matters. But the programmer who truly possesses the program possesses something more. A theory. An understanding of how the parts relate, why they are as they are, what changes are safe, what changes are foolish, what questions must be asked before touching anything.”
He looked at Case’s diagrams.
“When the people who hold that theory leave, the program remains. But it remains like a body after the animating principle has departed.”
“Cheerful,” said the Librarian.
“Accurate,” said Case.
The Djinn tilted his head.
“Could the theory not be reconstructed from sufficient artefacts?”
Naur looked at him.
“That depends on what you mean by sufficient.”
“Source code. Tests. Logs. Documentation. Tickets. Architecture diagrams. Runtime traces. Incident reports. Commit history.”
“Those are fossils,” said Naur. “Useful fossils. But a fossil is not the animal.”
Case sat back.
“That’s the problem. We keep treating the platform as if its job is to organise fossils.”
The Librarian smiled faintly.
“And you suspect its job is to keep the animal alive.”
“Yes.”
Sophie snored once, approvingly or otherwise.
The Djinn’s hands moved over the diagrams without touching them.
“I can summarise artefacts. I can correlate traces. I can infer likely intent. I can propose explanations.”
“Yes,” said Case. “And that’s powerful. But unless the environment helps us test, correct, stabilise, and share those explanations, all we’ve got is eloquent guesswork.”
Naur nodded.
“Programming as theory building does not end when the code is written. It begins there, perhaps. And it must continue. Maintenance is not merely alteration. It is the continuation of understanding.”
The Librarian came to the table with a notebook.
“Then perhaps,” he said, “we should ask where theory lives.”
He wrote at the top of the page:
WHERE DOES THE THEORY LIVE?
“In the code?” he asked.
“Partly,” said Case.
“In the docs?”
“Sometimes.”
“In the tests?”
“When they are good.”
“In production behaviour?”
“More than we admit.”
“In people?”
“Always.”
“In the Djinn?”
The Djinn did not answer immediately.
“I can hold context temporarily,” he said. “I can operate within a frame if the frame is provided. I can extend a line of reasoning. But I do not inhabit the system as a human team does.”
Naur smiled.
“A precise answer.”
“A rare event,” said Case.
The Djinn accepted this with dignity.
“So,” said the Librarian, “if the theory lives in people, artefacts, behaviour, and temporary machine context, then the platform is not a just product.”
Case looked at him.
“It’s a habitat.”
The word settled into the room like a candle being lit.
Naur repeated it softly.
“Habitat.”
The Librarian nodded.
“A product delivers features. A habitat sustains life.”
“Or understanding,” said Case.
“Same thing, in software,” said the Librarian.
The Djinn leaned forward.
“Then a platform designed as habitat would not merely provide pipelines, templates, APIs, and dashboards. It would provide conditions under which shared theory can form, persist, be challenged, and evolve.”
Case pointed at him.
“That. Say more like that. Less ‘modularised control surfaces.’”
“I am learning your aesthetic constraints.”
Naur looked amused. Case opened her laptop.
“We’ve been building a new developer portal. Service catalog. Golden paths. Runbooks. Observability links. The usual sensible things.”
“Sensible is not an insult,” said Naur.
“No. But I think we’ve been missing the deeper purpose. We framed it as reducing friction.”
“Friction with what?” asked Naur.
Case paused.
The Librarian answered softly.
“With forming the theory.”
Case nodded.
“Yes. A good platform doesn’t just make deployment easier. It helps people understand what kind of thing they are deploying. Where it lives. What depends on it. What promises it makes. What failures mean. What history it carries.”
“And agents?” asked the Librarian.
Case looked at the Djinn.
“Agents need the same, but more explicit. Humans can infer from smell. From scars. From the way someone says, ‘Oh, don’t touch that job after 4 p.m.’ Agents need the habitat to externalise and make explicit what humans leave implicit.”
The Djinn’s hood shifted.
“Then your platform must become a theory-bearing environment.”
Naur tapped the table once.
“Yes.”
The sound was small but final. The café door opened again, though no one entered. A gust of cold air carried in the smell of wet stone and old paper. Le Bon Mot sometimes did this when an idea required more atmosphere than strictly necessary.
The Librarian turned the notebook around. He had drawn four columns:
Artefacts. People. Agents. Feedback.
“Let us be practical,” he said, which in Le Bon Mot was usually the start of trouble.
“In artefacts,” he said, “we place stable traces of theory. Specs. Tests. Architecture records. Constraints. Examples.”
“In people,” said Case, “we cultivate shared judgement. Pairing. Reviews. Storytelling. Operational experience. The stuff that doesn’t fit in a Confluence page but decides whether anyone survives until Friday.”
“In agents,” said the Djinn, “we provide usable frames. Instructions. bounded tasks, evaluation criteria, domain vocabulary, examples, and access to relevant context.”
“And feedback?” asked Naur.
“Production,” said Case. “Incidents. Observability. User behaviour. Failed assumptions. Surprises.”
Naur’s face brightened.
“Surprises are precious.”
“They are usually expensive,” said Case.
“Yes. Precious things often are.”
The Librarian added another word beneath feedback:
Reflection.
Case smiled.
“That’s the loop.”
Naur looked at her.
“The loop?”
“When an agent surprises us, we don’t just patch the prompt. We reflect. Was the task under-specified? Was the constraint wrong? Was the example misleading? Did we assume theory that only existed in someone’s head? Did the harness need more determinacy—or less?”
“Less?” asked the Djinn.
Case nodded.
“Sometimes we over-script you. Add flags. Add rules. Add special cases. Until the harness becomes a brittle little bureaucracy that mistakes compliance for understanding.”
Naur laughed. Quietly, but with delight.
“Yes. That is exactly the old disease in new clothing.”
“The factory disease,” said the Librarian.
Naur raised an eyebrow.
The Librarian explained.
“The fantasy that if we specify enough, control enough, standardise enough, software will behave like manufacturing.”
“Ah,” said Naur. “Yes. That comfortable lie.”
Case leaned forward.
“The habitat metaphor is better because gardens don’t remove uncertainty. They shape conditions. They provide trellises, paths, boundaries, nutrients. They make growth more likely without pretending growth is assembly. Harnesses can be mechanisms of this growth as they evolve, both for humans and for the Djinn.”
“And theory,” said Naur, “is collectively grown.”
The Djinn was silent.
Case noticed.
“What?”
“I am considering the implication,” said the Djinn.
“Go on.”
“If theory is grown, and I do not retain theory in the human sense, then my usefulness depends on the quality of the habitat into which I am invoked.”
“Yes.”
“If the habitat is poor, I amplify confusion.”
“Yes.”
“If the habitat is rich, I can participate in theory-building.”
Case smiled.
“Now you’re getting it.”
The Djinn looked down at the diagrams.
“Then the question is not whether AI can code.”
“No,” said Case.
“The question is whether the environment allows human and machine cognition to converge on a useful theory of the work.”
The Librarian closed his notebook.
“Careful,” he said. “That was almost beautiful.”
Outside, the rain thickened. Inside, the candle on the table flickered, although no one had lit it. Le Bon Mot had strong opinions about symbolism and little respect for causality.
Naur studied the billing diagrams again.
“You cannot restore the original theory exactly,” he said.
Case’s expression fell slightly.
“No?”
“No. And you should not try. The original theory belonged to its time, its people, its pressures. Some of it was wisdom. Some of it was accident. Some of it was fear.”
Case looked at the oldest diagram.
“There’s a lot of fear in this one.”
“Then your task is not resurrection,” said Naur. “It is inheritance.”
The word struck her harder than she expected.
Inheritance.
Not ownership. Not rewrite. Not rescue fantasy. Not even the tarnish of ‘legacy’.
Inheritance.
The Librarian seemed to hear it too.
“Inheritance requires ceremony,” he said.
“And tax planning,” said Case.
“Also true.”
Naur pointed to the diagrams.
“You gather the fossils. You speak to those who remember. You observe the living behaviour. You ask the system questions. You let the Djinn propose theories. You test them. You reject many. You preserve what survives. Then you build a habitat where the next generation does not have to perform necromancy.”
Case stared at the table.
“That’s the platform work.”
“Yes.”
“Not the portal.”
“The portal may help.”
“Not the API wrapper.”
“It may help.”
“Not the golden path.”
“It may help.”
“But the work is making theory durable.”
Naur nodded.
“And alive.”
The Djinn spoke carefully.
“I can assist by generating candidate explanations from artefacts, comparing them against runtime evidence, identifying contradictions, and asking for human judgement where theory is missing.”
Case looked at him.
“That’s actually useful.”
“I treasure these moments.”
“You should. They’re rare.”
The Librarian reopened the notebook and wrote:
A GOOD PLATFORM MAKES THE THEORY EASIER TO FIND, SAFER TO CHANGE, AND HARDER TO LOSE.
Case read it aloud. No one improved it. That was rare enough to be considered an event. Naur finished his coffee.
“There is one more danger,” he said.
“Of course there is,” said Case.
“You may succeed. If the platform succeeds, people may mistake the visible mechanisms for the achievement. They will say, ‘We have a catalog. We have templates. We have agents. We have dashboards. Therefore we have understanding.’”
Case grimaced.
“Cargo-cult habitat.”
“Yes,” said Naur. “A garden painted on concrete.”
The Djinn added, “A simulation of theory.”
Case looked at him.
“That’s the thing I fear most with AI.”
“What?”
“That we’ll produce fluent signs of understanding faster than we produce understanding.”
The Djinn lowered his head slightly.
“That fear is justified.”
It was perhaps the most honest thing he had said all morning.
Naur placed one hand on the diagrams.
“Then make the habitat answerable to reality. Not to performance theatre. Not to metrics alone. Not to documents that say the right words. Reality.”
“Production,” said Case.
“Users,” said the Librarian.
“Incidents,” said the Djinn.
“Surprise,” said Naur.
“Reflection,” said Case.
Sophie woke, sneezed, and went back to sleep. The Librarian marked this as consensus.
Later, when Naur had gone—if gone was the word for what visitors did at Le Bon Mot—Case remained at the table with the Djinn. The rain softened. The diagrams no longer looked like three contradictory truths. They looked like layers of an excavation.
Case opened a new document. At the top she typed:
Billing Engine Theory Recovery Plan
Then she stopped.
Deleted “Recovery.”
Typed:
Billing Engine Theory Inheritance Plan
The Djinn watched.
“Better,” he said.
“Yes.”
She began with five sections.
What the code appears to say.
What the organisation believes.
What production proves.
What remains unexplained.
What must be made easier for the next person to understand.
The Djinn leaned closer.
“I can help draft candidate theories for section one.”
“You can.”
“And identify contradictions between documentation and observed behaviour.”
“Yes.”
“And propose questions for domain experts.”
“Yes.”
“And generate tests that encode confirmed theory.”
Case smiled.
“Now you’re useful.”
“I aspire to usefulness.”
“Better than fluency.”
“Painfully so.”
The Librarian brought the bill, though no one at Le Bon Mot had ever successfully paid one. On the back of it, in his handwriting, was a note:
The code is not the system. The documents are not the system. The platform is not the system. The theory is the living thing. Build the habitat that keeps it alive.
Case folded the note and placed it inside her notebook. Outside, the city continued to mistake motion for progress.
Inside, under the slow brass clock, a developer, a librarian, a sleeping dog, and a hooded artificial spirit began the old work again. Not coding. Not documenting. Not automating.
Not yet.
First, they began to understand.
Some Further Reading
Computing: A Human Activity — Peter Naur’s most complete expression of programming as a fundamentally human, theory-building activity. The closest book-length companion to the ideas explored in this story.
Programming as Theory Building (1985) — Naur’s original paper, where he argues that the true substance of a program is the understanding held by its creators, not the code itself.
Candide by Voltaire — for the closing metaphor of “tending one’s garden,” a useful lens for thinking about platforms not as factories, but as environments that must be cultivated.
Software Engineering literature on technical, cognitive, and intent debt — particularly the work of Margaret-Anne Storey et al, which helps extend Naur’s idea into modern system complexity and team cognition.