The Changelog: Software Development, Open Source - Exploring with agents (Interview)

Episode Date: April 24, 2026

Today on the show I’m talking with Amelia Wattenberger — designer, data-viz veteran, ex-GitHub Next, and now designing Intent at Augment Code. What if the last 30% of any software project is about to become the hardest part you’ve ever done? That’s the argument Amelia is making today. We discuss the identity crisis developers are having as agents take over the keyboard, the epic redesign of developer tooling in this agent-first world, the arc from autocomplete to chat to CLI back to UI, why Intent treats a workspace as their core primitive not a chat thread, the tradeoffs between one-worktree-per-agent vs. one-worktree-per-task, and why she thinks prototyping just got easier but finishing got harder.

What's up, welcome back to the change log. I'm Adam Stikoviac and it's been a minute. I've missed you. You know, sometimes you have to retreat to attack. I said that before in this podcast, how can you push at sustained high output thresholds when you need to slow down and check yourself? Get centered, get focused,

and then get back in a groove and do your best work. Rest assured, my friends, the change log is here to stay. Nothing's changing. and I'm working on some really big ideas, and I cannot wait to share them with you. Today I'm talking with Amelia Wattenberger, designer, datavis veteran X GitHub Next, and now designing intent at Augment Code.

What if the last 30% of any software project you're working on is about to become the hardest part you've ever done? That's the argument Amelia is making today. We discuss the identity crisis developers are having as agents take over. over the keyboard, the epic redesign of developer tooling in this agent first world we're in, the arc from auto complete to chat to CLAV back to UI,

why intent treats a workspace as their core primitive and not a chat thread. The treeoffs between one work tree per agent versus one work tree per task, and why she thinks prototyping just got easier, but finishing got harder. A massive thank you. to our friends at Fly without them.

This pod would not be here. They're such good friends, great partners. We love them. Check them out. Use them. We use them. Fly.io. Okay. Let's talk to Amelia.

Well, friends, I'm here with a good friend of mine. Michael Greenwich, founder and CEO of Work OS. Michael, Offer Agents. I feel like this is burgeoning. It's kind of happening all of a sudden. What's the state of the world for author agents? Yeah, it feels.

like author agents is one of those things that nobody knows what it means, but it's very provocative. Everybody wants to talk about it. Practically speaking, I think there's two things here. The first is when you say author agents, you're talking about how do I get the data into an agent that it needs to be able to do its job? And for that, we built something called Workless Pipes. It's actually more of an integrations product. It helps you take your agent and connect it to your customers, Google Drive, and connect it to

Salesforce and HubSpot and connect Slack and all the other stuff that they're going to use and do it in a way that's safe and secure and managed. That's one type of off for agents, kind of data access off. The other type is actually authorization. It's like permissions for what the agent is going to go do because you connect it to all these systems, but then you say what capabilities does it actually have? How can I restrict the agent behavior

so it doesn't go off the rails and go do a bunch of crazy stuff? That's a lot of stuff we're building today. We don't have a product announced yet for that, but we've been working on it. The third, I would say, is probably the identity layer for agents. How do I identify an agent by its name? That's really coming from the enterprise identity systems that are out there. If you look at Microsoft's Entra agent ID, they're doing a lot of interesting work there.

There's also expansions to Open ID Connect and skim for agents. We're building all of this into the WorkOS platform. So if you're looking for an identity stack that will support agents, again, feature-proofing, WorkOS is a great place to go. But it's changing really quickly. You know, none of us were talking about OpenClaw, you know, like weeks or months ago. And that's a new paradigm, I think we're going to see not just within consumer software,

but in the enterprise too. So it's an area of very, very rapid development. Well, it makes me think about agents versus people, not negatively, but this world where we'll have more agents than people. You know, today, if we have seven or eight billion people on the planet, in the future, we're going to have trillions of agents going off and doing things. And so the challenge around identity and authentication for, agents is actually significantly bigger than just how people interact.

In the same way like GitHub isn't going to work super well for agentic coding because you'll have so much more code getting written. The same is true for identity and permission and logging systems when agents start doing stuff with it. So we're building for that future today. All right friends, the next best step is to do what I've done, which is use off kit. Okay, that's how I authenticate my CILs, my APIs, my applications, all that good stuff. WorkOS.com is where you go. Try it out today. A million users with AuthKit for free. You can't beat that deal.

It's literally free. Again, workOS.com. Try it out today. Friends, I'm here with a friend, JS Partier slash friend of the developer world, Amelia Wattenberger. It is my first time actually, I think having a deep conversation with you. So I'm looking forward to this very much. We come from simple. Routes of desire. I haven't been to the labs you've been to in the, the GitHub next as you've been to in the depths that you've been to. I love the visual design you've done in the world and I've always been a fan of yours. So finally having a chance to go deep with you is a joy. So thank you for coming and welcome to the show. Yeah, happy to be here. It's long overdue. It is long overdue. I wonder why we haven't done it sooner. We always say that right. When we do the fun things in life, why didn't we do this sooner? every single time. We're just too busy working, you know. It's too much work to do.

I do want to understand how you're looking at the world we're in right now because there's some change if you didn't notice, Amelia. What do you feel about this change? I know our audience is like, gosh, can we get done with this? I don't think we can. I think it's here to stay. Yeah, yeah, a little bit of background about me that might inform my perspective. So I come from like design development database background,

and I joined the GitHub Next team, which is like the R&D team at GitHub shortly before we launch GitHub copilot, which in a lot of ways feels like the beginning of this craze. It does, yeah. I agree with that. And so I've been paying attention to this space pretty closely since, gosh, what was that, 2021, 2021, 2022. and I don't remember.

And it feels like things have been accelerating as far as like how quickly things are changing and how receptive we are to that change. But also if you take a longer view, they don't feel like they've changed that much, right? It's been like four plus years. And there has been like a pretty coherent. an arc of like first we did auto complete then we were like we want to have chat conversations chat GPT came out um let's ask agent let's ask not even agents let's ask LLMs about our code bases um and then we gave them tools right and they started writing code for us and then we moved to the CLI and now we're kind of in this like let's go back to the UI and apps arc um

but like over four plus years that's not that much change to have happened. I do think it's accelerating. So for like the first three years it was like, okay. So what are we doing? Are we actually changing that much? And now it feels like, oh yeah. We're like, we're like. Yeah.

But like it is important to take a longer view of it because day to day it feels exhausting, right? There's five new things every single day. So it's good to have a little bit of a, weight is actually changing that much that quickly perspective. Can you expose the insides of GitHub next and what brought on co-pilot

and what brought on this world? I do agree with you that that feels like the first version of this for developers was autocomplete from GitHub copilot. And really a lot of pushback even from GitHub and Microsoft for open source code

and training models. was like the first thing was really less about what we can do with it and more about why did you do this with our code, damn you, GitHub, Microsoft. So you were on the inside of all of the lab work there, the beakers, pouring things and things blowing up and maybe not blowing up. Take us into that world.

Yeah, so I don't want to claim like any ownership or like intellectual ownership over copilot because I joined like right when we launched. Like I helped with the launch. There are some interesting things. that are part of my experience of that time. There was a lot of pushback initially, even internally.

And then the first users, every time it was introduced to somebody, they're just like, yeah, we have auto-complete, right? Like, it's just better auto-complete. This is not very exciting. And then, like, a day, two days after anyone started using it, it's like, whoa, this is actually very different, right? Because mechanistically, it's not so different than the tools that we already had.

But in practice, it's very, very different. And I think, like, those earlier days in AI, there's way more pushback of, like, do we really need to do this? Look, we have so many things to do as a business at GitHub. Like, let's focus on those things first. This was GetUp Next, though, right? Like, wasn't this a product of that? Or did it come out of research from GetUp Next?

And wouldn't the next thing? I remember having conversations about that early on. Like, that was the whole point, wasn't it? Like, to do research and to do exploration? Yeah, exactly. So Get Hub Next was kind of formed around that time. It actually started as the office of the CTO before Jason Warner left. That's right.

And, yeah, that was kind of, those are, and those still are the marching orders of like, just like explore, right? It's one of my favorite places that I have worked where it's just a lot. It's quite a small team, maybe like 15 people and just like very experienced product engineers, researchers who all have these different backgrounds that just bring a lot to the table. and then you have this really nice Venn diagram of ICs of individual contributors who just really know their stuff, but they know different stuff. And they have some overlap with each other. So you get to figure out what to prototype and make squads. And it's very like autonomous. And, you know, what do you think comes next?

Let's explore that until we convince ourselves that it is or isn't the next thing. So I have a lot of love for that, too. What was your role there? You were doing a lot of data visualization, which is such a long word to even say. I don't know how you can say that perfectly three times straight, fast. I know I would struggle there. But nonetheless, it is very cool and it is very beautiful. What was some of the things that you did there to contribute and things that you really enjoyed doing? Yeah, what projects did I work on? In the beginning, it wasn't all about AI. So we did some fun, explorations. around like making data easy to work with and how does that loop into actions? Like how do you have these like how do you handle? Like get up actions you mean or do you mean actions in general? Yeah, get up actions.

Okay, cool. Get up actions is one of the coolest pieces of tech ever, honestly. It is so inventive. It's one of those things that once you use it and you really, really appreciate it and understand it and you examine it, you're like, wow, this is a very thoughtful piece of software. Yeah, yeah. It can be a little frustrating to work with because it's, you know, CI. But the way it was designed is actually quite elegant.

And it's actually really, really powerful. It's almost like separating compute from storage in a way or the way that you do that in distributed computing, you know, where you have the platform itself and then the runners. you sort of separate the engine that is the smarts, the if-then-else kind of scenarios with workflows and whatnot. It's really just, I think it's a pretty wild piece of software. Yeah, and I also think a lot about the way it's integrated with the code base. Like this is relevant these days with like agent rules, right? Like what goes in the code base and what doesn't?

And like what should be coupled with Git and Git branches and what shouldn't? And I think the way actions work, where they have to be checked into the codebase, is really nice because you get a lot of power out of that. So it's something I think about a lot. Let's go back to exploring, because I agree with you. What do you think about this world we're in right now? I feel like personally as a developer, what I'm doing is a lot of exploration. I feel like everything I build makes me build one more thing to make that thing smoother, better, whatever. and now I can because I have superpowers.

And so I don't feel encumbered by what I know. I feel unencumbered by what the agent knows. And I feel like every time I hit a problem, like, gosh, could somebody just solve, wait, hang on a second, let me solve that. Let me see if I can think about that a little bit because much like you, I have this product manager, user experience and design background that I don't really, that I haven't, you know, I use day to day, but it's not on my, the front and center of my resume, so to speak, because I've been a podcaster and software developer for so long,

that I've sort of left my roots in a way from the public eye. But internally, all Adam thinks about is design, intense, specification, how things should work. Why does it work that way? Oh, my gosh, a user would just be so frustrated by that. And so that, therefore, I have tastes that I just can't seem to let go of. What do you think about this state we're in with exploration, being able to explore more with software? Yeah, it's really empowering. Like, it feels like these agents are 80% good at doing anything, which really levels you up.

There's this concept I've been thinking about that I'm going to not put into words well, because these are kind of half big thoughts. But, like, if you think of, like, for any given thing that you're going to work on, if you think of the work linearly, right, like 0.0 to 0.5 is how. half of the work. Point five to one is all the way done. Right. It's linear because,

you know, that's the way we think about our work because it's been pretty static, like what takes a long time for a long time. And now that agents are here, they're kind of like blowing up that our expectation of how long things take and how valuable they are as a result. So that like,

what used to be, you know, 70% of the project is now like, you throw a prompt in the box if the prompt's good enough. And maybe there's some back and forth. You get 70% of a thing. Right. And like that number will go up.

But like that 70% has been squished into, you know, 10% of the project. And then that last 30% is actually really hard now because we're starting all these new things. I'm like, oh, I want to do A. I want to do B. You know, why don't we throw C, D, and E. because they're so easy to do. But then you have to at that point decide, like, do I keep going with this thing?

Because there's actually quite a lot of work to go from like, oh, here's like a kind of rough prototype to like here's like a polished version of the thing. And I've been very intentional and thoughtful about what it looks like and how it acts. And it actually feels a lot harder to do that because like you've stepped off the moving sidewalk, right? You're like used to going fast.

and then you're like, wait, no, I have to go slow again. And like, agent can't do this part for me. And it's really frustrating. And I have, like, six things that I'm juggling at once. So it's like, it changes the nature of things where as someone who's like, I love prototyping. It's like one of my favorite things. It's actually how I think of myself as a builder is I'm pretty much just a prototyper. Like, I believe very strongly that that is the way to get to.

really nice informed products. It's just like exploring within the medium. It makes that part way easier, which is great. But then it makes other parts feel a little bit harder. Yeah. In my opinion. Do you feel then that you, as a product type, do you feel like you, I mean, I've see your work, at least with what's in the public eye, maybe not what's behind the scenes

on your easel that's, you know, got to cover over it so nobody can see your painting kind of thing. I knew an artist at one point. I'd always peek in their studio. I always loved it because I got to see behind the scenes of what no one else got to see. And I got to see the unfinished, the exploration, oh, this was red. Now let me just paint over the whole thing again kind of thing. That's why I say that.

But I always appreciate that. But when we look at the way you prototyped, do you feel like it's hard to get to finished then, considering that? Or do you feel like you're in a place where, polish is just the hard part and that's the product in the end and that's the part that takes probably the majority of the time is like taking this thing that works for me or work for me in my scenario or my team's scenario to something that actually scales to multiple teams and is sign upable and usable and buyable and installable and instantiatable and all those things

Yeah, it's interesting. Like, how do you break that part down? You can break it down into like, like, polish and craft and like the art side of like, what it is, what is it that we think is valuable as a society is going to have to change because, you know, that 70% again is so easy that like, which also makes it hard to throw away, you know, you like throw in a prompt and it like builds a whole app for you. And you're like, this isn't exactly what I want, but it feels really wasteful. to throw this away because that would have taken me a long time.

Oh, yeah. We become hoarders in a way, right? A little software hoarders. Yeah, exactly. I got some software hoarding going on over here. So I'm empathizing big time. I've been running out of disk space. A lot.

You must write a lot of software. That's a lot. I tell agents to write a lot of software. Gotcha. So like that, like our impression of the valuable, like how valuable that. that part is is going to change. And then like what do we think is valuable as a society and what do we want to pay for? Like there's questions around that. And then there's also questions around like, how do you get it fully functional? Right. Like if I ask an agent to make a game or make like an

infinite canvas, there's usually like a lot of iteration and back and forth or just like manually getting into the code to get things like really feeling nice and working functionally. And like, I feel like those are the two hard parts that are left in that like 30% of like polish and finishing up. You know, the last 20% that is the 80%. Yeah. You know, I think polishing a product and delivering it to folks is actually the hard part. I feel like I've been building a lot of personal software and I'm kind of okay with that. I've been in a way feeling guilty for not releasing some of it to open source.

But I'm like, well, then I would have the burden of a problem. open source and maintainership, which I don't mind if I plan to, if my intent is to make it a product and give it to others, which I would like to do, given infinite time. I think at some point maybe agents can solve some of those challenges as an agent maintainer in a way, potentially. I just don't have the time to release it as open source and deal with potential issues or just somebody else's problems where they want to contribute a different direction. I'm like, hang on a second. this was a personal project. It's a USB stick on my curb. I gave it to the world.

It is what it is. It's open source, not open to contributions. I don't know if I want to be that guy either. I don't know if I want to be that person. I'm like, not invited. Can't contribute. So I just sort of just like hold it back. How do you feel about the state of the world?

Do you feel like every developer is in this version of a predicament? Yeah, the open source thing is really hard. There's the question of like, because these agents are getting better, how valuable, like, how does that change, how valuable open source projects are and, like, you know, NPM packages, which is kind of interesting. There's also, like, can we make it easier to do open source, right, to, like, maintain an open source project? You asked previously about what projects I worked on at GitHub Next.

And one of the things that we worked on was called Doc Pilot or Coblet for Docs, I think, is what we called it in the end. And it was like an early exploration of RAG, essentially, where we would index open source codebases and then have these kind of like chat or bespoke docs where developers can come in and say, like, I'm this type of developer, I'm good at these things, I'm bad at these things where my experiences are really,

we could like check their GitHub to see what they're really familiar with. Can you answer like this question about, the docs or do a walkthrough for me knowing who I am as a person and what this what this code base is. And there were some really interesting future directions, possible future directions around like, can we actually just make it easier for open source maintainers? Because like writing docs is usually not the highlight of what they do. It's like this tedious annoying thing that they have to do. and once they write the docs, they're stale.

So there are interesting, like, directions around we can automatically write these docs. And then if there are things that aren't fully explainable from the code base, we can just email the maintainers, right? Like, we can just interview them whenever something comes up where there's a gap. And so they wouldn't have to go, like, make a dock site. and write all the content. Instead, it would be auto-generated, but also be grounded within the code

and be grounded within their answers. And I think, like, you know, that was two, three, three and a half. I don't know. It was a long time ago. And, like, the things that we can do now feel even more crazy, right? Like, you could imagine being able to open source something and just, like, basically not having to maintain it. right? Like the docs are written up. Like you have agents like figuring out whether they should

update it in a way that users want. I saw one of the AI coding apps added like a feedback form that was like suggest a prompt for the codebase. So if they liked the prompt, they were just like throw it in an agent and then you know, polish it up and that's a new feature for the app. Like it feels like maybe we could you could do the same thing with like an open source library that like is kind of like community grown because agents are doing a lot of the the hard work of like maintaining the code and like aggregating across a lot of qualitative data which is users asking for things like it feels like we could push that pretty far in an interesting direction yeah yeah i think there's a lot of influx to open source

now, but then I, you know, when we're talking about this subject, I'm thinking about the things I'm making and while it's not polished, maybe it would be useful to somebody else. Maybe my design thoughts and traits and tastes actually translate to, you know what, I know I could generate that, Adam, but I like the way you thought about it. So maybe it's more of a personal solution to how I solved a problem or how I think about problems and how I break them down. I've mentioned on the podcast a couple of times. I don't know if you know about this, but I've been working on something I've got called Agent Flow. And it's not at all like intent, which we'll talk about here in a minute from Augment, friends of ours at Augment, but, and something you've, you know, you've designed. But, you know, I've thought about this problem of how can we, how can we as technologists build software? And I keep thinking about like a knowledge base. And the language of the agent is very much. markdown. Like I never thought I would care about how much marked down. And like you were just saying about

developers don't want to write docs. I'm like, you know what? I kind of like writing docs now, okay? It's like it's my ability to control that future in a way. Like if the doc says this thing or if the spec says this thing or I've adopted the way Python directs itself with PEPs. Python, I think they're called Python and Henswell Proposals. And I just swapped out Python for projects. So they're called project enhancement proposals. And that's where the work gets done. You know, so if it's a specification, it could be some research, it can be a knowledge-based article, it could be, I even have my agents write blogs.

I call them builder logs. It's so cool. When we're done with a journey, I'm like, hey, can you just write a story about that? And I use it to learn because I'm often exploring places where I don't know a lot and I need to get caught up. And I'm the kind of developer who just wants to sit there and say, just do all the things, to magical way and don't have any understanding. A lot of the reasons why I'm building software isn't just to build the software and solve the problem.

It's to understand the software that should be written to get there. And maybe in the future, that doesn't matter. But all I say is that I think a lot about this process of getting to good software. And I question, you know, is my software worthy of open source? Does somebody else want to use my stuff? And how will open source change when essentially, generating a solution, whether you have taste or not, is the closest version of free we've ever had.

Yeah. One, I want to check that out. That sounds really cool. Also, you're really good at naming things. Asian flow is cool. Two great gems in there. And two, just like, what does the world look like when we have software on demand and, I don't know, software too cheap to meter?

I think whenever I think down the path of like, oh, what if software is just instantly generated on the fly, I always come back to like people don't want to make all of their software, right? Like I don't want like a blank phone and to be like, oh, you know what? There's folders and I have an app where there's like emails in here, right? Like I don't want to have to think about that. I want like these smart defaults or like tasteful things that I've decided that this is the way I want to work because I see it out there in like it's fully fledged form, right? Like doing a lot of abstract thinking and projects talking about abstract things is really hard because you can say words and there's a picture in your head. And then the person you said those words too has a completely different picture in their head. So the farther you are away from something tangible and something fully fledged, the harder it is to communicate about, even if LLMs are so good at English and language.

So like there's got to be some room for taste and like opinions and like having proposals for the ways things are put together and how software works in that world. and like maybe things look more like some kind of like remix culture, right? Where I say like I want to use atoms and then like I can change it, right? Like I can change it on the fly. But like I don't want to go from like zero to one all by myself. I want to like go from 0.5 to 1. I want to go from 0.5 to 1. I've thrown a lot of numbers around and I don't know that they all make sense.

Well, you know, zero to 1 is a one term. I like 0 to 0.5. That's because that's where I feel I'm at. like a lot of my things are at 0.5. And 0.5 is usable by Adam. And Adam likes it. Okay. Yep. I like my stuff. You know, I'm constantly working on it. Hey friends. I'm here with Dan Mangus, co-founder and CEO of RWX. Dan, what makes RWX and the way you're doing CI so different and interesting to our audience? You know, obviously we're talking to you because we want to promote what we're doing.

We want more engineers to become aware of what we're doing at RWX. But I think the thing that's interesting to me is that R2X is really kind of the first major evolution in CI and the approach for CI. And this is just highly relevant with agentic driven coding. You know, CI has largely been the same since the advent of the practice. But these platforms were created when being able to run code in the cloud was really valuable. The fact that you could spin up virtual machines that would run some automation on a Git push was, you know, really impactful for engineering teams trying to like build good developer processes and tools. But that's kind of the extent.

What we've done at RWX is we've taken state-of-the-art techniques used in build systems at organizations like Google and meta. You know, Google has their internal build system blaze and inspired the open source Basel tool. But every engineering team I've talked to that wants to adopt Basel who just found it extraordinarily difficult to use and configure. You have to have a dedicated engineering team

to build and maintain the rules. It's hard to extend it to work with different types of languages and frameworks and engineering teams are looking to adopt. So it's been too prohibitive to actually adopt those technologies. But the ideas behind Basel are really impactful. They're similar to a lot of the ideas behind Nix. I would say NICS is kind of very similar in the difficulty to adopt. And effectively what we've done at RWS,

is we've taken those techniques. We've made it very easy for engineers or agents to actually adopt and utilize those, which namely are the automatic content-based caching, and the graph-based task execution, which means that RWX eliminates all redundancy. Whereas other platforms are having to run the same setup steps on the same jobs

in every virtual machine that's spinning up, RWX can run the setup once on one machine and then fan out accordingly based on just your dependency graph. So effectively with RWX, you never have to think about parallelization at all. On other platforms, it's always like, well, do I add this onto the existing job? Do I make a new job for it,

then to duplicate all that setup. With RWX, you just define the tasks that you want to run in the dependencies between it, and we will run it with maximum paralyzation based on your dependency graph. Well, friends, a good next step is to go to RWX.com. Learn more. Check out CI in a whole new way. Once again, RwX.com. I was telling you before that I feel like I get so far into one thing I'm trying to, like,

get it to be usable by the masses. But to get there, I've got to solve some more. other problems. So one thing I did recently was I created this thing called Gauntlet. I just bought the domain and it's going to send my software into the gauntlet. So rather than CI, it's really like a battle tested ground. There's ephemeral Incas containers involved. There's which is, do you know what Incas is, Amelia? I do not. This is the coolest new thing, by the way. It's not new. It's Canonicals LXD re-licensed because they had a license challenge and one of the original

creators, maintainers is a part of that. Forked it happily. Stefan, I forget his last name in the moment, but Incas essentially is system level containers and virtual machines. So think of like a hypervisor where it can instantiate an Lexi container or a VM

pretty easily on something like ProxMox, something like that, but super, super fast and built on top of ZFS. And just phenomenal piece of software. And so here I am trying to solve this one problem. And then I'm like, I get so shiny object, right? Shiny objected. And I have this idea to like turn my code base into a sandbox.

And I have a virtual machine over there on ProxMox. I'm like, listen to Agent, let's just build out a sandbox. And Prad is Proud and Sandbox is sandbox. And maybe the developers who have been down this road, this is like normal. For me, I'm like, okay, this is a brand new world. Let's figure out what sandbox feels like. We can break everything in here. We can tear it down and build it back up again.

And in fact, that's what we want to do because if we can, that means prod is a femoral in a way. And we can get back to zero or get back to one quickly. And so as I'm building this thing out and doing all this stuff, I'm like, there's a product here at him. Because like, I want to do this not for just this software, but for other things I'm working on. And so I started to get into this point where like, I stopped working on the main thing, you know. And now I'm over here working on this side project, this side quest that actually is really, really cool. So that's it. Like, that's what's happening.

I was like, I'm trying to go this direction. but I get shiny opted and now I'm over here building a side quest that's kind of cool. Are you doing things like that too or is it just like you just go straight and you're good? There's no straight in my role. There's no straight. Gauntlet sounds very cool. There never has been and it's even worse now than it has been, right? Like it's so easy to build things that we're like doing it more and more.

So we wanted to talk about intent, which is the app that I've been working with with Augment. code. And a lot of the motivation for that is like we, there are existing problems within software development that like we have never solved. And we're kind of just accelerating things. And it's kind of like, can we can we just solve these first so we can, you know, accelerate faster? So there's actually a project I did at GitHub next called like workspaces or something where GitHub's fully remote. And this was right after COVID. And like, to work collaboratively with other developers has never been easy, right?

Like GitHub says it's like the social hub for developers, or at least they used to. But like we don't really work together before the PR. Like before that, we're kind of just in our own heads. Is that right? PR's is where it happens. In my experience. Yeah, I guess the old way.

The new way is not so much. That's why it's surprising, I guess. It's like I guess I've been so steeped in this new way. I'd forgotten the old way that nothing happens until PR. If you're talking about agents or other other, like do you work with other developers before? No, I mean, a lot of it is not collaborative. I mean, in open source, yes, other developers, but that's usually the potato over the wall. It's not a lot of like team collaboration getting to X.

It's more like, you know, solo getting there. Which is weird, right? Like, it is. Like, especially if we work on, I know, as a lone wolf developer,

I kind of like it. But like, things should be shareable, right? Like, especially teams working on the same feature. We're doing all this like, duplicate conversations in Slack that,

like explaining the code that we're writing locally. And like there have been a few stabs at it and Replit kind of does this a little bit. But like, by and large, um, you know, typically a project is like, I have a Slack conversation.

I have a linear issue. I have a GitHub issue. Maybe there's a century bug. I look at it. I talk about it. Maybe I put comments on a doc in Notion. And then I make a branch in my like local VS code. And then I write code on it and, you know, the outputs in the browser.

And then like, oh, wait, I have to work on this other thing. So I like commit it and I put the branch down. And then I like go work on, you know, feature B. There's a like, you know, there's a bug in prod. Oh, no, let's fix it. And then I like go back to my future branch. But it's like, wait, what was I working on? And like, what's the progress? And what were the conversations I was having around this? And like the proposal is just like, let's have a new primitive, which is a workspace where everything lives so that it's easy for me to put down and pick up and hand off and share. And like our work as developers is,

only partially code. A lot of it is just like context integration and testing and all these other things. And so like let's build a primitive that works with that and stop pretending that everything's code all the time. All right. So that project was at GitHub next. And now it feels like I'm just watching things and like collaboration is even more important now because the same tools that would make things that collaborative with other

teammates feel like the same tools that we need to work with agents where we kind of just need like a room for everything for a specific task so that like the agents all know what each other are working on and I know who made what change and like we're having conversations in in public where like I'm talking to agent A and agent B knows about it and we're all working off like the same spec and documents and you know like embedded web browser so that that was kind of the like core, the spiritual core of this new app that I've been working with Augment Code on called Intent, where let's like add this primitive of a workspace. And then now that we have that, so within the app, everything's a workspace.

It's not like an agent chat. Anytime you want to start a new task, you would create a new workspace. So you say for this repo, I'm going to add. My demo I keep doing is adding dark mode to my website. And then, you know, that has its own like Get WorkTree. It has its own set of agents. It has its own set of like rich markdown documents to explain all the context and the spec. And then because that's all isolated, I can like switch between adding dark mode to my site and like maybe adding a new blog post.

Right. And those can have agents like whole teams, swarms, whatever orchestrate. of agents going at the same time, and they don't get confused between each other. And then when I switch between the workspaces, I have the visual reminder of, like, maybe the browser is open or the spec is open. And I know, like, exactly, like, what the progress is and who's working on what. So it's a little bit of, like, a redesign of how do we want to work? And can we build an environment where that's easier?

And then to come back around to what we were talking about, it just makes it so much easier to work on, you know, the 10 things I'm working on at once. Like this last weekend, I was adding, you know, 10 separate features to this app. And it's still a little bit crazy making, but it's so much easier. Well, the challenge, I think, which you may have solved for, and if I, if I understand correctly, a workspace probably has its own Git work tree, which means it's not the same shared code base. It's a four, not really a true GitHub for kind of thing or a Get For saying, but it's literally it's it's a separate instantiation of the codebase with its own Git history that it pushes probably to to Maine or to a branch if you're branching.

That's exactly, you know, I was just thinking about this this week, really, with agent flow. It was like the next way to get to where you want to go, I don't want to swarm a bunch of agents, but I do want to work in parallel. I want to have a couple at least because there's things that that might require a CLI touch and an API touch, which are two different code bases. I want to keep the CLI maybe open source and the API is proprietary. Maybe it's source available.

So you've got different kind of layers to your product. While one agent is working on the CLI, the other one's working on the API, I'm actually working in a model repo that has multiple sub-repos because I'm trying to keep the agent in one repo kind of thing. Which I think now, Codex actually happily just goes wherever it wants to. Whereas Claude seemed to be like, you know what, I'm only here. Okay, if you tell me to go over there, I'm going to get confused.

This is me right here, wherever you instantiating me at. And that's a new word, instantiated me. Instantiumated. I like it. You know, just this idea, though, that that's spot on. That's exactly where it needs to be. because if I'm going to have more than one agent, we have to have more than one code base.

If they're stomping each other's toes, it's like two devs working in the same repo, trying to commit the same. It's like, no, that is not how it should be. How did you, I mean, it seems obvious, but how did you get to that realization from a technical standpoint and also from a design standpoint? Mostly just trying to,

constantly pushing the bounds. They call it the bleeding edge because it's painful. Right? Like trying to use all the new tools. And I, you know, I found myself running eight different agents at the same time, all working on different tasks. And like they step on each other just toes. And like they start accusing you of changing things. Right. They're like, you gotta stop changing this file. There's changes in that file. I didn't do just so you know, okay. Like it wasn't me. They're like, please stop. I'm not committing that. I can't own that. I didn't do that.

I got that one yesterday, by the way. That was pretty funny. Really? Yeah, I was like, okay, chill. I'm with you. I know the other agent did it. I should be smarter and have, you know, intent here and do, you know,

multiple work spaces and be smarter about them. So I'm just not there yet, okay? Stop yelling. I'm coming. Yeah, it is interesting. Like, the, so two things. two things about what you're talking about. One is like a lot of the like new explorations from the other tools are around a work tree per agent thread.

So each agent has its own get work tree. And that's actually not the direction we went down. We have one work tree per task. And there's kind of these pros and cons for multiple. multiple agents working on the same tasks within the same environment. That's kind of been like an interesting research exploration. And I find it actually works quite well, where as long as the agents know what each other is doing and are able to see like,

okay, these are the three other agents within the workspace and like this one's working on subtask A and I'm working on sub task B. You really don't run into issues. The one set of issues that we did see a lot was like, We have them auto committing. It's like a setting. So like you split a task into sub-tas and then you like, you say like you three tackle these three sub-tas like in parallel.

And then auto-commit when you're done. And because Git is like the way Git works is like you have to stage files or hunks and then write a commit message and like run the commands like that, they would step on each other's toes with that. So we added a tool for like queuing auto-commits. And other than that, like, you get all of the benefits of like, you know, one's working on creating a component, the other one's working on adding the component to the layout, or another one's working on like global style changes, right?

Like, you do want some of these tasks to be done within the same environment because, like, usually when you split things into tasks, they're inherently linked together and like, you know, API change as well as like another one's making the page, right? Like you need those to be in the same place and, like, you want visibility between the those agents. You don't want just like completely new cloud environment for all of these agents as they're working on the same thing. So like it's been interesting exploring like what do you want sandboxed at any given time? And on the other thing that's been really interesting is just like orchestration paradigms. Right. Like yes with our given tools it's hard it's hard to

explore any kind of orchestration like I actually had like a home cooked like parallel running system because I was doing large refactors where I was like, I'm going to make a markdown file and it's going to be split into 10 tasks and then I'm going to kick off like 10 agents in parallel because it works faster and I can use cheaper agents when it's all spelled out. And like it just like was not conducive to like actually exploring like how to make that really nice. but like if you have the primitives to like kick off different types of agents and they all have visibility into what each other is doing, there's some really interesting paradigm. So like our default paradigm within the app is a space, a workspace starts with a coordinator agent, which writes the spec. And then it delegates subtas to implementers and then it in waves. And then it asks a verifier to validate those changes. And it works really well. But there's other paradigms like spin up two agents and they ping pong. between each other, right? And then like, Agent A goes and it critiques what Agent B did and does its own thing.

And, like, they kind of, like, you know, level each other up as they go. And, like, there's all these really interesting paradigms that I really want to explore. And then, like, you look, a gas town, right? And there's, like, you know, like, there's a deacon. And there's, you know, it's a whole town. Yeah. We have these mayors and stuff like that. Citizens.

I don't even know. I didn't go that deep yet. But is it? Like, that's exactly it, right? It's like impossible to follow when you're just like starting from the primitives, which are like an agent. So there's like a lot of really interesting things as far as orchestration that I feel like are just now being explored.

And there's a lot more that can be done there. But I think we just need the tooling to, to, to make it easy to understand who's doing what and, et cetera. Take me into this exploration around coordination, because I feel like that's probably the hardest part once you have multiple agents. I do think it's smart to do a task-based versus, you know, agent-based because you may want to have multiple agents, but then you have the issue of stomping on toes.

So you have to kind of coordinate it. Do you have like a coordinator? or an orchestrator or do you kind of give them hats? Do you give agents like, hey, agent you are, you're the verifier now. And now they assume this role. Is it stuff like that? How do you, how does the agent know? And then how do you trust the model to let it explore and push back on the other agents,

I guess, thoughts, if that's how you want to frame it? Yeah, yeah, that's a good question. So we have the concept of a specialist, which is. It's like a persona, right? And it's like a prompt and a default model and set of tools. So we ship the app with a default set of specialists. Like we have a coordinator, an implementer, a verifier. There's like a PR reviewer, UI designer.

There's some just like things to get people started. But users can tweak those or make their own specialists. And the default flow we have that we've found actually works really well is one coordinator that you start a space with. And it does all the research and it like rates the spec and it makes sure like it's usually the main thing that you're working with as a developer. And then that coordinator on the fly can create other agents like either blank ones or specialists. So we, in our default prompt for the coordinator, we say for the sub-tas, delegate them to implementer agents. And implementer agents, depending on how token sensitive you are, like it can be a cheaper model or it can be more expensive. I really want this to be as robust as possible.

And like those implementers get their own subtask. And it's the note that they can like write in and read from. And so they like, it's like kind of scoped. It's really well scope for them. But they're also told who else is working within the workspace. And I feel like that's made a lot of difference. It's just like the agents know and have visibility into who else is working. Right.

Like it would be weird to join a team and like not know who else was on the team or what they were working on. Yeah. Right. Like I'd be like, I don't know what's the scope of my work. So it's just like this really smooth flow of like coordinator delegates to implementers. And then we also found that agents don't always do exactly what they say they did. And like maybe this will change. But for now, sometimes an agent would be like I did XYZ.

And then, you know, you'd look at it and they only did XY. And so the coordinator is also told to delegate a verifier agent, which again, could be a cheaper model. It could not be. You could use a codex model if you feel like that works better for this case. And that verifier just knows exactly what the work is that just completed. And it like goes through and verifies it. You know, it runs the tests. It runs the app and looks at it and keeps everyone like to task. And it reports bets of the coordinator. And it's actually kind of a really interesting flow. I keep meaning to post about it of like, like having this one chief of staff that you talk to for everything.

And like it delegates to other agents. So it's like an interesting, it's a different flow where like the work can be happening and I can talk to the main agent about the work that's happening or like, oh, I found a bug and I'll just like, as I go through the output, I'll keep telling the bugs to the coordinator. And because it's not doing the work, sending messages. is not like queuing messages because they get sent right away. And it's not like interrupting an agent because the work doesn't stop. So it's been kind of an interesting change in pace of how I do the work with agents.

Yeah. That's exactly where I've landed too. I mean, it's funny how we think like this because I basically said to the agent, your work here is too important for you to do the work. You're the planner. You're my orchestrator. You check on things. You confirm the task as clear.

We sub-agent that, and because, unfortunately, Codex isn't smart enough to have sub-agents yet, or at least that I'm not aware of, and I just haven't explored that. So open a new tab, and we create a flow, essentially, and I'm calling them flows, where I want to get to, you know, from 0.5 to 1 or whatever phrase would apply to that. I want to have this task done, but you're my planner. You're the orchestrator, even between a couple of repos. So in the case of the sandbox, I have the main. main repo where I've got, I thought we actually landed on the fact that I just need like one

primary operator because I was trying to have an operator for that repo and an operator over here. And I'm like, well, hang on a second. Now they don't know what you're doing. You have all the context and it got messy. And so even with one operator between two repos and sort of two different versions, like you're here to battle test this thing. And they're over there coordinating work on the product to evolve it. And so it just made a lot more sense.

They're like, it got confusing for them and for me even. So I'm like, your work here is too important to do the actual work. You're my planner. You're my verifier. We are real time. If we see a bug, we log a bug kind of thing. If we have a thought about something, we'll spike out an idea or drop a document in there. But really it came down to that as like, I want to have sub agents.

They go and do the work. And yeah, you're right. if you had sub-agents or multiple agents working in a room together and they weren't told to introduce themselves, that would be weird. That would be weird, right? It would be weird, yeah. Well, hang on a second. There's somebody touching my files over here. There should be nobody in this room. And, you know, they've got no eyes in no hands, so to speak. So we kind of have to give our agents to do this work. We kind of have to give them eyes to see something and give them hands to maneuver something.

And at the same time, I've learned, tell me if you've heard this before, if you feel this way at least when I say this, trust the model. Does that ring a bell or resonate anything inside Jamila? Trust the model. It makes me uncomfortable. It makes it uncomfortable. I have the opposite philosophy. Oh, okay. Gosh, let's dig into that then. So I've pushed on the model to not trust it. And I don't know about you, but lately I've been just specifying things I want to do so well that when they come back with feelings, I guess, I don't know how to do their intentions or their thoughts on what I'm putting out there. A lot of my responses end up being, I like that.

What are your suggestions for this? I review their suggestions. And I'm like, my, a lot of my responses is some idea, they go and churn on it. I review it. And I'm like, this is awesome. And then I ask it for clarity and blind spots. And like, they go back and review what we've done because I don't got time to do that. go and review it for clarity.

Is this clear? Are there any blind spots? We're not thinking about that if we started to implement this now, the agent could do it, but it would be guessing along the way. And then that's not my intent. That's not my intention. And so then they come back like, well, here's five or six things that is unclear and here's like six major.

Here's two high blind spots and here's two sort of mediocre ones. And so I can think about those for sure. but I'm busy podcasting, responding. Like, I have a job. My only job isn't this. If this is my only job, I would probably read a lot more of it. So then my next question is to the agent, what are your suggestions on those things? Because I want to review your suggestions because you've got the time to examine it, agent, not me.

And so that comes back with these suggestions. I read those. I'm like, yeah, those are great suggestions. My next response, Amelia, is what? Do it. So a lot of my interaction with the, model is in a way trust the model, not because I blindly trusted, but because I've learned that it's got some pretty good thoughts. And it's a heck of a lot smarter than me and certainly

way faster. And so a lot of it is my intention, my ideas, my desires, my problems, it's helping me solve. And my responses are pretty mediocre. It's like, what do you think about that and do it? Like if you look to my history, my up history is like a lot of history. My up history is like a of that. Like, what do you think about that? Do it. What do you think about that? Do it. You know, I don't know. Anyways, maybe I'm revealing too many of my cards here in terms of like just how much I do trust the model when it comes to what I'm making. No, that's exactly right. There's, an augment launch this feature a while ago. And a lot of these agents have this, which is enhanced prompt, which is like you write a little bit and then you ask it to enhance the prompt

and it turns your, you know, 10 words into 100 words. And like, I like this because this is in a lot of ways what we're doing, right? We're trying to have a compressed version. And this is what talking is, right? Like you have a maximally compressed version of what it is that you're trying to represent that lives in your head or maybe doesn't even fully live in your head. It's just like add dark mode to my site. right like and this wouldn't work previously with code because there's a lot of things that are inherent

and you would have to assume in order to turn those words into an implementation right like first all what is dark mode right like what does this person mean when they say dark mode or like what pages should this apply to should this have like some kind of affordance to switch between dark mode and light mode. And there's like a set of like less and less obvious assumptions that you can make about what the person means when they say these words. And like you're doing, you know, I'm not going to bring out numbers again, but you're like, you're extrapolating.

Please do. I like your numbers. Don't feel bad about it. You're going from your stuff. 0.75 to 1. Okay. Okay. From add dark mode to this is the code for adding dark mode.

I feel like enhanced prompt goes from zero to point one. Okay. Nice. It's a little, it's the negative TLDR, right? Like it's a little bit more like, this is what you mean when you say that. And then the way enhanced prompt works, it's really nice because you can edit it. Right. You can read through, okay, this is a little bit expanded and like, oh, you're going to assume I mean this.

Let me actually tweak that because I see it. And like, it's actually not what I want. and then like extrapolate a little bit more you get to this like a spec right like that's like the spectrum development where like a spec is supposed to be somewhere further along that spectrum of like let's add more detail into what that would mean in the code but we're not going to have the fully fledged implementation because that would be the code right um or like that would be hard to read through and, you know, I can go from 0.5 to 1 and make assumptions, like, those assumptions along the way. Let's, like, get out the, like, big decisions and, like, agree

on them before we do the work. So, like, that's kind of how I think about the way we work with these language models is, like, we say a little bit, and then they basically flesh it out for us and turn it into code. This episode is brought to you by our friends at Nordlayer. Here's a weird asymmetry in the security world. The tools that protect the Fortune 500s, the big guys, the ones that actually stop ransomware before it encrypts everything. They aren't available to most companies that need them most. You, me, small businesses, mid-sized teams, startups.

They get breached constantly. We see this every single day in our news cycles. And the reason usually isn't that they're careless, is that the enterprise-grade stack assumed that you had a dedicated security team to run it. Most small businesses, medium businesses, startups, they just don't have this. Nordlayer is closing that gap. It's a network security platform that combines VPN, access control, and threat protection into one place, built on zero trust

deployable in under 10 minutes, no hardware, no quarter long rollout. And friends, this is affordable plans for just $8 a month. Enterprise-grade security, minus the enterprise-sized team needed to run it. Get up to 22%

off Nordlayer yearly plans, plus an extra 10% off with the coupon code, change log, hyphen, 10, hyphen, north layer. Yes, the code is change log dash 10

Nord layer or hyphen whichever you choose try at risk free with a 14 day money back guarantee check it out at Nordlayer.com

slash the change log and we use our link as you know you're supporting our show and we appreciate that once again Nordlayer.com slash the change log

my audience knows this love augment I use Augie on the daily Augie is my one-shot tool I love I love to just give Augie something just to churn on for a while. Like I'll do a lot of thinking with Claude with Codex.

I'm no fan of just one particular. I feel like any developer really should use everything they can actually afford and get their hands on. And I'll even just luckily mention. You mentioned, how did you describe? You said token, I don't think you said token efficiency, but where you wanted to be. What'd you say? Do you remember what she said about it? I mentioned before, like, people are differently token sensitive.

Token sensitive. I like that phrase a lot. I feel like that needs to be, you know, a phrase in our world because there are some that are more token sensitive. I'm like, hey, listen, when we're in, when we're orchestrated while you're telling this agent what to do, we're going to use codex or GPT 5.3 codex like on high. We don't care. Like, I want the best Kobe can. I have plenty of usage space so don't take me down to a lesser model

and I don't care about speed. I just, you know, it's working in the background so I'm not trying to get there in two minutes when five minutes is better or whatever the case might be. So being token sensitive, I think, is really an interesting place to be. And I'm just sort of like, you know what? I have access.

I'm going to use access. And maybe somebody is a little less, a little less like that. I'm trying to figure out where I was trying to go with that because I kind of sidetracked myself getting on token sensitivity there. But you're talking about like

enhanced prompt. Yes. How much I like Augie. Yeah, my one shot. Yeah. Thank you for bringing me back there. I really appreciate that. So big fan of Augie.

And now this is the feature I've never used though. I've never used this, this prompt enhance. And someone have to try it. And I guess my challenge there is that when we put our little pros into the text box, the CLI, the web app, I think Codex now has an app version, which felt so non-hacker, so I had to go back to Terminal. Even though they gave me 2X usage, I'm like, no, no, no.

I'm going back to where I feel a hacker, okay? CLI is just where it's supposed to be. Don't take us away from that. I guess maybe Intent did that too, so sorry about that. It's okay. Maybe you have some thoughts on that front there. I feel like Hacker is the way. Don't take me too far away from Hacker.

I feel at home in the terminal. It's about feeling good. But here I am in the terminal. And I just, you know, I have no affinity to like which model I'm using or which platform I'm using. But I've never used this enhancement. Because I feel like, at least for me and why I haven't leveraged it is because part of it is this dance. Part of it is this trust the model. And I'm not just trying to get to software.

I'm trying to get to reasoning for myself, not just for it, even though I say, hey, what suggestions do you have do it? That whole mantra back a minute or two ago, despite saying that, I still want to learn along the way. And so part of that learning is my troglodyte prose into it that comes out the other end with clarity. And it's that back and forth that I feel like it's like a potter and clay in a way. It doesn't turn into the bowl right away or this beautiful thing. Like, for example, here this my coffee cup is a hansami. It's Japanese. Like, this is Japanese clover here, Amelia.

It's just a typical coffee cup. But somebody made this with their hand. And it's amazing. And I love that. To get to that, you have to feel all the bumps. You have to feel all the pressure. And so I haven't wanted to enhance my prompts. Because I feel like not that I'm against it, but me sort of feeling the pace, feeling the pressure, the back pressure of my dumb idea turned into good idea to understanding that it's a good idea to understand a new paradigm to a different way of thinking about it, maybe introducing bun versus go or svelte with a svelk kit versus something else versus Tann Stack start.

Like, oh my gosh, the wars out there, right? and the wars are immense. But I feel like that's where I'm personally learning. And maybe that's a today problem, which I think is really important to mention, right? This is 2026 and this is how I feel today. This is the problem of today. Maybe in six months from now,

I won't care so much because the agent is just so smart, I should just forget trying to understand. I don't know. What do you think? I have a lot of thoughts there. And I'm trying to think of what would actually be most interesting. Like I feel like as developers, we're kind of having an identity crisis, right?

Where like, are we potters and are we supposed to be opening like a pottery factory? And like that's, you know, like there's two main joys that I feel with being a developer. One is like the craft of the code and learning the tools and knowing what are the bricks that you can build your buildings with. And the other is just like building things. and like thinking of something and then it exists, right? And I think the way you might feel about this new wave of tools lies along those lines of like, which is the greater joy for you?

And what do you find the most meaning from? Sure. And I've always been like, which is why I've moved more and more towards design. You know, like I started as a developer and now recently have had more and more design roles. is that it's just so interesting to be able to imagine something and then it like comes to life. Yeah. Like that is amazing to me. And like a lot of these are things that did not exist before, you know, like whether they're good or bad, this is the first time that they exist.

And there's something like really amazing in that. And a lot of, I feel like you're. your main motivations and what you find the meaning in, it informs the way you use these tools. That's true. And I do think it's important to still feel the clay, right? Like, you still want to be in touch with the physics of what it is that you're working on, and you want to feel in charge and in control and not like, like, I think about art, right? And, like, how generative art is changing.

And, like, people are kind of having to think about, like, like what is art and like what do we find meaningful? And like if I type a prompt into a box, then something comes out and it's like the Mona Lisa, right? Which honestly I think is overrated, but it's a good example. Like how does that change how I value the thing that came out of the box? And like can we have workflows where the thing that we think is meaningful,

which is usually like effort and thought and like the humanness that goes into it, can we leverage Gen. AI to make tools for which people to like make a thing and then like really sculpt it and craft it and like put intention and effort and human feelings behind it. So that it's not just like type prompt into box and it's fit something out, but it's not the usual like paint that we work with as painter.

right? And I feel like this applies to code too where like how do we how do we leverage AI to act like a tool and not like just an automation of what it is that we do as developers. And I think that's like a little bit for me what you're getting at of like. Very much. Yeah. Like what do we want out of this really? Yeah, it's like it's like trying to build a house and you're framing and instead of having one framer with one nail gun. and you have infinite in a sense or unlimited nails or just something that not so much speeds it up.

It speeds up the idea of thought. You know, you mentioned as a designer. I feel like I'm a software designer now, not a software developer in a way. Yeah. I'm designing it rather than developing it, but it's kind of both, but it's more designed than development.

And I think you're spot on with the identity crisis. I think a lot of people even listen to this probably somebody not listening now because he got upset midway. You know, maybe you're mentioned of more numbers potentially. I'm just kidding. I love that. Maybe it's something I said, you know? But I think we're all having this identity crisis to what are we really trying to do here?

And I think you're right, too. It depends on your motivation and how you leverage a tool. I think the way I look at what AI is today for developers. and how I'm using it is very much like a tool, not a create this thing for me. It's helped me create this thing. Help me use your infinite knowledge so I can connect my own dots, you know, my own problems.

That's why I keep inventing new software. My wife is, I think she may be on the edge of being not cool with it anymore. We'll see. Because I will often say to her in the morning, or in the evening we go to bed, babe, I invented something new today. And this is a very common occurrence. Like I mentioned gauntlet. And then there's Agent Flow.

And then there's BKT. A lot of these things are acronyms for some reason. My son's like, Dad, why are you naming all these things acronyms? And it's not really intentional, I guess. They're not really acronyms. But Agent Flow is an acronym. It's a full phrase. So get off my back.

But although the command for Agent Flow is AF, Amelia, how cool is AF, right? As a command, you type into a prompt. I think you win it, naming things. Yeah, well, thank you. It's not the millennial version of AF. It's just kind of cool. Either way, it's super short, super slim.

Hey, millennial stuff is cool. I'm an older fella, so I think I'm Gen Z, Gen X. I think I'm Gen X, I recall correctly. I forget which gens there are. I just know that I'm old now. I feel like, I still feel young, but I am old. So I'm often, like, in a room with folks. And I'm like, yeah, you're kind of like 10 years older than we are.

I'm like, sorry about that. Just maybe 16 years older than you are maybe even. You underage me. Thank you very much. It's weird how that happens. But very much in this identity crisis, very much trying to use AI as a tool to help me create and invent and design new things versus simply magic box. Give me something. You know everything.

I know nothing. Thank you very much. software created, product made, open source done, you know, 10 million ARR. You know, like, that's not my, that's not my world, you know. Not your vibe. I'm not even trying to vibe my way to get there. And I empathize those trying to get there because the world, the world says be richer. The world says make more.

The world says ARR, right? The world says high valuation. The world says raise $100 million. And kudos to those folks there. By the way, Michael Greenish, congrats on the 100 mill for Worker West. of Michael and WorkOS, but they just raised their Hunt and Mill just yesterday. And he's coming on the podcast this Thursday, so it'll come to the actual airwaves here soon. But no, not against that.

That's cool. And he started WorkOS before the advent of AI. And now AI is sort of reinventing or helping folks reinvent their platforms because, well, now, Amelia, you don't have to just support Goh, is your SDK because you're a Go shop. Now you can support TypeScript. God bless you. Go, pick your language that you want to, maybe even Ruby again, who knows, because that's the fringe, that's the edge case. What are your thoughts on that is like not just a tool to make more, but a tool to sort of flatten things because rather than just support an interface for my software, an API for my software that is only an API in this way, now I can have an MCP server, I can have SDKs, and I can actually have good SDKs because we can move a little fast. and support more of a footprint, that the footprint can widen because we have this new

invention tool, this new design tool we have. I feel like my answer isn't super different than what we've talked about before where it's like now that we can build anything, what is it that we build? Right. Like it's so tempting to add, you know, 10 new features to an app, especially with, you know, you get the 70% really quickly. Like, why don't you just polish that up and ship it out? you know, you're done.

You know, your app does, you know, it's an IDE and it's, you know, notion and it's linear. But then you just have this massive app and like, why? Yeah. Right? Like, you can only have so much intention behind what you build that it's only, it feels like it's becoming, the question is what you don't build as opposed to what you do build, right? Like if we if we can virtually eliminate our backlog in a week, how does that change what we decide to ship? Because the answer can't be ship everything.

Yeah. Because then, you know, your stuff for it doesn't stand for anything, right? If it stands for everything. So it's been as someone who likes to do scope creep because I like like fully fledged versions of things and like really thinking through. you know what is what is it if it does everything um it's become like it's a new muscle that i have to exercise right restraint no to things yeah for sure your choice is your superpower amelia do you uh are you a fan of notion because i think there's some change in the notion world which is interesting i just saw something you thought notion was just docs

everything just changed and so now they're like a version of Claude, I guess, in a way where they have Notion agents, and they're a sponsor. I'm not sure if they're sponsoring this podcast, and they may get upset, but that's just how it works. But I think I'm kind of confused by Notion, because, like, I like notion. I use Not what it has been, let's just say, not what it was, what it has been, which is a place to organize teams of folks or one people or many and collaborate with external folks on documents, workflows, statuses. It's a version of a document state machine, right? Comments can happen there. You can invite people in there.

And I think what inhibited my usage of it is just the difficulty it is to manage that kind of workspace anyways. So kudos to them for throwing agents in there or Notion AI, which I use. And I think it's super awesome. But now I'm not sure what Notion is because if Notion is where I go to build agents that don't even belong and notion, what is notion? So it kind of comes to this notion or to this thought that you had here, which is, you know,

if we have no restraints and we could just put, we can just build anything, what shall we build? I'm paraphrasing what you said and I don't remember it perfectly in my brain and feel free to restate your phrase. But how do you feel about that,

I suppose, where you've got a tool that was sort of known for one thing and now it's almost reinventing itself to the point where you're like, wait, now I go to know, for the thing I didn't go to notion for. And I'm just using them as an example because it's the most clear recent example of a,

not so much a major reinvention, but a major, major new feature that sort of makes you rethink. And they even said in their advertisements on who they are, we're not this anymore. You thought we were just this. Now we're 60%, not just the 40% you thought we were before. So what do you think about that with this massive reinvention and just doing more than you should, could? Yeah, I think it's like this reckoning of how do we use computers? There's two analogies that I have in my head.

One is like the IDE was invented almost half a century ago, right? And it's very good at working with the primitive of code. And you're always working at the code level, right? You're reading the code, you're writing the code, you're clicking between files. and we like through AI as chat on like on the side and we're like okay these agents are going to write and read the code for you so that's like there's like step one which is like what are the primitives build the UI around the primitives step two is throw AI so it can also use those primitives and then step three feels like kind of like reinvent the tool now that

our role in the system is changing right, where we're no longer mainly working with the primitives. We're like moving up a level on the ladder of abstraction and focusing more on like, for code the meta of like, what's the intent? How like, what are we building? What are we changing about it? What exists in the code base? And it feels like notions kind of going through the same, okay, we had documents.

And then we threw AI on the side of those documents. And now they're kind of moving to step three, which is like, let's work on the meta, right? Like I have this long list of bugs in my app. Can you transform that into like a summary or into some like higher level representation of this so that I can interact with it in like a much higher leverage way? And then there's like a next step which I'm super excited about adding to intent, which I'm. is you can go up another level, which is like if you add AI at a higher level, which I guess is kind of what Notion is doing, where like you can talk to an agent about all your work spaces. And you can say like, hey, what are my last 10 PRs? Can you make a workspace for each one of these?

And then you're like, what happened in my workspaces last night? And oh, like, mud, like nudge along these three tasks, right? Like, we've gone another. level up on the ladder of abstraction where like we're, it's like, um, moving higher in the air where the things on the ground, there's more of them, but they're smaller. And like, they're individually like taking up less, uh, of like our view as far as like our perspective is moving up and up and we can do more and more, but we can't use the same representations that we have then. And I feel like a lot of software is just going along this, this, this, trend of like, okay, like the way we interact with this is changing and how do we design around

that and how does that change our identity of software? Yeah, I like that idea. I mean, that's exactly it's exactly what I want, you know, as I mentioned before, I confided in you and to the rest of the audience that I have a hoarding problem with my software and I can't stop inventing new things because I keep finding more problems that I want some else to solve that I'm like, well, why don't you just take a stab at it? Because what's the worst thing can happen? Like, will you fail? to yourself? Like, what's the big deal? Let's just do it, right? Right. And it's the tension between, like, I want to feel the medium still.

Right. And I want to do more things. Right. So we need interfaces that make it possible to move between those two levels. I think about maps a lot, right? Like, a map is like an amazing feat of design. Like Google Maps. Right. We have static maps, but like Google Maps, right? Like, first of all, it's just amazing that we've mapped, you know, basically everything in the world. But like, if you think about all of the design decisions that go into, like, think of the map of your town at a high level. You see all the highways and like what's green and what's not green where the busy areas. You zoom in a little bit. You start seeing like smaller streets. You zoom in more and you see like paths and you see buildings and you zoom in more.

You can even go inside a building. Wow. It's just like amazing the like perspective shift that does. they have to manage in like one interface. And like the fact that you can seamlessly zoom in from like inside a building to like a whole town to like a whole country. Like it blows my mind. And I keep thinking about that. It's like how do we design other things that way now that qualitative things are a little bit more malleable?

Yeah. Yeah. I kind of want to either have own or create a software factory. not so I can turn out software, but because I think, and maybe at some point everyone else will truly be a builder because this will just flatten.

But I think for now, it's the was developers to be software designers or whatever our identity crisis is leading us towards is that I really want to have a software factory, but like I said, not because I just want to turn out software.

I want to have the zoom in. I want to have the macro and the micro because I want to have the big picture designer idea I want to have the intent idea. I think the name intent by Augment was just spot on. I don't know if you were involved in the naming of that, but was that your name? Did you name it? That was not me.

Okay. Were you in the work for the scrum or whatever you want to call it to sort of think through the name? Yeah, we kicked out around a lot of names. It started out as work spaces, which is very literal. A little, yeah, a little bland. You hear it and you're like, okay, I kind of get what that is. But like we kicked around a bunch and intent. Yeah.

Intent is, it, I still like it, which means a lot. I think intent is a pretty good name for where it's at. I'm not sure because even with my own names, I'm like, I don't know. You know, I don't know. All of the names you've mentioned have been great A. Well, thank you. I think it's fun as a designer, as someone with intent and good taste. I think I have good taste.

I've learned to trust my taste because I keep solving my own problems. And I think there's this agent psychosis thing that I think people have talked about. And I'm like, Adam, do you have agent psychosis? Because all your ideas are good. But it's not the agent telling me my ideas are good. It's me making the thing and using the thing. And me like, okay, the idea is good. And so I don't feel like I have this agent psychosis,

although I am very aware that it is a phenomenon happening to, folks, but I do want to zoom in because I want the understanding and reasoning. I do want to understand my choice between. So here's something I deliberate between recently, which is I like languages to compile to a binary. So Rust, Go, button. And then there might be more, but I'm just not familiar with every language it does. And so I largely deliver most of my software in Go for those reasons.

It's just easier to deliver a binary, right? So easy. Rust is a harder language to reason about. So I like Rust. I like to use Rust when it makes sense. But largely, my language of choice for most things is Go. And then I recently was building something with Ruby because I really want to get back into Ruby and particularly like Ruby on Rails. Because Rails does APIs very well.

And it obviously does web UI's extremely well, right? It's got models, views, context. It has all that stuff. Sorry, controller, not context. But then I was like, you know, I got to a certain point with this application where Ruby on Rails could have done it. But then it posed some challenges to deliver us. I won't go into the details, but you can't compile a Ruby on Rails app to a binary.

It's just not possible. And I'm not going to solve that problem yet. I don't think I'm ever going to solve that problem. Maybe somebody else is trying to. So then you have Bunn. And you're like, well, Bunn can deliver me a TypeScript application compiled down. And because the way SFELKit works and SFELT works, it's just writing, it's an abstraction above plain old JavaScript, which I don't want to write because who wants to do

that anymore, right? It's not smart. It's like not using agents. So I want to use Svelkit. And I want to make some really good friend and UI and, you know, just different things in the JavaScript ecosystem. And I want to leverage NPM and all the goodies that are there. But I can still have a compiled binary, right? I can take a Svelkit app in the software. And, you know, inside a bun and compiled down to one thing. And so all that to say is like, you know, when I explore my world, I want that. I want that micro. But then I want to zoom out to the macro and say, show me the map.

What's, where's the United States? Where's Earth? And Earth is like all my projects. And so I very much as a software designer, developer, builder, identity crisis, whatever you want to call me or us. I want the micro and I want the macro. So I applaud you for that work on intent to just give the zoom in and the zoom out. It's very much important.

Yeah, this is actually like, it's something I've grappled with for a long time is like, how do you represent something at the macro? How do you represent a code base at the macro? And it's a really, really hard problem for many reasons. One is which like there's no one representation that will satisfy. everyone because we all have different mental maps of a code base. And there is no like, you either visualize it as like, this is a directory structure because that's the only like pseudo spatial thing that we have or like you use the AST to generate a map or you do something more semantic that's like in my head, the structure is like

here's the front end, here's the back end, here are the API routes. So there's just like a lot of, there's a huge exploration area as far as like, what is a way to visualize code bases and tasks and like monorepos and sets of codebases and like how do you zoom out and what does that look like and what are the affordances that I want at that level. So it's something that I'm very excited to explore more. but has also been virtually unexplored. So there's a lot we can do in the short term and in the long term. I wonder, Amelia, if we're just code explorers in the end. You know, if we just become that, it just become code explorers. I don't know.

Every time I hit a hurdle, I want to explore further. And then I got to leverage my taste and justification for should I build that or should I pull back? Should I do that? Should I add this feature? Should I not add this feature? So I very much feel the tension that you've described here. What is the best way to get started with intent? Is it just if you had to give someone an on-ramp, go here, do this?

What would it be? You built the thing. Show off how you're proud. Come use it. We love feedback. It's free. Bring your own agent. You can use cloud code or codex or we recommend augments agent because it's really good

at saying grounded, especially in complex. code bases, augmentcode.com slash intent. Download it. We have a Mac release right now, and we've got Windows and Linux in the works. And just like open it up, start, tell it what task you want to do, and it'll make a spec for you and go from there. It's been really fun playing with it. And it's like, it should be a very, very smooth, fast onboarding where you just hook it

up to your assisting CLA agent. Yeah, I love that. I already had Augie installed to myself. And so I was like, yep, sweet. I already got that. I chose a repo to play in. I started playing with it. Of course, I went straight to my micro version of it, which was just me and an agent versus the swarm. I know we can go right or left, which I think is kind of cool. You can bifurcate the direction you want to go to there.

But I was like, I'm comfortable here for now, although I do think I want to swarm or have multiple agents. I forget what the terminology was that you use, but it was something like swarm or multi-agent or something like that. So for any given workspace, you can choose the specialist that you start with. And so you either choose the coordinator, which does all this orchestration, or you can just do like one agent that doesn't delegate. It just rights a spec for you. And then you ask it to, yeah, yeah, more of a back and forth.

Yeah, that's where I'm at for now. I'm still getting comfortable with trusting the models and trusting the agents to do all my things. But I do like the exploration of this world. Anything in closing, Emily, anything I didn't ask you that we can tail out. How could people track you, trace, you, follow you, pay attention to what you're putting down. I know you have a blog. Do you still write a lot? Are you, you know, how do you feel about writing?

How should people keep up with you? What's the best way? I have so many thoughts and yet so little time to write them down. I do have a blog. If you search, if you can spell my last name, you can find me. on all the things. W-A-T-T-E-R-G-E-R dot com. Nailed it. Exactly. I had it written right here. I was on your website.

Yep. Wattenberger. I have monopolized my family name online. Sorry, everybody in my family. Well, you know, when you're famous, you're famous, right? Amelia. Yep. Very famous. Well, thank you so much. It's been so awesome going deep with you on this conversation. The intent we have is super important. And as tastemakers, we have to align that with the future we're trying to get to. And it's objective to where we're trying to go and how we use these tools. But I love the conversation. Thank you so much for spending time with me. Much appreciated. Thanks so much, Adam. This was a lot of fun. Well, that's it. This show's done. Thank you so much for your patience, you all. You know, I know change is challenging. And I know information and, and lack of information when change happens is kind of a bummer, and I get that.

And I will tell you that I want to share everything with you. I want to share where I'm at. I want to share where I'm going. I want to share where the show is going. And I want you to rest assured that nothing is changing, but kind of everything is changing in a good way. This show is going to get better. The show's going to have more. And I'm going to diversify a bit, go some software, go behind the scenes a bit.

I've got some plans, but I'm in the moment. middle of re-architecting things. So be patient with me, be patient with the process of this podcast, and just know that I have good will for you and your best interests at heart. Many of you out there I call my dear friends, and I am so thankful for you listening all these years, your loyalty, and of course, your friendship. But this show today with Amelia is very cool. Talking about agents. It's kind of all the rage, as you know. It's everywhere. We can avoid it. But this really, Replatforming, the perspective that she brings to the table is such a unique perspective in her design skills, her intention on intent.

The product is paramount and so cool. And so going back through her journey, talking about intent and what they're doing with it, was so cool for me. And I enjoyed it. And I've enjoyed it too. Big thank you to our friends again over at RWX, our friends at WorkOS, our friends at Nordlair, and of course our friends and partners at Fly. i.io the beats as always by a great master cylinder those fantastic beats and thank you so much for

listening that's it the show's done we'll see you next week