Let the AI cook | ivan.codesivan.codes/blogMay 2026Let the AI cookAI coding works when the stack is right and the developer has the experience to trust the output. Most of the elaborate workflows being shared are people getting in their own way.I keep seeing posts where somebody walks through the elaborate workflow they figured out for getting AI to write production code, and the workflow gets way more credit than it deserves. The two things doing the work are the stack the model is writing into and whatever the developer has built up over their career: taste, pattern recognition, a feel for which way the code wants to go. Everything on top of those two is decoration.
What I hear from people trying to follow those workflows usually sounds something like this:

Spent an hour on this and Claude still couldn't get it right. I gave it the whole file, listed every edge case, told it exactly which function to touch, specified the naming convention. It still messed it up.

Prompt constraintsclick to toggleSpecify the fileList every edge caseName the functionPin the approachDefine namingMatch this styleSolution space0 of 6 constraints activeSolution space: 112 / 112
In cases like this the prompt itself is the problem, because each constraint added to it narrows what the model can do, and by the time you've stacked five or six the field of view is small enough that the model has to thread a needle through whatever assumptions you packed in along the way. Any time one of those assumptions is wrong, and at least one usually is, the output looks like a failure even though the model was doing exactly what you asked.
My version is usually two turns. The first one points the agent at context I already have locally, the second one says what to build:
BrownfieldGreenfieldWorking in an existing codebase.01Spin up an agent to familiarize yourself with the context in [folder].02Now fix the session expiry bug.
Both work because the priming step alone ticks a bunch of boxes the over-prompter is trying to hit one at a time. Once the agent has read the reference it naturally matches the conventions, the naming patterns, the way functions are structured, the way errors get handled, all the stuff people otherwise try to spell out constraint by constraint.
Once you accept the model can write the code, you're left with a choice about how to work with it. That's where most devs shoot themselves in the foot. Letting the model run feels like giving up control, while inventing a workflow feels like the responsible move, even when it produces worse work in more time.
The reason that feels like losing control runs deeper than the code itself. Devs have spent twenty years tying their sense of worth to what they produced, the cleverness of a solution, the abstraction nobody else saw, the late-night fix that worked on the second try, all of which was how the industry measured you and how you measured yourself. When a model arrives that can produce the artifact for you, often a better one, inventing a new layer of work it can't do yet is how you keep being at the center of things, but the layer keeps shrinking, and the people who can't let go end up spending more and more of their time on ceremony that exists so they can still feel essential.
What's left for the developer is the harder part of the job, which is picking the stack, having the taste, and catching the moment the output starts to drift, and the elaborate process layered around all of that is mostly busywork that lets you feel productive while you avoid the harder, vaguer thing.
Let the AI cook.← All posts15 min intro →

AI coding efficacy is contingent upon the appropriateness of the technological stack and the developer's existing experience and intuition. Many elaborate workflows shared for obtaining production code from AI often introduce unnecessary obstacles. The true drivers of successful AI-assisted coding are the underlying stack, the model being directed, and the developer's accumulated knowledge, including taste and pattern recognition; anything beyond these elements is often considered mere decoration.

Attempts to optimize the process through constrained prompting, such as listing every edge case or specifying naming conventions, frequently undermine the model's performance. Each added constraint narrows the model's scope, requiring it to operate on assumptions that may be incorrect, which ultimately leads to unsatisfactory output despite following the instructions precisely. This constraint-based approach highlights that the prompt itself can be problematic because the complexity forces the model to thread a needle through assumptions, often resulting in failure even when the request is technically accurate.

A more effective approach involves a two-turn strategy. The first turn establishes context by directing the agent to local context already present in the codebase. The second turn provides the specific directive for the required modification or build. This method proves superior because the initial priming step allows the agent to naturally internalize the existing conventions, naming patterns, error handling methods, and structural organization, thereby accomplishing many of the requirements that people attempt to spell out through explicit constraints.

The delegation of code generation raises a deeper psychological dimension regarding developer autonomy. Allowing the model to produce the artifact can feel like relinquishing control, whereas inventing a workflow feels like a more responsible action, even if the resulting code quality temporarily suffers. This feeling of losing control stems from the way developers have historically tied their self-worth to the complexity of the solutions they create. The advent of models that can produce artifacts challenges this framework, suggesting that the valuable role of the developer shifts toward selecting the appropriate stack, exercising taste, and recognizing when the output begins to deviate, rather than engaging in excessive procedural ceremony. Ultimately, the elaborate processes surrounding AI interaction are often busywork that distracts from the more crucial, albeit vaguer, skill of guiding the process toward the desired outcome.