"In the new version of the world, rather than typing a command to run a program, what you do is you type a prompt to launch an agent."
For decades, the command line has been a developer's staple. But what if its future isn't to be a better terminal, but something else entirely?
We're joined by Zach Lloyd, co-founder of Warp, to discuss this groundbreaking shift in developer tooling, sharing his bold vision that the future for developers is neither the IDE nor the terminal, but a new kind of platform built for launching and orchestrating AI agents. Zach explains how Warp is re-imagining the command line as the natural entry point for this evolution, transforming it from a place where you type commands to a place where you write prompts to solve complex problems.
Zach dives into the new developer workflow, where the focus moves up a layer of abstraction from the minutiae of flags and syntax to higher-level problem-solving and guiding agents. He argues that by being the platform itself—not just an app running within it—a tool like Warp can provide a far richer and more effective user experience than traditional CLI agents. Discover the new skills developers need in this era, from problem decomposition to clearly expressing intent in natural language.
Show Notes
- Try Warp: warp.dev
- Warp's YouTube Channel: Check out Zach's live streams and product videos
- Connect with Zach: LinkedIn | X (formerly Twitter)
- Connect with Brooke: LinkedIn
Transcript
(Disclaimer: may contain unintentionally confusing, inaccurate and/or amusing transcription errors)
[00:00:00] Andrew Zigler: Hi everyone. Today we're joined by Zach Lloyd, the co-founder of Warp, a groundbreaking startup that's re-imagining the command line terminal. And we've been seeing disruption everywhere in developer tooling. Mainly with Ides heavily disrupted. You know, gone are the days of the browser wars and here are the days of the IDE wars, and you have all of these competitions between, you know, vs code and windsurf and, and cursor.
[00:00:25] Andrew Zigler: But did you know that the terminal itself is just as ripe for disruption? And that's what Zach's team is shipping for the developers of the future. So Zach, thanks for being here today to talk about what you're building.
[00:00:37] Zach Lloyd: Yeah. Excited to join you. Thanks for having me.
[00:00:40] Andrew Zigler: we're, we're excited to dig in. Uh, our listeners are really keen to understand how software development in general is just being transformed and changed and what they can do to take advantage of it.
[00:00:50] Andrew Zigler: So let's learn about the terminal of tomorrow. I got some questions for you. I myself am a. You know, in our previous conversations you became fully aware that I'm like a terminal [00:01:00] nerd. So I'm like really excited to, to chat about this today. Um, because the terminal is something that has been like a staple for developers for decades.
[00:01:08] Andrew Zigler: We kind of just take it for granted. It's like a screwdriver. Why would you reinvent the screwdriver, right? You just have it on your tool belt in your box. But, it's an old school tool that kind of can be sometimes difficult to learn and use. Figuring out the commands that you can actually do on a terminal requires.
[00:01:24] Andrew Zigler: You know, in previous generations of developers going to places like Stack Overflow or asking, uh, cryptic questions or piecing together, uh, articles that you can find online. but now we're in a whole new world where developers expect answers at their fingertips, right? Where they're working, wherever they are.
[00:01:40] Andrew Zigler: And so, Zach, what inspired you to tackle this challenge, um, and work on the terminal as a new tool?
[00:01:47] Zach Lloyd: Yeah, so I've been a developer a long time. I've always, um, I've always used, used the terminal, but not like, loved using the terminal. And, uh, I've always worked with folks who were [00:02:00] really good at using it and seeing that if you get good at using the command line, it, it can be a, just like a huge boost to what you can get done as a developer.
[00:02:09] Zach Lloyd: that said, just to segue for a second, I actually don't think the terminal is the future. Or nor do I think the IDE is the future, like war warp. just to be really clear, just like did grow out of, uh, it started as a terminal. The vision was like, let's make a more usable, uh, more accessible terminal where you have to waste less time, like, you know, looking stuff up on Stack Overflow, like you said.
[00:02:31] Zach Lloyd: But I actually think that the, in the future developers are not gonna be using terminals or IDEs so much. What they're gonna be using is a platform. Um, it's all geared around doing like agentic workflows and, at Warp, the, the goal is to build that at this point, like we've started with the terminal as like the form factor, uh, whereas like cursor and windsurf, uh, vs.
[00:02:58] Zach Lloyd: Code, as you've mentioned, they've all [00:03:00] started with the code editor as the form factor for using AI to improve developer workflows. We've started with the terminal as the form factor, which I think in a lot of ways is actually. The more natural form factor. 'cause when you think about what you're doing as a developer using the terminal, you're, you're, you're basically, it's an interface for telling your computer to do things.
[00:03:20] Zach Lloyd: And so in the old school world, that's like you type a command and that runs a program and. And that program might run for a long time. It might not. In the new version of the world, rather than typing a commands run a program, what you do is you type a prompt to launch an agent. And so that's, that's where I think the world is, is going.
[00:03:41] Zach Lloyd: but you're right, we started as a, as a terminal, which is like a, I think a pretty unique, uh, entry point into the like, new world of how things are about to, to start working with ai.
[00:03:52] Andrew Zigler: what you're describing is really spot on in terms of like, there was, there's a future tool we're
[00:03:57] Zach Lloyd: Yes.
[00:03:58] Andrew Zigler: towards, but we have to start with the [00:04:00] tools that we recognize and understand and know how to use and maybe feel around in the dark or take those baby steps and figure out where these tools can go.
[00:04:08] Andrew Zigler: Um, and, and in your case, you, you started by looking at the terminal, you
[00:04:13] Zach Lloyd: Yep,
[00:04:13] Andrew Zigler: the classic, um. You know, ripple interaction with your actual computer base
[00:04:18] Zach Lloyd: exactly.
[00:04:19] Andrew Zigler: instead of the, the IDE and I, I, I'm wondering like when you went in there and you started tackling this problem, you know, there's a, there's a whole slew of like tra of traditional problems around terminals that developers face. did you go in trying to solve those problems or just using it more as like a canvas to create the next generation of tool? kind of
[00:04:41] Zach Lloyd: Well, it's.
[00:04:42] Andrew Zigler: at it.
[00:04:42] Zach Lloyd: It's changed a bunch. So we're, you know, we're, we're five years in when we started. We started before LLMs. And the, um, the problems that we were trying to solve at the outset were really things around like, there, there it was like, it's a hard tool to use. And so just [00:05:00] to give some examples, you know, like the mouse doesn't work in the terminal.
[00:05:03] Zach Lloyd: It's like, well, why are you using a tool? In, this was in 2020 where it's like you can't use the mouse. And I understand some developers don't want to use the mouse, and that's totally legit. You may be faster not using the mouse, but at the very least it should work. and there was another class of problems around, um, I would say like discoverability.
[00:05:24] Zach Lloyd: So. Y you know, the terminal is like infinitely flexible and powerful. Uh, if you can remember what the flags and arguments are for various commands, and we're like, why are people wasting time trying to memorize all that stuff? So we're like, how do we fix that problem? So at the beginning it was really just like, what would be a better, more accessible user experience?
[00:05:51] Zach Lloyd: something that. Kind of lowers the barrier of entry into the terminal. 'cause it is a, it is a tool where a lot of. Developers [00:06:00] have their first experience doing something, and it's not a very positive experience. It's like you're trying to set something up in Python and you hit some missing environment variable and you're like, what the heck is going on?
[00:06:10] Zach Lloyd: And so we were trying to lower the barrier, but we were also trying to make it so that for pro developers who actually were comfortable in the terminal, um, they could get more out of it. That's where we started, uh, as. LLMs came out. you know, we realized pretty quickly that this is like a very, very good fit technology for the problem set that we were working on.
[00:06:33] Zach Lloyd: and so we. You know, we did the thing that I think a lot of companies did in like 2023 when chat GPT came out. Like we put like a chat panel into the terminal, uh, which is like, you know, a very fast bolt on surface level solution. And then in, you know, we, we pretty quickly realized, hey, there's actually like a way deeper integration that would make more sense here in that the terminal [00:07:00] interaction itself is already.
[00:07:02] Zach Lloyd: Kind of a chat interaction. So having like a chat panel on the side of the terminal didn't make as much sense to us. It's just like, let's just let people interact with the terminal, via natural language. And so that was the next thing that we ended up launching in 2024. And then, uh, this sort of use cases that you could do with that have really evolved.
[00:07:23] Zach Lloyd: So at the beginning it was like, kinda like what you alluded to in the intro, it was like. A lot of people would use it to be like, how do I do X? So they would, they would use it as like a question and answer type, um, interaction pattern. Be like, how do I undo my last get commit? Or how do I like get out of this crazy detached get state?
[00:07:43] Zach Lloyd: Or how do I like rebuild my docker containers? Um, but what's happened is that the paradigm has shifted from the how do I like the question and answer to something that's much more imperative where a developer today using. [00:08:00] Uh, warp. You just say what you actually want the computer to do and it does it.
[00:08:04] Zach Lloyd: So you be you, you just say like, undo my last get commit, or like, fix this detached head state. And then what's happening is that the models and the amount of context that you can feed into them, the models have gotten way better. The context has gone up. And so the complexity of task that you can just sort of.
[00:08:20] Zach Lloyd: Prompt your way to doing it. It keeps going up the complexity ladder and so you can now like prompt it to build features for you to investigate production problems. And uh, it's just proven to be a very natural interface for doing that type of like, uh, you, you prompt the computer to do something type work.
[00:08:41] Zach Lloyd: So that's kind of where we're at today.
[00:08:43] Andrew Zigler: It. It is interesting how you describe it, how it evolves from the interrogative asking questions to the imperative and making commands, and we've seen this evolution in how folks interact with AI and use it with tooling and kind of what you're arriving at. Sounds so similar to me. I. To what we would [00:09:00] consider as to like a coding agent that lives in your, in your terminal.
[00:09:04] Zach Lloyd: what it is today.
[00:09:06] Andrew Zigler: Yeah. So like what you describe, it's like, it, it makes me think of, you know, you might use like, uh, Amazon, QCLI, right? Or you might use Claude code and you would, or Goose, right? And you would use it in the terminal. But in this case, the terminal itself is the age agentic tool. Um,
[00:09:21] Zach Lloyd: Yeah,
[00:09:21] Andrew Zigler: is what you, what you've built.
[00:09:23] Andrew Zigler: And so as part of that, do you find yourself, Are those competing tools or are they like a better together type of use case?
[00:09:31] Zach Lloyd: there they started off as sort of better together. Today it's really competing like. Um, cloud Code, er, goose, all of these terminal based coding agents, they are like a, I would describe them as like doing a subset of what Warp can do, and I think Warp is actually the better interface to do what you do with those tools.
[00:09:52] Zach Lloyd: The advantage that war has compared to something like Cloud Code, which is a very cool tool, is that cloud code is running [00:10:00] as a, um, A CLI app. So it, it's something you boot up your terminal, you run Claude, and then you're inside of a ripple inside of your terminal and the downside of that is kind of like the downside that Warp itself is trying to address five years ago, where if you're running an app inside of a terminal, you're really limited in terms of what you can do with the user experience.
[00:10:26] Zach Lloyd: So you can only render characters, the mouse doesn't work again, which is annoying. you lose the ability to do any kind of richer ui, so like in Warp for instance, when we present a diff to the user, they can edit the Diff using their mouse and like wizzywig tools. Whereas when Claude Code presents a diff, it's like an immutable thing that is just like printed to the screen.
[00:10:51] Zach Lloyd: Um, Claude Code, you can like run multiple of them. But because you're running them as like, uh, multiple terminal [00:11:00] apps, you, you don't get like any kind of like layer of management for them at the actual app layer. So like for war for instance, it's like we let you have like a, a nice like panel that shows all of your running agents.
[00:11:13] Zach Lloyd: We give you system notifications when agents need your attention. And so. Just by moving up one layer in the stack to be the actual like platform as opposed to an app running in the platform, we can offer a, uh, a much better, richer experience, uh, than one of those other apps. And like for instance, like another great example of this is, so when you run a, an arbitrary ripple within warp, so say you're running like the node rep or like the Postgres rep warp can give you AI inside of those running apps.
[00:11:46] Zach Lloyd: Uh, by virtue of the fact that we are the terminal, whereas like something like Cloud Code or Goose or whatever, they don't have any access to the platform layer. It's like the difference between like being iOS and being an iOS app. So I, I do think [00:12:00] we're at like a way more powerful, uh, layer in the stack.
[00:12:03] Zach Lloyd: And so yeah, we are essentially competing with those tools. I think with a better experience at this point.
[00:12:09] Andrew Zigler: Yeah, it's, it's cool how you're right, that it's like the, it's the tool itself, so you get all the context baked in through all of the layers. Everyone knows when you use a terminal, it's like, it, it becomes inception. Your, like application. In an application. In an application. But like we're
[00:12:22] Zach Lloyd: this is.
[00:12:22] Andrew Zigler: the core of it, you know,
[00:12:24] Zach Lloyd: It's kind of like there's a lot of people who really love using Team Ox. I don't know if you, if you, you know,
[00:12:29] Andrew Zigler: tux. Yeah. I
[00:12:30] Zach Lloyd: so Te Ox drives me crazy 'cause I'm like, you're, it's like, why are we like emulating a terminal within the terminal as opposed to just building the features that you might like.
[00:12:40] Andrew Zigler: I, I want split windows and panes,
[00:12:42] Zach Lloyd: Yeah. And like we just have that natively at like the app level. Um, but there,
[00:12:47] Andrew Zigler: an improved terminal experience. Right,
[00:12:50] Zach Lloyd: yeah. Yeah.
[00:12:51] Andrew Zigler: would not use tux if it was built into the terminal I was using.
[00:12:55] Zach Lloyd: Yes. And so in Warp it is, but people still, like, there are, I, I [00:13:00] don't wanna be totally dismissive, like there's cool stuff that Team UX does that Warp doesn't currently do. Um, and likewise, there are some advantages to just being a pure CLI app. I don't wanna be dismissive of those tools either. Like, like you can run those tools, um.
[00:13:15] Zach Lloyd: Like on, on CI or something like you, you don't, you don't need the ui. And so there's use cases where I think they're better, but for the most part, if what your workflow is as a developer today. Is like, Hey, you want to come in and open up your tool and start multitasking with agents to fix bugs, to build features, to investigate production.
[00:13:39] Zach Lloyd: Um, I think it's way better to do it at the layer of like the outer app, not at like an app running within the terminal. Yeah,
[00:13:48] Andrew Zigler: it inside of a
[00:13:49] Zach Lloyd: yeah.
[00:13:50] Andrew Zigler: it all up and getting all of your henchmen, doing your stuff completely i's like, and what you're describing actually is such a critical part of building the terminal, I think. Uh, which is why [00:14:00] it's so fascinating how you're tackling the problem because I terminal's one of those things where folks get really opinionated
[00:14:06] Zach Lloyd: Oh yeah.
[00:14:06] Andrew Zigler: their terminal can and should work.
[00:14:08] Zach Lloyd: Oh yeah.
[00:14:09] Andrew Zigler: I'm like, I'm like a dot files disciple. I
[00:14:12] Zach Lloyd: Yeah.
[00:14:12] Andrew Zigler: repo that I manage, right? And I have my team books config. Like I, I have my opinions for how all of these things work. And so like when, when I'm going to use a new tool, I want, um, it to play nicely with those things. But at the same time, I wanna take advantage of new opportunities.
[00:14:27] Andrew Zigler: I'm willing to throw away some of that personalization. I've. Scraped on top of maybe an I, I've personalized it to make the tool that wasn't user-friendly, more user-friendly for
[00:14:37] Zach Lloyd: Um,
[00:14:37] Andrew Zigler: if a more user-friendly tool comes along, then that's an opportunity for me as a developer to try something new, which is like what you're building.
[00:14:45] Zach Lloyd: you have an amazing attitude. Like, uh, there are, I think that that's an awesome way of, of, of looking at it. Um, I. Like there are very,
[00:14:56] Andrew Zigler: the opposite
[00:14:57] Zach Lloyd: I I I,
[00:14:58] Andrew Zigler: with the terminal?
[00:14:59] Zach Lloyd: I [00:15:00] do like on on on Hacker, on Hacker News. There are people who think that, um, you know, warp is like akin like a sacrilegious thing because it, you know, it breaks some of the assumptions that.
[00:15:14] Zach Lloyd: People have historically made between terminals and shells and dot files and just like how that whole ecosystem, uh, has traditionally worked and that if you are a like terminal power user who has spent a lot of time building muscle memory or configuring that, and then you come into warp and it doesn't.
[00:15:35] Zach Lloyd: Work the way you expect. I think it's very understandable that you would be frustrated with that. On the flip side, my um, you know, my feeling is that setting all of that stuff up asks the user to do an awful lot of work and puts a very, very high barrier to entry in terms of getting like a good terminal user experience to the point where I think it, it really like [00:16:00] turns a lot of people off of using the command line at all.
[00:16:03] Zach Lloyd: And so. You know, and this is the camp that I was in, and I'm not like a, like I'm a pretty experienced developer, like I was a principal engineer at Google, I built a lot of Google Sheets product and, and like, but I was, I, I'm of the development mindset where I'm like a little bit lazier and I'm just like, I want things that just work.
[00:16:24] Zach Lloyd: I want defaults that are sensible. I want UX patterns that are familiar to me. Uh, and I think a lot of the world is like that. Uh, and I always felt like there was kind of a. Like a sort of vocal minority of power users who like the existing thing that made it harder to innovate and improve the base experience for the rest of developers.
[00:16:49] Zach Lloyd: Um, and so, you know, I, I, that's what we've tried to do. Uh, but it definitely has like irritated some people who are maybe more traditionalists and that's okay.
[00:16:58] Andrew Zigler: Well, it's [00:17:00] like there's a lot of opportunity to customize the stuff, but I think what people
[00:17:02] Zach Lloyd: Yeah.
[00:17:03] Andrew Zigler: is that we customize it ultimately because it doesn't, it, it doesn't quite hit what we need. We need all these extra things. So we do take the time as the developer to go in and.
[00:17:14] Zach Lloyd: Yeah.
[00:17:14] Andrew Zigler: in.
[00:17:14] Andrew Zigler: And then you end up like, well, if I'm sprinkling them, them in and I'm the only one who's using this, I'm gonna make it perfectly tailored for me. And then this is where you get that, like staunchly, entrenched configurer,
[00:17:24] Zach Lloyd: Yeah.
[00:17:24] Andrew Zigler: know, dot files configured developer. but I'm definitely at the mindset where it's like, uh, trying out new tooling, new ways of using these tools is what we all need to do right now, is what we talk about every week on Dev
[00:17:34] Zach Lloyd: Everyone should be doing that. Yeah.
[00:17:37] Andrew Zigler: Should be. And so it's like a huge opportunity.
[00:17:40] Zach Lloyd: And like a lot of the, it's a huge opportunity. I, I agree with that completely. And a lot of the kind of older ways of working that we're very like tuned, They, they were just tuned for a world that existed before ai. And I, I also think there's a lot of developers who were kind of tired of hearing about ai, but just to give an example, it's like [00:18:00] you may have like some crazy list of aliases that you've set up, uh, around doing like complicated get things you may have like very complex like completions set up again for like, you want your tap, please do all this stuff.
[00:18:15] Zach Lloyd: All that makes, it's just like less necessary and less useful in a world where you can just express your intent directly in English to do a, to do a task. And, the AI will help do it for you. And there will be some people who like lament the, the loss of like. Oh, but I used to know like the 50 different flags, but I like think of the space it opens up in your brain and in your day to do what I would imagine is like more fun, more cool, like deeper problem solving and like it to the extent it moves you up a layer of abstraction and frees your mind from having to deal with that minutia.
[00:18:59] Zach Lloyd: To me, that's just [00:19:00] so much. Better and even more fun as a developer. Uh, and it's not about like replacing like, it's like, it's like getting rid of the kind of work that I like, don't like doing as a developer. Like, oh man, I have these merge conflicts. That's not a good use of my brain power. A good use of my brain power is like, let me think how the product should work.
[00:19:20] Zach Lloyd: Let me think how the system should be architected. I think like you have to at least try these new tools and, try them with an open mind. Like what, what you were saying,
[00:19:29] Andrew Zigler: Absolutely. And this kind of gets now at the core of our discussion, I think about where this is all going and how the roles of developers will evolve because we are all moving up the cognitive food chain, so to
[00:19:40] Zach Lloyd: yep.
[00:19:41] Andrew Zigler: what we're, what we are doing and what we focus on, um, in our day-to-day jobs are, it's much broader and it's more decision management.
[00:19:47] Andrew Zigler: It's about understanding the product and the impact of what we're building, uh, building for the customer, the end user as opposed to like you, you, like you just alluded to. Kind of getting lost in this like, um, sea of all the minutiae [00:20:00] of trying to execute those obscure git commands or figure out, you know, all of these things that you typically have memorized or alias, uh, to do your job when you can ultimately, um, express those needs with natural language.
[00:20:11] Andrew Zigler: So, when we're stepping into this new world, I'm, I'm curious to know where do you see this going for a developer as somebody who orchestrates agents, and how is Warp building for that?
[00:20:23] Zach Lloyd: Yeah. So that's, that's what our entire product is oriented around right now, is what I think the new workflow is gonna be. Um, I think the new workflow, if your developer is, you're gonna, you're gonna have a bunch of stuff to build. You are gonna have a bunch of stuff to fix, that's not gonna change. But the way that you use the tools to build and to fix and to improve your systems and to ship product is gonna change to one where it's like your one higher level, uh, of abstraction as you do your work.
[00:20:57] Zach Lloyd: And so your typical day might be like, [00:21:00] Hey, you're gonna come in, you're gonna open up, let's just say you're gonna open up Warp for now. 'cause that's the, that's the product that I'm working on. You're gonna, um. You're gonna have like things you want to accomplish. So you might want to build a future. And so you're gonna start by sort of telling your computer, Hey, I want to build this future.
[00:21:19] Zach Lloyd: Here is the context, here are the designs. I don't think right now you are typically going to like one shot it. Right? And I think this is like a fear that a lot of developers have is that it's gonna be just like type of prompt walk away. Like I'm using these tools. Daily to do my, my normal development work and like they can one shot simple things.
[00:21:45] Zach Lloyd: I think the complexity of the things that they will be able to, one shot is going to go up, but really you're still gonna have to be like, let me work with, uh, let me think about how to decompose this problem. Let me think about how to check in on the progress to make sure [00:22:00] that. You know, if I'm gonna delegate pieces of it to an ai, it's not going too far down the wrong path.
[00:22:05] Zach Lloyd: Um, but you're gonna eventually get to a point where you start to kick something off and it could be like, Hey, go up to point X and then check back in with me, or check back in with me. If you hit some error that you can't resolve, you're gonna start that task and then you're gonna move on to your next task.
[00:22:21] Zach Lloyd: And that task today as an agent task might run for like. One to 10 minutes in a year from now. I think one of the axes that you're gonna measure the progress of this stuff on is like how long it runs for. It might run for 10 minutes to 30 minutes, it might start running for an hour. but you're gonna start another task and you're gonna go through that same process of like, let me work with an agent to decompose this task in a way that makes sense.
[00:22:45] Zach Lloyd: let me understand. What the agent is proposing. And so I think this is one of the other failure modes. As I, as I work more and more closely with these tools like Warp or Cloud Code or Cursor, I, I've, I've worked with them all [00:23:00] like a real failure mode. If you're a real developer, using these tools is like, set them free and, and you come back and there's like.
[00:23:08] Zach Lloyd: Thousand lines of code written, and you're like, I don't understand why it did this. This is, we could never check this in. Like maybe it kind of works, but it's like this was a waste of time. And so these tools are gonna have to become really good at explaining their thought process to you and making sure that you as a developer are not just like doing dumb stuff.
[00:23:29] Zach Lloyd: Like, you know, there's a very high risk of shipping bugs or shipping security issues. And so they're like. Explanation and comprehension piece of it I think is really important. Um, but you're gonna be working closely with these agents, almost like they were like, you know, I don't like to anthropomorphize it too much, but kind of like, they're like, like teammates a little bit.
[00:23:50] Zach Lloyd: Uh, and you're gonna have multiple of them going. And the net effect to you as a developer is that it's gonna be a. A multiplier [00:24:00] of what you're able to get done. It just, it truly will be, um, it's going to make you do harder work. I really think in the sense of like, you're gonna have to use your brain to do the stuff that the agent is not good at doing right now, which is like good abstractions, good system design, good performance, making sure code goes into the right place, but you're gonna let the agent.
[00:24:26] Zach Lloyd: Write a lot of your code, like you're not gonna be typing code very much. I don't think, uh, you're not gonna be typing commands very much. You're gonna be thinking more and like guiding more in English. And so I think that's the workflow that's coming. And so then as a someone who's building tools in this space, what we are trying to do is build the right set of tooling to support.
[00:24:54] Zach Lloyd: That workflow. And I don't, like I said earlier in, in, in this conversation, I don't think [00:25:00] that tooling exists. I don't think it's the IDE, I don't think it's the terminal. I don't really think it's something like, um. Devon or like these things that are like autonomously running around your code base. Not today at least.
[00:25:12] Zach Lloyd: Maybe, maybe those work for very simple tasks, but because you need the developer's brain in this deeper way, I think it's the tool that like best allows the developer to do kind of the hard thinking in the orchestration, uh, to get the results they want.
[00:25:29] Andrew Zigler: Yeah, you're touching on the skills. To that developers will need to embody to, be better developers. And we've heard this from a lot of folks on Dev Interrupted. Dr. Ashoori from IBM
[00:25:41] Zach Lloyd: Mm-hmm.
[00:25:42] Andrew Zigler: about the new skills that developers will need to, to have. And really it focused around, you'll become a decision manager more than an action doer. Which really aligns with what you're talking about in terms of setting these agents off to do their tasks and you're not really writing the code, you're understanding the abstractions and the end result of
[00:25:59] Zach Lloyd: Yeah. [00:26:00] Yeah.
[00:26:00] Andrew Zigler: So it's like a new, uh, a new skillset really. Um, it's really can be night and day from some of the skill sets that traditional engineers or engineers until now have been, have been building. Are there other skills in that toolbox that you think are really, uh, critical for folks to start building as they start kind of moving up the food chain?
[00:26:19] Zach Lloyd: there's the foundational stuff that you, you get in. When you study computer science or you study math, or basically study anything with like a, like rigorous reasoning, I think like problem solving is your number one skill still as a developer. It's just like, it's like where in the, where in the stack are you doing that?
[00:26:43] Zach Lloyd: Like back in the day? You know, you were, you were doing it with Assembler and then along came like C and then came c plus plus and then came Java, and then Python, and then JavaScript and like the, the distance from the [00:27:00] metal, increased. But the fundamental like skills of like logic and problem solving and just like reasoning through tasks, that's a constant thing.
[00:27:11] Zach Lloyd: And I, I don't see any world where that it goes away. And if anything that's like more and more important. Can you see the big picture? Can you see how pieces fit together? So that's like big, big picture way more tactically. Um, I think like you're gonna have to learn how to use this new tool set. and that's like,
[00:27:34] Zach Lloyd: again, I don't wanna overemphasize that 'cause I don't think like a developer is like defined by how well they can like use their IDE or the terminal or something. But you, there is an actual skillset in, in how do you, how do you prompt, how do you decompose problems in a way that that. The models are good at doing bite-sized pieces of them.
[00:27:57] Zach Lloyd: This is all like totally new territory, [00:28:00] um, where it's like there's no real best practices. No one is learning how to do this, but uh, you know, kind of. I, I, I would imagine that similar to like taking like a high level programming class, at some point you're gonna take a high level class or course on like how to effectively work with AI to build systems.
[00:28:20] Zach Lloyd: and so, you know, I, a lot of people miss that. I think like a lot of good engineers will have their first experience with AI be something like, they hit some issue and they're like, okay, I want you to fix this thing for me. And like, they'll literally prompt it like that and like, that's not gonna get the job done, uh, any more than like, you know, like you, you have to
[00:28:44] Zach Lloyd: explain in a lot of detail what it is that you want done. Uh, in order for it to do it, it can't read your mind. Uh, it's not like magic. And having that kind of bad experience I think has led people to believe that the technology is, [00:29:00] is useless or it's like it's not there yet. And like there's some truth to that.
[00:29:05] Zach Lloyd: you know, even I think if you tried. Working closely with ai six months ago, you would find that like, Hey, it's not quite ready. Uh, but the, the rate of progress is like so fast. Um, that, you know, having one bad experience like that is like, uh, you have to get past it. You have to learn how to use the new tools and, you know, you have to kind of do like a continuous education thing because the power of the tools is changing very fast.
[00:29:30] Andrew Zigler: what you're touching on is so true that folks who use these kinds of tools, maybe like six months ago and didn't have a great experience, never revisited them. Their mindset about what they can and can't do is fundamentally just. The, it's an, it's a, it's an era behind, it's a decade
[00:29:45] Zach Lloyd: Yes,
[00:29:45] Andrew Zigler: terms of how far,
[00:29:46] Zach Lloyd: is crazy. The rate of progress is remarkable. Yeah.
[00:29:50] Andrew Zigler: of progress is remarkable. And then the need for continuous education is just profound. Like, it's just like you need to be a voracious learner to be a developer now. And, [00:30:00] uh. What advice would you give to one of those folks who maybe, uh, tried one of those tools and have a good experience and they're just like, you know, maybe they're a skeptic now, or, or they don't know exactly how to, to get started. What, what would you, what would you say to, to get them back into the mix and trying out a tool like Warp?
[00:30:18] Zach Lloyd: Yeah. So f first off, it would just be like an open-mindedness I think is really important. approach it like a tool. So like, I think that that a thing that turns a lot of developers off to this stuff is, it's overhyped. It's like you see all of these Twitter demos of it doing stuff and they're like, yeah.
[00:30:42] Zach Lloyd: Right. Um, and so, so view it as a tool. It is my first, is my first, uh, thing. And so, and what does it mean to view it as a tool? It means that, there's like some, um, responsibility of the user of a [00:31:00] tool to learn how to use it well. So it's like, you know, you wouldn't like open up Vim and be like, well, maybe you would.
[00:31:10] Zach Lloyd: Like, I, I, I would open up Vim and be like, what the heck is this? But like, but like,
[00:31:13] Andrew Zigler: how do I exit? How do I close
[00:31:15] Zach Lloyd: or, or get, or whatever. It's like there's a learning curve. And so approach it from the standpoint of like, Hey, um, I'm gonna try this. I'm gonna need to learn how, how to use it. Um, I would say realize that the, it's a kind of weird tool in that it's like got like a sort of stochastic quality or like a random quality to it.
[00:31:39] Zach Lloyd: It's unlike any other, tool that you use that's like purely deterministic, whereas AI is, is just not fundamentally, there's like a, I mean, it is fundamentally a function I guess, but like you have to use it as though, as though there's like an element of randomness to it, which is kind of a foreign experience for most, uh, for [00:32:00] most developers.
[00:32:00] Andrew Zigler: Yeah.
[00:32:01] Zach Lloyd: would recommend like seeing if there are people on your team who are using it successfully and like learning how they're using it and having them. Share prompts that they're having success with, share tasks, share how they like, what their workflow is. there is a lot of good content online on this.
[00:32:22] Zach Lloyd: Like I even, I'll, I'll plug, I do a live stream where I try to use AI to do real coding, pro problems, not like, um, like one shot. Marketing websites, which I think is like a lot of like what the, what people have seen. Yeah.
[00:32:41] Andrew Zigler: Make, yeah.
[00:32:42] Zach Lloyd: Yeah. And so I think seeing that type of development where it's like, I'll be like, okay, I'm gonna go one step here.
[00:32:50] Zach Lloyd: I'm gonna have it write tests, I'm gonna verify that the API looks good, then I'm gonna go to the next step. And so showing how you can use it to break down a problem, that would be my, my [00:33:00] advice. And then you just like recognize that the stuff is changing super duper quickly. And so, you know, you may have tried it and, and it's.
[00:33:08] Zach Lloyd: It's, it's really much better now and we'll probably be much better six months from now.
[00:33:13] Andrew Zigler: yeah, exactly. Um, I, I love too that you learn in the open that you have a live stream where you kind of hack around with these tools. People can get a glimpse of your, of your thought process. I, I think, which I think is most critical, almost like the body doubling of, I'm gonna
[00:33:26] Zach Lloyd: Yeah,
[00:33:26] Andrew Zigler: developer use this tool.
[00:33:28] Andrew Zigler: Like,
[00:33:28] Zach Lloyd: totally.
[00:33:28] Andrew Zigler: gonna critically fail for this, for this guy. And
[00:33:31] Zach Lloyd: No, and it, and it, it,
[00:33:32] Andrew Zigler: fix it,
[00:33:33] Zach Lloyd: and it fails for me all the time and that's.
[00:33:35] Andrew Zigler: the time.
[00:33:36] Zach Lloyd: That's okay. Like at the end of the day, I still think it's like a, uh, an a net gain when used properly.
[00:33:44] Andrew Zigler: You know, as we start to kind of wrap up our conversation, we've covered a lot of ground about what you've been disrupting, what you've been building, the skillset of developers of tomorrow. I'm wondering from your perspective, are there any kind of like. Top level points that you'd want to end on if talking [00:34:00] about like how developers will orchestrate with agents of tomorrow. Perhaps there's something that you see about the future of development that you think a lot of your peers are missing or are maybe not quite on your level to, uh, in terms of understanding where it's gonna go. Any kind of, uh, points like that, that you'd like to end it on.
[00:34:19] Zach Lloyd: I think one big point that, um, is maybe overlooked is like. This is a real change in behavior, um, that we're asking developers to make. Uh, I think there's a lot of like, thought of like, okay, you've, you put these capabilities out there, you, you do demos online. Uh, that developers will just overnight change the way that they work.
[00:34:47] Zach Lloyd: Most developers are not working with agents right now. The extent of most developers use of AI right now is auto complete, which is a great feature. but I think [00:35:00] it's fundamentally gonna become obsolete, uh, as developers move to a way of working where they're not doing so much stuff by hand. They're not editing or coding by hand.
[00:35:12] Zach Lloyd: And so from a product standpoint, what I think is really interesting to explore is like how do you meet developers where they currently are in their current workflows? So whether it's in the terminal or the IDE. And like get them without beating them over the head. Like, you need to work with ai. You need to prompt, but get them to want to do it and get them to have that experience of like an aha moment that this is actually fun.
[00:35:41] Zach Lloyd: That this is actually like a cool new way of solving problems. That this isn't like a thing that's competitive with me. Um, 'cause I feel like there's a lot of like. This is gonna take my job. This is gonna like, replace me. I, I have just the opposite experience at this point, which is like, this is [00:36:00] super fun.
[00:36:00] Zach Lloyd: This is like a, I'm playing a game of like trying to get, this like alien brain to like help me do my work. And it's like a great puzzle to solve, which is like one of the things that I love about coding to begin with and development to begin with is that puzzle solving nature. And so. You know, I, I'm, I'm just trying to think for Warp, this is a thing that's very top of mind for us of like, how do we get developers to have that experience of like, this doesn't suck.
[00:36:30] Zach Lloyd: This is actually fun. This lets me get more done. This lets me focus on like, stuff that I want to do, and get them to. Experience that as opposed to be told that they need to start working in that way. So I think whoever's gonna be really successful, um, in this new like product space is gonna be, uh, a product that like, gets really good at that 'cause, 'cause that changing developers behavior is really hard and I know that from, from being in this space for a while now.
[00:36:59] Zach Lloyd: And [00:37:00] the best way to change their be their behavior is to just like give them the experience of the new thing and then have them want to change it. So that's my last thought.
[00:37:09] Andrew Zigler: Amazing. Well, that's really well said, Zach. And you know, we've covered a lot of ground here about how Warp is evolving to meet those new needs of the developer, um, and kind of re-envisioning the whole developer experience. And I can't think of a better note to end on than to say that, you know, you have to get folks excited about where this is going, and you
[00:37:26] Zach Lloyd: Yep.
[00:37:27] Andrew Zigler: that internal momentum, not by saying this is how it must be, but seeing this is how it.
[00:37:32] Andrew Zigler: Can be and
[00:37:34] Zach Lloyd: Yeah,
[00:37:34] Andrew Zigler: a better world. And, and I think that you said that really well. Um, and, and for folks that are curious about like what we talked about today, where can they go to learn more about Warp and what you're building?
[00:37:43] Zach Lloyd: just go to warp.dev. Um, you can download it. It's, it's totally free to get started. You can watch videos on it. Um, you can check out our YouTube channel if you wanna like, see us doing interesting stuff and learn more about the product before you try it. But yeah, that's [00:38:00] it.
[00:38:00] Andrew Zigler: Amazing. Well then we'll drop those links in the show notes so folks can check it out. And to you, if you've been listening, you know, um, this conversation is a one part of, of a long saga conversation we've been having on Dev Interrupted about how the developer experience is evolving, how people are using new, tools to get more work done.
[00:38:17] Andrew Zigler: So, if this is something that is really interesting to you that you're working on, on your teams. You know, Zach and I want to hear about it. So come on LinkedIn and tag us about today's episode. We're, we're posting this episode on Substack and LinkedIn. It's really easy to give us a, like a, a, a notification and let us know what your team is doing that was successful or unsuccessful, or what your own personal experiences were around using these kinds of tools because. When we're all having conversations about it, we can all get better informed about where it's going. Um, so thanks for joining us for this conversation, and we'll see you next time when Dev Interrupted.
[00:38:53] Zach Lloyd: Thanks for having me. This was awesome.
