Season to Taste: The Case for Iterative Cooking

Most cooks treat a recipe as a script to be executed: measure, combine, heat, serve. But the best meals I've made came from treating the kitchen like a codebase — writing a first draft, tasting it, and refactoring on the fly. The first time I made a Thai green curry from a cookbook, I followed every quantity exactly. The result was flat: too sweet, not enough salt, and the heat was buried under coconut cream. Instead of accepting it, I tasted, added fish sauce, tasted again, squeezed in lime, and tasted once more. That iterative loop turned a mediocre dish into something I'd proudly serve. It also taught me that a recipe is a starting point, not a contract.

In programming, we have a name for this: test-driven development. You write a failing test, make it pass, then refactor. Cooking can work the same way. Before you commit to a full pot, pull a spoonful, let it cool slightly, and evaluate. Does it need acid? Salt? Fat? Heat? Each adjustment is a micro-test, and the feedback is immediate. I keep a small notebook in the kitchen, jotting down what I changed and how it tasted — a commit log for dinner. Over time, those notes become my personal documentation, revealing patterns: my palate prefers more acid than most recipes suggest, and my oven runs 15 degrees hot. That data is invaluable.

Consider the humble tomato sauce. A standard recipe might call for onions, garlic, canned tomatoes, basil, and a pinch of sugar. But tomatoes vary wildly in sweetness and acidity. If you blindly follow the recipe, you might end up with a sauce that's cloying or harsh. Instead, taste after the tomatoes have simmered for twenty minutes. If it's sharp, add a grated carrot or a small piece of butter. If it's dull, a splash of red wine vinegar can wake it up. If it's bitter, a pinch of baking soda neutralizes the acid. These are not random hacks; they're adjustments based on real-time feedback, just like debugging a function that returns unexpected output.

There's a deeper parallel: both cooking and coding reward small, reversible changes. In code, we avoid massive rewrites that break everything; we commit often. In cooking, it's easier to add than to subtract. If you oversalt a soup, you can dilute it with unsalted stock or add a peeled potato to absorb some salt. But it's far better to salt gradually, tasting between additions. I learned this the hard way after ruining a batch of chili by dumping in a tablespoon of salt at once. Now I add a quarter teaspoon, stir, wait a minute, and taste. The delay matters — salt needs a moment to dissolve and distribute.

Timing is another variable that recipes rarely capture well. "Cook until done" is as vague as "handle errors appropriately." What does done mean? For a steak, it's an internal temperature. For a stew, it's when the meat shreds with a fork. For a stir-fry, it's when the vegetables are crisp-tender. You have to develop your own sensors. I use a instant-read thermometer for proteins and my ears for onions — they should sizzle, not pop. These cues are learned through repetition, just like recognizing a stack trace or a memory leak.

Mise en place is the equivalent of setting up your development environment. Before you turn on the heat, chop the onions, measure the spices, and open the cans. This isn't just about organization; it's about reducing cognitive load so you can focus on tasting and adjusting. When everything is ready, you can react instantly to what's happening in the pan. I've had disastrous results when I tried to chop garlic while the oil was already smoking. The garlic burned, the oil turned bitter, and I had to start over. Now I prep everything first, even if it takes an extra ten minutes.

Finally, embrace version control for your recipes. I use a simple text file with dated entries: "2025-03-15: Increased ginger to 1 tbsp, added 1 tsp soy sauce. Result: better umami, slightly too salty. Next time: reduce fish sauce." This is no different from a Git commit. It lets you revert a bad experiment and build on a good one. Over months, you'll develop a set of personal recipes that truly reflect your taste. And isn't that the point? Cooking, like coding, is not about following instructions perfectly. It's about understanding the system well enough to make it do what you want.