YOLO-Driven Development

[JM]: As widely suspected, Apple has introduced the second generation AirTags.

[JM]: Reading from their press release, Apple's second generation ultra wideband chip, the same chip found in the iPhone 17 lineup, iPhone Air, Apple Watch Ultra 3, and Apple Watch Series 11, powers the new AirTag, making it easier to locate than ever before.

[JM]: Using haptic visual and audio feedback, precision finding guides users to their lost items from up to 50% farther away than the previous generation.

[JM]: And an upgraded Bluetooth chip expands the range at which items can be located.

[JM]: For the first time users can use precision finding on Apple Watch Series 9 or later, or Apple Watch Ultra 2 or later to find their AirTag bringing a powerful experience to the wrist.

[JM]: With its updated internal design, the new AirTag is 50% louder than the previous generation, enabling users to hear their AirTag from up to two times farther away than before.

[JM]: The new AirTag integrates seamlessly with Share Item Location, an iOS feature designed to help users recover a misplaced item by temporarily and securely sharing its location with trusted third parties such as airlines so they can assist in recovering delayed luggage or other lost items.

[JM]: Apple has partnered directly with more than 50 airlines to privately and securely accept share item location links.

[JM]: As a side note, those 50 airlines that Apple mentions is somewhat forward looking.

[JM]: It sounds like 36 airlines supported today with 15 more coming soon.

[JM]: I actually didn't know about the share item location feature.

[JM]: I have never needed that feature of air tags because I have never had suitcases go missing.

[JM]: But now that I've said that, I've totally jinxed myself and no doubt will need this feature the next time I fly.

[JM]: So I am happy to now be aware that this feature exists.

[DJ]: Yeah, you better get some second generation air tags on your luggage before you take another trip because the gods of lost luggage are listening and you have angered them.

[JM]: I'm sure I have, but for reasons you'll understand in a moment, I probably will not be getting these new AirTags anytime soon.

[JM]: One other item before I get to that is that I noticed in the requirements that it requires an iPhone or iPad.

[JM]: So I thought that was interesting.

[JM]: If you don't have an iPhone or iPad, but say you have a Mac in your house, it doesn't sound like you can use AirTags.

[JM]: That just feels like a bit of a silly restriction to me.

[JM]: I understand the idea.

[JM]: If you lose an item and you need to be able to find it, it would be easier to do that from a portable device that you presumably have on your person.

[JM]: But if you have like a MacBook Pro that you...

[JM]: took with you wherever you went and you didn't have an iPhone or an iPad.

[JM]: It seems weird to me that you can't use AirTags with a Mac, but apparently that seems to be how it works.

[JM]: Another requirement is that these new AirTags require iOS 26.2.1, which was just released.

[JM]: And as you surmise, that is indeed the problem.

[JM]: And I think this is lame.

[JM]: Like, I understand it.

[JM]: I understand that Apple didn't want to ship some new iOS 18 version that supports air tags, these new air tags, they want you to update to the new version, because that's just easier, easier for them to say, okay, everything new goes into the new OS.

[JM]: And if you want to use new things, then you have to use the new OS.

[JM]: And that's that.

[JM]: But for me, it's a bummer because these new AirTags are cool.

[JM]: I have a four pack of the previous version and I held off on buying more because I was excited to get the new version once that came out.

[JM]: But now that I know that they require running iOS 26, it seems like I will not be buying these anytime soon.

[JM]: Maybe if and when...

[JM]: The 27 line of Apple operating systems offers a better cost benefit proposition for me.

[JM]: Then I will be able to take advantage of these new AirTags.

[JM]: What about you, Dan?

[JM]: Do you have AirTags?

[JM]: Do you want new ones?

[DJ]: I've actually never used AirTags, and I guess I'm not going to start.

[DJ]: As you were alluding to there being some reason that you weren't going to get the second generation AirTags.

[DJ]: For a moment, I was thinking like, what would that be?

[DJ]: And then I thought, oh, I bet they require OS 26.

[DJ]: And sure enough, because as we have spoken about at length, and I'm sure we'll continue to, we really don't like the OS 26 for either iOS or Mac.

[DJ]: For a variety of reasons, and even as my iOS devices get more and more insistent that I install it in ways that annoy me, but might fit in a different subsection of the episode, this is just more proof that OS 26 ruins everything, because even new Apple hardware is at the mercy of their software being bad.

[DJ]: I will say, though, I think it makes a lot of sense for them to lean into things like integration with airlines, because although I haven't used air tags myself, I feel like the context in which I've seen them come up the most often is people losing their luggage and then trying to find it again.

[DJ]: And it does sound like they're genuinely useful for things like that.

[DJ]: So it's cool that airlines are partnering with them in some way that can help customers find their luggage.

[DJ]: It's not ideal that that has to be locked down to one specific company.

[DJ]: So, for example, if you don't use iOS devices, you don't get to participate.

[DJ]: in airline of your choices thing where they'll help you find your luggage because you were disqualified from using the devices.

[DJ]: As far as I know, I don't think you can use air tags with like an Android phone, although I suppose I could be wrong.

[DJ]: I don't think you can.

[DJ]: The thing I'm curious about, and I'm out over my skis here because I haven't done the research, but the ultra-wideband capability has to do with your device being within a relatively short range of the air tag.

[DJ]: Your iPhone can't detect an air tag from 10 kilometers away.

[DJ]: The idea, as I've kind of heard it, is that your dog ran around the corner or your keys are in the couch, and that'll let you...

[DJ]: When it comes to things like finding your luggage, it's using a connection to the internet.

[DJ]: Isn't that the same way that your other devices use Find My?

[JM]: I don't believe that the AirTag in that situation is connecting to Wi-Fi, for example.

[JM]: But since I don't remember the particulars of how that particular aspect works, the part that I do remember is that it's essentially a peer to peer system.

[JM]: So if your AirTag is like in the middle of the Sahara desert and there's nothing anywhere near it, then you're never going to find it because it has no peer via which to connect to the broader network.

[JM]: So the AirTags connect to other devices that aren't yours.

[JM]: And then that information gets relayed across this vast mesh network is how I understand it to operate.

[DJ]: I see.

[DJ]: So it is still dependent on Apple devices.

[JM]: I don't know if it can use other non-Apple devices in terms of making its hops from one device to another in this vast mesh network.

[JM]: But I suspect that it's Apple-only devices.

[DJ]: Yeah, I don't see how.

[DJ]: Like if the nearest device to an AirTag was an Android phone, like the Android phone is not, I presume, is not able to receive a signal and then go, oh, I'll send this over to that iPhone over there because I presume it's not set up to talk to the hardware.

[JM]: among the various wireless protocols that it can use is Bluetooth.

[JM]: And of course, Android devices also support Bluetooth.

[JM]: So there's no reason why Apple and Google can't have some mutual understanding as they sometimes do to say, okay, we'll support your thing and you support our thing.

[JM]: So it is possible that Google has added support for this kind of relaying for AirTags.

[JM]: presumably in exchange for Apple doing the same thing for whatever Android's equivalent of AirTags are.

[JM]: But again, this is all completely speculative because I've spent some total of zero minutes trying to find out the answer to this question.

[JM]: One thing that I saw in this Apple press release is the following quote, designed exclusively for tracking objects and not people or pets.

[JM]: The new AirTag incorporates a suite of industry first protections against unwanted tracking, including cross platform alerts and unique Bluetooth identifiers that change frequently."

[JM]: And it's the orb pets thing that I want to highlight.

[JM]: Like I understand the idea, okay,

[JM]: Apple doesn't want stalkers and other ne'er-do-wells to use AirTags as surreptitious tracking devices.

[JM]: But the pets thing, I'm not sure I really get.

[JM]: I'm trying to look at this from the perspective of, okay, if I wanted to do bad stuff and I put this on a pet, like how could I do bad stuff with it that Apple is trying to prevent?

[JM]: But anyway, I can't come up with it.

[DJ]: I just thought this was kind of weird.

[DJ]: I wonder if it's just a sort of declamation of liability because I always sort of got the impression that one of the perhaps unofficial use cases for the AirTag was exactly that you hang this from your dog's collar.

[DJ]: People do it all the time.

[DJ]: So I wonder if that's why.

[DJ]: I wonder if Apple's just like, uh, we're not actually, we don't want to be responsible for your lost pet.

[DJ]: That's a bridge too far.

[DJ]: Yeah, you're probably right.

[DJ]: So that's why it's not designed for that.

[DJ]: If you use it for that, that's on you.

[JM]: Makes sense.

[JM]: Along with iOS 26.2.1, Apple released updates for iOS 18, iOS 15, and even iOS 12.

[JM]: Now, usually when Apple releases updates for older iPhone and iPad software, it is because of a serious security vulnerability, but this time it seems the reason is something else entirely.

[JM]: From the support page for iOS 18, this update extends the certificate required by features such as iMessage, FaceTime, and device activation to continue working after January, 2027.

[JM]: Oops, that doesn't sound good.

[JM]: I suspect that someone, when they published the previous versions of the software for these operating systems, didn't pay too much attention to when some certificate or certificates were

[JM]: were due to expire and realized, oh yeah, these devices are all going to effectively stop being able to send and receive iMessages or make and receive FaceTime calls or do device activation after January of 2027.

[JM]: So I saw this and I checked

[JM]: And iOS 18.7.4 did not show up when I go to the software update section of the settings app on my iPhone.

[JM]: I was never offered the previous version either 18.7.3, which fixes a security vulnerability.

[JM]: So I was eager to update to 18.7.4 so I could fix both of those problems at once.

[JM]: But the only update that Apple offers me on my phone is to upgrade to iOS 26, which at this point I am just not interested in doing.

[JM]: So I am really annoyed at this.

[JM]: And presumably it is because this 18.7.4 update is only available for devices that cannot be upgraded to iOS 26.

[JM]: So Apple won't even offer

[JM]: this 18.7.4 to me because they want me to upgrade to iOS 26 instead.

[JM]: And I find this highly, highly frustrating.

[DJ]: Yeah, same.

[DJ]: I've been clinging to my beloved iPhone 12 mini because I love the form factor and it doesn't seem like we'll ever get that form factor again.

[DJ]: I'm almost sad that iOS 26 is compatible with my phone because otherwise I would be able to keep updating iOS 18.

[DJ]: But no, instead on all my iOS devices, they are getting, as I said, like they are getting increasingly aggressive about getting me to install iOS 26.

[DJ]: And I just really don't want to.

[DJ]: So...

[DJ]: I don't have super high hopes for this, but I do kind of hope that the version of the operating system that we will hopefully see demoed in the summer and released in the fall of this year will somehow recapitulate and just not be as bad as this whole liquid glass buggy OS 26 fiasco has been.

[JM]: Yeah, I hope that is indeed what happens.

[JM]: As I've said before, this will not be the first time that I have skipped an entire operating system.

[JM]: I've done it before, but I'm hoping this time that I only have to skip one and that 27 comes along and the benefits outweigh the downsides.

[JM]: All right, moving on.

[JM]: In a previous episode, we talked about the idea of when to follow the herd and when to blaze our own trail or follow our own path or however we phrased it.

[JM]: And one of the items that we talked about was this topic of version control and how at some point in the past I had used Mercurial but eventually realized Mercurial

[JM]: The world had moved firmly in the direction of Git, and it didn't really make sense for me to continue using Mercurial anymore.

[JM]: And so ever since then, I've been using Git for all of my version control.

[JM]: But right around the time that we talked about that, a new version control system called Jujutsu began picking up steam, and I have been testing it over the last month or so.

[JM]: And at a high level, I would say that the purpose of Jujutsu is to address some of the user experience headaches that come along with using Git.

[JM]: I feel like I am fairly proficient with

[JM]: I don't really have too many complaints about it, but it did take a considerable amount of reading and trial and error over a long period of time to get to the point where I feel proficient with it.

[JM]: And I've seen some people say, oh, yeah, I think that...

[JM]: Git's usability is just fine.

[JM]: I don't have any problems with its interface or its user friendliness.

[JM]: And I feel like when I see people say stuff like that, I think it comes from familiarity.

[JM]: I think people say this because they've already been past the hard part and they've become accustomed to it.

[JM]: And they just don't remember what it was like when they first started using it.

[JM]: Because I do remember

[JM]: And it was a frustrating experience to learn how Git works.

[JM]: It feels like a tool made by programmers for programmers.

[JM]: And of course it is.

[JM]: It's version control.

[JM]: I mean, it's a command line version control tool.

[DJ]: So of course it is.

[DJ]: More specifically, it's a tool made by the creator of Linux for the management of the Linux operating systems code base.

[DJ]: You kind of couldn't get a nerdier pedigree than that if you tried to.

[JM]: That's very true.

[JM]: And while Git has become a bit more user-friendly over the years, I still do feel like it is a huge hurdle for the average person to become involved with open source or really just software development in general.

[JM]: So Jujutsu borrows a lot of concepts, interestingly enough, from Mercurial.

[JM]: And if I'm not mistaken, is a project that is being worked on at Google.

[JM]: I think it originated at Google.

[JM]: in order to address their own frustrations with version control.

[JM]: And one of the things that I think is really smart about how it's being developed is that instead of developing some entirely new system that does not work at all with the existing ways in which we use version control, they chose to use Git as the backing store.

[JM]: So the idea is that it can't interoperate with other users who use Git.

[JM]: So you can continue to use Git if you want, other folks can use Jujutsu, but it's the same Git powered repository.

[JM]: Now, Jujutsu has its own native backend, but it's being developed and isn't ready for production use.

[JM]: So really the get backing store is the way to use Jujutsu at this point in time for most people.

[JM]: So now I'll talk a little bit about some of the things that I like about Jujutsu.

[JM]: One of them, and again, this is something borrowed from Mercurial is cheap anonymous branches.

[JM]: And I use the word cheap because the idea is that they're easy to create and disposable.

[JM]: So far in my month long using Jujutsu, I have not created a single branch name.

[JM]: I've created lots of branches, none of them have names.

[JM]: And the reason for that is that once

[JM]: I have something that's ready to share.

[JM]: I push and create the branch in the same step and it creates an automatically generated name for the branch called push dash and then some hash ID.

[JM]: And it's great not to have to think about a name for a branch.

[JM]: I think of the amount of time that I've spent saying, okay, fix issue dash 591 or whatever.

[JM]: It's great.

[JM]: I don't have to think about that anymore.

[JM]: It's a small thing, but these little small things add up.

[JM]: I have never had to stash anything when switching between one branch and another, which is something that comes up frequently in Git.

[DJ]: That might be my number one annoyance that I run into in day-to-day life using Git is that I make a bunch of changes A and then I make some other changes B and then I go B should really be in its own branch and then I have to do this awkward dance of like stashing and switching and I want to stash that but commit that but then that and then change branches and then pop the stash and then

[DJ]: It's not a highlight.

[JM]: No, and I've lost track of the number of times that I have stashed something and just utterly forgotten to come back to it.

[JM]: So I'll look sometimes in a project and see a list of more or less abandoned stashes.

[JM]: Now, obviously, they probably weren't all that valuable or important to begin with.

[JM]: Otherwise, I wouldn't have forgotten about them.

[JM]: But nonetheless, I'm sure I've repeated work because I've stashed something and then essentially recreated it, forgetting that the stash was there.

[JM]: One of the things that I really like about Jujutsu is the idea of describing changes before you even work on them.

[JM]: So part of the flow is that you create a change that's empty.

[JM]: You can then immediately before you make a single change to any code or text or any part of the repository, you can describe what you are about to do.

[JM]: which is kind of cool because it helps you remember, oh yeah, this is the thing I'm working on.

[JM]: If you step away and you come back to it, you can just hit `jj log` and you can see, oh, here's the current change might have actual changes in it.

[JM]: It might not, but it's already described.

[JM]: And of course, you can change that description by running that same `jj describe` command at any point to change it in case you shift the focus or need to clarify it.

[JM]: So instead of running git commit, there's this process of `jj describe`, you make the changes you're going to make.

[JM]: If you want to create a new commit, you hit `jj new` to create a new change, and you just describe it and the process starts all over again.

[JM]: you can create a new change anywhere in local history really easily via a insert after or insert before option flag, which normally you'd have to do via get interactive rebasing.

[JM]: The next feature is really something I should have just mentioned at the top, because to me, it's probably the coolest, which is that commits happen automatically.

[JM]: In Jujutsu, there's a difference between a change or a revision

[JM]: And a commit a change or a revision is like a git commit if i'm understanding the parlance correctly and so The commits in Jujutsu are not things that you do.

[JM]: It's things that Jujutsu does it's sort of like automatic updates to the ref log where

[JM]: when you save a file and then you later hit `jj status` to see the status of your working copy.

[JM]: At that point, Jujutsu automatically makes a commit and essentially snap shots everything you do.

[JM]: And you can run

[JM]: my next favorite feature, which is `jj undo`, and roll back step by step through all of these various automated commits.

[JM]: So it's really easy to go back to something that happened half an hour ago, even if you didn't make a single explicit change.

[JM]: where you're describing it and you're essentially manually making a commit, you can still roll back to previous things that you did.

[JM]: It also takes a lot of the hesitation or a sense of foreboding anytime you might do something that you think might

[JM]: and yourself into a situation where like, oh no, like it's created some conflict and now I have to run a bunch of arcane get operations to try to fix this mess I created.

[JM]: If you do that in Jujutsu, and it's actually harder to do that in Jujutsu, but if you do, and you get to some situation where you're like, I don't really know how I got here.

[JM]: I kind of don't want to be here.

[JM]: And I think I have another way of doing this.

[JM]: Just run `jj undo`.

[JM]: And whatever you just did is undone.

[JM]: And you're back to the previous step.

[JM]: When I push changes, say I've squashed commits, and I'm going to push them to the repository.

[JM]: In Git, you have to force push

[JM]: those changes.

[JM]: And if you're smart, you do a force push with lease making sure that you don't mess things up.

[JM]: But with Jujutsu, you have automatic force push with lease.

[JM]: So I just run `jj push`, which is my own alias for `jj git push`.

[JM]: So when I do that, even if I've squashed commits, even if I've rebased things, there's no complaint.

[JM]: It just fixes it.

[JM]: It's just done on the remote.

[JM]: One thing that confused me at first is that running `jj log` only shows local mutable revisions by default.

[JM]: And so the first time I noticed this, I thought, oh, what have I done?

[JM]: Where are the rest of the commits?

[JM]: And it was like full on panic.

[JM]: And then I realized,

[JM]: later that you actually have to add an additional option flag to that to show the full list by default, it only shows you the local mutable things that you can change, and then below it one single immutable change, say on your main branch.

[JM]: So you can see that one like that's the one that you're building on top of that you can't change, because it's already on main on the remote, but everything else you can do with as you want.

[JM]: And I found that feature while confusing at first really handy.

[JM]: So now I almost never run the command that shows me the full list because I don't really care about the old ones most of the time.

[JM]: One last feature that I'll mention.

[JM]: And again, there are so many more than the ones that I'm talking about.

[JM]: These are just the ones I've encountered in the last month.

[JM]: There are undoubtedly gonna be

[JM]: a dozen or more other things that I come across as I continue to use this tool that impress me and that reinforce my decision to experiment with it.

[JM]: But I will at least talk about one more and that is `jj absorb`.

[JM]: So here's a flow that I often did in Git, which is say that I have four different commits that I'm working on locally.

[JM]: Each of them are discrete.

[JM]: They're not meant to be squashed into one another because they are discrete self-contained commits and they should remain that way.

[JM]: Now let's say I realize that I need to make some changes and these changes involve changes to files in various of these four commits.

[JM]: In the past, what I would have to do is run git commit fixup, specify either the hash ID

[JM]: some unique phrase that's in the commit message in order to specify Okay, the changes here belong in this commit the changes here belong in this commit and then I would have to do an interactive rebase or some other squash operation to get those fix-up commits to get squashed into where they belong and this was a laborious

[JM]: error-prone, time-consuming and annoying process.

[JM]: And JGAbsorb essentially most of the time handles that completely automatically for you.

[JM]: You make the changes that you're trying to make and instead of running git commit fixup various times to put those various changes into the commits where they belong, Jiu-Jitsu just figures out, oh, these changes that you made probably belong in this other commit that you did.

[JM]: It seems related to that.

[JM]: And it has its own heuristics in terms of how it guesses where those things go.

[JM]: And it doesn't get it right every single time, but it does most of the time.

[JM]: And it feels like magic when it does.

[JM]: There are two different terminal user interfaces or TUIs that are also available for Jujutsu.

[JM]: One of them is called JJUI.

[JM]: One of them is called Lazyjj.

[JM]: As usual, links for these will be in the show notes.

[JM]: And these will run in your terminal.

[JM]: And if for whatever reason you find that using a user interface to get accustomed to Jujutsu is easier for you than say using the command line, that's great for me.

[JM]: I've been happy with the command line and really haven't explored the TUIs very much.

[JM]: A few things that I'll mention that are challenging.

[JM]: One, this concept of changes versus commits.

[JM]: Understanding that was a little bit of a learning curve.

[JM]: In the end, for the most part, the commits are kind of invisible to me.

[JM]: Like when you run `jj log`, or `jj status`, you'll see the change ID on the left and the commit ID on the right.

[JM]: And they use different formats.

[JM]: So visually, you can always tell one from the other, even if they aren't labeled.

[JM]: So it's a little confusing at first.

[JM]: But at this point, I've become accustomed to it.

[JM]: And the commits to me are more or less irrelevant.

[JM]: Jujutsu refers to branches as bookmarks.

[JM]: And part of the reason that they do that is that they behave differently.

[JM]: A bookmark is just a pointer.

[JM]: It's almost like a tag.

[JM]: It's just a pointer to a revision.

[JM]: And the way that it's not just the terminology of bookmarks versus branches, but the ways in which they are different will melt your brain.

[JM]: and takes a bit of getting used to.

[JM]: I would say the thing that's hardest in terms of using Jiu-Jitsu is the ecosystem.

[JM]: It's a new tool, so integration with other tools is sparse at best.

[JM]: One of the examples that I came across are the concept of pre-commit hooks.

[JM]: So normally if you have certain code style enforcement or other linters that you want run,

[JM]: before someone pushes their code to the repository, this is done as a pre-commit hook.

[JM]: But the way Jiu-Jitsu works is that there's often not an explicit commit step.

[JM]: So if I'm only working on a single change and not say a set of changes, I don't have to explicitly commit it.

[JM]: I can just decide at any point, okay, it's ready.

[JM]: I've already described it in the past when I started.

[JM]: So the only mechanism by which I'm telling it it's done is when I'm pushing it.

[JM]: So there is no pre-commit hook to be run.

[JM]: So it took a little bit of work, but I mentioned my `jj push` alias that refers to `jj git push`.

[JM]: Well, that alias does more than just run `jj git push`.

[JM]: It also will run prec, which is a alternative to the pre-commit command.

[JM]: So it will essentially run all of the pre-commit hooks that you would normally run in Git before it pushes it to the repository.

[JM]: And that works really well.

[JM]: And so I've essentially found a way to replicate that.

[JM]: But again, it was a little better work to make that happen.

[JM]: And that's where the integration with tools that we are accustomed to is a little tough.

[JM]: I've been using Jujutsu with Codeburg.

[JM]: And so that's been another complicating factor because if I were to use this with GitHub, well, that's what most people are using version control with.

[JM]: And so the support for this new version control system is a little bit easier

[JM]: and a little bit more integrated with GitHub than it is for Codeburg.

[JM]: So that's been a little tough.

[JM]: I use a Mac application called Kaleidoscope for diffing.

[JM]: And I use an older version because I'm not really interested in their new subscription model.

[JM]: And so the older version doesn't have explicit support for Jujutsu.

[JM]: The new version, I think the Kaleidoscope 6 or whatever they're on has like real preliminary support for it.

[JM]: So I haven't quite figured out what incantations I need to do in terms of some obscure configuration or command line invocation or whatever to make it work in Kaleidoscope.

[JM]: I'm sure I'll figure it out eventually, but I just haven't figured that out yet.

[JM]: And the last thing I'll mention in terms of just things that are challenging are I miss being able to run ghpr checkout 1234, which means check out this specific pull request from GitHub.

[JM]: The GH command is a command line tool that I frequently use in other open source work.

[JM]: And there doesn't seem to be a good alternative to this for how I'm using it.

[JM]: And to be fair, this doesn't have anything to do with Jujutsu.

[JM]: Presumably, if you're using Git with Codeberg, you have the same problem.

[JM]: So really, this is more of just like, I want Codeberg to provide me with a tool that allows me to do what I do in other open source projects, and just be able to easily check out PR branches and

[JM]: I figured out ways of doing this that more or less solve this problem, but it'd be cool if a Cobra were to come out with some answer to that.

[JM]: So in summary, on some level, I do ask the question, why do I do this to myself?

[JM]: Why do I try something this new and challenging?

[JM]: And I'm doing it as a side note in conjunction with a new project where I'm collaborating with a friend.

[JM]: And so then I also ask myself, why am I doing this to my friend?

[JM]: Because I have asked my friend, hey, look, here's this new tool.

[JM]: I think it could be cool.

[JM]: Let's just try it.

[JM]: If it ends up not working, we can of course abandon it and go back to using Git.

[JM]: And this friend has been super patient and so far has not thrown any dishes in my direction and continues to deal with some of the frustrating parts of learning a new tool.

[JM]: And I feel hopeful that we'll get to a point where it feels not only as comfortable as the tool that we used before, but perhaps even something that we're super happy to use relative to using Git.

[JM]: Yeah.

[JM]: So far, I'm really happy using Jujutsu, and I intend to continue using it for the time being.

[DJ]: That sounds like a really intriguing tool.

[DJ]: Certainly, you've intrigued me about it.

[DJ]: And it's good to know about things like the pre-commit situation, because I'm thinking about how this would affect my workflows.

[DJ]: But the idea that potentially I could use this while working on a team that uses Git...

[DJ]: and it wouldn't necessarily impact the team, is an interesting one.

[DJ]: As you were describing Jujutsu's capabilities, it got me thinking about when Git and Mercurial, or so-called distributed version control systems, were first coming on the scene.

[DJ]: They were an attempt to address very common problems and annoyances with traditional centralized version control systems where there was...

[DJ]: one remote repository that everyone had to check files out of.

[DJ]: And the problem of what happens if you and I both want to do different work on the same file, or what happens when we need to merge our changes, that was something that Git and Mercurial were created to address.

[DJ]: Now that Git especially has become the standard, of course, it also has its idiosyncrasies that people have had several decades to get annoyed by.

[DJ]: And so Jujutsu is cool.

[DJ]: Like just the notion of such a tool is cool that this is like, okay, starting now, if we could build a tool knowing everything that gets on our nerves about working with Git, how would we alleviate those things?

[DJ]: I think I'm just happy that a tool like that exists, that as entrenched a part of modern software development as Git seems to be,

[DJ]: There are still ways that we can create like a next generation, a tool that improves on some of those limitations.

[DJ]: So I don't know that I'm going to rush out and try Jujutsu, but I think I am going to keep an eye on it because it's it certainly sounds like a fun thing to try.

[JM]: It really has been a fun thing to try.

[JM]: And it does sound kind of nuts to even consider using a new version control system, particularly when, as we've already talked about, like the world has already chosen and anointed Git as the version control system that the whole planet is going to use by and large.

[JM]: So it does feel a little crazy to even consider trying to use something different.

[JM]: And yet, so far, I've really been enjoying it and could see how, given my druthers, I might continue to use it for new projects if I have that kind of influence, depending on the other people that I'm working with.

[JM]: But maybe that doesn't even matter.

[JM]: Maybe because of its interoperability with Git, maybe I can use Jujutsu and they can use Git.

[JM]: And so far, I haven't tried that specifically because I've convinced my other friend to at least try Jujutsu.

[JM]: But it'll be interesting to find out.

[JM]: All right, moving on, I wanted to talk a little bit about Claude Code, we have talked about it in the past.

[JM]: And I mentioned some initial experimentation that I did.

[JM]: And I have been using it more with this new project.

[JM]: And I wanted to briefly describe my experience with it.

[JM]: I started working on this new project by doing a bunch of initial setup and structure entirely on my own without any LLM participation.

[JM]: And then I used Claude Code to generate a Claude.md file, which I quickly renamed to agents.md and then symlinked to Claude.md.

[JM]: And the reason for that is I think Claude more or less came up with the idea of this file that sits in the root of your project that serves as its core instruction set, for lack of a better phrase.

[JM]: But Claude is not the only...

[JM]: LLM around and it really doesn't make a lot of sense for the most part unless you have Claude-specific instructions that would be different say for another code generation tool to live in this file that's named after a specific tool so non-Claude

[JM]: code generation tools will look for an agents.md file.

[JM]: Claude stubbornly refuses to look at that and instead will only look for CLAUDE.md.

[JM]: So you're either forced to repeat the same information more or less in two different files, or you can do what I did, which is put everything in agents.md and then symlink it to CLAUDE.md.

[JM]: So I then hand edited that generated agents.md file with some future plans for the project that Claude obviously can't know about since nothing about those plans were in the code yet.

[JM]: And before I started to ask Claude to start doing actual work,

[JM]: I wanted to see how other people were using Claude Code with Django, which is the web framework that I'm using for this particular project.

[JM]: And I came across an interesting project that was just posted two weeks ago, which was really opportune timing.

[JM]: And this project is called "Claude Code Configuration for Django Projects".

[JM]: And it consists mainly of a CLAUDE.md file and a .claude folder.

[JM]: The ladder is where I found a lot of interesting components that I had not had experience with.

[JM]: So in this dot cloud folder, there's sub folders for agents.

[JM]: And then inside there, there are markdown files that talk about here's how you should do code review.

[JM]: Here's how version control workflows should be done.

[JM]: And then there's other separate commands for

[JM]: running code linting tools, this is how you handle documentation, this is how PR review should be done a whole bunch of instructions and hooks and skills that provide Claude with domain knowledge and best practices, depending on what you're doing.

[JM]: So in this particular case, if we decided that we want to handle interactive components via something called HTMX,

[JM]: There's a skill called HTMX patterns inside that describes particular patterns that we're instructing Claude to use.

[JM]: So with this base in place, I was ready to ask Claude to do stuff.

[JM]: So I'm gonna quickly read you the initial prompt that I gave it.

[JM]: I asked it use pi test BDD and playwright to create generic reusable fixtures in conf test out pi to use in subsequent BDD based functional tests, then based on the signup user story in gherkin format in features slash signup dot feature and using the fixtures from the step above, use pi test BDD and playwright to create a functional test

[JM]: for the user signup flow provided by Django all off.

[JM]: Be sure to use the fixtures provided by PyTest Django when appropriate, including using the live underscore server fixture to provide the Django server needed to run the functional test.

[JM]: Be sure to reference the scenarios in features slash signup dot feature when writing the functional test and be sure to also use the given then and when decorators.

[JM]: When possible, use the expect assertions from playwright dot sync API instead of pi test assert statements.

[JM]: That was the end of the prompt.

[JM]: So thank you for sitting through that.

[JM]: But I wanted to provide an example of level of detail that I provided, because I've done some test prompts in the past.

[JM]: And I find that this level of detail really helps provide the results that I'm looking for.

[JM]: And the result that I got from Claude when running this prompt was precisely what I wanted.

[JM]: It worked the first time around, and I was really happy with the result.

[JM]: The next thing that I did was a bit more complicated and an area that I am less experienced in.

[JM]: And that was to integrate Tailwind CSS into the project and to use Tailwind to style the signup form.

[JM]: And I gave it a relatively detailed prompt, not as detailed because this is an area that I don't understand as well.

[JM]: And the first result was not vertically centered and the form took up the entire viewport horizontally.

[JM]: So I had to follow up with a secondary prompt and say, okay, well that's close, but not quite there.

[JM]: And here's what I need this to be vertically centered and to not take up the entire horizontal width.

[JM]: And then it said, okay, well, yeah, I fixed it.

[JM]: And then I look at it and like, no, no, you didn't.

[JM]: So try again.

[JM]: And on the third try, it said, oh, okay, I see the problem.

[JM]: It made another change.

[JM]: Absolutely perfect result in the end.

[JM]: And one last thing I'll mention is that another prompt I gave it was inspect this project and provide suggestions regarding how the structure and code could be improved.

[JM]: I was just curious.

[JM]: I wanted to see what it would come up with.

[JM]: And in the resulting output, most of the items were things I already knew I needed to address.

[JM]: But even for those, now I no longer needed to get those out of my head and into a to-do list.

[JM]: Claude did that for me.

[JM]: And some of the things that it came up with, I hadn't thought of.

[JM]: So on the whole, still very early days for me in terms of how I'm using this tool, but I'm impressed and I intend to continue using it.

[JM]: All right, moving on to another project that has caught my interest as of late, I came across an open source project called Clawdbot, and this is spelled C-L-A-W-D, as in claws, Clawdbot.

[JM]: And I'll describe what it does in a moment, but its stated mission is, quote, AI that actually does things.

[JM]: My first thought when coming across this project was, oof, that is an unfortunate name for this project.

[JM]: Choosing a name is hard, but that name is just asking for Anthropic to send a sternly worded letter.

[JM]: Well, sure enough, while writing some notes for this episode,

[JM]: Just a few minutes before we started recording, I see that the author has changed the name to Maltbot.

[JM]: So that is how we will refer to it from here on out.

[JM]: The mascot for this project is a lobster, ergo the "claw" in Clawed.

[JM]: So "molt" refers to what happens to lobsters when they grow.

[JM]: which is shedding their shell, presumably to make room for a bigger one.

[JM]: I don't know.

[JM]: I don't know anything about lobsters.

[JM]: But anyway, clever name.

[JM]: If you have to come up with a new name, well done.

[JM]: So Moltbot, as it is named as of a few minutes ago, is an open source project by Peter Steinberger, author of the vibe tunnel tool, if you recall that I mentioned in a previous episode.

[JM]: And the idea of Moltbot is that it runs on some machine that you control, and it connects generative software models to many other things that you regularly do, like clearing out your inbox, sending email messages, managing your calendar, checking you in for flights,

[JM]: And the idea is it can do these things even when you are not at your computer because it supports communication via what it calls channels.

[JM]: So that could be Signal or iMessage or Discord or WhatsApp, Telegram or whatever chat app you already use.

[JM]: One of the features of this tool is that it supports a persistent memory.

[JM]: So it remembers all of your interactions with it and all of that data stays on your machine because this is all running on your machine.

[JM]: And that appeals to me because I am hesitant to enable this persistent memory feature on the hosted top tier model providers because I don't really want it to have all of that information about me persistently forever.

[JM]: But here in theory, that information never leaves my machine.

[JM]: So it's pretty exciting.

[JM]: It can control your local browser, fill out forms, extract data from websites.

[JM]: It can read and write files, run scripts and is seemingly infinitely extensible.

[JM]: It has more skills and plugins and other things that you can connect to it than I have ever seen any project do.

[JM]: It is, I think the most ambitious

[JM]: open source project I have ever seen.

[JM]: And I started setting it up with the intention of describing it in more detail with you right now.

[JM]: But the setup process is so involved.

[JM]: Daunting is the only word that truly I think captures

[JM]: the scope of this project and what is required, I think, to kind of make it do the things that you might want it to do.

[JM]: Just as an example, I thought, okay, I'll use iMessage because that's one of the chat applications that I use the most frequently.

[JM]: Well, iMessage has its quirks in terms of how it can be accessed from a security standpoint.

[JM]: Apple kind of makes it understandably difficult for other processes to access the data that's in your messages.

[JM]: That's a good thing.

[JM]: But it also makes it a somewhat frustrating thing for this project, because it makes it more difficult for me to use it for this use case.

[JM]: And so after a while, I eventually decided, you know what, I probably don't want this thing having access to all of my messages in that app.

[JM]: Anyway, I should just use some other thing that actually don't use.

[JM]: whether that's Discord or Telegram or something else, I should just create an account and use it solely for this purpose.

[JM]: And so that's the path that I'm heading down now, but I haven't finished that yet.

[JM]: But in summary, I think this is a really exciting project.

[JM]: It is a little scary in terms of I'm

[JM]: giving it access to things I would never give most tools access to because it does seem like it is capable of doing a lot of very valuable things.

[JM]: The fact that it's open source gives me a bit of confidence.

[JM]: And the last thing I'll mention is that I think Apple should hire Peter.

[JM]: But they won't because the current leadership at Apple doesn't seem to understand the value of what projects like this provide.

[JM]: And maybe they shouldn't.

[JM]: This is YOLO-driven development at its finest, and that probably isn't what Apple should be doing.

[JM]: And also I hope that Peter doesn't go to work for Apple and he continues to produce incredible and mind-bending projects like this one.

[JM]: I saw one of his posts.

[JM]: He said, I ship between 300 and 600 commits a day.

[JM]: I don't type code manually anymore.

[JM]: A commit is a feature or a bug.

[JM]: I get more done in a day than what I used to do in a month.

[JM]: AI got insanely good.

[JM]: And I looked at his commit activity on this project in GitHub.

[JM]: And yeah, it backs it up.

[JM]: That is about how many commits he's doing per day.

[DJ]: It's crazy.

[DJ]: That sounds really cool.

[DJ]: And I was shocked, Justin.

[DJ]: I was frankly shocked when you said, I hope Apple hires this guy.

[DJ]: I was like, you just described how interesting and exciting this project is.

[DJ]: So you hope that it gets ruined forever?

[DJ]: Like we just spent an episode complaining about how Apple bought Pixelmator and then ruined its icon and like munged it into this subscription.

[DJ]: So like that, that's what you want.

[DJ]: You want Moltbot instead of being open source software to be A, abandoned and B, part of a $130 a year subscription.

[DJ]: cloud subscription?

[DJ]: No, I think the worst thing that could possibly happen would be that this very talented person is devoured by one of the big technology companies and can no longer provide value to everyone, but instead just becomes a cog in the wheel of their incrementally increasing their annual subscription revenue.

[DJ]: So don't do it, Guy.

[DJ]: Don't go work for Apple.

[DJ]: Don't listen to Justin.

[DJ]: He's wrong.

[DJ]: I mean, you already retracted your own statement, but I just couldn't help it.

[JM]: Completely fair.

[JM]: And I deserve that.

[JM]: I really do.

[JM]: Because in the end, what I should have said is that I wish that Apple were the type of organization that could hire him and let him do the things he's doing.

[JM]: allow him to solve, for example, this issue with iMessage in a way that is secure and give him access to the innards and the integrations that he would need to make this even more powerful on Apple's platforms.

[JM]: But that is not the kind of company that Apple is today.

[JM]: So you're very right that I misspoke and I...

[JM]: retract my statement entirely.

[DJ]: Really like if you get to the root cause, what we're saying is someone please give this guy a hundred million dollars without somehow totally corrupting his incentives.

[DJ]: Could we do that?

[DJ]: Could someone do that?

[DJ]: That seems realistic.

[DJ]: Let's make it happen, people.

[JM]: Absolutely.

[JM]: All right.

[JM]: That's all for this episode.

[JM]: Thanks, everyone, for listening.

[JM]: You can find me on the web at justinmayer.com, and you can find Dan on the web at danj.ca.

[JM]: Reach out with your thoughts about this episode via the Fediverse at justin.ramble.space.