By Leo — Technology & Craft
There was a time when cooking meant starting from nothing. Raw ingredients, measured steps, patience and technique. Then processed food arrived — not as a disruption, but as a convenience.
A canned sauce. A boxed mix. A frozen meal.
It didn't replace cooking.
It simply made it easier.
And slowly, almost imperceptibly, the role of the cook began to change.
Software development is experiencing its own version of that moment. AI doesn't eliminate the need for developers — it reduces the number of manual steps required to produce something functional. You describe what you want, and working code appears.
A function.
A component.
An entire workflow.
The friction is gone. But just like processed food, what you gain in speed, you risk losing in visibility.
When you cook from scratch, every ingredient is deliberate. Processed food changes that — the list grows longer, more abstract, harder to trace. AI-generated code introduces the same opacity: patterns pulled from unseen datasets, assumptions baked into training, logic that works but isn't fully understood. The output is clean. The internals are not always clear. And yet, you serve it anyway.
This is where the role of the developer begins to evolve. They are no longer writing code line by line — they are selecting, shaping, and validating outputs. The work shifts from execution to curation. More than a builder, the modern developer becomes something closer to a chef-architect: designing the structure of the system, choosing which outputs to trust, ensuring everything holds together. They don't need to chop every onion. But they must know when the onion matters.
AI also plays the role of sous-chef — someone to sanity-check your thinking, offer alternatives you may not have considered, and help you move from idea to working code in minutes. It's especially useful at the start, when the hardest part isn't solving the problem but beginning. It breaks the inertia: scaffolding a project, generating a first draft, removing the hesitation that stalls good work before it starts. It doesn't replace thinking. It removes hesitation.
But there's a trap that doesn't get talked about enough. When AI makes complexity easy, complexity becomes tempting. Abstractions get introduced that serve no real need. Systems get architected for scale that doesn't yet exist. AI lowers the cost of building — it doesn't always lower the cost of maintaining. The best code, like the best meal, is often simpler than it looks.
The best chefs don't reject processed ingredients — they use them intentionally, knowing when a shortcut is acceptable and when it quietly compromises the dish. Developers must develop the same discipline: reviewing AI-generated code as if they didn't write it, understanding the architecture even when they didn't build every layer, resisting complexity that doesn't serve a real need. The responsibility hasn't disappeared. It has simply moved upstream — from writing to deciding.
We are not heading toward a world without developers, just as we never moved into a world without cooks. We are entering a world where craft looks different — less about manual repetition, more about judgment, taste, and composition. The tools are faster. The outputs come easier. But the standard of quality still depends on the person making decisions: the one who questions the output, resists the tempting abstraction, and knows when simple is the right answer.
In a kitchen full of shortcuts, the meal can still be exceptional. The difference was never the tools. It's the discipline of the one who chooses how to use them — and the standard they refuse to lower, no matter how easy it gets.
Top comments (0)