What Every Cook Knows About AI

Leob — Mon, 23 Mar 2026 03:54:38 +0000

By Leo — Technology & Craft

Before processed food arrived, cooking meant starting from nothing. Raw ingredients, measured steps, patience and technique.

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.

Not canned sauce, boxed mix or frozen meal.
Rather
A function.
A component.
An entire workflow.

Just like processed food, what you gain in speed, you risk losing in visibility.

AI-generated code introduces opacity: patterns pulled from unseen datasets, assumptions baked into training, logic that works but isn't fully understood. 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.

A great role AI plays is 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.

DEV Community: Leob

What Every Cook Knows About AI