CHAPTERS
Designers becoming builders: code as the shared language
Ryo sets a clear goal at Cursor: push designers to code and blur the traditional designer/engineer boundary. He argues that AI agents reduce the fear and overhead of “learning everything first,” letting people start by building and iterating. The key shift is that code becomes the common medium for collaboration, not mockups or specs.
- •Personal KPI: “turn all the designers into coders” at Cursor
- •AI agents remove upfront barriers (Git, editor mechanics, low-level dependencies)
- •Start by building something imperfect, then iterate toward quality
- •Designers and engineers converge: designers code more, engineers design more
- •“Magical things” happen when everyone can communicate through code
Learning by building (and how agents compress the learning curve)
Ryo traces his path from making websites as a kid to becoming a professional designer, emphasizing self-teaching through shipping projects rather than coursework. He contrasts slow, curriculum-driven learning with agent-assisted learning-by-doing, where gaps are filled in real time. The result is faster feedback loops and less intimidation for non-engineers.
- •Early web-building experience blurred design/engineering/product into “the whole thing”
- •College CS helped structure thinking but felt outdated compared to shipping projects
- •“Figure it out” learning: build first, learn concepts later
- •Agents can research, suggest best practices, and unblock missing knowledge
- •Rapid iteration changes who can prototype and how quickly they can learn
Onramp tools: from “vibe coding” to full-power building in Cursor
For designers stuck in a narrow workflow, Ryo recommends starting with constrained tools (e.g., Figma Make, v0) that feel familiar. When those limits appear, Cursor becomes the step-up environment where the same interaction style scales to “anything” you want to build. Cursor’s value is flexibility: fewer constraints, broader scope, and deeper capability.
- •Start with constrained, workflow-friendly tools to build confidence
- •Expect to hit a ceiling where constrained tools can’t do what you need
- •Cursor feels similar but is “unopinionated” and general-purpose
- •Scope: web, iOS, and beyond—an editor + agents that can write anything
- •Key promise: designers can code without “knowing how to code” at the start
Inside Cursor’s design team: tiny team, everyone codes, engineers design too
Ryo describes joining Cursor early (20 people) and scaling rapidly to ~250, while design remains a small four-person team. Because Cursor is a tool for developers, most employees are power users with strong opinions, which shapes product decisions. The design challenge becomes creating a simple core that still adapts to different working styles and preferences.
- •Ryo was first product/design hire; company grew from ~20 to ~250 fast
- •Design team is ~4 people (product + brand) and everyone codes
- •All employees are users; engineers bring strong UX preferences
- •Need a simple core that supports both keyboard-centric and click-centric workflows
- •Ongoing cleanup: unify features, reduce random UI accretion, preserve power
Designing systems, not features: primitives that scale (Notion as an example)
Ryo contrasts feature-by-feature human-centered design with a systems-first approach. Feature accumulation tends to create button overload and fragmented concepts, while systems design decomposes problems into primitives that recombine flexibly. He uses Notion’s blocks/pages/databases as an example of stable primitives enabling emergent complexity.
- •Feature-by-feature design often leads to complexity creep: more buttons and nav
- •Systems-first design: identify primitives and core concepts that remain stable
- •Focus on recomposition: decompose, unify, and reconfigure instead of constantly adding
- •Notion example: blocks, pages, databases, teams combine into many workflows
- •Design work becomes maintaining a simple core while enabling sophisticated layering
Unifying Cursor’s AI surface: merging chat, composer, and agents into one model
When Ryo joined, Cursor’s AI experience was fragmented: chat, composer, and agents overlapped, with confusing toggles and hidden capability. His first major change was to unify these into a single “Agent” experience with modes as settings, and to make agent the default. This reframing made the product easier to discover and helped adoption take off.
- •Earlier Cursor felt like VS Code + a few disjointed AI features
- •Agents were hidden behind confusing UI (e.g., “normal vs agent” toggle)
- •Merged chat/composer/agent into one primary concept: “Agent”
- •Modes become settings (ask mode, plan mode, etc.) rather than separate products
- •Switching the default to Agent drove a major behavioral shift in usage
Rebuilding Cursor around agents: flipping the UI from files-first to agent-first
As the world moved toward agents writing more of the code, Cursor’s interface needed to reflect that reality. Ryo explains Cursor 2.0’s “agent layout,” where you start with a prompt box, can run multiple agents, and only dive into code when you choose to review changes. The goal is approachability for new builders without losing the depth required by experts.
- •Market shift: from AI assisting coding to AI doing most coding for you
- •Cursor 2.0 flips hierarchy: agent-first instead of file-tree-first
- •Multi-agent orchestration: see states (blocked/needs review/running) and swap contexts
- •Review button surfaces diffs and changes without requiring constant code browsing
- •Better starting state for non-coders: no blank editor/file tree as the first experience
Website and brand evolution: from “futuristic gradients” to clear, interactive demos
Ryo and Aaron critique early Cursor marketing as visually noisy and unclear, with code screenshots that lack relevance for many audiences. The newer site focuses on clarity, human-made art, refined typography, and—crucially—interactive, real-in-browser product examples. This helps users reach an “aha” moment immediately, without installation or setup.
- •Early site problems: distracting gradients, unclear messaging, contextless code imagery
- •New foundation: refined logo/type (custom typeface), light/dark that follows system
- •Human connection: wallpapers from historical art, explicitly not AI-generated
- •Interactive examples are real and editable in-browser (not static screenshots)
- •Homepage messaging anchors on core concepts: Agents, Tab, ecosystem integrations
Prototyping with “Baby Cursor”: a sandbox for fast, living interaction design
Ryo introduces “Baby Cursor,” a lightweight, purpose-built prototype environment that mimics core Cursor interactions without production complexity. It lets designers explore new ideas like keyboard navigation, previews, internal browsing, and multi-agent workflows using real AI outputs and live states—things that are painful to fake in Figma. The point is to feel the product alive early and iterate quickly before upstreaming ideas to the main app.
- •Baby Cursor: small playground replicating key hotkeys and interactions
- •Prototype without production codebase complexity; build “just enough” environment
- •Real AI outputs and live UI states make it more testable than static mockups
- •Example exploration: running multiple agents simultaneously and comparing outputs
- •Many features can incubate here before being merged into Cursor proper
Plan Mode in action: English → PRD → build → debug loop (no code required)
Using his “real OS” playground, Ryo demonstrates Cursor’s Plan Mode: describe a goal, have the agent inspect the codebase, ask clarifying questions, then produce a PRD-like plan. After approval, the agent builds changes quickly, and the user iterates by giving feedback when something doesn’t work. This shows a new workflow where intent and evaluation matter more than manual implementation.
- •Plan Mode supports ambiguous starts: ideate, clarify, then execute
- •Agent searches the repo and proposes a PRD-like plan before building
- •One-click Build executes the plan; speed/cost improvements make iteration practical
- •Iterative fixing: add share button → discover it’s not hooked up → request a fix
- •Design implication: default onboarding should be “just start,” not “open project/clone repo/SSH”
Design as sculpting, not painting: embracing imperfect first drafts
Ryo frames modern AI-enabled design as sculpting: generate a rough but real artifact, then refine it through successive edits. Unlike traditional pixel-based workflows that produce non-functional canvases, agent-built prototypes are executable systems where interactions, motion, and states can be experienced. Designers’ advantage shifts to taste, craft, and the ability to push rough outputs into polished, coherent products.
- •Old workflow: paint on non-real artifacts (frames, pixels, static mocks)
- •New workflow: generate a working “clump,” then sculpt toward the desired result
- •Expect 60–70% correctness on first pass; iteration is the core skill
- •Designers add value by making outputs “pretty,” coherent, and detail-perfect
- •Live prototypes elevate focus on interaction/motion and real usability
The future: blurred roles, adaptive UIs, and system thinkers with deep craft
Ryo predicts interfaces won’t disappear but will be decomposed into primitives that AI can recompose per user and context—without becoming random or unfamiliar. Designers should double down on craft and details (where AI lags) and become stronger systems thinkers who understand constraints across layers. The most important strategic advice: define the stable core concepts that won’t change over 10 years, then build everything as evolutions and recombinations of that core.
- •Roles converge: designers code, engineers design; code becomes shared language
- •Adaptive UI should be context/user-specific, not constantly regenerated randomness
- •Keep familiar primitives (tables, to-dos, previews) but unify them in one agent-driven place
- •Designer growth areas: craft/detail mastery + systems thinking + domain constraints knowledge
- •Founder advice: identify core concepts that won’t change and let everything evolve from them
