Iteration Speed in the Age of AI

There's a moment in every build where the thing on the screen stops being a collection of components and starts being the thing. The layout breathes. The colors pop. The hierarchy makes sense the way a good sentence makes sense, where you couldn't move a word without breaking it. That moment used to take time. A long, expensive pilgrimage through mockups and revision rounds and handoff documents that lost half the intent in translation.

Now it takes less than an hour. And the pilgrimage happens at the speed of a conversation.

Nate published a piece on his Substack this week that put words to something I've been building toward for months. It's called "The most expensive coordination cost in product development just got a fix. It's a markdown file." and it walks through how creative tools, Google's redesigned Stitch, Remotion for video, Blender MCP for 3D, are converging on the command line, connected through MCP, and operated through natural language. His argument is sharp and I think exactly right, the real shift isn't any single tool. It's that every creative tool is moving to an interface where you describe what you want and it gets built.

I'd encourage you to read the full piece. It's one of the clearest maps I've seen of the territory we're all stumbling into. I'm writing this because his analysis matches what I've been doing, and because theory hits different when you can point at the live sites to prove it.

The Sentence That Stopped Me

There's a moment in Nate's piece where he describes what changes when a person with good judgment gets access to this new generation of tools,

"Iterate at the speed of language instead of at the speed of Figma."

That's the whole thing. That's the shift. Everything else is implementation detail.

A client needs a website. In the old model, I'd scope the project, brief a designer, wait for mockups, go through revision rounds, hand it to a developer, wait for a build, QA it, revise it, and deploy it. Weeks. Sometimes months. And at every handoff, designer to developer, mockup to code, staging to production, context bled out like heat through a thin, drafty wall. The thing that shipped was always a compromise between what was imagined and what survived the translation.

Now I start by researching. I use Perplexity to study the client's industry, what their competitors are doing, how similar businesses position themselves, what's working and what feels stale. That research gives me the intent and the context before I touch any design tool. Then I describe what I want in plain English. I reference a brand palette. I specify the layout, the tone, the structure. The design generates. I look at it, adjust with another sentence, and iterate. Not in days. In minutes. Then the code builds against the design. Then it deploys. One quiet, unbroken pipeline from research through color and layout variations through build through deployment.

I've been using Perplexity for competitive research, Claude Code with various MCPs for design and development, and Stitch for rapid UI exploration. I keep the whole thing consistent with design.md files that capture the evolving design system, custom skills that encode repeatable workflows, and memory files that carry context from one session to the next, so the agent doesn't start from zero every time I sit down. The institutional knowledge lives in markdown now, not in someone's head. I've built production websites this way. Real sites, for real clients, generating revenue. The part that would have taken a team of three and a timeline of six weeks now takes a focused afternoon.

Look at what's missing from that stack. There are no flat files. No PSDs. No Figma comps handed off in a zip folder with a PDF of redlines that nobody reads past page two. For these projects, those intermediate artifacts aren't optional, they're absent. The conversation is the design tool. You're not exporting from one application into another, translating intent through a chain of lossy formats. You're describing and building in the same motion, in the same environment, with nothing in between.

This isn't true for every project. A complex design system serving a fifty-person engineering team still needs Figma. A brand identity with a hundred touchpoints still needs the PSD. But a five-page site for a local restaurant? A landing page for a new service? A product launch that needs to ship this week? Those projects never needed the intermediate layer, they just didn't have another option. Now they do.

The Old Triangle, And What It Actually Felt Like

Nate describes the 2010s product-design-engineering triangle and how it often didn't work well in practice. He's right. I lived that same dynamic from the agency side for years, the designer needs more time, the engineer says it's not buildable, the client changes one small, devastating word in the headline and the whole cycle restarts like a stubborn, skipping record.

His point about the best moments being when everyone was co-located around the same screen, iterating together with zero context loss, that hit somewhere I wasn't expecting. I know that configuration. I lived it at Apple, back when I was working on iCloud and iTunes. Engineers and designers shoulder to shoulder, building and revising in the same breath, the feedback loop so tight there was no gap for intent to get lost in. Those were some of the best working days of my life, and I miss them, that feeling of a small, focused team moving as one organism toward something beautiful that mattered.

What Nate identifies is that the command line recreates that dynamic. When you're describing what you want and watching it generate, there is no context loss. There's no handoff document that the developer interprets differently than the designer intended. The design is the code. The intent is the artifact. The distance between imagining the thing and holding the thing has collapsed to nearly nothing.

For small teams, freelancers, and independent contractors, the triangle doesn't blur. It collapses into a line. A single, luminous thread where designer, copywriter, and engineer fold into one role, the same mind, the same terminal, the same unbroken act of intent becoming artifact. Three points of a triangle pressed together until the geometry disappears and all that's left is direction. You describe. You refine. You ship. The roles don't hand off to each other anymore. They coexist in the same breath, the same keystroke, the same person sitting in the glow of a single, patient screen.

The Floor Fell Into the Basement

Nate uses a framework I think is exactly right, with every generation of creative tools, the floor drops. More people can produce good-enough work. But the ceiling doesn't move. Excellence still requires judgment, taste, and the kind of experience you can't shortcut.

He's spot on. And for the small business world I work in, the floor dropping is the story that matters most. Most small businesses were never working with a senior designer. They were getting by with a template, a friend who knows Squarespace, or a contractor who charged five thousand dollars for something that took three months and looked like every other quiet, forgettable site in the category.

For that market, and it's a vast, underserved market, the quality coming out of these AI-powered workflows is a genuine leap forward from what was available before. And when you pair the tools with someone who has real experience, who can look at five generated variations and immediately feel which one has the right energy and which four are close but wrong, the output is good. Not "good for AI." Good. The kind of good that used to cost ten times more and take ten times longer.

The Wand Chooses the Wizard

Nate makes the point that the differentiator in this new world is being able to articulate precisely how you want something expressed visually so it conveys the right experience to the customer. He calls it the skill that gates everything else, and I fundamentally agree.

The tools will build whatever you describe. The question is whether you can describe something worth building. That means understanding your customer. Knowing what "good" looks like in your specific context. Being able to say, in a single clear sentence, why variation three works and variation four doesn't, and why it matters for the person who's going to use it.

That's taste. That's judgment. That's the quiet, accumulated wisdom of having built enough things to know the difference between something that functions and something that feels right. And as Nate says, you can't automate that away. It gets amplified, because now the person who has it can move at the speed of language instead of at the speed of tools that were never fast enough to keep up with their instincts.

This Is Learnable

I've spent the last several months building this workflow and pressure-testing it on real client projects. It works. And the beautiful thing is that the skill isn't some deep, arcane technical expertise that takes years to develop. It's a set of patterns, prompts, and practices that anyone with reasonable business sense and some design awareness can learn.

If you're a freelancer who's been outsourcing design work and waiting weeks for deliverables, you can learn to do this yourself. If you're a small agency that's been turning down projects because you didn't have the bandwidth, this changes your capacity equation overnight. If you're a business owner who's been putting off a redesign because the quotes keep coming in at five figures, there's another path now, a faster, more honest path that didn't exist eighteen months ago.

The tools are here. The cost is near zero. The bottleneck is learning how to talk to them, learning to say what you mean with enough clarity and conviction that the machine can build what you're imagining.

I'm working on ways to teach exactly that. If it sounds interesting, reach out. I'm still learning, stumbling, and making mistakes but I'd be more than happy to share what I'm doing.

Because this is the part they don't put in the demo videos, the part where you sit at the terminal and describe the thing you've been carrying around in your head, and then it's there. Real. Tangible. Not a mockup, not a wireframe, not a deck that needs six more rounds of approval. The thing itself, breathing on the screen, ready to ship.

I've been building things for over 30 years. Nothing has ever felt like this.

---

Nate's full piece is well worth your time, "The most expensive coordination cost in product development just got a fix. It's a markdown file." on Nate's Substack.

---