I have a ton of personal software that I've had agents make for me so that I can be more productive and the agents can be more productive. And these are all in packages inside of Kody, but this video isn't about Kody. This video is about how you can make your agents more useful and more powerful and more efficient for yourself. However, you build your personal software.

Every one of us needs to have personal software. This is the age of personal software and making software that works for you and specifically the way that you want is going to make you more productive, assuming that you have a good idea of what things are actually productive for you. And that is the real challenge in this day and age when you can just tell an agent to make a thing for you. It's really important for you to understand what are the things that agents can really unblock me from.

And actually, I've got another video where I talk about how your agent wants your job and you need to give that job to your agent and move up in the next step of the abstraction ladder. So go ahead and watch that video. But the idea here is that you look at all the things that you're doing today and you figure out how you can get agents to do those things. But even more, figure out how you can take the things that the agents are doing today and turn that into deterministic code so that your agent doesn't have to do that work either.

And now you go from spending many dollars on the tokens that the agents are using to less than a penny on the things that deterministic software can do for you. So there are layers to this. And we're going to talk about them. This is better with Kent, where you and I get better together by learning durable skills.

I hate model choosers. I hate having to choose which model to use for a given task. And lots of PRs are actually a bunch of tasks bundled into one. And I don't want to have to keep on switching the model or tell the agent to use a different model for each different task.

That's babysitting. I don't want to babysit the team lead and tell it, okay, for these tasks, you should be using these models because they're faster or cheaper or whatever. And for this one, no, this is a big task. This is really important.

We're going to have to make sure we use this better model. And so what I end up doing most of the time is I just use the model that I think is going to probably do the work at a reasonable cost. And hope that everything turns out okay. Well, this isn't a problem.

If I'm using Devin fusion, Devin is cognition software engineering agent. And fusion is the harness that routes across models while the agent works. So you get a strong lead for handling the planning, ambiguity and review. And then the groundwork is handled by cheaper sidekicks.

And so you don't have to babysit the team lead to make sure that it's using the right models for the right jobs. Devin handles all of that for you with its fusion option. So if you're interested in a strong agent that stays in the software engineering lane and stops making you play model roulette, then check out Devin at Devin dot AI. So let's take a look at some of the packages that I've got.

So one package that I have is called release. And what this does is it's responsible for creating the release notes for my active projects. So here Kody, of course, is an active project of mine, most active project. Every one of these release notes was generated at I think three am mountain time.

That looks at the last 24 hours and just generates release notes based on things that landed in main, super, super helpful. And we've got Kody video and Kody exchange also have that same thing all set up all from this one package for releasing. And I also made this travel map that shows all of the places that I've been all over the world. And this was loaded with data by my agent looking through my calendar and then just loading it up with data.

And now it's able to just look at my calendar every day. And if there's a new event that shows up there where I'm traveling somewhere, it can add another dot to this. So the agent doesn't have to be involved anymore. This is another package I've got where I can just put stuff I want to remember files and contact information, whatever.

Another one here for my home maintenance that tells me when I need to do a certain thing for one of the appliances in my home or whatever. This one's actually very fresh and very helpful. I just changed a bunch of filters and different things in my home. So that was that already is paying dividends.

This is a fun app that shows the commits and the size of my code base for Kody as the code base grows. And that's just kind of tickle my fancy sort of thing. It's not actually all that useful beyond just interesting. And then here's an inbox for the system email that's being sent out by Kody.

Here is the mail room for my own personal inbox inside of Kody. And then every single day at eight or seven am, I get a message from Kody sent that sent to Discord with a link to the morning brief that highlights the interesting things that are going on that day and things that happened yesterday. And then here is my shade automation control center. So I can control all of the shades in my house through here and also a waiting on me.

And this one looks through like a ton of integrations that I've got and surfaces things to me for me to address and to kick off a cursor cloud agent or my grockbot or something to go and address different interesting things going on in my life. And then my audible library. And this one's pretty cool because it integrates directly with the NAS that's in my closet. So I can download my audible library and have a backup or an archive for all of the books that I buy on audible.

And I've actually got another app on my phone. This is a native app that I had cursor build for me. And this connects my phone to my home NAS, which is connected to Kody. And so then I can ask an agent to like tell me stuff about my phone and open an app or whatever.

And so this is just a connection app, a proxy to my phone from the agent that I'm using at the time is pretty cool. And all of the web apps that I showed you are also installable on my device as well, because they're all progressive web apps. So I want to show you how I made this so that you can be maybe inspired on how you can make agents more effective at building software for you to solve the problems that you're dealing with today and make things that the agents are doing today more deterministic as well. So that app that all of these other apps are based on is called the package app kit.

So this is a package that I have inside of my Kody, and you could create something in GitHub, or if you get Kody, then you can do the same sort of thing you could even fork mine, I can make mine public. And this just has design tokens and PWA install and update stuff about version cache helpers and Kody package things, utilities that other packages want. And so it's super handy and helpful in building out applications like this. It is built with remix.

Right here, we've got the starter for remix. We also have a starter for raw fetch. And you can have a starter for really anything that can be bundled with ES build and can be run in the context of a Cloudflare worker, because all of this is running inside of a dynamic worker inside your Kody account. And I think that actually is pretty cool.

You can take a look at the live app right here. And it's got like a design language and it has instructions on how to boot up a new app. And this is really cool because I can actually use this with any agent because it's Kody, I don't have to have a coding agent. I can actually use any agent.

So I've got Claude on my phone right here just to show you how powerful this is. And I'm going to just say, I want you to make me a Kody package app that is basically a tinder for the things that need my attention. So it shows the most important thing on front. And then I can swipe it left or right.

And the next most important thing shows up. And we'll see how that goes. This is going to take a second. So you typically are just going to go off and make yourself a sandwich or something and come back when it's done.

But for the purpose of this video, we'll just fast forward it for you. And here it looks like it's asking for me to make some decisions. So I'm going to say gmail, github, calendar, and yeah, Kody tasks to Kody tasks to. And I think we should have right is keep and swipe left is archive and delete.

The important thing to remember with all of this is that the whole thing is just a process of taking what you do today, giving it over to the agent, and then having what the agent does today, and handing that over to deterministic code. And that process is all about cutting costs and making things more reliable. If you are doing it manually yourself, that costs you a lot of time, which is opportunity costs for the other things that you could be doing. So you hand it off to your agent.

Now your agent is doing it. But it's not always super reliable. It might not do things quite the right way every time. And it also is really expensive using all those tokens.

And so if you can get what the agent is doing and move it into deterministic code, now it's going to do the right thing every single time, assuming that there are no bugs, which of course they're going to be bugs. But you work on those, and you get it to a good place. And then it doesn't cost you nearly anything. For example, my shades automation, every single day, there's a job that wakes up and looks at where the sun is going to be at different places in the sky for that day.

And it schedules when all the shades are going to come up and down based on that. And that costs me less than a penny every day. But if I had the agent go and do that through some sort of heartbeat or something like that where it wakes up and it's like, okay, let me get everything scheduled, that's going to be pretty expensive from an inference perspective. And then before that, I was doing it manually myself.

And that's expensive from a time perspective. And often I don't even do it because it's annoying. And so this whole process of going from the thing that you are doing to the agent and then into deterministic code, that's what you should be looking for as far as opportunities of making software for yourself. Oh, so this is actually really cool, because Claude discovered another package that does a lot of the same things.

And so it's just going to use that package instead of reimplementing all of the like retrieving stuff from Gmail and GitHub, etc. And this is one of the really great things about my system for making personal software is that all the different packages of personal software are composable. So you can install and use other packages. And so you should make sure that your system is set up in this way so that your agents can compose those different solutions together.

One other interesting thing about Kody, while this finishes up, is that every package is in a Git repo that's hosted on Kody. And because I'm running this on Claude on my phone, it doesn't have Git. So it can't make Git commits or anything like that. And so what it does instead is it makes those Git commits through MCP.

So it just writes some code and says, I want you to execute these Git commands. And then that runs inside of Kody. And Kody actually executes the Git commands. So it's pretty cool what that does for your agents that even run on your phone, even if they don't have all the capabilities that your regular coding agent is going to have.

So for your own personal software factory, you've got to figure out how to make it so that you don't have to be at your computer to build that software. Figure out some mechanism for you to be on your phone, you have an idea. And instead of just writing it down, you just give a prompt to an agent and it goes off and builds it efficiently token wise. Sweet.

So it looks like it's finished. I've got a reserve handle substring hyphen check. Okay, we're going to keep that durable object overload error. Yeah, we're going to ignore that error rate is elevated.

Oh, we probably better keep that. So I was able to just build this and it's actually hosted and running it's got storage. It has access to all of my integrations, everything. And I was able to do that just from my phone.

The easier this is to do the more you're going to do this. And the more you do it, the more you'll see value in what you're doing. So what your homework is for today is to create a starter for your agents, make it really easy for an agent, not just easy, but token efficient as well. Instead of having the agent have to, you know, run the Vite command to spin up a new project every single time, you probably have a way that you prefer the pieces of your software to be put together.

You probably have an established mechanism for communicating with third party services. And if you don't, then use Kody because Kody provides all of that out of the box. But once you have that, then you can make a starter that takes advantage of all those things and guides the agent to build the right thing the first time. And the more you do this, the easier it gets and the more value you get out of it.

So that's your homework. Make a starter for your agents. This has been better with Kent, where you and I get better together by learning durable skills. And I hope that you make the world a better place with this one.

If you enjoyed this, please like comment and subscribe and share this with your friends so that more people can build better personal software for themselves. And that's going to be it for us till next time. Thank you for getting better with me.