Greek Fire

The Byzantines held a weapon their enemies could barely counter, and then lost it entirely, because the one thing that mattered was never written down. Software is lost the same way.

August 13, 2026 7 min read

For more than five centuries the Byzantine Empire held a weapon its enemies could barely counter. Greek Fire was a liquid sprayed under pressure from bronze siphons mounted on the prows of ships. It clung to whatever it touched, it was almost impossible to put out, and it went on burning on the surface of the sea. It broke Arab fleets at the walls of Constantinople in the 670s and again a generation later, and it kept doing so, in one form or another, for centuries. And then it was gone. Not defeated. Forgotten. The recipe was a state secret held by so few hands that when those hands were gone, so was the weapon, and its exact composition has been unknown ever since.

The striking part is not that an empire eventually fell. It is that the Byzantines lost a working technology while still holding everything visible about it. The ships survived. The siphons survived. The tactics were written down. What did not survive was the one thing that made any of it matter: what the substance was and why it was made that way. That knowledge was never committed to anything more durable than the memory of the specialists entrusted with it, and memory is exactly the medium that does not outlast a generation.

The artifact survives, the reasoning does not

History keeps a whole category of these. The Antikythera mechanism, recovered from a shipwreck around 1900, is a bronze device of dozens of interlocking gears that modeled the motions of the sun and moon and the wandering of the planets. It is Greek, more than two thousand years old, and nothing of comparable complexity appears again for well over a millennium. We have the object. We can see, now, roughly what it did. What was lost was the tradition behind it, the accumulated know-how that could build another one, and the object by itself could not carry that. An artifact is a result. It is not the reasoning that produced the result, and the reasoning is the part that does not come back on its own.

A codebase is an artifact in exactly this sense. It is the surviving object: complete, inspectable, still running in production. What it does not contain is why it is the way it is. Which approaches were tried and abandoned. Which constraint each odd-looking choice is quietly respecting. What the team decided, and what they decided against. That reasoning lives where the recipe for Greek Fire lived, in the heads of the few people who were there when the choices were made.

It leaves the way it always has

And it leaves the same way, too. Not in a dramatic collapse but one resignation, one reorg, one quiet departure at a time. Each person who goes takes a piece of the recipe with them, and the code they leave behind is the siphon without the formula: plainly built to do something, no longer able to explain itself. Nobody notices on the day it happens, because the thing still runs. You only find out later, when a change has to be made to a part of the system and the honest answer to "why is it like this" is that the person who knew is three jobs away and was never asked to write it down.

AI sharpens this rather than softening it. A coding agent reads the artifact and only the artifact. It can see every inch of the siphon and infer nothing about the formula, because the formula was never in the metal. So it does the reasonable thing and copies what is there, and the system fills, quietly, with choices reproduced for reasons no one holds anymore. The knowledge does not have to walk out the door to be lost. It is enough that it was never written where the next builder, human or machine, would look for it.

Writing the recipe down

This is the whole case for keeping a record of decisions, and it is narrower than it sounds. Not documentation of what the code is; the code already is that, exhaustively. A record of what was decided and why, attached to the part of the system it governs, so the reasoning arrives with the artifact instead of leaving with the person. That is what Brief is for: the recipe kept next to the thing it explains, and surfaced when a person or an agent works on that thing, so a capability is never one departure away from becoming something your team can only stare at.

The Byzantines could be forgiven for losing Greek Fire, because they had no real way to keep it. For them the knowledge and its keepers were the same thing, and keepers do not last. That excuse is gone. The reasoning behind your systems can be written down and held somewhere more durable than a memory, next to the code it accounts for, where the next person and the next agent both inherit it. So it is worth asking, of the systems your team depends on and can no longer entirely explain: how much of how they work lives anywhere but in someone's head, and what happens to that knowledge on the day they leave?

Frequently asked questions

What was Greek Fire? Greek Fire was an incendiary weapon used by the Byzantine Empire from the 670s AD: a liquid sprayed under pressure from bronze siphons that clung to surfaces and kept burning on water, decisive in defending Constantinople against Arab naval sieges. Its exact composition was a closely guarded state secret, and the formula has been lost ever since. Its introduction is traditionally attributed to Kallinikos, a refugee who came to Constantinople from Syria.

Why was Greek Fire lost? Because the recipe was held as a state secret by a very small number of people and was never durably recorded. The ships, the siphons, and the tactics were known and written down, but the composition, the part that actually mattered, lived only in the memory of the specialists entrusted with it. When that lineage was broken the knowledge went with it, even though the empire still possessed everything else.

What does Greek Fire have to do with software? A codebase is like the surviving siphon: a complete, inspectable artifact that does not contain the reasoning that produced it. Why the system is built the way it is, what was tried and rejected, which constraint each choice respects, all of that lives in the people who made the decisions and leaves when they do, one departure at a time. An AI coding agent reads only the artifact, so it reproduces existing patterns without the reasons behind them, and the knowledge is effectively lost even while the code still runs.

How do you keep a team's technical knowledge from being lost? Record the decisions and the reasons behind them, and attach each one to the part of the system it governs, so the reasoning travels with the artifact instead of leaving with the person who made it. A product context layer such as Brief does this: it keeps the recipe, the decisions and their rationale, next to the code they explain, and surfaces the relevant one when a person or an agent works on that part, so a capability is not one resignation away from becoming unexplainable.