The term vibe coding refers to a conversational, AI-assisted workflow where you tell an AI what you want, run what it generates, paste errors back, and iterate—often accepting changes without deeply reading the code. Andrej Karpathy coined the term “vibe coding” for this way of generating code and UI, but “vibe” because a kind of shorthand for a more intuitive, flow-based way of working, using natural language to induce and shape the output of an LLM toward working code and artifacts.
LLMs have become synonymous with “chatting.” You ask a question, it gives an answer. You correct it, it revises. It’s a back-and-forth — quick, conversational, a little improvisational, fairly transactional. The human stays in control, steering every line of thought.
But while “vibing” does feature a chat interface, the way the user works, the language they use, the intent they have, the exhaust from the engagement all have a different quality and utility. We might call a more formal design approach to “vibe interfaces” intention-driven composition.
Instead of telling the model how to do something, you describe what should exist and why. You set an objective or direction, define the ingredients that matter, and hand over the how to the system.
It’s the difference between saying:
“Move the button 20 px left and make the label bold.”
and saying:
“Add a set of quick-edit buttons so users can easily adjust content in place.”
The first is micromanagement. The second is delegation — a design intention expressed as an outcome. You’re not chatting; you’re setting something in motion. And what follows isn’t really a chat, it’s a user-driven collaboration.
When you work this way, you’re operating at a higher level of abstraction. You’re specifying the conditions of success, not the steps to get there.
It’s a subtle but profound shift in how humans relate to tools:
From control to orchestration. You define the score, the model plays the music.
From procedural to declarative. You focus on what should be true when it’s done, not how to achieve it.
From operator to art director. Your job becomes shaping intention, evaluating resonance, and deciding what “good” means.
That’s not “vibes.” It’s systems thinking applied to language.
The loop looks like this:
Intention — You define the purpose or desired qualities of the result.
“Create a visual layout that feels clean and direct, with clear actions for quick editing.”
Generation — The model interprets that and proposes a realization.
Review — You look at what came back. Does it meet the intent? What’s off?
Refinement — You adjust your statement of intent, not the instructions.
“Make the actions feel less cluttered, more like part of the flow.”
Note that lots of folks approach this mode of working like they are trying to instruct the LLM on what and how to do it. This approach is usually brittle, frustrating, and expensive. The LLM often behaves worse when you’re trying to apply more and more control over what it’s doing and how it’s doing it.
Each pass through the loop tightens alignment between what you meant and what the system understood. You’re effectively programming by feedback — but in natural language.
Instead of drawing a wireframe pixel by pixel, you tell the model:
“I want a dashboard that shows performance trends and lets managers drill into anomalies fast.”
It generates the structure, layout, and suggested interactions. You don’t describe coordinates; you describe behavior and affordance. Your human job is to evaluate fit, not syntax.
Traditional prompting:
“Write a blog post about AI design with three sections and an example.”
Intention-driven:
“Write something that helps readers grasp the shift from micromanaging AI to directing it — practical, reflective, no hype.”
Now the model is filling in an intention, not following a recipe. You can steer tone and depth without scripting the outline.
Procedural prompting:
“Write a Python loop that parses JSON files in a folder.”
Intention-driven:
“I need a utility that scans a directory and outputs a summary of JSON contents — it should be easy to adapt to other formats later.”
You’re defining outcomes and properties: extensibility, simplicity, generality. The model figures out the implementation.
Working this way changes the human-AI relationship. You move from writing instructions to expressing intentions — and that’s a higher-order creative act.
It’s also how complex systems are built in the real world. Architects don’t tell masons which brick to lay next. Product directors don’t specify every line of UI. They define direction, goals, and constraints and trust skilled systems to execute within them.
That’s what these models have become: adaptive systems that can interpret and act on abstract guidance. The chat interface just disguises how much control you can actually delegate.
Intention-driven composition rewards clarity of vision, not command syntax. The better you can articulate what matters, the more powerful your results.
That means asking yourself questions like:
What am I actually trying to achieve here?
What should this thing make possible for the user or reader?
What qualities define “done” or “good enough”?
If you can answer those in natural language, you can work at a creative scale that used to require whole teams.
Once you see the difference between chatting and intention-driven composition, you realize the interface shouldn’t treat them as the same thing. These are different cognitive modes. They place different demands on attention, structure, and memory. They deserve different environments.
Chatting is discursive. It’s exploratory, relational, full-context, memory-flowing. You’re thinking with the model.
Intention-driven composition is instrumental. You’re shaping an object. You’re setting constraints, describing outcomes, and letting the system handle the “how.” It’s not about conversation — it’s about construction.
Right now, most AI interfaces cram both behaviors into one chat window and hope the user figures out the difference. If we take this shift seriously, we need UI that reflects the different modality.
Chat mode is for thinking.
Vibe mode is for building.
When a user starts describing what a system should do, how a user should feel, or the qualities of a finished artifact, the interface should step out of chat and into composition mode automatically. The system should know the difference.
Chat mode keeps the memory, the context, the loose narrative thread.
Vibe mode is more like a contained workspace. You don’t want your larger ongoing relationship with the LLM polluted by three digressions and a frustrated rant at the LLM about why can’t it just fucking follow instructions!. You want a contained workspace where every what happens in that messy space doesn’t get out and impact all your other conversations.
When a user enters a compositional moment, the environment should feel different.
Chat mode can be bright, conversational, breathable.
Composition mode should tighten. Darker or more focused styling. A container that feels like a drafting room or editing bay, not a group text. The tone is: you are shaping something real now.
Think less messaging app, more creative suite:
Fewer distractions
Clear artifact viewport
History pane showing iterations like design revisions
Controls for committing, forking, or discarding work
This isn’t aesthetic whimsy — it signals a shift in how the brain should operate. Further the adjustment helps the user have different expectations, assume different controls and support.
Claude uses spatial and structural cues — rows, expandable canvases, visual hierarchies — to mark type rather than tone. It’s quietly teaching the user:
this part is dialog (transient, social, flowing)
this part is artifact (persistent, structured, inspectable)
That’s why its expanded row → canvas gesture works so well. It’s a spatial metaphor for shifting from linguistic interaction to object manipulation. The affordance tells you: “you’ve left talk-space; you’re now in build-space.”
ChatGPT, by contrast, keeps most things in one homogenous text stream – excepting Canvas mode. That has a cognitive upside — low visual noise, fluid reading — but it blurs functional boundaries. Commentary, reasoning, and deliverable all live in the same typographic register. The user has to interpret which layer they’re in, instead of the interface signaling it directly. The chat slides over to the side to make room for Canvas, but even after using this mode for over a year I don’t have a strong mental model of if the chat is the same or different than when Canvas is closed. When Canvas is open I’m not clear on if a message will always assume the context of the Canvas is the intended target because there isn’t strong enough visual affordances to guide that understanding.
Claude externalizes structure; ChatGPT internalizes it. Claude gives visual grammar to modes of reasoning and production; ChatGPT relies on linguistic inference.
In an intention-driven environment, that distinction becomes critical. If “chat” and “compose” are different states of cognition, the UI should mark the transition. Without that, users can’t develop intuitive literacy for when they’re steering thought versus shaping an artifact.
Composition is messy by design. You explore, discard, refine. That’s normal. But the mess should stay where it belongs: inside the artifact workspace. It should never leak back into the main conversational thread.
Allow dead ends. Encourage throw-aways. Treat “wasted” exploration as a first-class part of the process.
The model should not be “learning from” every half-sentence you typed while you were riffing ideas for interaction controls. That noise shouldn’t stain the rest of your relationship with the AI.
Not every compositional act is a full-scene transformation. Sometimes it’s mid-stroke tuning.
There are levels:
Full artifact creation from intention
Medium-scale revision (“make this friendlier, more direct”)
Micro-edits driven by intention (“tighten this section”)
The interface should adapt intelligently:
Zoom out to “vision and constraints”
Zoom in to “fix the pacing on this paragraph” or “clean visual hierarchy here”
This isn’t about a single “vibe mode.” It’s about a system that can flex across levels of abstraction, the way a good editor or design partner would. Even dedicated Vibe tools like Lovable or Bolt don’t strongly support this zoom-in-out, and it can be frustrating when a command you issue ends up refactoring everything when all you wanted was to fix a minor interaction detail.
It’s a creative operating system.
One that recognizes:
when you are thinking,
when you are specifying intention,
when you are shaping structure,
when you are refining execution.
Right now, most AI tools treat all language as the same. One input field. One log. One performance mode. Real creative work has phases. You don’t brainstorm on the same canvas where you finalize. You don’t sketch structural intent on the same layer where you kern letters.
Language is now a design surface. A production surface. A composition surface.
If the tool doesn’t treat those modes differently, the user will feel the friction — and the system will never reach its potential.
When tools understand how we are speaking, not just what we are saying, the work gets faster, the thinking gets sharper, and the role of the human gets bigger, not smaller.
We stop chatting and start composing.
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.