Cursor Designer: Why Software Must Retain Its Human Touch in the Age of AI Acceleration

The Most Fundamental Change AI Brings: The Build Loop

Rio believes the most important change AI brings isn't efficiency — it's the transformation of the build loop.

The concept of the Build Loop originates from the "feedback loop" theory in software engineering. Traditional waterfall development models slice the software lifecycle into sequential phases — requirements → design → implementation → testing → deployment — with each cycle often spanning months or even years. The rise of Agile development and Lean Startup methodologies attempted to compress this cycle, introducing the "Build-Measure-Learn" framework that shortened iteration periods to weeks. AI-powered coding tools are now compressing this cycle further, down to minutes — essentially reducing "feedback latency" to near zero. Cognitive science research shows that the shorter the feedback delay, the faster skills are acquired. This is the neurological foundation for what Rio describes as "judgment forming through correction."

In the past, building software was a slow, expensive loop: you had an idea, translated it into a spec document, designers designed it, engineers implemented it, product managers reviewed it, QA tested it, and then everyone moved on to the next thing. Because the loop was expensive, we guarded it — arguing before touching anything, planning before handling materials, trying to "get it right upfront" because the cost of mistakes was too high.

Now, the loop has become extremely fast: you have an idea, ask for a version, check the result, revise it, run it, continue — sometimes in minutes, sometimes in seconds. Rio emphasizes this isn't just a productivity change; it transforms how judgment is formed.

"The first version is almost always wrong. The concept is too vague, the transitions are janky, the spacing is technically correct but visually off, the copy says the right thing but not the true thing. You only notice once it exists, and then you fix it. That small correction — that's where judgment forms."

This is where taste is born, where craft evolves. "Taste" is a concept long undervalued in the design world. Psychologist Mihaly Csikszentmihalyi's "Flow" theory suggests that when skill level matches the challenge at hand, people enter an optimal creative state. The formation of taste requires extensive "deliberate practice" — psychologist Anders Ericsson's research shows that the core of professional expertise isn't repetition, but continuous correction through immediate feedback. What Rio describes as "the small correction being where judgment forms" is precisely the core mechanism of deliberate practice. As AI automates the execution layer, the path to cultivating human taste must shift toward higher-order judgment training — a development with profound implications for education and career development.

The deeper promise of AI isn't to help us build more things faster, but to bring more people into the loop — designers can get closer to implementation, engineers can explore different architectural directions, and people who never thought of themselves as programmers can build the first version of something that only existed in their minds.

The Danger Isn't That Machines Are Too Creative — It's That Humans Are Too Passive

But as the loop accelerates, it can also be hidden. Rio sharply identifies a paradox of our current moment: two things are simultaneously true — more people can build, and more mediocre things can be built.

When building something costs almost nothing, mediocre products tend to look "good enough": they work, they ship, they fill the space. And now there could be an infinite number of these — software that functions but is meaningless, interfaces that are correct but lifeless, products manufactured by agents, genuinely cared for by no one, launched into the void.

"To me, that's the real risk. Not that machines become too creative, but that people become too passive around them."

Rio describes this dangerous pattern as "pulling a slot machine": you make a wish, the machine disappears, then returns with something seemingly reasonable — buttons work, pages render, demos pass — but you never entered the decision itself. You just approved the surface. This phenomenon is known in psychology as "Automation Bias" — when humans over-trust automated systems, critical thinking gradually atrophies. This has been well-documented in aviation accident analysis, where engineers often fail to intervene when autopilots issue incorrect commands. The real danger is the interface turning humans into "approvers," and us confusing "output" with "material."

He draws a brilliant distinction:

• Output ends the loop — it says "here is the answer";
• Material invites you back into the loop — it says "come touch it, shape it, make it yours."

If AI hides too much of the process, it can still give you output, but it takes away the struggle that makes you stronger.

The Glass Interface Principle: Seeing Through How the System Works

Rio joined Cursor precisely because he experienced this problem firsthand. Cursor inherited a mature editor foundation from VS Code, but as model and agent capabilities rapidly advanced, the question became: if we redesigned the software environment for a world full of agents, what would it feel like?

The answer is what they internally call "Glass." Rio is careful to clarify that Glass isn't a visual style — not frosted glass blur effects — but an interface principle: the system should let you see through how it works. This philosophy resonates deeply with the core proposition of the "Explainable AI" (XAI) field — researchers are exploring how to keep AI decision-making processes readable for humans without sacrificing user experience. The EU AI Act similarly requires high-risk AI systems to provide explainability documentation. The Glass principle can be seen as an attempt to translate this regulatory demand into product design practice.

In a black box, AI disappears and returns with a verdict. In Glass, AI works in a way you can observe:

• You can see the plan;
• You can see the streaming output of thoughts and tools;
• You can see the changes, watch commands run;
• You can stop it, shape it, inspect it deeply, take it over.

The key is Progressive Disclosure — a classic design principle from the field of Human-Computer Interaction (HCI), systematized by IBM researchers in the 1980s. Its core idea is to present information and functionality in layers according to frequency of use and complexity, avoiding cognitive overload. Apple's iOS design language and Google's Material Design both rely heavily on this principle. You don't have to read every line, but you always can. For experienced programmers, this means letting agents run freely and stepping in when needed; for designers, it means accepting the structure and tweaking a detail until it "feels right"; for beginner programmers, it means slowing down, reading the plan, and learning through observation. The same system supports all three.

"When an agent works for a few minutes, you need guidance. When it works for hours, you need legibility across the entire system. Without visibility, it's not a tool — it's a liability. A black box optimizes for clean output. Glass optimizes for human agency. A black box reduces software to a wish and a verdict. Glass turns software into clay."

Baby Cursor and Baby Glass: Using Tools to Think About Tools

The Cursor team began exploring this more radical interface reset in January of this year. Glass started as "Baby Cursor 3" — an Electron prototype built on top of Cursor CLI. Electron is an open-source framework developed by GitHub in 2013 (originally called Atom Shell) that bundles the Chromium browser engine with the Node.js runtime, allowing developers to build native desktop apps using web technologies. VS Code, Slack, and Discord are all built on this framework. Choosing to build a new Electron prototype from scratch rather than modifying VS Code meant shedding the historical baggage of a mature editor's massive codebase — the trade-off being the loss of an existing ecosystem in exchange for extreme experimental flexibility. Baby Cursor's significance wasn't in rebuilding the entire production architecture, but in creating a fast, flexible experimental space for "thinking with the hands," free from VS Code's constraints.

Because it was built using Cursor itself, the loop became incredibly tight: idea → prototype → reaction → edit → repeat. Rio points out that speed itself isn't the interesting part — what's genuinely powerful is that faster prototyping helps the team reach conviction faster — no longer aligning through documents and opinions, but seeing through demos; no longer trying to predict the product from a distance, but discovering it through building.

Later, Baby Cursor evolved into Baby Glass and became a web app, making team sharing easy, turning the prototype from a private sandbox into a shared "environment for thinking about the future." This is precisely the kind of loop Rio wants AI tools to create: not just faster output, but faster contact with the material, faster learning, faster disagreement, faster collaboration, faster formation of belief.

Craft Doesn't Disappear — It Migrates to Judgment and Responsibility

If agents can execute an ever-larger portion of the loop, what's left for humans? Rio's answer lies in what comes before and after the loop.

Before the loop, there's what sets you in motion — a friction you can't ignore, a gap that bothers you, a sense that "something should exist," even before you can articulate it clearly. Rio recalls his early experience with a Mac:

"The Dock would bounce, Genie effects would fly, Exposé would scatter windows like cards on a table. None of it was necessary, but it all felt like someone cared. Software had texture, had opinions, and you could feel the person behind it."

Behind these animations was the philosophy of "Emotional Design" — systematically articulated by cognitive scientist Don Norman in his book of the same name, in which he divides design experience into three dimensions: Visceral, Behavioral, and Reflective. With the rise of A/B testing culture in product management, emotional experiences that are difficult to quantify often lose out to data-driven decisions, causing software to trend toward a homogenized state of "functionally correct but utterly soulless" — a phenomenon the design community has called the "McDonaldization of design." Somewhere along the way, software became smoother, faster, and more consistent — and also more boring. The quirks were removed because the test data looked bad; the warmth was cut because it couldn't be measured. "We optimized ourselves into a world where everything works perfectly and nothing feels like anything."

Now AI makes speed superhuman — you can generate an entire product in an afternoon. But the cost is the same: when building costs almost nothing, slop becomes free too. That's precisely why humans matter more, not less. Taste is not a prompt. Caring is not a parameter.

After the loop comes responsibility: What did we release into the world? What did it change? Who did it serve? What does it make it easier for people to become? Agents can execute the loop, replicate the loop, produce 10, 100, 1,000 versions — but they don't know what's worth protecting, don't know whether something is "technically correct but lifeless," don't know what a thing is quietly pulling us toward.

Rio therefore outlines a migration path for craft — one that closely mirrors the economic theory of "Skill-Biased Technological Change" (SBTC). Every major shift in production tools throughout history has eliminated execution-layer skills while placing a premium on judgment-layer skills: the printing press displaced scribes but elevated editors; spreadsheets displaced manual bookkeepers but raised the value of financial analysts:

• When execution is expensive, craft exists in execution itself — carefully written code, precise layouts, copy rewritten 12 times;
• When generation is cheap, craft migrates upstream to judgment (what to ask for, what to keep, what to reject, where to slow down), and downstream to responsibility (what was released, what was changed, who was served).

Conclusion: AI's Purpose Isn't to Make Humans Disappear

Rio's talk ultimately returns to a simple belief. He built RealOS — a personalized computing environment — precisely because he missed the feeling of "computers as an open playground" — a place to tinker and think. When he turns an idea into something he can touch, play with, and change, it "stops being an idea and becomes a place I can think inside."

"That's why I build. Not for productivity, not for disruption, not for any grand abstraction. But for that moment when something that only existed in your head becomes real enough for someone else to see and touch."

Tools will change, models will change, the economy will change — but this part won't: you feel something is wrong, you make a mark, the world responds, you make it real. The future Rio wants isn't a boring future where software builds itself while humans watch from the sidelines, but one where people participate "as authors rather than passive approvers."

"If we get this right, the future won't just be faster — it'll be more human." That line may be the most important reminder for everyone building AI-powered developer tools.