34: Ryo Lu - It's All the Same Thing

Ryo explains his recurring mantra that everything is built from the same simple parts that recombine to create complexity. He discusses how this applies across abstraction levels - from core concepts to UI to data models - and why complexity must come before simplicity, using the swan metaphor (serene surface, paddling beneath).

• •All apps and systems are fundamentally built from the same simple building blocks (databases, information organization) that recombine into complexity
• •Design must operate simultaneously at multiple levels of abstraction - from high-level concepts down to pixel-level implementation
• •Complexity comes before simplicity: you need the underlying system to be robust before the surface can be simple
• •User-centered design that only solves discrete problems creates disconnected 'random choices' - need to maintain conceptual coherence

Ryo discusses design as the practice of understanding underlying structure and making things 'true' - finding the ultimate solution given constraints. He explains how the best solutions feel retroactively inevitable, though the path to get there is ambiguous and requires constant iteration.

• •Design is about asking 'what is this thing really?' and identifying its essential properties that can't be removed
• •There exists an 'ultimate solution' for any given constraints and point in time, though it may change as conditions evolve
• •Core building blocks of software (like Notion's flexible primitives vs Asana's rigid tasks/projects) determine future extensibility
• •The best solutions feel obvious in retrospect, but require projecting toward an ideal future while iterating from present reality

Ryo describes how his design process has fundamentally shifted from drawing/painting in tools like Figma to sculpting with code using Cursor. He emphasizes that software's true material is code, not pixels, and AI enables designers to work directly with that material through rapid iteration.

• •Design used to feel like painting (creating from nothing), now feels like sculpting (finding what's already in the marble)
• •The actual material of software is code that renders pixels, not the pixels themselves - designers must work with the real material
• •AI enables going 'backwards' to a more direct relationship with making, like being a kid with tools again
• •Prototypes in code are superior to mocks because 'it existed and because it existed, it could be improved' - you learn from real material

Ryo shares how RyoOS, which started as a simple soundboard app, became a comprehensive operating system built entirely in Cursor. He describes the iterative process of adding features, then refactoring and abstracting common patterns, demonstrating the 'throw paint then clean up' cycle.

• •Started with simple vibe coding in v0, moved to Cursor when hitting constraints, learned by building incrementally
• •The process alternates between adding new features (chaos) and refactoring/abstracting common systems (order)
• •Building RyoOS taught that 'you can do all of this' - AI removes barriers between having ideas and implementing them
• •Maintenance and cleanup are invisible but critical - abstracting file systems, auth, state management across apps

Ryo discusses Cursor's journey from code completion to chat to agents, and his role in unifying these into a coherent system. He explains how Cursor aims to be the single place for all software creation activities, not just coding, by bridging different roles and workflows.

• •Cursor evolved from autocomplete to chat to composer/agent - Ryo's first act was merging these into unified 'agent' concept
• •The goal is making Cursor the hub for all software creation: PM planning, design exploration, engineering, testing, feedback
• •Built on VS Code's solid primitives (editors, workspaces, files) that don't need to change even as capabilities expand
• •Design challenge is serving everyone from beginners to power users, from vibe coders to serious engineers, in the same tool

Ryo distinguishes between technical readiness (model capabilities) and cognitive readiness (human ability to use those capabilities). He explains Cursor's role is simplifying and making obvious what's possible, while models handle the technical complexity.

• •Models provide technical readiness (new capabilities), Cursor provides cognitive readiness (making them usable)
• •Humans are 'single-threaded' and can't process too much - need to simplify information presentation even as underlying complexity grows
• •Multi-agent systems fail when they give users '15 agents, 2000 lines of changes' with no steering wheel
• •Solution is better packaging, framing, and interfaces - like having one PM agent that coordinates others rather than managing each separately

Ryo explains the importance of 'slack' in systems - redundancy and multiple paths that enable exploration without breaking everything. He describes the balance between chaos (allowing divergence) and order (unifying and cleaning up) as essential for evolution.

• •Best systems have slack: redundancy isn't waste, it's optionality that allows exploration and evolution
• •Designers must allow 'ugly things' and 'random buttons' to exist temporarily, let them simmer, then refine
• •The goal is equilibrium at the 'edge of maximum chaos' - stable enough not to collapse, loose enough to evolve
• •Process alternates between divergence (letting people experiment) and convergence (unifying patterns, reducing entropy)

Ryo addresses the concern that AI produces soulless work, arguing that the key is putting your soul into the refinement process. He emphasizes that AI output is always the beginning (slop), not the end - you must care about every detail and iterate relentlessly.

• •AI-generated work starts as 'slop' - the gray-purple gradient is just the beginning, not the end
• •Soul comes from knowing yourself well enough to be irreplaceable - having taste, intuition, and opinions about how to shape the world
• •Taste develops from consuming widely (books, fonts, artists, the world) and building repeatedly - 'taste is eating food, not thinking about food'
• •The question isn't 'will I be replaced' but 'do I know myself well enough to become irreplaceable'

Ryo challenges the false choice between moving fast and ensuring quality, arguing that genuine excellence requires both. He explains how to maintain this balance through flexible systems, simple cores, and constant refinement while shipping quickly.

• •The myth of 'move fast and break things' vs 'move slow for elegance' is false - you need both agility and quality
• •Complex systems can be high quality and fast if their core parts are simple and well-designed
• •Create space for people to experiment and ship fast without disrupting the core system
• •Constantly wrangle chaos back to order: unify patterns, clean up the core, then allow new experimentation

Ryo explores how teams will work differently in the AI era, moving away from traditional management layers and linear processes. He discusses Cursor's vision for multiplayer collaboration where AI bridges different roles and thinking styles.

• •Traditional team structures (layers of management, linear processes) won't work at scale with AI
• •Cursor hires high-agency people who were founders or makers - they want to build, not overthink
• •Future teams need alignment on direction while maintaining flexibility - 'controlled chaos' at organizational level
• •Multiplayer Cursor will enable different roles (PM, designer, engineer) to work in their preferred medium while AI translates between them