The Flake Eater
A short story of flaky tests that feed on cognition, ruin flow, and slow the flow of value
The first time anyone saw the Flake Eater, it was hunched on the edge of the CI dashboard, quietly chewing a failing test. Nobody paid attention. They assumed it was some new mascot marketing had deployed without permission. They did that sometimes.
It was a small creature then—grey, harmless, furtive. Every time a test failed for no reason, it would scuttle across the logs, nibble something obscure, and vanish. Developers dismissed the failures as “environmental.” They reran the build. The build went green. Everyone moved on.
The Flake Eater grew.
Soon it sat on the shoulders of developers as they worked, whispering things like “Probably flaky. Try again.” That was its first trick: convincing people the alarms meant nothing.
Its second trick was subtler: it learned to feed on attention.
Whenever a build turned red, a developer would stop mid-thought, break flow, open logs, squint at timestamps, and swear. The creature would feast, slurping the context straight out of their heads. By lunchtime, half the team couldn’t remember what they were doing or why they’d ever believed any of this was supposed to be enjoyable.
As the Flake Eater fattened, the organisation slowed. Cycle times lengthened. Pipelines queued. People grew jumpy—no one wanted to be the person who triggered a red build. No one trusted green either. The creature had taught them: the colour of the lights was no longer connected to reality.
One morning a junior engineer named Sara discovered the Flake Eater sleeping inside the testing suite. It had grown large enough to block the path of value entirely. You had to step over it to ship software. It snored in retries. It exhaled uncertainty. Its skin was covered in the names of tests the team had once believed in but now merely tolerated.
Sara watched it for a while. Then she asked, mostly to herself, “Why do we let this thing live here?”
Her question drifted through the office like a power outage. People looked up from their screens blinking, as if waking from a long dream of low-level frustration.
The creature stirred.
“Look,” said an architect, “we don’t like it. We’re just… busy.”
“It’s always been here,” someone muttered.
“We can’t kill it,” said a senior dev, “it sometimes catches real bugs.”
“The rerun button is right there,” someone added, as if that solved anything.
Sara studied the creature more closely. Its belly glowed with the faint, stolen light of broken flow states. She suddenly understood: this thing wasn’t feeding on builds—it was feeding on cognitive clarity, on the clean, straight lines of thought engineers needed to make sense of unfriendly systems.
The creature yawned. Its breath smelled like unresolved race conditions.
“Maybe,” Sara said carefully, “the Flake Eater only lives because we refuse to stop feeding it.”
She pulled a chair to the centre of the room—an unreasonable thing to do in a software company—and began listing the flakes. One by one. Their behaviours. Their patterns. Their lies.
The more she named them, the smaller the creature seemed to become. Its edges flickered. Its confidence wavered.
Someone else joined her. Then another. They quarantined the worst offenders. They fixed time-dependent logic. They introduced contract tests where baroque end-to-end monstrosities had once prowled. They built seams into the code where previously only tangled webs existed.
With every repair, the Flake Eater shrank.
It screeched when they stopped rerunning and started investigating. It withered when the team refused to merge on red. It collapsed to the size of a mouse when the first “Flake Budget” appeared on the engineering wall like a declaration of independence. It nearly died when the team discovered the joy of reliable feedback loops, and flow returned like warm electricity to their minds and keyboards.
One day it was simply… gone.
Some say it skulked out through the ventilation system. Others claim it dissolved when the last nondeterministic test was fixed. The truth is simpler: creatures like that can’t survive in environments where signal is respected, flow is protected, and developer cognitive load is treated as a finite, precious resource rather than a landfill site for organisational neglect.
A few years later, a new hire heard an old-timer telling the story of the Flake Eater in a joking, mythical tone.
“Did it really exist?” they asked.
“Oh yes,” the old-timer replied. “And it could come back any time.”
“How would we stop it?”
The old-timer smiled. “Easy. Don’t feed it. Honour your feedback loops. Protect your flow. Trust red. Trust green. And if you ever see a test that fails sometimes—kill it or fix it. Never negotiate.”
And somewhere far beneath the CI dashboard, in the sediment of discarded logs, something ancient and hungry shivered—unfed, unwelcome, and afraid.