In AI-first mode, production costs are virtually zero—it’s validation that becomes the bottleneck

The Day Production Became the Easy Part

The first time I built a fully functional prototype in one evening instead of a week, I realized that the focus of my work had just shifted. Not the tool—the profession. For a long time, the bulk of my work consisted of production: designing, coding, writing, assembling. Production was the bottleneck, and my entire process was organized to protect it. We planned at length, validated the brief, and aimed to get it right the first time, because a second version was expensive.

In AI-first mode, that calculation falls apart. Producing a first version costs almost nothing. And when production becomes virtually free, it’s not the speed that really changes—it’s where the work takes place. It shifts downstream, toward evaluation, selection, and validation. That’s where, now, quality is won or lost.

The unit of work is no longer the deliverable; it’s the iteration

In a traditional model, we move in a straight line: we plan, we execute, we deliver. Since each version requires time and energy, we try to avoid mistakes before producing anything. Everyone has experienced that 15-page PRD written before a single line of code—the document that attempts to predict what we’ll only truly know once we start building.

With an AI-first approach, we reverse the order. The cost of a first version drops to the point where it’s faster to build it than to describe it. We no longer plan first to avoid mistakes, but to test quickly, compare different approaches, and learn. The unit of work is no longer the final deliverable—it’s the iteration. And this isn’t just another productivity gain—it changes what we’re optimizing for. It’s the same shift I described when comparing static sites to WordPress: AI doesn’t just speed up the old process; it changes its very logic.

What This Means in Practice

The Prototype Becomes a Tool for Reflection, Not Just Production

In a traditional approach, we write a document, a brief, or a PRD, and then we build. With an AI-first approach, we generate several functional versions of an idea before we even have all the answers. The prototype ceases to be the end result of the process and instead becomes its driving force.

When I built my expense management app with Claude Code, I didn’t wait for the perfect PRD to get started. I let the prototype resolve the questions the document couldn’t settle. Instead of spending a long time describing a hypothetical solution, we make it visible early enough to critique it, improve it, or abandon it. And scrapping a mockup you built in an evening doesn’t hurt; scrapping three weeks of work does—that’s when you get stuck on a bad idea just because it cost a lot.

We explore breadth before going into depth

Traditional work encourages us to choose one direction and then delve deeper into it, because we only have the resources to explore one at a time. An AI-first approach allows you to explore multiple avenues in parallel: different concepts, multiple mockups, various page layouts, and different content tones.

The trap is confusing this breadth with progress. Generating ten directions is worthless if you’re unable to quickly eliminate eight of them. The skill that’s becoming rare is no longer the ability to produce—it’s the ability to choose. Knowing how to eliminate a good option because another is better—that’s the real work. Value is shifting from the hand to the eye.

The role shifts from producer to director

With AI, I write less from scratch, I code less from scratch, and I design less while staring at a blank page. This doesn’t diminish the human role; it shifts it. The work is shifting toward framing, direction, critique, coherence, and decision-making. You have to know what to ask for, what to keep, what to correct, and what to discard.

The real danger isn’t that AI will produce poor work. It’s that it will produce plausible work—clean, credible, convincing—and that we’ll delegate judgment to it on top of that. AI generates, suggests, and accelerates, but it has no real responsibility and no complete understanding of the context. If the result is wrong, it’s not the AI that answers to the client. Delegating execution, fine; delegating judgment, never. That’s the line I refuse to cross.

Verification Becomes the Real Bottleneck

Here’s the crux of the matter. When production becomes extremely fast, it’s no longer creation that slows down the work. It’s validation. The bottleneck doesn’t disappear—it shifts one step downstream, precisely where it’s monitored less closely.

Is the text accurate? Is the code secure? Does the design hold up from one screen to the next? Does the solution meet the need, or just the demand? Can the prototype become a viable product, or does it fall apart as soon as you put it to the test? Each of these questions requires a human capable of making a judgment—and that work hasn’t accelerated at the same pace as development.

That’s why audits, reviews, testing, and deployment become even more valuable in an AI-first approach—not less so. Just because it’s become easy to produce ten times as much doesn’t mean we should lower our standards. Quite the opposite: the higher the volume, the more valuable the ability to say “no, that won’t work” becomes.

Context Becomes the Key Asset

In a traditional model, value is tied to the deliverable: a page, a mockup, a document, a campaign. In an AI-first approach, a large portion of that value shifts to reusable context—system prompts, conventions, the design system, components, PRD templates, brand guidelines, validated examples, and knowledge bases.

This is exactly the shift I described when moving from prompt engineering to context engineering: it’s no longer the magic formula of a prompt that determines quality, but the entire environment we structure around the model. That’s also why I spend so much time providing Claude with my clients’ design system and voice rather than correcting each output by hand. We’re no longer just building deliverables: we’re building systems capable of producing more of them, faster and with greater consistency.

But—and this is the nuance that too many people miss—more context isn’t always better. Piling on guidelines often ends up having the opposite effect of what we’re aiming for. Beyond a certain point, too many constraints lock the model into predictable, repetitive, and flat responses. The goal has never been to provide as much information as possible, but rather the right information. Building context isn’t about accumulating—it’s about calibrating.

Data quality becomes strategic

AI relies entirely on what it’s given. If the data is incomplete, contradictory, or poorly structured, the results will inherit these flaws—without warning. Conversely, a few well-chosen, representative examples often outperform a mountain of vaguely relevant information. The key isn’t the quantity of data, but its quality, recency, and relevance to the objective. I’d rather have five impeccable examples than fifty lackluster ones: the model learns the average of what it’s shown.

The real risk: lots of activity, no direction

The “AI-first” approach has a structural flaw. It makes it so easy to generate ideas, text, interfaces, and prototypes that we can accumulate dozens of versions without ever knowing which one is actually better. Movement, lots of movement—but not necessarily a direction.

There’s a second, more insidious pitfall: believing that by adding ever more rules, context, and guidelines, we’ll automatically get better results. In reality, this often traps the AI in repetitive patterns and stifles the exploration of new solutions.

The discipline that saves the day lies here: defining the criteria before generating. Without criteria decided in advance, you’re not comparing options—you’re accumulating possibilities—and you’re telling yourself that’s work.

In summary: we’re no longer looking for the right version; we’re looking to find it faster

Traditional work seeks to minimize errors before producing results. AI-first work accepts error as a normal step, but makes it fast, visible, and inexpensive. This isn’t a license to let your guard down—it’s a shift in where you focus your rigor.

AI can process enormous amounts of data and context, but its performance doesn’t depend on the quantity of information we feed it. It depends on the quality of the framework, the relevance of the context, and the human ability to evaluate the output. The machine has made production nearly cost-free; it has not made judgment optional.

The fundamental difference can be summed up in one sentence: we no longer work to produce a good version; we work to build a system that helps us find the right version faster—without ever losing the judgment needed to distinguish what is truly useful from what is merely easy to generate.