34-ryo_lu 2.png

Description

Ryo Lu (Website, X) is the head of Design at Cursor. Prior, he was a designer at Notion, Stripe, and Asana, working on some of the most influential software tools of the last decade. He is now focused on building the next generation of tools for making software.

Our conversation is an extensive exploration of Ryo’s design philosophy, which is anchored in his recurring mantra: “it’s all the same thing.” He sees the world as fundamentally modular, where simple rules and patterns endlessly recombine to create emergent complexity. For Ryo, design is consciously participating in this process: seeing through the surface to understand the underlying structure and rearranging it into new forms. This means constantly moving between simplicity and complexity, chaos and order, bare material and highest levels of abstraction.

We discuss how his process has evolved with AI. In the past, designing in tools like Figma felt like painting; now, working in Cursor feels like sculpting clay or finding David in the marble. So much of his philosophy is about getting closer to the material—in this case, code—and letting it provide feedback. There is no better example of this than his personal project, ryOS, a nearly full-on operating system he built entirely in Cursor. It is soulful, deeply personalized, and the opposite of “AI slop.”

This is a philosophical discussion about designing things that feel “true” or even “inevitable,” but it is also a practical one. We talk about balancing agility and quality, allowing for “slack” in systems, and how to create soulful things with AI. Ryo is a profound thinker, but he is also a prolific doer, and it is this marriage that makes him so effective. I hope you are inspired to get closer to your own material, to be more flexible and dynamic, and to expand the boundaries of what you can personally create.

Dialectic is now presented by Notion. I am now focused on Dialectic full-time, thanks to their support. You can read more about why Notion embodies Dialectic’s values and our partnership announcement here. Notion is an AI-powered connected workspace where teams build their best work. Notion is also where I compile research for episodes and the home of my new site where you can find all links and transcripts.

Timestamps

0:00: Notion Announcement & Dialectic’s Future
4:45: Intro
7:46: “It’s all the same thing!”
17:25: Technical and Conceptual Readiness and How AI Helps us Deal with Complexity
20:58: Designing for true-ness and inevitability
27:28: Practicality and False-Compromise
33:45: Working with Material and Different Ways of Thinking
44:06: ryOS and Designing for the Full Spectrum of Users
59:39: Allowing for Slack and Some Amount of Chaos in Design
1:04:55: What is Cursor, Conceptually?
1:10:33: How Using Cursor Evolves
1:15:50: Designing for Power While Not Alienating Users
1:19:59: How Ryo Designs at Cursor: Abstractions, Writing, Prototyping
1:23:57: Process, Creating Soulful Things with AI, Refining Taste
1:31:08: Balancing Agility and Quality, Chaos and Order
1:37:00: Great Teams and Great Products
1:39:41: Grab Bag: Human Tech, Why Tools Need Stories, Why Cursor Isn’t a Slot Machine, Notion & Cursor, Steve Jobs, Liquid Glass
1:56:16: Tenderness & Empathy

Links & References

Transcript

[00:00:00] Notion Announcement & Dialectic’s Future

[00:04:45] Intro

[00:07:46] “It’s all the same thing!”

Jackson: Ryo Lu.

Ryo: Okay, let’s go.

Jackson: We’re here. Thank you for being here.

Jackson: I’m really excited about this.

Ryo: Of course. Yes.

Jackson: We’re going to start with a catchphrase of yours: “It’s all the same thing.” What does that mean and what does it tell us about design?

Ryo: When you look at all the apps you use, or even everything around you, even looking at ourselves as humans and life forms, we are always built with the same parts. They are really simple, but when you merge and recombine them, they give rise to complexity. The most fundamental elements are the same. A lot of the concepts that we use—regardless if you call it a task management thing or a document thing—are all just information organized in databases. So there’s not that much difference. It is something at the core that is the simplest form of the thing itself. It is most likely things that you have seen before, or where there are analogs in nature.

Jackson: When you talk about those simple things, are they abstract? Are they patterns, metaphors, or ideas? Or can they also be very concrete?

Ryo: I think they can be very concrete. It is the same thing manifested at different levels of abstraction.

Jackson: Okay.

Ryo: You can think, “These are my core ideas,” but then you have to determine how to visually represent them in a constrained 2D space like a screen. Maybe it is a phone, or maybe you stretch it to a window where you have more space. Then, what are the things that should be shown? What are the relationships between them? What are the important bits that you want people to get? It is almost like a multi-floor apartment. You want people to go to the lobby on the top floor with the best view so they can see everything. They think, “This is cool. Now let me go to the place I want.” That is for the users, but the same thing applies when you are designing UI, flows, or the data model. You are conceptualizing how to make this into a big, scalable, distributed system. When you are operating on all these layers, they are still just manifestations of those core concepts. If you keep everything together, it feels cohesive. Many people think of these as separate things. They treat them as, “I need to do this box first, and then do that box.” The people doing the boxes don’t talk to each other. Then they build something that kind of… wiggles.

Jackson: It doesn’t have the connectedness. You wrote a little essay about complexity coming before simplicity. In one part, you say it is like a swan—serene on the surface, but paddling like hell beneath. That is an amazing metaphor. Why does complexity actually have to come before simplicity?

Ryo: Conceptually, it is possible to say, “These are the core building blocks of my world, and that’s it.” But it needs to survive in the real world. People don’t come here to look at your essay or your academic idea of how to connect computer ideas. They are here to do something. Ideally, they do the thing they want to do first, without thinking too much. They can slowly master, configure, and customize it. Then they know what is in there. You can do it from both ends; they are almost two sides of the same coin. However, a lot of people only see one side. We do a lot of user-centered design where we start with the user problem and decompose it. We do research, look at numbers, and figure out if solution A or B is best. “A is the best. Let’s just do A.” You keep doing this, and suddenly you have a platter of random choices. They don’t connect, and they become discrete buttons on your UI. That is crazy when, fundamentally, all of these ideas might be the same. Maybe they are better, reconfigured versions of your original ideas.

Jackson: You are sort of seeing both aspects of the swan at the same time. You are seeing the elegance in the…

Ryo: You need to test your model with real-world examples and people. As you do that, you figure out which part of the system is weak and needs to be made better. Maybe we really need to add this new thing; then we should probably do it because a lot of people need it. But if you’re just conceptualizing in your own world and ideating, then you’re not really doing anything. You’re not helping anyone.

Jackson: You’re untethered.

Ryo: Yeah, you’re just having fun by yourself.

Jackson: Another line from you: “The universe is fundamentally modular. Simple rules endlessly recombining, creating emergent complexity. Design is the human practice of participating in that process consciously. We look at the world, identify the patterns, extract the rules, and use them to build new realities.” I’m curious at the most zoomed-out level: what initially drew you to what you describe as design? And what keeps you coming back? What is it about this philosophical approach to the world that’s so compelling?

Ryo: When I started, I did not know the difference between engineering, design, or product. I just saw things that were made by people. I started playing with software when I was a kid. I would get pirated CDs that were almost like monthly software subscription packs. You just load them on your PC and play with all the new apps. I started playing with all the office tools, like fonts, Excel, and PowerPoint. Then Photoshop, video editing, 3D making tools, programming tools, and making websites. As you make things, you start realizing the end output of what we do is just code. But there’s a lot of depth in all the layers. If you’re curious enough, you can go to every layer really deeply. The more you do these things—make more websites for different kinds of people or make different apps—you realize a lot of it is just the same ideas. You can also trace it back to history. When you look at people when they started, when they were just ideating, things were not real because they weren’t ready. But the ideas were there. All you’re doing is remixing the idea and repackaging it a little bit. You want to find out the core essence—things that you cannot remove, that will always be there—and then you keep making those better.

[00:17:25] Technical and Conceptual Readiness and How AI Helps us Deal with Complexity

Jackson: You used the phrase “things weren’t ready.”

Ryo: Yes.

Jackson: Design applies across disciplines, but in technology, you are dealing with the rate of progress. I’m curious, especially since you have this great future site you made for Cursor where you list the arc and lineage of computing. We’re in the middle of an immense amount of readiness. What has your relationship been like to things being ready—or not ready—over the last two years with AI models and Cursor?

Ryo: There’s the technological level of whether it’s ready, but there’s also the conceptual level. For example, Notion.

Ryo: Even though technologically everything is fully ready, Notion itself is almost just databases in the cloud. You can do live editing with people; you’re just manipulating blocks and databases. The ideas have existed for a long time, but people have not caught up or are not familiar with these ideas. It’s still kind of foreign to people. Then, boom, AI happened. Using this new, primitive technology, we can actually help people understand better or make translations of ideas.

Jackson: It’s the conceptual gap.

Ryo: You can use that to bridge the gap. Instead of people making databases manually or having to learn about coding—where there are so many layers and dependencies—you can reduce that to nothing. To run a program, you used to need to know so many things. But people start from the other end. They get some output, they play, they tweak. As they do that, they learn instead of backing into it or doing it in reverse. We are fundamentally the limiting factor as humans. Our brains can’t process too much information; we can’t hold too many concepts in our heads. We’re simplifying the amount of information or ideas that you’re giving to people. It used to be that designers, thinkers, and inventors had to do it. They were thinking about the simplest configuration of the thing and what the parts were. But now, a lot of it can be handled by AI. You can reach to lower-level primitives or even connect more things.

Jackson: You can pull in more complexity.

Ryo: But the presentation layer can still be simple, and the simplicity can be more subjective. It is not designed by the designer. It is the ideal configuration for you, the person using the thing. AI can do the translation.

[00:20:58] Designing for true-ness and inevitability

Jackson: We’re talking about simplicity, but there’s another comment you made that is very similar to something you wrote about making things true. I think truth and simplicity seem interesting next to each other. You say design is the practice of seeing through the surface of things to understand their underlying structure and then rearranging those elements into new forms that didn’t exist. Design is philosophy because it forces you to ask: What is this thing really? What are its essential properties? What can I remove before it stops being itself? Once I understand that, what new things can I build? This is the work: not making things pretty, but making things true. What is the difference between truth and simplicity? What does it feel like when you’re designing and approaching trueness or truth?

Ryo: I believe there is an ultimate solution given the amount of space, the constraints, and the things you know. But the problem is you never know everything, and things always change. Maybe it is the ultimate solution for this point in time and this condition, but tomorrow it’s not true anymore. However, when you’re making software, there is always a set of things that don’t really change. It is so important to figure out what those things are. Those are your fundamental building blocks or ideas. I see software as just a tree of concepts. You package it up, give it a name, give it a UI, and put it out.

Jackson: Are those concepts changing a lot, or are they changing very little?

Ryo: Most likely, they don’t change. Or it is really hard to change them, especially the ones that are core to the thing. For example, I worked at Asana. Asana is basically projects and tasks, and everything revolves around it. Every data model is locked in there. It will be hard for Asana to expand into whatever. But it is easy for Notion to do that because Notion’s building blocks—the underlying abstractions—are more flexible. They actually don’t change that much. All you’re doing is fixing some problems with how they connect to each other. Now there is a different kind of data that we can present better. What are the better views for that? How do people combine these things so that they can do a lot more crazy things? How do you help people instead of them building this thing? Maybe the AI agent does this thing. Say for Cursor, that common layer is even lower, which is code. It is so generic it means you can actually do anything.

Jackson: Is truth universality? Is it the same thing?

Ryo: Given this constraint, what is that ultimate answer? What is that simplest configuration of your system that does everything—the most beautiful state?

Jackson: You have another idea about inevitability. You say the best future solutions seem almost retroactively inevitable. The philosopher who said that “the truth is what never had to be said” might as well have been talking about a product so perfectly aligned with its context that no competitor can propose a simpler alternative. This connects to truth and universality. What you are pointing to is what you said earlier: there actually is some objective, final—at least final for right now—form. How do you design towards inevitability?

Ryo: You always design. Say there is a set of fundamentals that don’t change, and then there is an ideal future that you want to go to. Then you figure out what the deltas are between that.

Jackson: Take Notion as an example. We are going to take a really simple set of very flexible building blocks. When you were working on it five years ago, or Ivan when he was working on it 10 years ago, you may have had some sort of future conception. I’ve seen some of the early decks Ivan had.

Ryo: There’s crazy stuff in it.

Jackson: It’s amazing. But on some level, of course, he didn’t fully know. I am curious how important specificity is for that inevitable future outcome.

Ryo: It looks retroactively inevitable, but when you get there, it is very ambiguous. You actually don’t know. You look at what you have and what you want to do. You can just imagine your future state, your ideal. Don’t limit yourself. You start thinking about the big changes you need to do and the little steps you need to take. The closer you are to the present, the clearer the step is. The further out, the muddier it is. The only way you can start going towards it is to do things. You build steps, prototypes, or pieces of it. As they get built, get used, and get feedback, you clarify the thing and move forward.

[00:27:28] Practicality and False-Compromise

Jackson: A lot of this is philosophical. Someone might listen to this, and this combination of complexity and simplicity is really appealing. Most designers, most people making things along a long road… We are forced to compromise somewhere along the line. It feels like one of the things getting in the way of trueness or inevitability is practical compromise. You’re also very practical; you’re pulling this thread in many ways. I’m sure there are a million compromises Notion could have made along the way, and many compromises Cursor is faced with.

Ryo: Yes.

Jackson: How do you relate to that?

Ryo: I don’t want every single thing to be perfect. There are certain things that are okay to be a little divergent. You let it go a little bit, let it roam, and see how the thing does. You’re on this constant loop of reexamining what you have in your system. You look at all the things you add and see how they’re perceived. Maybe now you need to unify these things, or clean this part up. Once you do that, you open up and—boom—this amount of people can use it now. You make this part of the experience better. It’s not a feature-level thing anymore. It’s about all these things together making a better system. Because the system is more flexible, extensible, and capable, it can do a lot more for a lot more people. It’s not just about making “feature A,” seeing how it does, and running some numbers on adoption or retention.

Jackson: It feels like it goes back to the swan, or maybe another metaphor. You seem to be constantly taking stock of both the pixel and the picture of the cloth.

Ryo: You need to go around these layers of abstraction if you really want to make something truly simple. A lot of people think simplicity is about removing things, getting rid of any feature that gets used by less than 5% of users. But then you’re removing something that maybe the 0.1% power user really loves and depends on. Maybe the better way is to Marie Kondo it. You clean it up a little bit or reorganize it so most people get the easiest path, but there are still little pathways for others. You don’t have to take things away; you just tuck them away. Or you build elevators.

Jackson: It’s funny you bring up Marie Kondo. For many people, that’s very aspirational. For others, it seems unrealistic—like she doesn’t live in the real world. You’ve written and talked about minimalism. I think people take it too far and it gets a bad rap. You present as very refined, and you clearly care about aesthetics. And yet, yours has a lived-in messiness almost. How do you have that sort of tidy, thoughtful, careful, and also aliveness in a system?

Ryo: A lot of people think you have to have this or this, when you can actually have both. Should it be simple or complex? Should it be flexible or rigid? To me, software is almost like a life form. It runs, it mutates, it changes itself. You don’t have to be so opinionated. Your opinion is actually taking the stance of, “I don’t have too much opinion.” You always make things start really simple, and then you let people play with it. You let people discover what they want or their way to do things. It’s not my way.

Ryo: I don’t want to force my way of thinking onto you—saying, “This is how you do it: one, two, three.” I just give you pathways, elevators, and the tools to do the thing you want.

Jackson: You have a line somewhere: “No point solutions, always spectrums.” I think that captures it.

Ryo: Fundamentally, all these tools are the same things. If you’re okay with that, then you don’t really have to pick. You don’t have to ask, “Do I want to use Cursor for salespeople or Cursor for coding?” It might be the same thing.

[00:33:45] Working with Material and Different Ways of Thinking

Jackson: I want to talk about that process of making. You started to get at it a little bit. You have this metaphor of sculpting, or finding what’s in the stone, that is really powerful. That’s not totally intuitive for how people think about creating. You say: “There’s a quiet, almost mystical art to starting with something so unrefined that you’re unsure if it’s mud or marble, impatiently revealing its shape until others recognize its beauty. In the end, they’ll say, ‘Of course. It’s so obvious.’” Why must greatness be emergent?

Ryo: Because you haven’t seen enough, and you haven’t tried enough. You think, “This first idea I have is perfect.” You throw it out there and realize maybe only you think like that. Or maybe people like it, but they don’t really understand the words or the nuance. Then you need to keep tweaking and getting input. You never start with the ultimate answer. You always start with shit, and then you make it better and better.

Jackson: Is that the case for every medium?

Ryo: I think so. Even when you’re painting, you start with pencil sketches, and then you layer the paint on top. When you’re sculpting, you start with just a blob of clay. You make the high-level shapes good enough, and then start working on the details. It’s the same thing. You never get the first shot right. This is even more true with AI. But with Cursor Composer, because it’s so fast, it’s a different way to do things now. You’re building as you’re seeing things, as you’re thinking, and as you’re designing. It’s all together.

Jackson: You referred to software earlier as an organism. Maybe that’s true about software inherently, but it feels especially true with AI now. When we met, you talked about how you used to work being much more like painting or drawing, and now it feels more like sculpting or finding something new with stone. I don’t know that that way of thinking is intuitive to people, even those who make software. Have you started to think about it in a fundamentally different way with AI, or is this actually just a continuum?

Ryo: I think it’s almost going backwards. I started building things myself and designing everything. A lot of times I did not use pixel tools; I just coded it. Then I became a professional product designer.

Jackson: Capital D designer.

Ryo: Interesting. Now I just make mocks and fancy animated prototypes. I would drop that mock into my PM’s PRD and wait for things to happen, and things wouldn’t happen. Now it’s going backwards. If I have an idea, I’ll just prototype it out like a kid with a piece of clay. If there’s a bug, I’ll make a screenshot, circle the thing, ask Cursor to fix it, and it gets fixed. Instead of waiting or getting stuck in pictures or words, you actually make the thing. You use code as a tool to communicate your ideas better. Because we’re software makers, the best tool is code.

Jackson: I interviewed a couple of industrial designers early on, Che-Wei and Taylor. One of the things they feel really strongly about is that they hate renders. Their view is: make the prototype. I almost feel like this is the digital version of that. Get it down in the metal code.

Ryo: Exactly. You have to play with the material. Our material as software makers is never the pixels. It is the code itself that renders the pixels.

Jackson: You have a line I love: “But it existed. And because it existed, it could be improved.” That captures the power of working with actual material. When we were first talking, you said, “I use Figma when I want to go into my old way of thinking.” That obviously relates to what you just said. I’m curious today, maybe because you’re designing Cursor which is less about the pixels already, when do you find yourself tempted towards the old way of thinking? Will you be using Figma at all in a year?

Ryo: Oh, yeah. They are just tools. Sometimes we think in words, sometimes we think in pictures.

Jackson: On podcasts, we definitely think in words.

Ryo: Or making videos. Some people do that. Or slides. Those are just different artifacts or forms to help us think. I don’t want to take them away. Different people have their preferred form to think. Maybe some people are more linear; they just write text. I like bullets. I think I got the disease from Notion. All I do now is go out and walk, have ideas, open a Notion doc, and put in a list. Once I’m done with my walk, I’ll go back. Maybe then I’ll draw some pictures or do Figma. Because I’ve been doing this for so long, it’s like water to me. I don’t think when I make more artboards or use the Figma shortcuts. So when they change shortcuts or move around my things, I get mad.

Jackson: I saw you were really mad that they had changed the checkbox.

Ryo: Oh, for the Notion to-do box.

Jackson: Yeah.

Ryo: That’s for another thing. I feel like every piece of software is almost like a person. It has a vibe, a history. It has some character essence. You don’t want to lose that. You don’t want to water everything down to border radius or pixels. Sometimes it’s good to keep that lineage and keep a thing that’s maybe a little weird, but so characteristic.

Jackson: On the note of your thinking time, you talked about using different tools like Figma. You’ve also talked about your walking and the value of idle time—the space between. Thinking time isn’t wasted time. Maybe this runs against what you just said about it feeling like water, but are those different modes? Watching you use Cursor, at least on your phone while you’re hanging out, it didn’t seem like you were doing very much thinking. You were just throwing paint at the canvas.

Ryo: Right.

Jackson: But when you write about your walks, that feels very structured. Is that maybe a template?

Ryo: That’s more for the longer-term things. Vague ideas, ambiguous dreaming. It’s for thoughts like, “Maybe we should do this,” or “Maybe we should do it this way.” What are the components in there? How do I break it down? What are the things people care about?

Jackson: Whereas when you’re using Figma or Cursor…

Ryo: Those are more for things like Figma. There is still some difficulty.

Ryo: It takes more time to build a really crazy prototype in code. If you want to communicate ideas in 2D space really quickly, draw some pictures. That’s fine. When the thing gets to the state where I think I know what it is, I want to figure out how they fit together and how they work together. Especially with building AI stuff, there are so many procedural and non-deterministic things that you need to think about. It is really hard to simulate in Figma or static pictures.

Jackson: You’re not with the material. You’re not up close to the material.

Ryo: You actually need to glue it up and see how they fit together, see how the states transition. If I get this error, what happens? Or if the return gets too long, what happens? You’d never get that in Figma.

[00:44:06] ryOS and Designing for the Full Spectrum of Users

Jackson: I want to talk a little bit about ryOS, both because I know you’re very obsessed with it and it feels like the perfect embodiment of this sort of working with clay. I would strongly encourage people listening or watching to go poke around with it. As I understand it, Real started as a soundboard app you made for your friends when you were leaving Notion. It feels like this infinite thread you keep pulling or this piece of clay you just keep turning over in your hand. When we first met, for context, you had your phone out. We were just talking, and you were literally making apps as we sat there. What have you learned about making things and maybe even about yourself from this crazy project?

Ryo: I learned that I can do all of this. I think that’s the biggest thing. It’s all little ideas piling up on each other. You start with something simple and small. You just keep building and see it grow. When it grows to a size where there are some constraints, things change. I actually started the soundboard thing in v0, not Cursor. I ran into some errors where I realized I needed to do it in Cursor.

Jackson: Did you use Cursor much prior to that?

Ryo: Not really. I tried three times. I churned three times.

Jackson: Interesting. Why?

Ryo: The first time, I saw a new code editor and wanted to try it out. I typed some lines. It completed five lines of code instead of one line of code versus GitHub Copilot. Then I churned.

Jackson: Because you felt like it was trying to do too much.

Ryo: No, it’s just completing code with more lines. The second time, it was the chat. It’s like ChatGPT next to your code. It can read the code and answer some questions. It couldn’t do much, so I churned. The third time was discovering the agent.

Jackson: Is this post-using v0 or pre? After. Okay.

Ryo: I needed some tool that can let me do anything. Then I found Cursor, and I was hooked. You start from simple things. You just ask for a little crazier idea, and then you see it getting built. Now with Plan Mode, you actually see how the models think. You can change it. You can be part of every step. That is still your clay, but the model now handles all the parts that I don’t really care about. I actually studied computer science because I love computers and software, but I hated writing code. All the algorithms and stuff we learned are kind of useless. What I care more about is the ideas. How do people feel?

Jackson: How quickly can I make this thing?

Ryo: Exactly. It’s the thing, the idea, the concepts. I want to play with the concepts.

Jackson: You mentioned ryOS. It doesn’t seem like something that could be built by just throwing more paint at the canvas. It feels like the type of thing that should have needed to be more planned.

Ryo: There are a lot of things that say it’s not just throwing. It’s a constant throwing things and cleaning up shit. It also happens there in ryOS.

Jackson: What is the cleaning up? That’s what we’re not seeing.

Ryo: You don’t see that, but you can see it in my commit logs.

Jackson: The maintenance.

Ryo: The more things you add, the more you realize it’s the same thing I talked about earlier. All these apps need some AI endpoint and some auth, and they need to store their states. They need to write or read into the file system. I started doing the file system part from the text edit app, but now I want all the other ones to use the same ideas. Then I need to abstract the system, put that part out, or unify some state management things. Then you need to refactor your original things, even though to the user it looks exactly the same.

Jackson: That part of it, I think, is where people get stuck. I watch you use Cursor, and you’re just nudging the model. Your prompts are not long specs; it’s just poking it. Can you come up with an app idea? Your language is really casual. To the average person using V0, or the person who tries Cursor and is churning—you’re very clearly focused with Cursor on building for the hardcore user. But for someone who has somewhat of a computer science background who hasn’t written a lot of code, I wonder about the poking process. You’re getting more invested so that you care enough to do the hard maintenance part.

Ryo: I learned a lot by building ryOS. Even since I became a professional product designer, I would have little projects on the side. The first few years I kept doing those, and then I got busier and stopped. Every time I try to go back, I need to learn React 18, Tailwind CSS, all of those new things. It takes a long time. I have to read all the docs and understand how people do things now. Now with the agent, you don’t have to do that, but you’re still doing that. The agent helps you do the research. It comes up with how people do it now and gives you some alternative options. Maybe you know certain things and you don’t know certain things, but the agent can help you find your way. Then you can say, just do this. It will write the code. You can still look at the code and learn from its output how things work.

Jackson: You’re getting deeper into the complexity, intentionally or otherwise.

Ryo: Just by reading—a lot of users say this too—they love reading how the models think. They actually want to expand everything and look at all the output because it helps them understand what the model is doing. They gain trust from it and learn, especially when they’re starting to code.

Jackson: It might be a strange comparison, but somebody I interviewed was talking about reading with his 7 or 8-year-old daughter. Reading books with her that were actually far beyond her ability level pulled her in. Now she’s reading well beyond her level. There is something about being exposed to someone else’s thinking. Even if it’s GPT-5, Codex, or Composer.

Ryo: As you said, most of the prompts that I did in ryOS are just really short, simple things.

Jackson: Yeah.

Ryo: Theoretically, we are ready. You can actually build a lot of things and just vibe. But I’m cheating a little because I know things beforehand.

Jackson: Right.

Ryo: I know how to get the AI unstuck when it stalls. As I play more—my full-time job is to play with all these models and use Cursor—I develop intuition on how different models behave as I make things. I learn their limits: maybe this one is faster, this one is slower, or this one is smarter at certain things. A lot of people don’t know what to do yet. That helps me put this understanding back into the tool.

Jackson: On that last note, when is it Cursor’s job to solve those things versus the model’s job to improve and solve them?

Ryo: It’s both. The models are rising in capabilities; they are getting better at using terminal commands or clicking around in a browser. As they get better, you still need a way to unlock those capabilities, fit them back to the tool, and package them up. You need to make them really obvious so people can just play with them. They shouldn’t have to think too much about how to trigger it or use some crazy script. You start simplifying and making things that are possible more obvious for more people.

Jackson: That’s an interesting way of thinking about it: making the next step more obvious.

Ryo: You’re constantly simplifying, unifying, and figuring out how to clean it up even better now that you have these vaRyous components.

Jackson: It feels like it relates to the readiness concept we talked about earlier. Maybe the model’s job is the technical readiness, and your job at Cursor is the cognitive readiness.

Ryo: Yes. Humans are single-threaded. We’ve been trying a lot with multi-agent systems and parallelization, and nobody has really solved it yet. Most people are still thinking, “Let’s just give you 15 agents.” Those 15 agents might make 2,000 lines of changes.

Jackson: It’s all horsepower, no steering wheel.

Ryo: Exactly. We need to figure out better framings, packaging, or interfaces for people to get utility out of these things without breaking their minds, changing too much, or feeling overwhelmed.

Jackson: You’ve obviously worked on a lot of different types of systems and are drawn to this container-type tool. With Cursor and Notion, you have a line where you say systems thinking is essential because it is the only path to building products that scale not just technically, but cognitively. When designing a tool like that, is the goal to allow the user to stay as single-threaded as possible?

Ryo: No. It’s up to you. You need to design the zero state, the one state, and the n-state for everything, and then see how they meld together.

Jackson: This is the simplicity-complexity balance.

Ryo: When you have N times N times N, it will be kind of crazy, but if you really want to be there, so be it.

Jackson: You should meet the user where they’re at.

Ryo: If you are someone who has ADHD or wants eight different windows all running, so be it.

Jackson: The average person probably wants…

Ryo: Maybe average people just want one main thread. That’s how we’re thinking right now: instead of needing to review changes from 15 different agents, maybe we help you cluster them and organize them semantically. Instead of talking to each of them separately, you just talk to one person or agent. It’s almost like your PM or your assistant. It’s going to figure out, “These guys are blocked. Do you want to approve the terminal command? These changes, I think they’re pretty good. This is bad; you should look at it.”

Jackson: There’s a very small subset of users who want StarCraft, and most people want Candy Crush.

Ryo: I’m fine with both. We can actually do both—like a TikTok and a StarCraft—because of AI.

[00:59:39] Allowing for Slack and Some Amount of Chaos in Design

Jackson: There’s an idea I think is really interesting and connected here, which is about slack in systems. You say the best systems have slack in them. Redundancy isn’t always waste; it’s optionality. Multiple paths mean you can explore without breaking everything. The core remains simple while layering itself into more complex permutations. Controlled chaos means you’re stable enough to not collapse, but loose enough to evolve. I think that’s such a powerful metaphor. Maybe slack is that willingness to go as complex as I want to. Somewhere else you talk about that sort of chaos and order together.

Ryo: You let diversions happen and you let things evolve. It’s like evolution. Nature is constantly making more permutations of the same thing, just a little different, to see which one works better.

Jackson: How do you give a tool more slack? What does it mean to add slack to Cursor?

Ryo: It’s a little complicated. All designers are kind of perfectionists; we want things to be exactly what we wanted. But sometimes you just allow this ugly thing to pop up, or this random button someone else added, and keep a blind eye on it. You let it simmer a little bit. You let our internal group of people play with it more. Maybe people threw the first bucket of paint. Now that it’s there, you can see it, you can play with it, and you can think about it more to understand it better versus…

Jackson: Sort of roping off the canvas.

Ryo: Right. Then it’s like, “Ah, now I know how this thing fits with the other things,” or “This thing is actually a start of something much bigger.” It becomes this constant chaos-convergence thing. It gets into an equilibrium. You want that thing to be almost at the edge of the maximum chaos you can allow.

Jackson: Your job as a designer is almost…

Ryo: You’re trying to help people. Here is the line; don’t cross it.

Jackson: Yeah.

Ryo: You’re also helping people reduce entropy—just tame it back a little bit. You might say, “You two should talk together and make this actually the same thing.” Or, “You’re making a new thing? Cool. Think about these four things that we have.”

Jackson: Yeah.

Ryo: That’s it. I’ll just let them think about how this new thing relates to the four things. Ideally, they come back with a good answer.

Jackson: You’re almost like the game maker, or the agent of evolution setting the rules of what is tolerated. But critically, you’re not snuffing things out too early.

Ryo: You’re mostly an observer. I’m not dictating how things should happen. I just tell you, “Given all the things I know, here’s probably how we do it.”

Jackson: This is why you seem very attuned to not just the different ideas for Cursor inside the company, but all over Twitter—from different stakeholders, students. You’re almost trying to broaden the aperture of what is allowed in.

Ryo: Fundamentally, it is the same thing. All the vibe coding tools, Cursor, all the CLI agents—it’s all the same thing. But only Cursor tries to bridge all of them. I try to give people their ideal form. A big reason Cursor got popular is because it looks exactly like VS Code, at least before. But as we notice, people change their patterns of usage. People moved from manual coding—reviewing every line—to using more agents.

Jackson: You have to move with them.

Ryo: Then we just flipped. Our defaults change as the world moves and as the product evolves. But fundamentally, it’s still the same thing.

[01:04:55] What is Cursor, Conceptually?

Jackson: What is Cursor? Obviously, Cursor is a plugin or a skin of VS Code on some level.

Ryo: No, not just that.

Jackson: Of course not just that. It’s changing every day. When we first spoke, you related to Cursor almost like it’s your little butler that just does things for you. It’s your hand. We talked about code being the universal language. In many ways, it feels like Cursor is just this medium to work with code and the computer. So I’m asking about what Cursor will be when I ask what Cursor is. Do you have a metaphor? Is it just the agent?

Ryo: I see it as just one slice of making software: actively coding. When you sit at the computer, we put an AI next to it to help you write the code. Now, I want Cursor to be one place where you can do everything about making software. That is not just writing code, and it’s not just the developers. There are PMs thinking about what to do, how to measure things, aggregate all the data, synthesize it, and figure out what problems to fix. They break it down into tasks. There is the designer. Maybe they’re trying to explore higher-level abstractions in 2D space. There are the engineers writing the code, but they also need to review and test whether it worked. Once you put it out, you need to get feedback and input from the market and people using it. All of this is making software, especially in a team or a company. Now, people’s workflows, tools, metaphors, and artifacts are all scattered and disjoint.

Jackson: Yes.

Ryo: Cursor can actually help everyone put everything together again. Using the agent, we help you translate between your form of thinking—your preferred artifact—into the code itself. Then anyone who wants to build software, or any team, can be closer together. The agent helps them, solving a lot of the issues we have today that were created by all the tools we’ve made in the past.

Jackson: We just need one more tool.

Ryo: You need a thing that melds them fully.

Jackson: What about Cursor’s shape makes what you’re describing theoretically possible? People have been trying to build the final tool forever. Acknowledging that you are still currently serving mainly devs.

Ryo: People joke that Cursor is a fork of VS Code and just a code editor. But if you look at VS Code deeply, there are actually really good low-level primitives. For example, there’s the concept of editors. You can open different files in different kinds of editors: code editors, diff viewers, markdown previews, or browsers. Just having this allows me to present things to people differently, even though underneath it’s still the same code.

Jackson: Is that because it works with files?

Ryo: That’s another thing. In VS Code, there’s a concept of a workspace, which is just folders and files, maybe tied to a repo. A lot of these low-level ideas don’t have to change, and I don’t intend to change them. I don’t know if we will ever detach from VS Code. Maybe once we go fully agent.

Jackson: Or at least for a lot of the people using the code.

Ryo: Exactly. The challenge for me is to tie all these different workflows and preferences together into one thing. You have to come up with different reconfigurations and determine how users transition between these states. What do different people see by default? How do they customize it? How do they actually talk together?

Jackson: That’s a really complex problem.

Ryo: How do we move Cursor from a single-player thing to a multiplayer thing?

Jackson: You have your work cut out for you.

[01:10:33] How Using Cursor Evolves

On the note of using Cursor, we talked about the way you poke it. Your advice was to treat it as someone who’s a little dumb, composing things it’s seen before. Don’t expect it to come up with full components. You shared a list of 12 rules for using Cursor back in April. One that stood out to me was: “If the code is wrong, just write it yourself. Cursor learns faster from edits than explanations.” Obviously, that works for someone with coding ability, not without. How often is advice like this changing?

Ryo: It changes a lot. I would say a lot of the things I said in April don’t apply. For example, the agents are now so good at finding stuff that you don’t have to cite the exact file anymore. Back then, if you didn’t include the right context, the agent would just come up with something random or make a mistake.

Jackson: Is there anything that has remained true consistently as long as you’ve been working on Cursor? What is staying the same?

Ryo: Not much.

Jackson: You have to be surfing the new wave.

Ryo: Things are constantly changing. Even the things that appear the same might be replaced under the hood.

Jackson: That’s exciting, but also difficult. It goes back to having a tool you’re used to, and then they change a little. Geoffrey Litt has this metaphor about when they change your chef’s knife. That’s hard.

Ryo: I guess there are things that don’t change. Say, the agent. Before I joined Cursor, there were five things: Command K, Tab, Chat, Composer, and Composer Agent.

Ryo: The first thing I did was to merge the agent. Chat, Composer, and Agent became just Agent, with specific modes if you want specific behaviors. The idea is they’re all the same; they just apply configurations on top of the agent. Maybe this specific agent has custom prompts, a specific model set to it, or tools it can or cannot use. That’s it. You give it a name. These agents all operate on different models. Those don’t change. They need context. That doesn’t change. You need to show something with the editors. That doesn’t change.

Jackson: But all those things are changing.

Ryo: All the things inside are changing.

Jackson: I guess your bet is that if somebody is playing with the clay, they’re okay with change because they are living with the material.

Ryo: You have to be. In my career as a professional product designer, the thing I hate the most is people wanting the design to be final. “Where’s the final version of this mock? If you don’t have it, I won’t start building it.” That doesn’t make sense because the first mock is never right. You have to keep building it. Now the reverse happens at Cursor, which is chaotic, but I’m okay with it. Our engineers or enterprise PMs start “vibe coding,” and weird patterns emerge. You need to clean it up and wrangle it back. Because AI is really good at composing parts, I’m thinking we need to build bricks—really good bricks. From all the things we have, we need to suck out the patterns, the core bricks.

Jackson: This is something you guys did a really good job with at Notion. You were pretty principled about what the bricks were going to be.

Ryo: Notion did it more on the conceptual level.

Jackson: You mean tangible feature bricks?

Ryo: Low-level components up to patterns that people can reuse. Not just “every dialogue is different” or “list view is different.” You start helping people create patterns that work and fit together, that both humans and agents can use. This makes things better by not reinventing the wheel every time. When agents lack guidance, they have a tendency to do that.

[01:15:50] Designing for Power While Not Alienating Users

Jackson: We talked a bit about designing for hardcore users. Even if people are vibe coding with Cursor, the lines are thinning. I found a line from you somewhere where you talked about designing for power—to give the user power. What does that look like in the context of Cursor or more broadly?

Ryo: I don’t see users as dumb. They can figure things out. They don’t have to be babysat. I want to make things the simplest possible when you start, but as you go, you get all the depth you want. As a beginner, you get the same tools the pros use, just packed differently. You don’t see everything yet, but the thing you get can do 80 or 90% of what you want.

Jackson: My intuition is that most engineers feel there’s vibe coding and then there’s real engineering. Obviously, that distinction is being challenged. What does it look like to design for power and seRyous hardcore users on the vibe coding dimension?

Jackson: Part of that is conceptual. They have to be willing to say, “I’m going to give up the wheel,” or maybe not the wheel, but “I’m going to let the engine be.”

Ryo: We do little nudges and change our defaults sometimes. Those are probably the most powerful tools you can use as a product or a piece of software. You want to introduce them in a way that people can still get out of it if they want, but you want to show them: “Here is the new world. Here’s how you do it.” If they don’t want it, they can get out. But it’s the same thing, just reconfigured or slightly more optimized for the new way of doing things.

Jackson: There’s a little trust there too. If you trust us for a minute, let us show you how much the agent can do.

Ryo: A lot of people haven’t felt it yet. Or maybe they tried it before, but it didn’t work, and they lost their trust.

Jackson: They churned three times. Like you.

Ryo: Yeah. For now, you can probably do something pretty impressive even on the first shot. But even four months ago, that was not the case. Maybe the first time you tried Cursor, it didn’t work, got blocked, or did something stupid, and now you don’t want it. We need to figure out how to get the new people in without too much thinking and setup so they can do stuff. We need to get the existing users onto better, more up-to-date ways to do things without—

Jackson: Feeling like they’re Bubble apps.

Ryo: You want to carry them over instead of teleporting them to the new world where they ask, “What the fuck is this?” Then there’s getting the people who tried Cursor before—and thought it wasn’t good—to come back, because it’s good now. There’s work for us to do there. They are solvable problems, but there are many, many problems to solve.

[01:19:59] How Ryo Designs at Cursor: Abstractions, Writing, Prototyping

Jackson: I have some questions about process and other related topics. You wrote this amazing essay about creating something great. First—and maybe this is silly—is design just writing now? It seems like most of the design you’re doing involves going on your walks, then going to Cursor and writing.

Ryo: Yeah.

Jackson: Maybe you write a longer spec sheet as Cursor improves.

Ryo: I do write docs. I think it is just about communicating your idea and all the details you can think of in a way that is digestible for your peers—and the agent.

Jackson: Critically.

Ryo: Depending on who I work with, I will change the way I make these things. I work with an engineer named Ian. He loves mocks and pictures. When I do live code prototypes, he doesn’t like it. He just wants Figma mocks with every detail in one picture. So I just do that with him. If I talk about something more vague, or people have vague ideas, I keep it to bullets or simple writing. When we want to do something bigger—like a multi-month staged project—then I’ll write a big RFC. It’s all inherited from the way we did it at Notion, the writing part. But with Cursor, there is another element. I have an idea, I add it to my prototype, and then say, “Ho ho, look at this. Should we do it? Yeah, let’s do it.”

Jackson: I suspect those two modes together are quite powerful.

Ryo: You get from the most high-level, abstract level to the most detail.

Jackson: When you say the abstract level, do you…

Ryo: I mean long writing, high-level bullets, or just “what are the ideas.”

Jackson: And the constraint is a really detailed spec doc and an actual prototype. Two forms of almost different trees of detail.

Ryo: It’s the same thing, but visualized differently at different levels.

Jackson: On that note, what does a week look like for you? What does your time look like? I think Cursor has one meeting a week. You’re going on walks, thinking, prodding ryOS, or in Figma sometimes. What is that pie chart of time?

Ryo: That’s kind of random. Every week is very different. We also jam with people at the office. People are always there, but there aren’t many meetings.

Jackson: It sounds like a lot of talking, but not scheduled meetings.

Ryo: Yeah, chatting, talking, jamming, drawing pictures. Finding people to help join us.

Jackson: Podcasting sometimes. And getting designers to turn into coders—you’re a big ringleader for that.

Ryo: Yeah, I want to make it happen.

Jackson: What do you say to the average designer currently who’s feeling stressed out?

Ryo: You’re ready. It’s time. Just start building.

Jackson: Just start pulling the thread. Get in there with the clay.

Ryo: And then send me all the feedback. If you don’t like what you’re seeing, we’ll fix it.

[01:23:57] Process, Creating Soulful Things with AI, Refining Taste

Jackson: One intuition people have around AI—especially the average creative or non-technical person—is that vibe coding or AI can make slop, but it can’t make soulful things. You’ve certainly made the most soulful vibe-coded work that I’ve ever seen.

Ryo: You just need to put your soul in this. You need to care about every detail. You need to not accept whatever purple gradient the AI gave you as the end. That is just the beginning. You always start with shit. You always start with slop with AI, and then you refine it. You make it better.

Jackson: It’s the beginning, not the end.

Ryo: Yeah. You just poke at it with little prompts, and it gets better. It’ll take some turns.

Jackson: You say, “In the age of AI, the question everyone’s asking is, ‘Will I be replaced?’ The real question is, ‘Do you know yourself well enough to become irreplaceable?’” I don’t think we’re through with technique, skill, craft, and mastery. I am curious if there are any of those that you think are worth mastering now, but it seems to me that it’s actually more about intuition or sensibility. Can you talk about that?

Ryo: The AI models are trained on all the public knowledge, information, and code that it can see. You are trained on the same thing: all the books you’ve read, all the fonts that you know, all the artists that you admire, and the world around you. You build that intuition or taste, and you start forming an opinion about how you want to shape the world. You express it by building.

Jackson: Not by thinking, by the way.

Ryo: Not just thinking. You have to keep making things and keep looking at things.

Jackson: One of the things that gets missed when people talk about taste is that taste is eating food. Stop thinking about food.

Ryo: Yes. You need to keep eating and making shit. And then make the shit better and better.

Jackson: You critique design as aesthetics a lot, but you’re also very attuned to aesthetics. ryOS is like the most specific thing ever. You’ve perfectly handcrafted and recreated Aqua, among many other things. What is your relationship to not holding aesthetics too tightly, but also still clearly putting a ton of time, effort, energy, and thought into it?

Ryo: I think it’s like…

Ryo: How you present things visually will always be there. I don’t really think about it anymore; you just start noticing if this feels off or that feels wrong. Once you have a set of patterns, you don’t really think about it anymore unless it’s something new that you want to stress or put a little more flare into. But all the foundational bricks need to fit perfectly, even in the visual space. In the visual space, the bricks are the color, the spacing, the layout, the grid, and the different type scales and font sizes.

Jackson: It’s part of the big picture.

Ryo: It’s part of it. It’s more like one layer of it. Ideally, the thing is constructed in a way that is the simplest form for the low-level ideas you want to convey.

Jackson: I like that. They’re compressed.

Ryo: It’s compression to pixels. You still think about it, but you don’t think about it too much.

Jackson: It has its role in the hierarchy.

Ryo: I also dislike how people think of them separately. At Google, for example, they have interaction designers and visual designers. They’re split, and that’s bad. You create a world where the visual designers only think about how the button looks.

Jackson: They aren’t thinking about what it looks like to press the button.

Ryo: Or what it feels like. They aren’t asking how the buttons should be fitted together or why there are so many buttons.

Jackson: You’re always backing into this. You need to have the cohesion in mind when you’re in the micro. In that greatness piece you wrote about focus and breadth, you said we’re taught to focus early, choose what’s important, and discard what’s peripheral. But strict focus is a ruse. The treasure lies in expansive searching and stitching together a tapestry of interrelated issues later. Once you roam far enough, clarity will guide you toward the right edges. Until then, let curiosity roam. It almost feels like that operates on two axes: the axis of the incremental new thing and the axis of hierarchy and cohesion.

Ryo: You do that at the same time. That’s why it’s chaotic and ambiguous.

Jackson: You have to rein it in with order.

Ryo: When people try to put this into a linear process or order, they fuck it up because there is no more emergence.

Jackson: One view says that Google doesn’t have real designers. Another view says the people at Google are talented and capable, but their system is failing them. It seems like you think the latter.

Ryo: I think the latter. A tool like Cursor in its ideal form can help with this. People with different roles are stuck in boxes right now. You just break the box and let them build the thing they want.

[01:31:08] Balancing Agility and Quality, Chaos and Order

Jackson: Another part of that essay on greatness says to pursue agility and quality in equal measure. The myth says you must choose: move quickly and break things, or move slowly and ensure elegance. But genuine excellence emerges from a dance between speed and depth, agility and quality. I love this: “Like a skilled musician who can improvise yet still maintain impeccable technique, you must learn to adapt fluidly without compromising the integrity of the final piece.” I’m curious how this dance works. It makes sense to me that it could happen working solo on a short-term project without much of a plan. But how does that happen in other modalities, either with wide collaboration or on a big long-term project like Cursor 2.0? How do you embody that in that type of context?

Ryo: You let chaos be and you wrangle it at the same time. You don’t pick sides; you find an equilibrium.

Jackson: Between the complexity and simplicity.

Ryo: Same thing with how fast you want to go versus how much thinking you want to do. Especially in this age, it’s actually so easy to just try things out.

Jackson: In so many of your answers, it starts with just saying it doesn’t have to be a choice. You’re allowed to do both. They’re the same thing.

Ryo: People get stuck thinking they need to pick sides or make hard trade-offs, when all of these are just variables. You can add a little bit here, lower a little bit here. It’s all dynamic. You want to be more flexible to the situation you’re in and the change that’s coming. You don’t want your system to be stale or stuck in a form that you can’t get out of as the world is changing. You want to keep the essence clean and simple. You want to create a space for people to play with ideas so they can ship really fast, but maybe it doesn’t disrupt the rest of the system as much. Once you have more room, or you’re constantly wrangling things back to unify them, then you keep the core system better as you add or experiment with more things.

Jackson: A complex system can actually be quite high quality and fast if its parts are simple.

Ryo: Yes.

Jackson: Yet we build all this complexity, scaffolding, and arbitrary bureaucracy. All these “shoulds.”

Ryo: Right. Ideally, you’d actually get rid of all that crap that is not even part of the system—the software itself.

Jackson: It’s bloat.

Ryo: It’s like everything around it, the processes—a lot of it just doesn’t make sense. They slow things down. They slow this loop down: you have an idea, see it real, test it out, and then you iterate on it.

Jackson: How many people are at Cursor now?

Ryo: Three hundred.

Jackson: You were obviously at Notion for a long peRyod of that growth. When Cursor is 3,000 people, how does this not happen?

Ryo: The Planner agent will be ready by then. Multiplayer Cursor will be there.

Jackson: Sure enough.

Ryo: How Cursor does it really fast and pretty well is that a lot of people we hire are just really high-agency people. They were founders before who have made stuff. They just want to build; they don’t want to think too much.

Jackson: That definitely works with 30. Maybe that works for 300. All wisdom would say that doesn’t work with 3,000. Even if you had 3,000 Steve Jobs, it would actually be a disaster.

Ryo: I’m not sure. That is actually part of the questions we need to answer: in this new world of building with AI, how do teams work? I think it won’t be too close to what we had before, like layers of management and linear processes. It’s probably not going to be that. So what is it? How do you insure people are aligned on the general direction, but each person has the agency to build whatever they want to an extent? We need a system to help people control this. We need to make sure these people are actually talking to each other and sharing the same information when they do stuff. That’s the main problem we have now. People are so disjointed. They talk to their own teams that are created with row boundaries. They work in their own files and own tools.

[01:37:00] Great Teams and Great Products

Jackson: One thing that maybe helps, that you also have in that essay, is about the quality of a team. You say the team that molds greatness is not a conscript army, but a band of pilgrims. Such people don’t hide behind process or hierarchy.

Jackson: What does it feel like when you meet a group of people? You’re in a room or visiting an office, or when you first met the Cursor people. How can you tell that it’s a band of pilgrims?

Ryo: Just see what they’re doing and what they care about. You ask them, “Why are they here?” And they tell you, “Because I love programming.” They just like doing this thing. They’re into it, they’re passionate, they care deeply, and they want to make the best thing. They want to put the work in. You see it. They don’t talk about equity or investment. They talk about the latest models, the new ideas. They exchange their ideas. They’re there for quite a long time every day, and they’re doing that not being forced.

Jackson: On the note of the essay about making something great, do you aspire to greatness?

Ryo: Oh, yeah.

Jackson: What does that mean for you?

Ryo: To me, it means you make something that helps a lot of people, that lasts. Ideally, it is pretty close to the ideal configuration of the thing.

Jackson: That truth, that trueness we talked about.

Ryo: Right. But sometimes you fake it. Sometimes we make the upper layer really nice and pretty and cohesive, but under the hood is chaos. But that’s fine. You just do that slowly.

Jackson: It’s like the picture of the SpaceX rocket (engine) or the iPhone. The iPhone Air now is…

Ryo: Even if you look at the inside, it’s so pretty.

Jackson: I want the clear iPhone Air too. That would be amazing.

[01:39:41] Grab Bag: Human Tech, Why Tools Need Stories, Why Cursor Isn’t a Slot Machine, Notion & Cursor, Steve Jobs, Liquid Glass

We have a little time left, so I have a bunch of speed round questions. First off, maybe it relates to your last answer. What does it mean for technology to feel more human? Not exactly the easiest speed round answer.

Ryo: I think it should fit each human better. It’s different for everyone. Some people prefer something really simple. Some people actually want to see every button. Some people like talking, some people like reading. Some people like watching YouTube tutorials, going to a course, or buying a book.

Jackson: It’s fit, it’s a personal connection.

Ryo: It’s about fitting the human in the way they do things. Not in the way I do things, or the way our engineers do things. Those can be good examples. As it fits you better, it inevitably needs to understand you better. It needs to understand your preferences, your way of thinking, how you talk, and the things you care about.

Jackson: It’s almost like being seen by a design or a product.

Ryo: When you do it, it just feels like you’re in flow and you don’t think. Kind of like how I use Figma. But that took years of training. But now it’s maybe a couple of tries and you’re there.

Jackson: You write a lot and you clearly are really thoughtful about the narrative and the conversation around Cursor. We spoke about this briefly: tools are all selling ideas. They’re all attaching themselves to ideas. There’s a lineage of ideas they’re pointing at. How you talk about tools matters tremendously. You have to plant seeds. What do you mean by planting seeds? How do you think about shaping what people think and perceive about Cursor?

Ryo: Software to me, kind of like what we said, is just a tree of concepts packaged up in the word Cursor or Notion. Notion is blocks, pages, databases. Cursor is agents, models, contexts, and editors maybe. But you also want to create a brand that lasts, that is not just your present form. It is a little bigger and ties with the past and the future.

Ryo: Cursor is definitely not just “AI coded.” It is not even that Cursor makes you extraordinarily productive. It is bigger. You want to tell the bigger story, but you also want to tell smaller stories to different groups of people. You have to tie them all together.

Jackson: The product is like the ship, and the story is that we’re going to the Americas. Having that broader context is important. People attach a lot of identity to the things they use to make things.

Ryo: I think it’s actually a service. We need to do more of this to paint a picture for people to see how we came here. We need to show how these things are actually the same ideas, how the ideas originated, and how they interweaved.

Jackson: That’s so important. AI is so alienating to people.

Ryo: A lot of people, when they start, actually just start from “now.” They don’t see the past. They don’t know how we came here.

Jackson: Or they’re living in the past and say, “I don’t like this future.”

Ryo: They’re stuck in the past, and they don’t know how this future can take them there.

Jackson: You mentioned a tweet where you said, “Don’t build slot machines.” A few people accused Cursor of being a slot machine. What do you say to that?

Ryo: I don’t think Cursor is a slot machine because slot machines don’t let you open them up.

Jackson: It’s a closed black box.

Ryo: I actually don’t want your primary way to interface with Cursor to be like the CLI. In the terminal, you are in this little box, constrained to just that input. You type the thing in a little box, hit enter, and wait to see what happens. In Cursor, that is possible, and you can do it like that. But that is just one form of it.

Jackson: It’s the beginning.

Ryo: You will naturally hit these moments: “I see a code block. Maybe I want to click and see what’s in it. I’m done with this chat. I hit this review button.” Now I see all the things. It slowly teaches you. Now we’re doing code reviews, where we stitch the agent reviews with the code review, with git, and all the other stuff. Even as a newcomer, you come in and start with a simple thing. You slowly get to the complexity if you want. I don’t force you either. If you don’t want to open the code, you don’t have to.

Jackson: Keep hitting the slot machine if you want.

Ryo: If you want that, it’s fine. I don’t think that’s a stupid slot machine either. Again, it’s customizable. You can open it up and do whatever to it. Even in the simple form, you can still customize the thing. You have the whole spectrum of control. From the most manual coding, where you just type and it’s still your thing, our tab model is still the world’s best thing. You type, and boom, it completes your thought. It jumps you to the next place. You keep going. If you prefer that and you’re in your flow state there, you should keep doing that. Then there is a small chunk of professional developers who have become very “agent coded.” They don’t do manual coding as much. For them, we have tools to focus on one agent, spin up multiple agents, and manage them at a higher level soon.

Ryo: Then you get the whole spectrum. For these people, they can find their preferred spot, open it up, and do more if they want. But I don’t force them into a little box where all they can do is put the prompt in a box and see what happens.

Jackson: Is there a pattern from Stripe to Notion to Cursor, as you’ve spent most of the last decade there?

Ryo: I don’t see them as too different. They’re actually very similar. Stripe to me is just passing messages around the internet, but the messages are transactions or money-related. Notion is basically the Meta SaaS tool—databases and all the archetypes of views and patterns. Cursor brings it more low-level, but it’s also more flexible. You actually break all of these patterns and parts completely. At some point, you will get it composed by the AI or with our presets so you get the tool you want.

Jackson: You have a line somewhere where you say you are “building stuff that frees up people’s minds.” It felt like that’s true for all three of those things.

Ryo: It’s helping people make the thing they want.

Jackson: What have you learned from the Notion founders and the Cursor founders, respectively? Or maybe even Stripe?

Ryo: From Ivan, he showed that systems thinking and aesthetics can be melded together. You don’t have to pick.

Jackson: Wow.

Ryo: From the Cursor people, it’s just that you should YOLO, do stuff, don’t think too much, and keep doing it.

Jackson: Ambitious naiveté.

Ryo: Exactly. That is actually so good in this age because nobody knows what they’re doing.

Jackson: Right.

Ryo: All the old ways of doing things don’t really apply anymore.

Jackson: What do you love about Steve Jobs?

Ryo: I love him as a spiritual figure. I’m not religious, but I feel like sometimes people need something there, and I put this as a symbol. That helps me a lot.

Jackson: What does that symbol represent?

Ryo: It forces you to think about everything, all the details, and come up with the simplest thing. He helped me start all of this. He got me into design—the old Apple. They showed how computers can be beautiful.

Jackson: Maybe on that note, what is the difference to you between Liquid Glass and Aqua?

Ryo: Aqua is more about bringing physical metaphors into the computer so people feel more familiar with things. If you look at the icons, they almost look like the emojis we use today. They’re super detailed, with real-world reflections and material. Back in the day, it looked completely different from the gray boxes people used, like the beveled 3D buttons. That was pretty game-changing. They also mastered how to render fonts. Back then, Aqua was made of PDFs rendered on your screen. You could stretch the UI freely. The text was not in little bitmap pixels; it was all anti-aliased and perfect. Liquid Glass almost feels like a flex on what Apple can do now. It’s kind of weird. I get the point: they’re trying to unify the design language across all of their platforms and come up with one thing. But how you use the phone versus how you use the Vision Pro when you stare at things is different. They need to track your eye, your finger, and your little pointer on the mouse button. They’re all different.

Ryo: Your interface probably can’t be the same thing, but they tried to make it the same. This material, even though it’s inspired by glass, is purely digital. They’re just flexing that they can build system-level shaders and make them perform across every single UI. My menus can morph into a button and out from the button, but to the users, what’s the point?

Ryo: It makes a lot of the UI hard to see. The tabs take so much space. You need to keep clearance for the tabs, the shadows, and the little blur under it. When you compare the old iOS and the new one, you actually see less text or there’s less stuff you can do. Maybe the priorities have changed. Instead of being truthful to the platform itself and the way you interact with it—whether it’s a finger, your eye, or a pointer that has different precision—let’s just make everything the same.

Jackson: I have to stop you because I know you can rant about this all day. Just a couple more questions. What makes NewJeans stand out in a world of factory-farmed K-Pop?

Ryo: It’s the same idea. All the new things we make are just remixes of old things. What NewJeans did was mix things really well. They gave these girls a space to be themselves and have fun. That’s why it feels so different from all these scripted, manufactured K-Pop songs. Most people are just mixing a lot of crazy things together now, whereas NewJeans is more thoughtful. It’s about taste and constraint.

Jackson: In some ways, K-Pop can feel like asking, “What does the algorithm want?”

Ryo: Exactly. You find a concept, get a lot of songwriters, and buy a lot of songs. Then they just mix these parts or genres. Put the English, Korean, and Japanese lyrics together. Boom.

Jackson: Can you say something about Zhuangzi’s Butterfly Dream?

Ryo: It’s like life, in a sense. Reality is not that real. A lot of it is just in your head. Sometimes you feel like you’re living in a dream where you can actually mold anything.

Jackson: It’s like that old Steve Jobs video. When you figure out that the world is moldable and plastic…

Ryo: You can poke it and get feedback. It’s like the butterfly. Sometimes you just let things go and see how it happens. Sometimes you go back and take control, like waking up from the dream.

Jackson: You’re in between dream and reality. We’re always doing that, by the way. We’re on autopilot, and then we’re not.

[01:56:16] Tenderness & Empathy

I was talking to ryOS, Steve Jobs, and Pope Francis. The Pope said something about a “revolution of tenderness,” and Steve was skeptical. So I asked Ryo what tenderness means to him. He said tenderness is when a system or tool feels intuitive, almost invisible, making things smooth and delightful. It’s the empathy baked into the design. We didn’t talk a lot about empathy today, although it’s running in the background of our conversation. It’s clear you are deeply empathetic to the people you care about—people who make things. What does IRL Ryo think about tenderness?

Ryo: It’s putting care into things, the people you meet, and the people we serve. It is being truthful. The ideas we work with, or even the technology, are universal and generalizable. It’s not exclusive to a group of people.

Ryo: You understand what you need and what you are frustrated with, and then you find a group of people who are similar to you. The people at Cursor all share similar problems. They make stuff for themselves and build this tool. Then it’s about how we bring it out to more people like us, or even beyond people like us. That might be the next breakthrough. The vibe coding tools and the pro coding tools today are still very split. It’s really hard for non-technical people to come into Cursor today, but also very hard for them to progress from a vibe coding thing to a real thing. Maybe we can help with that. We can help turn designers into coders, PMs into coders, and coders into designers.

Jackson: It’s all the same thing.

Ryo: It’s all the same thing. We start realizing we don’t have to put boxes around our heads or our eyes. We can actually do things. We can do things better with other people who have different areas of specialization, but we’re all thinking about the same thing. People don’t have to fight. Instead of fighting about bureaucracy, you fight about the truth: What is the best thing to do? What is the ideal configuration of the thing we’re doing together? You help people erase all the parts of their job that they don’t really like doing. You help people amplify their strengths—what they care about and what they’re really good at. You help meld these people’s strengths together, and then the agent covers the rest.

Jackson: Ryo Lu. Thank you very much.

Ryo: Thank you.