The End of the Designer–Engineer Divide

Ryo introduces his personal KPI to turn all Cursor designers into coders, explaining how AI agents eliminate the need to learn low-level coding concepts upfront. He describes his journey from building websites at 11 to professional design roles at Asana, Stripe, and Notion, emphasizing learning by building rather than formal education.

• •Designers can now start coding without knowing how to code by letting AI agents fill knowledge gaps
• •Traditional barriers like needing bootcamps or months of learning are eliminated—just start building and iterate quickly
• •Self-taught approach of 'making stuff without knowing what the fuck I'm doing' is now accelerated by AI tools
• •Shared language between designers and engineers becomes code itself, not just mockups or specs

Practical advice for designers stuck in traditional workflows to break out and start building. Ryo recommends starting with constrained tools like Figma Make or v0, then graduating to Cursor when you need full flexibility. He describes his role at Cursor and the small, code-focused design team structure.

• •Start with live coding tools like Figma Make or v0 to get comfortable with coding workflows
• •Graduate to Cursor when constrained tools limit what you can build—it's unopinionated and can do anything
• •Cursor's design team is 4 people (including brand) out of 250 total, and everyone on the team codes
• •Engineers at Cursor also design because they're all users—creates healthy tension between experimentation and simplification

Ryo's first major project was merging Cursor's fragmented features (chat, composer, agent modes) into one unified agent experience. He describes how the agent was hidden behind obscure toggles and how simply flipping the default to agent mode caused usage to explode. The second major redesign (Cursor 2.0) shifted from file-centric to agent-centric UI hierarchy.

• •Merged chat, composer, and agent into one unified experience—they're the same agent with different settings applied
• •Agent mode was hidden behind a 'normal vs agent' toggle that nobody understood—making it the default drove massive adoption
• •Cursor 2.0 flipped UI hierarchy from file-centric (editors, file tree, agent sidebar) to agent-first (prompt box front and center)
• •New layout makes Cursor accessible to non-coders: empty state is just a prompt box, not intimidating blank editors and file trees

Ryo contrasts traditional human-centered design (specific solutions for specific users leading to feature bloat) with systems-first design (decomposing problems into flexible primitives). He uses Notion's core concepts (blocks, pages, databases) as an example of how simple primitives can emerge complex functionality without adding buttons.

• •Traditional design approach: solve specific user problems → accumulate features → product becomes massive and incoherent
• •Systems-first approach: identify core primitives that stay constant but evolve and make new connections
• •Notion example: just blocks, pages, databases, and teams—different configurations solve diverse use cases
• •Design role is decomposing new features and merging them back into existing primitives rather than adding new concepts
• •Healthy tension: let engineers experiment and add things, then designers unify and simplify underneath

Walkthrough of Cursor's website evolution from confusing dark gradients and hidden features to clean, light design with interactive examples. The new site shows actual working code demos, uses human-created art instead of AI-generated images, and focuses on core concepts (agents, tab autocomplete, ecosystem integration).

• •Old site: dark, distracting gradients, showed chat/composer/agent separately, buried the agent toggle
• •New site: follows system theme (light by default), custom typeface (Carthagothic), human-created artwork from past centuries
• •Interactive demos are real working code—users can try features directly in browser before downloading
• •Each page focuses on one core concept with visual illustration: agents, tab autocomplete, ecosystem connections
• •Goal: get people to moment of using product immediately, not through download/install/setup friction

Ryo demonstrates 'Baby Cursor'—a simplified, personal version of Cursor built in an afternoon for exploring design ideas. It reconstructs core UI and interactions without production complexity, allowing designers to feel ideas 'alive' before implementing in the real codebase. He shows how features like the internal browser and multi-agent execution started here.

• •Built in a few hours as a scaled-down Cursor with all primary interactions and AI model integration
• •Allows rapid exploration of ideas without dealing with production codebase complexity
• •Features like internal browser preview and running multiple agents simultaneously were prototyped here first
• •Much faster than Figma mockups with fake data—you get real, working interactions immediately
• •Eliminates waiting for engineers to prototype ideas—designers can test and compare approaches instantly

Ryo demonstrates Cursor's new Plan Mode by building a share feature for his personal OS project. The agent asks clarifying questions, generates a PRD-like plan, then executes it. When the share button doesn't work initially, he iterates by telling the agent to fix it—demonstrating the 'sculpting' workflow where you start with 60-70% output and refine.

• •Plan Mode: agent asks questions, creates detailed plan (like a PM's PRD), then executes when you approve
• •New composer model is 4x faster than Sonnet and 2x cheaper—changes happen almost instantly
• •Workflow: vague idea → agent generates 60-70% solution → designer sculpts it to perfection through iteration
• •No code touching required—spoke entirely in English, got working feature with proper UI integration
• •Designer's job shifts to making output pretty and detailed—the part AI can't do yet

Ryo describes the fundamental shift in design process from painting pixel-perfect mockups (artifacts that aren't real) to sculpting working code. Designers and engineers will blur roles with code as shared language. He emphasizes being comfortable with imperfect initial output and focusing on craft, details, and system thinking.

• •Old way: wireframes → paint layers with styles → create artifacts stuck in canvas (not real)
• •New way: ask agent → get 'clump of thing' that's real → sculpt/mold it closer to vision through iterations
• •Designers must focus on craft and details (what AI can't do) and become system thinkers understanding multiple layers
• •More domain knowledge + agent + codebase knowledge = more powerful output
• •Enables focus on interactions, motion, and details that were too hard to prototype in static frames

Ryo's vision for future interfaces: they'll stay but get completely decomposed, with AI composing them based on user preferences and context. Instead of fixed apps (Google Docs, Jira), everything breaks apart and synthesizes in one place. The key is showing structured views (to-do lists, tables, previews) when they make sense, not just raw text output.

• •Interfaces will decompose into primitives that AI reconfigures for each user's preferences and context
• •Same tool (like Cursor) might look different for designers vs developers, but it's the same system reconfigured
• •Adaptive UIs should generate the right thing for the right user/context, staying familiar for each individual
• •Structured views (lists, tables, previews) are still more efficient than raw text for parsing information
• •Core system and how pieces fit together stays the same; AI helps users find their spot and adapts as they use it

Ryo's key advice for designers building companies: identify the core concepts that won't change between now and ten years from now. These define what the company is about. Start with the most essential pieces, then evolve them through small steps. References Jeff Bezos's philosophy of focusing on what won't change (selection, low prices, fast delivery) rather than what will.

• •Most important design problem: identify core concepts that won't change over 10 years and how they fit together
• •From those constants, determine first steps and most essential pieces to start building
• •As you progress, figure out how things evolve and take small steps toward the vision
• •Like Bezos's Amazon principles: focus on what won't change (customer wants selection, low prices, speed)
• •Core elements define what the company is about—make sure they're always accessible even as interactions evolve