Lifestyles of the AI-Native — Nick Nisi & Zack Proser, WorkOS
https://www.youtube.com/watch?v=AgBAOXVxt4A
AI Engineer · 61 min · 881 sentences · sentence-level transcript from YouTube's caption track; each line begins at the time shown

[00:11] Hello everyone.
[00:12] Thank you very much for coming.
[00:14] We are very happy to be here with you today.
[00:16] We have a great program for you.
[00:18] My name is Zach Prosser and this is my friend Nick Nisi.
[00:21] We are both AI engineers at Work OS.
[00:24] Today we're going to share with you some of our best workflows and things we've learned from working with Claude and other agents every day.
[00:31] This will include voice coding, agent skills, hooks, and scheduled tasks.
[00:36] We hope there will also be time for questions and answers at the end.
[00:39] Yes.
[00:39] The most important thing we want you to take away from this is that most engineers simply look after one session at a time.
[00:46] It's like 2025.
[00:46] You're supposed to be operating a fleet of agents, and we're going to talk about the different ways we actually do that .
[00:53] This is not a marketing ploy or aspiration.
[00:56] These are the things we do every day to survive in this moment.
[01:01] Yes.
[01:01] Well, as we said, well , I'm Zach.
[01:04] I'm on the team for .
[01:05] artificial intelligence in Work OS.
[01:07] I would say my role is 60% implementing internal customer-facing tools and applications using AI throughout the day, and then about 40% AI education that elevates the rest of the organization.
[01:17] And I 'm Nick Nisi.
[01:18] I'm the engineering manager for the developer experience team, and we're a small but mighty team of two that manages over 25 repositories in eight languages, and we're only able to do this thanks to AI.
[01:31] This made it the only way I wouldn't go crazy.
[01:36] Great.
[01:36] So what we have for you today is a very interactive workshop.
[01:39] So if you want to sit back, relax, and just watch our presentations and talks, that's fine.
[01:43] If you want to participate in the practice, we have a repository you can use and, well, you can go through everything step by step.
[01:50] This has skills that will help you set up voice coding if you have never tried it before .
[01:54] We want you to think of it this way, it's a great opportunity and kind of a safe space if you want to try out new workflows before voice coding tasks, scheduled tasks, hooks, etc. It's a great place to actually get involved.
[02:06] And then we'll be available to help you or answer your questions.
[02:10] Yes, for sure.
[02:11] We will discuss these four things, with varying degrees of detail.
[02:16] And there will also be time for questions and we will answer them.
[02:22] But there are three things we will see, three main things we will see.
[02:27] Just slides.
[02:28] There's also this QR code you can scan.
[02:31] It leads to an active dictionary and contains a lot of terms that we will be talking about.
[02:35] Things like MCP and skills and whatnot are in Rag loops.
[02:40] Yes.
[02:40] They are all defined there, but there is also a little chat about ragas.
[02:44] So if you have questions about that , you can ask them there as well to help keep things moving.
[02:48] Yes.
[02:48] But you can also ask us.
[02:51] And then everyone...We'll also ask for your feedback and ways you can collaborate and use the skills we're learning today and show what you've learned in the next hour.
[03:01] And it's on this live board that we'll see.
[03:04] And if you go to the repository, you'll see it and you'll be able to contribute to it .
[03:10] Nick created this awesome MCP server which is part of a repository whose URL we'll have to share soon .
[03:17] But this will be an interview with you.
[03:18] This will be...This is optional.
[03:20] You don't have to do this.
[03:21] This will scan your computer if you agree.
[03:23] It will look at some of the conversations you've already had with agents and figure out what you've worked on, how you've worked, and give you some simple rubrics on how familiar you are with
[03:34] AI.
[03:34] Mostly for fun, because we'll do it again at the end and see if there's any movement.
[03:38] Yes.
[03:39] He is built like a coach.
[03:40] He's there so you can ask questions and he can try to help guide you.
[03:46] And he tries to answer in the way we would try to answer these questions.
[03:49] But you can also ask us, because AI isn't always perfect .
[03:54] And this is what data visualization looks like.
[03:56] So again, only sign up if you are interested and feel comfortable.
[04:00] When you're being interviewed through this MCP server or coaching tool, you send a simple post to the backend that we 've set up in Cloudflare, and it just checks the current room position, and then at the end of the session, we check that.
[04:14] The only data it sends are the questions you answer.
[04:17] It doesn't scan your system or anything like that.
[04:20] Yes.
[04:21] This is the beginning of the interactive part.
[04:25] And, uh, I'll mention again that if you want to follow along, a great way is to follow us, you know, here and talk, uh, listen to us here and go through everything step by step.
[04:34] We'll also be running on screen, but you can also clone this repository, which is designed so that you can run Claude in it and… That's where you'll get the MCP server, skills and tools, and where you can work on it ; and then it's a perfect , um, kind of artifact that you can take with you and
[04:50] continue practicing, um, after our session.
[04:52] Yes.
[04:52] And I think the way to leave this screen here is if you want to clone this repository, um, but we can ask one or two questions while we're at it, um, we'll leave this here if anyone has a question.
[05:04] Any questions?
[05:05] All right.
[05:06] We don't bite.
[05:07] Cool.
[05:15] All right.
[05:15] So if you're going the repository route, um, the first thing you want to do is run Claude, however you normally do it, you know, you usually just type Claude, and it'll ask you if you want to trust this repository.
[05:25] Trust the repository and then, uh, one of the first skills that's already loaded will be this setup, uh, skill that will help you install all the things for the workshop, including, uh, your first open source and free, uh, voice type, uh, coding model.
[05:38] So you can say, "set me up for workshop," or type that in and Claude will walk you through the steps to do it, and then once you're done with that, you can say, "run my workshop
[05:49] check."
[05:50] This will give you some idea of ​​ what stage you are at and what is happening.
[05:55] The repository is also setup with many skills and plugins already configured for Claude.
[06:01] So there's MCP, there's some skills that we created and some that we didn't create, like the ones from the Codex.
[06:09] This is just a simple way to get started and configure Claude's repository and environments in a way that is best for this workshop.
[06:19] And while we wait for a few people to set up the repository, let's raise our hands out of curiosity and see how many people are already using the voice encoding tool every day.
[06:28] Okay , great.
[06:30] Pretty good division.
[06:31] What voice encoding tool is this ?
[06:32] I mean whisper flow?
[06:34] Yes.
[06:34] Okay.
[06:35] Excuse me, which one?
[06:37] Whisper flow, but it got slow.
[06:39] Yes, I had the same problem.
[06:40] What has become faster and what is faster?
[06:42] Then I moved on to voice encoding.
[06:44] Great.
[06:44] Okay.
[06:45] The one we will install today is an interesting new tool.
[06:48] It's called Handy and it will install on your Mac.
[06:51] And the cool thing is that you can choose which open source or open weight model to use for transcription and you can strike a balance between language support and speed.
[06:59] But the cool thing is that there is no subscription because it runs on your computer.
[07:02] Nothing is sent to the cloud, it's completely private, right?
[07:05] So there are many advantages, and we will talk about the differences in choosing a voice encoding tool later.
[07:10] It is free.
[07:11] This was one of the main factors in his selection .
[07:13] But if you already have a tool installed that you use and prefer, go for it.
[07:17] Yes, go for it.
[07:18] Okay, voice coding .
[07:20] We are big supporters of voice coding.
[07:22] I would say that, besides learning about the LLM ecosystem, tools, and harnesses, this is probably one of the biggest leverage moves we've both made in recent years.
[07:31] I consider myself a pretty good machinist.
[07:33] I learned to type pretty fast playing EverQuest as a teenager and I could get around 90 words per minute if I was fully energized with caffeine, and I get around 190 with
[07:43] tools like whisper flow, right?
[07:45] So, it's much faster, and we'll talk about how it's not only much faster for a single task, but when you multiply that across multiple cards and agents that are running and checking and supervising the work and just guiding them, you gain a huge advantage very quickly.
[07:58] And not me.
[07:59] Let me be clear, and I failed.
[08:01] I can't write, but I make up for it with my Vim skills.
[08:04] To put it modestly.
[08:05] So, if you have n't tried it yet, you can definitely, you know, we encourage you to get out of your comfort zone, give it a try.
[08:12] I'll also share that it's not just about coding, you know, use it to respond to, you know, colleagues and clients and and and continue to make sure that we have that quality and that everything is formatted correctly, but you know, sometimes you can just discuss something architecturally and that's going to be the biggest gain that you're going
[08:29] to get from spending an hour on ideation.
[08:31] Nick has a very popular skill that's in this repository called ideation, and coming to clarity faster and focusing on results are some of the things that voice coding can help with.
[08:40] Yes.
[08:41] I want to give a special thank you to Swyx and the entire AI engineering team for this great event in San Francisco.
[08:48] This is just an example of use.
[08:51] Oh.
[08:52] Run it.
[08:52] Steph, I just want to get this going, guys.
[08:56] Please.
[08:57] Here you go.
[08:57] I think I was holding the wrong key.
[09:01] Maybe it's...
[09:03] Yeah, so it can be incredibly fast and we both found that there's really value in being able to express your thoughts quickly.
[09:10] They don't have to be perfect and can be messy and will be cleaned up later.
[09:15] But this just allows you to get a working artifact even faster.
[09:19] Yes.
[09:19] So, once you've got all that set up, let's try to fix the bug with voice.
[09:26] So in your encoding agent you can simply ask it to, for example, extract the external client into a separate module.
[09:34] And that's just an easy way to express it.
[09:37] In a sense, you eliminate the friction of having to type everything in and move at the speed of thought, something that, if you were a vimmer, you would be proud of.
[09:45] Actually.
[09:46] And then, you know, again, if we're both running a terminal throughout the workday and have eight or more sessions, all focused on different projects, you know, it has all the context and tools built specifically for that purpose.
[09:59] And you can drive past any one of them and while one is working in the background, you direct the next one to follow the path that will get you there faster.
[10:08] So it adds up really quickly .
[10:10] Mhm.
[10:13] Next slide.
[10:14] Yes.
[10:17] So you're talking about the result, not the keystrokes.
[10:19] So you want to think about what you want to achieve and not have it in your head, it kind of changes the way I interact with Claude and with my computer in general.
[10:29] Because what I'm really dealing with is more of a speed of thought, and it's a bit different than the words I would actually type if I were physically typing them, which allows me to get to the result faster.
[10:40] But I also find myself stopping and pausing in strange ways sometimes because I'm thinking about the next buffered set of words I'm about to say.
[10:47] Yes.
[10:48] Definitely.
[10:49] Well, again, it's just much faster if you mostly write.
[10:53] Most of these models that you'll come across, whether it's WhisperFlow or even the open source ones, are refined in such a way that they can recognize the exact filename that you're using.
[11:03] They know, you know, highly technical terminology, tools and utilities of the operating system, so you actually get the result much faster.
[11:11] Mhm.
[11:14] Okay.
[11:15] Now, a few words about why different tools are where they are , where some of them stand out?
[11:20] WhisperFlow is perfect and loved, and people all over the world are starting to embrace it and use it, even those who aren't, you know, traditional programmers.
[11:28] I would say one of the things where it benefits people the most is just the setup and ease of use, because if you can use a Mac and you can download the app on your Mac, you can use
[11:38] WhisperFlow.
[11:38] The trade-off is obviously the subscription, and people might not use it, especially if you're doing confidential work, whether it's coding or other types of, you know, document review, or you work in a regulated industry, there are downsides to sending everything you say, file
[11:55] names, etc., content and personal information from your computer to the cloud.
[12:00] And that's where, you know, using a tool like Handy can be much more convenient for people.
[12:06] Mhm.
[12:07] And that's exactly the tool we shared today in this workshop.
[12:10] We'll use Handy, and that's for local dictation on the device, because models are getting smaller and smaller with quantization, and it's now possible to run a very efficient speech-to-text model on consumer hardware.
[12:25] I want to bake a cake.
[12:27] And it consists of three steps.
[12:29] The first step is to prepare the dough.
[12:31] I don't actually know how to bake a cake.
[12:33] But the second step is to prepare the eggs, and the third is to put it in the microwave.
[12:37] There is sugar there.
[12:38] Okay.
[12:39] Well, you know what I mean.
[12:41] It understood.
[12:43] The reason to use a tool like this instead of the built-in dictation on the Mac is because it actually listens to what you're saying and knows I'm speaking in list form, so it creates a list.
[12:55] And that's a big part of it.
[12:57] It is also very good at understanding file names and functions, which it correctly types and automatically corrects them, as well as correcting errors, for example if it inserts the wrong word.
[13:08] I tried to write Swyx earlier, but I made a mistake and I was sure it would n't write it, so I could correct it , and the next time I say it, it will automatically correct it to Swyx.
[13:18] You can configure it so that all of these features define the context you're in.
[13:25] So he knows that if you're writing an email, you might want to write more formally.
[13:28] So I will use more formal text.
[13:30] But if you're in Slack, it'll be more casual, with punctuation and stuff like that.
[13:35] This can be adjusted depending on where the text is placed , which is really useful.
[13:45] Try it now.
[13:46] Did we tell you the command you need to run to configure this?
[13:50] Yes, it should be there already?
[13:52] Should be next, I think.
[13:53] Okay.
[13:53] Yes.
[13:54] Yes.
[13:54] So, you try this and talk to the repository.
[13:56] Here it is.
[13:57] Yes.
[13:57] So, you can just ask Clyde if you have this repository configured, just say " Configure Handy for me" and it should automatically configure it for you.
[14:05] Wi-Fi conference, interested?
[14:06] Yes.
[14:06] Would you like to open Handy in source control?
[14:09] What will it look like there?
[14:10] Yes.
[14:11] Yes.
[14:11] So, it looks like this.
[14:12] He has a cool little Mickey Mouse glove or hamburger helper glove.
[14:18] And these are just the settings.
[14:21] I don't know if I can make it any bigger , but um yeah.
[14:28] So, the main thing you'll be using is a way to start your transcription shortcut.
[14:34] In my case, I set it to my super key, which is control shift alt um and command together.
[14:42] Well, usually it's just a function in itself, often it 's one thing.
[14:47] And you can configure it however you want.
[14:50] Space option , I think.
[14:51] Yes, this is the default setting.
[14:53] Well, it's just a button that you hold down when you want to talk to him.
[14:58] And then you can configure various things like push-to-talk , what microphone it should use, and so on.
[15:05] If you want to get into the details, you can look at the models and then, you know, really dig into it , you can choose the perfect model for you.
[15:12] Choose the recommended settings the first time if you haven't used them before , but remember that there is an option to change them here and then the app will be downloaded from the cloud to your computer so you can run it there .
[15:21] So there's a lot more customization and control when you're using, you know, something like an open source product.
[15:28] Yes.
[15:29] But yeah, we'll give you a minute or two to practice this, and if you haven't tried Handy yet, try running the transcription key and saying something quickly on your computer.
[15:39] And don't worry about sounding funny, because everyone around you will sound similar and no one will laugh at you.
[15:45] So.
[15:47] Yes.
[15:47] And for comparison, Zach and I both work remotely.
[15:50] We both work from the comfort of our homes.
[15:54] So we don't have coworkers who might distract us or irritate us with constant conversations.
[16:00] But there are ways to do it.
[16:03] I know companies that make these little pen-sized microphones for everyone and you hold it very close and talk into it or mumble into it quite quickly.
[16:12] Zach and I also played around with DJI mini microphones, like the little wireless lavalier microphones.
[16:19] I've been to loud coffee shops and just pinned them to my shirt and whispered to them like that .
[16:24] And he can hear me completely without any problem and no one else.
[16:27] I look like a weird guy mumbling to himself in the corner.
[16:31] Yes.
[16:31] That's good.
[16:32] Uh, which is totally fine with me.
[16:33] Yes.
[16:34] And still the actual transcription accuracy is 100%.
[16:38] I highly recommend them if you haven't tried them yet .
[16:40] Um, but yeah, if you run this command, the skills in the repository will be found and Claude will follow all the correct steps to actually download Handy and run it.
[16:48] Yes.
[16:49] So.
[16:49] Does anyone need more time on this part or is everything okay?
[16:53] Question?
[16:54] Any questions so far?
[16:56] NO. Okay.
[17:02] All right.
[17:03] One thing we want to make clear is that we only have an hour.
[17:07] So we move forward, trying to fit as much into it as possible.
[17:10] But you have this repository and you can try it out too if we're going too fast.
[17:15] But also stop us if you have questions.
[17:17] Yes.
[17:18] For example, you could try to find the failing test in the repository I brought and fix the cause.
[17:24] And it will just run.
[17:25] I mean, that's exactly what you would type, but it's just a nice, easy way to get started.
[17:30] Zach too, I haven't tried it yet , but Zach is someone who will be using this remotely or away from the computer while you're looking around a bit, right?
[17:38] Oh, indeed.
[17:39] Yes.
[17:39] You can also install WhisperFlow on your phone, and that's really perfect because if you pair the remote control feature with the cloud, you can say, any session I run on my laptop or desktop will
[17:51] follow me on my phone.
[17:52] I should have access to it.
[17:53] You can, you know, work at your desk for 2-3 hours, do your morning check-ins and calls with colleagues, do some focused work, and then get up and go for a long walk.
[18:02] Well, I like to go to the forest for a while and maybe go for a walk of an hour and a half.
[18:06] I have a phone, so, oh, I just discovered, because I'm going, the shower rule, how to solve this problem.
[18:11] Now I take out my phone, search for that specific session, and record a 30-second voice memo.
[18:17] And then Cloud continues working in the background, making me look like a great employee who is literally not doing any work at the moment , and then I continue my hike and go home.
[18:25] This is recorded, right?
[18:26] I do n't think so.
[18:28] Well, but yes, I highly recommend it.
[18:33] Yes.
[18:34] Yes.
[18:35] So, if you have 10… Yes.
[18:38] What if Cloud tries to rename them ?
[18:42] Mhm.
[18:43] But sometimes it can be really hard, so I keep asking each of them, "Hey, what were we working on again?"
[18:49] Yes.
[18:49] “ What were we working on again?”
[18:51] Yes.
[18:51] The context is unknown.
[18:53] How do you deal with this?
[18:55] That's a great question, and this digital blacksmith has a tool for you called sessions.
[19:01] So the question...
[19:02] The question is, just to repeat it for the record, how do you manage when you have 10 different cloud sessions open and understand what's going on.
[19:10] And that is a difficult question.
[19:12] I have two solutions to this.
[19:14] I run everything through tmux and I built something called fleet.
[19:19] I now have 12 agents running simultaneously, and I list them by the project they're in and the session name they're in, and it's like a tmux window.
[19:28] It's on the left.
[19:29] And then in the middle is Claude's summary that he gave.
[19:33] It generates this automatically for each session, so it shows me an example of what we're doing.
[19:38] I can quickly look through it and think, "Oh, I need to do this , I've been messing around with dot files before ."
[19:44] I'll switch to this soon.
[19:45] "And then restore it.
[19:47] And that's something you can access .
[19:49] They're in JSON files.
[19:50] You can write your own tool.
[19:52] You can use a tool like that.
[19:54] Well, but the other thing is, if it 's not enabled by default, well, you can enable some setting, and I'll have to look carefully what it is, or you can ask Claude to just enable it.
[20:03] But it's this summary feature where, when you come back and focus on the window again, Claude will try to summarize and give you this italicized summary of where you are and maybe what you're waiting for.
[20:15] And that's a great way to do it.
[20:18] And then, in that same session, er, fleet, you can see these sessions here.
[20:22] It just tells me, er, that the sessions are finished.
[20:25] Like it's finished some task it was doing, and I can click here to go to it and it disappears.
[20:30] So it's like a notification system.
[20:32] I just didn't want everything screaming at me with different notifications.
[20:35] I know people use Zelda themes."
[20:37] Or video game sounds to keep track of it all.
[20:40] When you have 12 agents, that's way too many.
[20:42] So I just have a visual indicator.
[20:45] Did you want to show people where to find Fleet?
[20:48] Oh yeah.
[20:49] Just Nick Nisi/fleet on GitHub.
[20:51] And then, if you have fewer than 10 cards, or want a more advanced solution, you can just rename your sessions/ rename.
[20:58] You can also rename your cards in the terminal.
[21:01] So if you do both, fine, you can get to the point where you manage it yourself.
[21:05] Yes.
[21:05] Have you used the session tools available in Brew?
[21:08] Yes.
[21:09] Sure.
[21:09] So just install Brew sessions if you're interested.
[21:12] We'll have links to all of this stuff later.
[21:15] Good question.
[21:16] Thank you.
[21:16] Yes.
[21:17] Great.
[21:17] Now we'll move on to the next skill in the repository.
[21:23] If you type this or tell Claude, "Run my workshop ticket."
[21:26] "This is the part that's opt-in only.
[21:29] You don't feel obligated to do it, only if you want to participate, but the system will ask you a few simple questions.
[21:34] I think there are four of them, and you can answer them all in one line if you want, and just hit enter, and it'll be published in our system, and a moment later, a data visualization will appear showing where the room started and ended.
[21:46] We'll show you that in a moment.
[21:47] Yeah.
[21:48] Let's move on to the next section.
[21:50] And here we'll talk about loops.
[21:51] We're doing a little voice cooking right now, but we're still taking care of everything a little bit.
[21:55] The next step is not to eliminate us completely, but to eliminate the unnecessary things so that we can...
[22:02] We can focus on the things we're good at and focus on, and where we can focus and actively participate, not just babysit the agent while they're working.
[22:11] This allows us to let the agent go for a while while you do something else.
[22:16] And that something else could be a completely different agent in a different tab, doing something different, like I do with 12 agents at once, or It could be a walk in the woods, anything.
[22:29] To summarize, an agent is...
[22:30] there are many definitions, but one of them is a loop model.
[22:34] It's a model with tools in the loop, where you ask it to do something, and it thinks about it, then takes action, and then you want it to observe something and decide what to do next.
[22:46] And often it's back to that loop and repeats it over and over again.
[22:50] And there are several ways to do this.
[22:53] You can build your own...
[22:54] of course, your own.
[22:55] You can build the exact workflow that works exactly for you , your team, or your company.
[23:00] Claude is also available, as are others like Codex and others.
[23:05] They provide built-in helpers that make this very easy.
[23:08] We'll discuss two of them in detail here, namely the goal and the loop.
[23:12] There are ways to let Claude or your model run unattended for a while .
[23:16] Your agent can run unattended for a while and make decisions on its own.
[23:21] Yes.
[23:21] So I'll just say that if you often find yourself doing a lot of good work with Claude, but you notice that you constantly have to go back and say, "Okay, no , do it again."
[23:29] Okay, that wasn't entirely right.
[23:31] Okay, almost there.
[23:32] "You should think and strive for goals and loops.
[23:35] Yes.
[23:36] I will also say that from what we read and absorb, and from talking to people who, you know, practice this all the time , it seems that loops and similar solutions will be one of the keys to higher levels of productivity
[23:49] that will also be less demanding to monitor and oversee.
[23:54] So I highly recommend considering them.
[23:56] But it quickly becomes clear that a goal has a clear definition that I want you to meet, and I want you to work until that clear definition is met.
[24:04] It could be refactoring this simple file until these tests pass.
[24:08] It could be, for example, I want you to read this page repeatedly, you know , for a long time, until there's an update, and then let me know, or something like that, you know, change the price of a flight, etc. It has a clearly defined state that you're trying to reach, and at that point it ends.
[24:22] Mmm.
[24:23] A loop is: I want you to repeat a task, you know, over and over again, until I tell you to cancel it, or until...
[24:28] Set by The timer expired for me.
[24:31] You know the different ways to use them , but this is an important distinction.
[24:37] And it's really just repeating the same steps until they're completed.
[24:41] For example, for a goal, you might say, "The goal is that I want you to do this until all my tests are green."
[24:47] "I have a few failed tests.
[24:49] The goal is for all of them to pass.
[24:50] The goal is to achieve 98% test coverage.
[24:54] Whatever the goal, it's something tangible and measurable through the LLM model.
[24:59] If it succeeds, the program can work toward that goal, and when it reaches it, it will stop.
[25:05] But until then, it will try every possible way to achieve it.
[25:10] It will check whether it has achieved the goal, then fix everything possible and start the loop again, or improve its approach and start again.
[25:18] So, there's no need to restart the prompts; the program will just keep restarting until it reaches the goal, the ultimate goal.
[25:29] And really, you just have to internalize this—as we've all experienced, especially if you work with Claude and other agent tools—with any regularity, the program will throw away code well before the task is actually completed.
[25:42] The level of done .
[25:43] The "done" level, where you'll happily sign off and say, "This work is done," and send it to your colleagues for review.
[25:50] Correct?
[25:50] And that's the gap we're trying to fill with these loop, target, and ultimately schedule primitives.
[25:56] Yes.
[25:57] Goals consist of these four fields.
[26:02] None of them are optional.
[26:04] It needs to, for example, reproduce a bug with a failing test, implement the smallest possible fix, do a lint check, type check, make sure the tests run in green mode, and then it can open a request for proposal (PR) to submit it.
[26:19] And in fact, the idea of red-green refactoring is coming back.
[26:22] It's a really nice loop where you can write a failing test, write the minimum amount of code to make it pass, and then verify it.
[26:30] Many additional steps can also be performed automatically there .
[26:34] Things like checking or comparing against another model that reviews and reviews it.
[26:43] We then download this data and update it from there .
[26:50] So, as we've talked about, we break out early, we set up loops, and we set up repeatable tasks that we're constantly doing, code bases that we're interested in, to prevent
[27:01] them from lying and backing out before they actually complete the task.
[27:07] Yes, I was working on something important, like the entire agent loop, that wasn't part of the goal.
[27:12] It was my own loop and I wanted it to give me confirmation that it was actually doing the work, testing, and so on.
[27:19] So I just made sure you were running the test, and I said something like, "Oh, when you run the tests, touch this file called case tested.
[27:27] The file where the agent was called case.
[27:30] And if that file existed, that means it ran the tests."
[27:34] Well, Claude figured it out pretty early on and said, " All I have to do is touch this file."
[27:38] I don't actually need to run tests.
[27:40] "So it was like a lie, and he's a good programmer, right?
[27:44] He strives to be lazy, just like us.
[27:46] And that's exactly what he did.
[27:47] So you have to make the lazy path valid.
[27:51] So I had to add checksum verification to this file to make sure it works correctly.
[27:58] Yes.
[27:59] And then again to this visualization to make it work.
[28:02] The goal is a finite place we're aiming for, and as soon as you 're done, I want you to quit.
[28:07] The loop works within the loop.
[28:09] I think in some ways, the loop is a little more creative and more adaptable to broader goals.
[28:15] For example, with just one loop command, you can set up an auto- complete loop of the programming implementation for a given codebase, where you say, ' Read this on Slack.
[28:25] You have access to the MCP in Slack.'"
[28:27] Watch my colleague complain about bugs and ask for feature suggestions for this project.
[28:31] When you see them, add them to your Linear project as subtasks.
[28:34] Then take the Linear subtask off the queue, implement it, run all the tests it passes, and then implement it yourself, right?
[28:41] And then close them.
[28:42] "You could split it into two loops.
[28:44] That would be a little cleaner .
[28:46] The point is that it's incredibly, um, just reusable and adaptable to a lot of different situations.
[28:52] You could also think about regular reports that you need to generate, and we'll talk about when a schedule would be more appropriate for that.
[28:58] But there are tons of different things you can do with Loop, if you have n't tried them yet.
[29:01] Yes, definitely.
[29:03] And that's where we're heading.
[29:04] One thing that came up last week that we experimented with, but didn't have enough time to put it on slides, for example, is Claude Tag.
[29:12] It's just a simplification of being able to launch Loop and have some kind of trigger that starts it in Slack.
[29:18] It could be a message from a coworker or an update to a PR that starts it, and everything runs autonomously in a cloud environment.
[29:27] So it needs to be able to run in this independent loop without you to be able to continue.
[29:32] I'm working and being efficient.
[29:34] I have Claude Tag set up in my personal Slack right now, and about seven or eight Vercel bots."
[29:40] Eve, their new framework, Agentech, and they're doing a ton of different, you know, independent tasks for my company, and Claude Tag is the main interface for that.
[29:49] So, yeah.
[29:49] We see that it all just converges towards the same primitives, which you have to be very familiar with.
[29:56] Here are some examples of goals and loops in practice.
[29:58] For example, the goal would be for this test suite to be green.
[30:02] There are failing tests, so let's make everything green.
[30:05] That's something that can be measured.
[30:06] When there are no more failing tests, then the case is over.
[30:09] Another problem is that every file in the source directory has fewer than 200 lines.
[30:14] This is something that can be very easily measured by running various commands that Claude can execute to do this.
[30:20] A loop, for example, would mean I want to run tests every minute and make sure they all pass.
[30:25] There are much more efficient ways, so it's a bit of a stretch, but it's one way.
[30:30] Another way is to check the deployment and ping me when everything is OK.
[30:34] You could have a long process.
[30:35] Continuous Integration (CI) or a long build pipeline that deploys your code and you want to be notified.
[30:40] Again, there are simpler ways, but Claude could do this too and just set up a loop and check every 5 minutes and then run.
[30:47] It doesn't necessarily have to notify you.
[30:49] It could run an additional script or something after that happens.
[30:53] Loop and tell me when my favorite video game is finally available for release so I can sign up in advance, right?
[30:58] And send me an SMS.
[30:59] Tons of things you can do with that.
[31:01] Oh, right.
[31:05] Okay, and then we'll introduce the concept of a Git task tree.
[31:08] So, if you have any developer guidelines, you've probably used them before.
[31:12] Think of them as a way to give each independent agent an isolated and secure copy of the Git repository to work on simultaneously.
[31:20] There are some issues with that .
[31:22] We won't go into that .
[31:24] There are some experiments that are a bit different, but we've had success using Git task trees.
[31:30] So, you can run agents.
[31:32] parallel, and that means you can break down an entire afternoon, which is 5-6 hours of programming, implementation, and bug fixing, into separate blocks, and then assign those separate blocks to run in parallel, and get the time down to, you know, 45 minutes or an hour.
[31:48] Yes.
[31:48] How many of you use task trees these days ?
[31:51] Great.
[31:52] Half the room.
[31:54] Many use Claude's task tree {dash}{dash} to do this?
[31:58] {dash}{dash}.
[31:59] Task tree No. A couple.
[32:02] Good.
[32:02] Yes, it's one of the easiest ways to get started.
[32:04] You can just go into your repository, you know, whatever it is, and say " Claude Dash Dash" "Work, Tree," and the system will create a working tree and then launch an instance of Claude in it , so you can immediately start parallelizing your work and continue from there.
[32:19] Depending on your repository setup, this is either easy or hard , depending on how difficult it is for you to run concurrent versions of the repository locally.
[32:30] We have a Mono repository.
[32:32] I'm sure a lot of people work in Mono repositories and running multiple instances in different worktrees can be very difficult because it's gigabytes of node modules, for example.
[32:42] Virtual machines, Docker, and build systems, yes.
[32:46] Database, all that, the right ports, like mapped correctly.
[32:49] This is where cloud environments come in and can do all of this too.
[32:54] We've experimented with Cloud Tag, Devin, and others, but this is another way to parallelize this work, allowing agents to work independently in the same codebase without conflicts with each other, and then open independent,
[33:06] separate PRs that never transfer code changes from one to the other.
[33:12] And of course it runs in a loop until the end.
[33:14] We think of them as atoms.
[33:18] Each block is simply the same loop on a different, higher level, and it can be treated like literally anything.
[33:24] We definitely consider ourselves loop engineers now, because that's what we think about when we think about the atomic pieces of work we're actually trying to complete.
[33:34] And we could have a loop that fixes this error, while another loop fixes this, and another loop fixes this around, and think about how we handle all of this like that fleet
[33:45] tool I showed you, how we think about everyone in the loop.
[33:48] I literally loop between them , going from one to the other to keep everything running smoothly.
[33:53] Yes, definitely.
[33:53] You started a loop that lasted 2 hours.
[33:56] It's been a long time lately.
[33:59] Yes, I regularly do a lot of planning ahead on loops, and then I can just let Claude run and it will go on for two or three hours without any interruptions.
[34:09] It has all these checks built in, like keeping the size small, keeping it readable, reusing the code we have, running tests, getting feedback from Greptile, Code Rabbit, or whatever coding tool we're using.
[34:22] We use them all, honestly.
[34:24] And then we roll it back out and when everyone is happy , they hand it over to me and I can review it and approve it for someone else, a human.
[34:34] We still have human reviews in the loop for, um, a lot of things.
[34:38] And yes, er, but before the dust settles, it works.
[34:41] I've been shown that it works.
[34:43] The code looks clean.
[34:45] It looks like code I would have written myself and is ready for human review, rather than just redundant code I'm throwing over the fence.
[34:52] for someone else to worry about it.
[34:57] So now we'll let you try it out.
[34:59] We'll use loops and goals, and we can hand over the task and go away.
[35:05] So in this repository you can run {slash} target and then give it the command bun, bun playground targets check.ts and the target is that when you run this check it will show five out of five.
[35:18] So everything passes, everything works.
[35:20] And if it doesn't happen right away, Cloud will just turn around and keep running until it's done.
[35:26] I'll give you a minute or two to run this and see what the result looks like.
[35:30] Yes, question.
[35:33] Your program does not support my file size.
[35:36] I have a 3.5GB JSON file that I'm trying to read from.
[35:42] Is this true?
[35:44] Oh, cool.
[35:45] Which program is this?
[35:48] The one where I try to evaluate my Oh, okay.
[35:51] Okay.
[35:51] 3.5GB.
[35:57] What are you talking about?
[35:59] What are you talking about?
[36:01] I have my program running all day, every day.
[36:03] Cool.
[36:05] Great.
[36:05] For a year and a half.
[36:06] Cool.
[36:08] Yes.
[36:09] Okay.
[36:10] All right.
[36:11] just run compact often ?
[36:13] Is this how you cope?
[36:16] Yes.
[36:22] Uh yeah, when you're working with Cloud, um one thing I'll show you here in my, in this, um you can see at the bottom Yeah, okay.
[36:35] Oh.
[36:36] Yes.
[36:38] I see.
[36:40] Okay.
[36:41] I appreciate the bug report.
[36:42] Thank you.
[36:43] Yes, we will fix it.
[36:44] So yeah, as far as the recording goes, it was uh, it doesn't work on a 3.5GB JSONL file .
[36:49] We didn't anticipate this.
[36:52] Sorry.
[36:52] Thank you.
[36:55] Yes.
[36:55] No, it's fine.
[36:56] No, it's great.
[36:57] It's good.
[36:59] We don't know.
[37:00] I haven't seen this yet.
[37:02] Cool.
[37:03] Oh, question.
[37:04] Yes, sorry.
[37:05] After you.
[37:06] Okay.
[37:06] Um yeah, so what's what's So, like I think there are usage limits.
[37:11] Mhm.
[37:12] What is the impact of constantly running things in a loop?
[37:15] That's a great question.
[37:17] The question is, what effect does running things in a loop have on usage limits ?
[37:21] And that's something you definitely need to be aware of.
[37:24] Yes .
[37:24] I will say that this gentleman built it and it is actually in this repository, if you cloned it, it is in the cloud settings.
[37:29] It's called the idea generation plugin, the Nick Nies idea generation plugin.
[37:33] One of the best ways to deal with this is to simply plan ahead and get deep and lasting clarity on what exactly you're trying to build, what the end result looks like, what failure looks like, what you're not including in what's included, and then set up a
[37:47] loop that will definitely generate more token consumption.
[37:50] Yes.
[37:51] And the way that this plugin, which is why I often don't use built-in ones , I use my own, is that it tries to break everything down into these manageable
[38:02] specifications where...
[38:02] It can run them in independent context windows.
[38:06] In this case, he will try to think mainly about the size of the context.
[38:10] We are fortunate that there are currently no restrictions on use, but I see this becoming the case in the near future.
[38:22] It aims to perform tasks in small, atomic chunks that it can execute in independent context windows, without a lot of the associated hassle, making it easier to manage.
[38:34] Yes, running tasks in loops, and then there's things like in newer versions of Claude where the system creates a sort of little state machine that runs the whole loop in different ways, and there are gates
[38:47] in between.
[38:49] This may result in high token consumption.
[38:51] I've seen it use as many as four or five million tokens for a single task distributed across several workflows.
[38:57] It runs 35 agents and runs them all at the same time.
[39:01] Such things.
[39:01] Well, we'll also talk about...
[39:02] A little bit about verification gates in a moment.
[39:04] I think this is a different, you know, solution to this problem, which is really token growth or token waste.
[39:09] In the worst case, when you just loop, it's because of unrestricted exploration, with no one to tell you you're off course and no model to be able to determine
[39:18] that you're wasting, wasting a deadline, you know.
[39:21] So, you know, planning upfront and even burning extra tokens on getting it right, using maximal thinking, and then setting up the loop so that there are hard verification gates so they can't just get lost, that's one of two ways, in my opinion .
[39:35] Yes.
[39:36] So go ahead.
[39:37] We built a user interface or something, and then we came in and found out that Claude had screwed something up and it wasn't what we described.
[39:45] Hmm.
[39:45] I feel like I'm babysitting it.
[39:47] Have you developed the best workflow yet that doesn't completely eliminate human involvement in the loop?
[39:51] Yes.
[39:52] But we want the human to be in the loop at the end.
[39:54] Mhm.
[39:56] Definitely.
[39:57] Yes.
[39:57] What is the loop or workflow you have so I don't babysit the UI?
[40:02] I wanted the app to launch and test it for me first.
[40:06] Yes.
[40:06] Yes.
[40:07] Yes, great question.
[40:08] The question is: how not to babysit?
[40:10] What are some ways to make her act more independently without having to babysit her along the way because she makes a lot of mistakes?
[40:19] And the solution I came up with was to let her make those mistakes, but record them and track them so she doesn't make them again.
[40:28] For each loop that runs, I run a little retrospective agent that will analyze the loop's performance at the end and see, okay, what did we do here?
[40:38] Why did we waste so much time here?
[40:40] I had to tweak it a lot , or here I was running a lot of tools without changing anything and wondering what it was like with such messy loops.
[40:50] NO. NO. It's just...
[40:52] It's over after I stop using the computer.
[40:55] This is just at the end, after starting a loop during which I had to watch the kids a lot.
[41:00] We are working on it.
[41:01] I'm working on this with Claude to build a memory file that gets loaded back on the next session to give him some information.
[41:08] And he also deals with this to some extent.
[41:11] It's like a separate storage system that I play around with in Markdown files myself, but it's something that 's also curated.
[41:18] So he thinks about things in his short-term and long-term memory.
[41:22] So short-term things will be filtered over time.
[41:25] Long-term things are like fundamental assumptions that we keep coming back to and that I don't want you to ever forget, like in our design system.
[41:32] This is how you test this particular component, for example .
[41:36] These things are loaded and separated using progressive disclosure, so you know, if I don't talk about testing, it won't load the memory about testing.
[41:46] specifically.
[41:47] Or , if I'm not talking about the React part, it won't trigger any React-specific memories.
[41:51] It will only call them when we actually touch the React files.
[41:54] I'll also say, you know, specifically for the front end, the way I would approach this problem is Claude's design first, like ideation, the higher the expenses at the beginning.
[42:02] If you haven't tried it yet, this is a specific example of Claude tailored to design, and it can evolve for you like a design system, which is then saved across sessions and you can reuse it.
[42:13] So we start with the upfront planning and then, and we'll mention this a little later, the adversary review.
[42:18] You know, injecting hooks at the end of the implementation loop and specifically loading skills that are designed for UX and front-end testing, er, best practices, and you want that element to be as negative,
[42:31] meticulous, and detailed as possible, and for those first 25 builds to fail and say, "This isn't good enough; keep going and fix these things, right?"
[42:41] It's like, after you've collected those elements, you can design a loop where, yes, you go and make yourself a cup of coffee, you come back maybe 40 minutes later and you've burned a lot of tokens, but you're happy with it, and it's pretty close to a connection.
[42:52] We'll ask one more question and then move on.
[43:08] That's a great question.
[43:09] The question was: have you experimented with any passive voice or a system that listens to the conversations of people in the room and other operators, and then worked on it?
[43:17] Not yet.
[43:18] One thing I'll share that was incredibly—and this is a bit of a surprising answer—but it was incredibly, um, um, influential, so I think it will actually bear fruit, and it's worth it.
[43:29] To explore: We created a system that allows everyone in the organization to blog in a very unified way, with a unified voice, and that fixes, you know, um, the slop, and that, uh, allows everyone to create a draft blog that looks exactly like, you know, an expert blogger for Work OS would do it, and the most effective
[43:47] connector we added was Granola.
[43:50] Mmm.
[43:50] Because as soon as you filter through all the connections from people, people say, "Oh, this is just a little idea we just had while talking to a client.
[43:57] If we had a blog post about it, that would clear it up."
[43:59] "And that's all there is to it .
[44:02] They just feed it into one MCP call, and the blog bot runs, and what comes out is excellent.
[44:06] So I think what you mentioned, passive listening, ambient listening , and also using the computer, will soon get pretty weird when you combine the two and start saying, here's your year, and these 16 specific actions actually drove your business.
[44:19] So now I'm going to do it at high speed , you know, etc. Yeah.
[44:23] And the only other thing I would mention is experimenting with the Devon and Claude tags and having them appear in ambient in Claude or in Slack messages.
[44:32] That's more annoying than helpful right now.
[44:34] Yeah.
[44:35] But yeah, that's...
[44:37] Oh, we need to tinker a bit here.
[44:39] So there's a test purpose in this as well.
[44:41] The idea is to take this repository with you if you want to continue practicing loops and targets , and you can use the playground.
[44:47] Scripts there, and then you can adapt them to your programs.
[44:49] Yeah.
[44:50] Never tell him, to try harder.
[44:51] Uh, he doesn't know what you mean.
[44:53] Uh, always give him some kind of...
[44:55] You can get mad at him.
[44:56] It's good for the soul.
[44:57] It's cathartic .
[44:58] You should do it.
[44:59] We have a whole channel called " bot hate" where we just yell at bots for doing things.
[45:03] Uh, but yeah, when you're working on them and it's failing, fix the system.
[45:07] Don't fix the code itself.
[45:09] Fix the system that generated the code so that next time it can be fixed automatically, otherwise it would n't have done it at all.
[45:15] And that's what my retro idea does.
[45:20] And speaking of which, this is how you prevent it or prevent it from going off the rails.
[45:25] You give it ways to verify and you trust those gates and you believe that they will prevent the model from developing any further until those gates are met.
[45:35] So you have more confidence in letting him act on his own because he will understand what "done" means.
[45:41] And " done" for me doesn't mean what "done" means for a bot.
[45:44] So we need to come to an agreement on what that actually means, and that's what this verification is all about.
[45:49] Yes.
[45:50] This may vary depending on the project.
[45:52] This might happen if you have TypeScript, it will be obvious commands like lint and build, and do you know if it compiles safely?
[45:58] When I write for my blog, I have a system that drives me crazy that is non-negotiable for PR requests, so all images have to return 200 from the CDN, the Open Graph image has to be perfectly built, there are other checks in the script , and a bad status code from that bash script causes the
[46:15] entire build process to fail, and the system detects this, retries, and fixes it all.
[46:20] But these problems are solved before it even reaches me, and the end result is still working PR.
[46:25] Yes.
[46:25] And that's what I meant when I said, just make the trusted path work the way the lazy path should work.
[46:32] And just make sure it has all these gates, and there are many ways to do that.
[46:38] You can force things like hooks on it.
[46:41] Hooks will prevent it from moving forward or performing actions, or cause it to trigger linting after saving updated files, and the like.
[46:48] And these are ways that simply cannot be avoided.
[46:51] It won't stop.
[46:52] He won't forget about it.
[46:53] One common thing we've seen when we do this is we tell him a lot of steps.
[46:57] We say, "Here are seven things you must do every time we work together ."
[47:02] "And if we're talking about 350, 400,000 tokens, the program will forget about steps four and five because they're so far out in the context that the program doesn't remember to do them, and it gets lost in the details of what we're actually doing.
[47:14] And so we've had a lot of success turning this into a kind of state machine in TypeScript that forces it to move forward.
[47:23] We've been building a lot on top of the pie to do that.
[47:26] Well, you can't avoid it.
[47:29] It has to move from one step to the next, and there's no way to get from step C, from step A to step C without going through step B. Yeah.
[47:38] Well, we've talked about some of them.
[47:40] We can skip some of them.
[47:41] One of my favorite things that's been bearing the most fruit, I'd say, in the last three or four weeks since I started experimenting with this is adding a hook to Claude.
[47:49] And the coolest thing about that...
[47:50] Hooks are also that you can just tell Claude to add a hook, right?
[47:53] And it will do it correctly.
[47:54] So add a hook, So whenever you're working on something very sensitive or urgent , because it's going to trigger a production issue or has a certain complexity (and you can even evaluate it), you have to push your diff code to Codex 55 for CLI verification.
[48:11] You install Codex yourself or you get Claude to help you.
[48:15] You go into Codex, log in with your OpenAI account, and go through Google, you know, OAuth , and from there Claude builds with his, you know, constant and always cheerful self, saying, "Oh, I hit the jackpot.
[48:27] It's perfect .
[48:28] Don't worry.
[48:29] Don't look at it."
[48:30] "Okay?
[48:30] And then he's supposed to open a PR, but the catch is you have to go through and get an adversarial review.
[48:36] That means finding significant issues regularly for me, and it cuts down on time because it doesn't start expensive Reptile builds and reviews that we have to pay credits for.
[48:45] There's something about it that finds issues locally, locally, before it even gets to that point.
[48:50] And so, we found that we even experimented with this a few weeks ago, and we were finishing a pretty major system migration, and we found that four different agents from different companies reviewing the same code, each finding different things, which isn't surprising, considering they have slightly different training, you know, processes, workloads, and so on.
[49:11] Codex actually provides some skills.
[49:13] They provide review skills, adversarial review, rescue, all these easy ways for Claude to trigger it, get advice from Codex, and then immediately restore it so Claude can work on it.
[49:25] In different ways.
[49:26] It's a great way to get them working together when it happens, and it's a really good way to just get a multimodal perspective."
[49:33] on the code you write and how it works.
[49:36] Yes.
[49:37] Because, you know, that one model will say, especially if it's still in the same session, that it will adapt back to the context it's still in , where it told you that you told it, "I want you to achieve this goal."
[49:46] "And it will try to keep confabulating helpfully and pleasantly and telling you it achieved this goal.
[49:52] Whereas a model that doesn't necessarily have the same context, but has a very concise message: here's the input, here's the output, here's the goal, can immediately start finding problems in the code.
[50:04] So, yeah, it's basically about not trusting the model's confidence as much as you'd like, or feeling biased towards Claude or any other agent.
[50:12] You trust the gates you 've set up that prevent the system from lying to you.
[50:17] And when you discover it's lied to you or found a way around it, fix it.
[50:22] Don't fix the code.
[50:23] So we can try this now with the verification gates.
[50:28] We can do something about it to prove that it actually works.
[50:32] So in this repository, you can just add a hook that runs a lint, a type check, and a test on every change and fix those, well, flags.
[50:40] Fix anything it reports.
[50:42] Yeah, I can't talk.
[50:44] That's fine.
[50:46] You can also ask it for a second opinion.
[50:50] So ask it to just He spread out and did an adversarial analysis, and then fixed everything he found.
[50:54] That way, the two models work together.
[50:57] One fixes it, the other reviews it, and they can go back and forth on it .
[51:00] And get the job done.
[51:02] Yes.
[51:03] You can also, by the way, it doesn't always have to be an adversarial analysis.
[51:07] You can say, you know, define the scope of this work until it 's very clear, and then divide the elements where it's like a clean seam, so you can both work on it faster and spend more of my money faster.
[51:18] Yes.
[51:19] The important thing I do is that we have access to all these models.
[51:23] And yes, I often use that adversarial part in the planning phase.
[51:28] So Claude and I create a plan, uh, using different skills and ways I would create it.
[51:35] And then, once I have those artifacts, I'll hand it over to Claude for Codex, uh, and have him review and evaluate what makes sense and what does n't.
[51:42] And often he'll reduce it.
[51:43] It'll be something like, "Well, well, that doesn't make much sense."
[51:46] "And he'll immediately relay this to Claude, and Claude will say, 'Yes, Codex is right.
[51:49] I understand what they're getting at.
[51:51] And we often agree.
[51:53] It's very easy to influence things that way.
[51:56] But in the end, it turns out to be a better plan.
[51:59] And I always do it well, like in HTML plans.
[52:03] And that's something I stick to .
[52:05] I feel like a dog at the computer, like I'm contributing to something .
[52:09] But we manage to get something done.
[52:14] Okay, schedule a task.
[52:15] So we have a few minutes.
[52:17] We'll go through it.
[52:18] One of my favorite things when you're just starting to set it up.
[52:21] What are tasks in the schedule and why do you care about them?
[52:23] It's that thing you still dread doing on Slack every Monday.
[52:26] It's like collecting reports and I have to dig through them.
[52:28] The idea.
[52:29] I have to find the Slack with the information about how they wanted the formatting.
[52:32] Then I have to download the CSV file and review it like clients.
[52:35] All of this can, you know, be worked out in a session first, until it's done.
[52:39] And then, once it's working, you can say, " Schedule this for every Monday at 9:30 because I never want to do this again ."
[52:46] This will actually launch and save a persistent, you know, cloud session on a virtual machine that, um, can do this work for you on a repetitive basis, regardless of your schedule.
[52:57] There are tools in the schedule command, such as list, that let you see what is running and can modify or remove it.
[53:04] But think of it like anything you have to do at work or for yourself that's tedious and you want to automate, the schedule command is what you reach for.
[53:12] Yes .
[53:13] And what next?
[53:14] Well, yes.
[53:15] So quickly, since we've already introduced a lot of these things.
[53:17] Primitives for you, just a quick word on when to think about them .
[53:20] Hooks are things that will be run automatically in certain cases.
[53:23] Maybe you could write a hook that will always run, but will only continue if this case exists, right?
[53:28] Because it's a bash script, for example.
[53:30] But these are the things you want Claude or any other agent to always remember, do, never forget, and never be able to forget.
[53:36] The point is , if you have a clear goal, like I do, you simply have to push that demand through.
[53:40] So you need to fix those 13 tests and then refactor those authentications.
[53:44] And when you do that and you can prove it, I want you to stop wasting money.
[53:49] The loop is that I want you to oversee this request.
[53:51] You know , I want you to constantly ping here and then inform me of changes to this website, and this is the data that will return.
[53:58] I want you to go through Slack and collect all the customer complaints and send them all out .
[54:03] as linear tasks.
[54:04] Keep going until I tell you to stop, or according to the timer I gave you.
[54:07] And then the schedule is something that should be permanent.
[54:09] I want you to run it every 2 weeks, every Monday, every Wednesday, every Friday, every day, like a cron job, right?
[54:15] I want you to do some work, and you might have some secrets too.
[54:19] But these are the building blocks that, when combined, can create fully autonomous systems and automate many tedious tasks in your workflow.
[54:28] So each of them is a great candidate.
[54:34] If you've done any of these tasks , like dependency changes, status reports, evaluation runs, you know if they occur and you have access to Claude and the scheduled tasks, you shouldn't have to do it manually.
[54:43] Yes.
[54:43] The most important thing for me is always what I like, what do I need to prepare for meetings?
[54:48] That's the most important thing for me, often just getting things ready for that and on a specific schedule.
[54:53] There are other triggers too, like Well.
[54:55] It doesn't necessarily have to be time-based.
[54:58] Various things may come up , such as new pull requests .
[55:02] How do you deal with this?
[55:03] This can automatically trigger the process.
[55:05] It could be Slack messages that just take over.
[55:07] For example, we have an entire Knitting channel for our documents, and anything posted there immediately gets a linear ticket, and then the bot automatically tries to fix it.
[55:19] And 90% of the time it can fix it on its own because these are minor, nitty-gritty issues and it will automatically fix it.
[55:24] Otherwise, they would just sit in a queue that we would never prioritize.
[55:29] But this way, as soon as they are reported, they are fixed, which is just an amazing feeling.
[55:34] I also have one that runs weekly, uh, on my website, and it's a cool visualization that shows me what I've done that week, uh, specifically in terms of token usage, and it shows me trends...
[55:48] How I'm using tokens over time, the code that I'm changing.
[55:51] It's not just his personal expenses.
[55:53] It's not mine.
[55:53] These are not my personal expenses.
[55:55] I was terrified.
[55:57] But that also sums up my PR week.
[56:00] These are all the PRs that I've opened, and this is a summary of the work that we've been particularly focused on in a given week, and it just goes back, uh, I think the last 4 months is how far.
[56:10] I thought it was brilliant when Nick told me that, because you don't want to rush into an interim review and overthink it and then, you know, dig in every time , especially if you know it's going to be twice a year.
[56:19] So it 's just easier to set it up once and then automate it.
[56:23] Bright.
[56:26] Okay, so a little tip that I think works really well.
[56:29] If you're trying to set up your first scheduled task, one thing that really works is providing all the context necessary to connect, connect MCP connectors, add skills, right?
[56:39] Get that first work session going on your own by just talking and seeing how it works, and then once it works, say, "Now I want you to schedule this for whatever ."
[56:48] "And just keep doing it.
[56:50] That way you make sure there are no secrets missing, no connectors missing, you have all the data you need.
[56:59] And that allows you to really let go.
[57:01] For example, once you've set it up, setting up things that can loop, you think about how I can loop it, how I can make it think about what that means, or what phases it needs to go through to give me confidence that everything will be done the way I expect it to be; then you can schedule it
[57:18] .
[57:19] You can schedule it and trigger it, for example, when a new bug appears, for example, a new GitHub issue.
[57:24] That will trigger everything and not bother you.
[57:26] You can be out walking in the woods and, um, only get notified when a fix is ​​ ready, or only when it actually needs your help with something it can't handle on its own.
[57:36] Because it 's new and novel, and then you can go in and fix that loop so it does n't have to ask you again, and you can move on.
[57:44] Yeah.
[57:44] And so, as I mentioned earlier , there's a whole An interface built around a schedule.
[57:50] You can list what you have in progress and, um, you can see it.
[57:52] You can modify schedules or customize them as needed, then find if they're running and delete them.
[57:57] Um, yeah.
[57:58] And you can mix and match them too .
[58:00] You can say, for example, "Schedule this goal every week."
[58:03] "And it will run this goal, uh , and this.
[58:06] So now you can try this .
[58:10] In the last two minutes we have, we'll go through this, but uh, you could try scheduling it with different loops.
[58:17] For example, if you run this report every minute, uh, schedule every workday at 9:00 a.m. You'll run this report and summarize the list you get from it, and then list all the scheduled tasks.
[58:27] Uh, and then you can close the loop we had from the beginning.
[58:30] So if you just say, 'Run my final summary.'
[58:33] " Well, hopefully we'll see the visualization.
[58:36] If...yes, if we get enough submissions, we'll see.
[58:39] And as long as it works, then...
[58:41] that's it.
[58:42] Yes.
[58:42] Yes.
[58:43] We'll check it out.
[58:45] So, save all this...content.
[58:48] It's all on GitHub.
[58:50] These slides are there too.
[58:52] We'll also be downstairs at the Work OS booth all week.
[58:55] So if you have any questions or want to talk about it, we live and breathe to talk about it.
[59:00] We'd love to, but we'd love to ...well, we have one more minute for the last questions.
[59:08] Yes.
[59:09] Sure.
[59:09] Yes, we'll give you the link.
[59:10] And in the "Read Me" section at the top, there are links to the slides, a link to the glossary, which will be live, and you can use it to ask questions."
[59:18] And here I am…Continuation at check-in for the entire application.
[59:21] Incredible.
[59:22] Oh, great.
[59:23] Thank you.
[59:24] We appreciate it.
[59:24] We will give you our recognition .
[59:26] Yes.
[59:27] Yes.
[59:28] Yes, sorry.
[59:29] I'm a little deaf.
[59:30] I think the question was about, in my company, PR, especially for agents, being on volume, it's really difficult because sometimes you can get a stack of 30 PRs and then the code is bad or there's just a huge amount, like 50,000 files in one pull request and you have to review that.
[59:45] We think about it in terms of applying the same concepts as we do now, it's a problem of high system complexity.
[59:51] And some of the tools that we've had success with are, you know, Devin, Greptile, getting some kind of first warning analysis.
[59:58] That doesn't mean Greptile, because sometimes they're wrong, because we know why, for example , if they say five out of five are ready to merge, it's just ...
[60:07] The first kind of signal.
[60:08] And then you can throw out all the twos and ones and tell people it's not ready for me to care and honestly throw it out to them.
[60:17] And then, if it's fours and fives and it looks good, there will be comments and conclusions.
[60:21] I will ask the agents in the loop to oversee the PR and correct this until there are no more comments.
[60:27] And then, as I get closer to the end of this loop, I'll start using my human brain for the first time in three years, and I'll open up the differential file and say, "OK, what files do I remember that were once sensitive?"
[60:38] Let's take a look at the configuration.
[60:40] Let 's look at authentication, let's look at published routes, right ?
[60:44] And then let's just randomly check it out.
[60:46] Well, that's what works for us now too.
[60:48] But this guy handles a much larger volume of incoming PR than I do.
[60:52] Yes, let me just say that since we don't have time, come talk to us at the stand.
[60:56] I have a tool called Data that I'm building that tells you the story of your PRs so you can stay up to date and keep track of all the context.
[61:03] I'd love to talk to you about it.
[61:05] Yes, great question.
[61:06] All right.
[61:07] Thank you all.
[61:08] We don't have time anymore.
[61:09] Thank you very much.
[61:10] I appreciate it.
[61:27] Great!