I am making a sourdough starter today. Fresh jar, a scoop of wholemeal flour, a splash of water, a stir with a cheap rubber spatula. Not precious about it. In six weeks, if I do this properly, I’ll have bread again.
The last one was two and a half years old when it died – not through drama, through a quiet chain of postponed feeds that started with a busy week and ended two months later when I opened the jar to a monstrous mess of black mould that was by this point very nearly ambulatory and would, given another week, probably have begun drafting grievances about the state of the fridge. I scraped it into the bin, washed the jar, and here we are.
I’m not new to sourdough. I’ve made every beginner mistake and a few advanced ones. This post is about what I intend to do differently, and why almost all of it is actually about software.
What a starter actually is
A sourdough starter is a colony of wild yeast and lactic acid bacteria living in a paste of flour and water. You feed it, it eats the sugars, it rises and falls. You bake with some, set the rest aside, feed it again. Flour, water, time, consistency. There is no secret. The mystique around sourdough is almost entirely vibes.
Starters aren’t hard to make. They’re hard to keep. And everything I failed to do with the last one is something I was failing to do in a codebase somewhere at the same time.
Lesson one: consistency beats intensity
Somewhere in the first week or two of a new starter, it will begin to smell strongly of acetone – the acrid chemical note of nail polish remover. All new starters do this. It’s a normal stage of the culture establishing itself, but if you haven’t seen it before it can make you worry.
This is the moment most new bakers panic. They read the first thing the internet tells them – “your starter is sick, feed it more” – and do the wrong thing with great care: more frequent feeds, stronger flour, warmer water, twice-daily instead of once. It feels active. It’s almost exactly the opposite of what the starter needs. I know, because it was me in my very first week, and the starter responded by smelling worse for longer than if I’d left it alone.
The fix is boring. One feed a day, same time, same ratio, same flour, until the phase passes. A small ritual I do while I make my wife tea.
The best starters are not the ones fed most dramatically, but the ones fed most reliably.
The team that runs a three-week “tech debt sprint” every quarter is feeding their codebase intensely but inconsistently. The team that quietly deletes one dead file, writes one missing test, and closes one stale TODO every week is feeding it consistently. Six months later the second team has the cleaner codebase and a deeper understanding of it. Twelve months later it isn’t even close.
Consistency compounds. Intensity burns out. The last starter died because I fed it generously on Sundays and missed too many Thursdays in a row.
Lesson two: maintenance is not waste
Every time you feed a starter, you throw most of it away. It feels profligate. It feels like you’re killing the thing you’re trying to grow.
The reason isn’t volume; it’s ratios. Between feeds the microbes exhaust the sugars and leave their waste behind. The culture turns tired and acidic, and the yeast – which is what actually makes bread rise – struggles in those conditions because bacteria tolerate them better. Leave it long enough and the yeast is outcompeted and the starter goes sour and sluggish.
The discard resets the balance. Throw most of the culture away, keep a small inoculum of still-healthy microbes, feed it generously. The microbes have a huge meal ahead and plenty of space. They multiply back to strength, the yeast keeps up, and the discard itself isn’t waste – it makes excellent crackers, pancakes, and pizza dough.
Codebases are the same. Every week I delete some code – dead feature flags, tests that no longer test what the code does, config files for services we stopped running. Each deletion is uncomfortable in the moment, because I wrote this, and it meant something once. But what remains is closer to the shape I can work with. The point isn’t the size of the codebase; it’s the ratio of living code to tired nobody-remembers-why-this-is-here code. Removal isn’t the opposite of care. It is the care.
And keep the whole thing small. My starter lives in a small jar in the fridge. Unimpressive. Not Instagram-worthy. It waits quietly for Friday afternoon before Saturday’s bake. The counter-top sourdough that looks impressive in a sunlit photograph is also the one that usually dies when life gets busy. Good maintenance is almost always quieter than the thing it’s maintaining.
Lesson three: the practice, not the artefact
If the new starter lives twenty years, good. If it dies in two months and I start another, also fine. The point isn’t this jar; it’s whether I can keep the practice going.
The San Francisco sourdough at Boudin Bakery has been continuously fed since 1849 – older than California’s state government. The actual organisms don’t live anything like that long: yeast cells bud and split every two to three hours, and no cell in today’s culture has any ancestor alive more than a few weeks ago. What persists is the practice of feeding the jar. The culture is remade every week. The practice is the thing.
The code you wrote ten years ago is mostly gone by now – rewritten, replaced, deleted, refactored into something unrecognisable. What remains is the habit of care. Code is the artefact. The practice is the point.
Today, the jar has nothing in it
The starter has made nothing so far. It isn’t even, strictly, a starter yet – a scoop of wholemeal flour, a splash of water, whatever wild yeast happened to be on the flour. What it has is an idea of what it will become and a set of practices I intend to follow to get it there.
Tomorrow morning I’ll discard most of it, add fresh flour and water, and stir. The morning after, the same again. The acetone phase will come and I’ll resist the urge to panic-feed. In six weeks I’ll bake bread I’m happy with.
The thing I’m committing to today is not a jar. It’s a practice. The practice is what will produce bread; the jar is just where the evidence lives. The code I look after is the same: it needs my presence on a schedule I can keep, long enough for the compounding to catch up to the cleverness.
Feed the practice. Learn from the maintenance. Stay focussed. Don’t get attached to the artefact. Start again when you have to.
The practice is the point. Everything else is decoration.