And I typed almost none of it.

Rationale

Yes, this is another blog post about what it’s like to use LLM-based coding agents. Yes, this would have been more timely two months ago. Since I’ve already taken my time, let me put things into the appropriate context by explaining my rationale first.

Do Next

The first reason I made Listless is that I wanted a ‘do next’ app.

Apple’s Reminders is the primary repository for my to-do lists. But I’ve always found it productive to have a place where I write—and crucially prioritise—the stuff I want to accomplish in the extremely short term (i.e. today or this weekend). This is my ‘do next’ list. It’s not something I want to keep around and slowly work through. It’s an aid to help me stay focused in the moment.

For years, I used the excellent Clear to fill this need. Clear was (and still is) a to-do list app oriented around gestures. When it launched in 2012, it included iCloud sync between iPhone, iPad and the Mac. After going dormant for a few years, it relaunched in 2024 with a new business model that required a subscription for iCloud syncing. I’m not philosophically opposed to subscription pricing but something about losing access to a capability that I previously had rubbed me the wrong way.

Polished Slop

The second reason to make Listless is that I wanted to see whether you could use a coding agent to create a polished app. A hallmark of indie software for Apple’s platforms has been its niceness. I grew up using Windows and didn’t switch to the Mac until 2010. Like other long-time Windows users who switched to the Mac (Marco Arment, Casey Liss, Ben Thompson), I noticed that despite Windows having the reputation for the most software, if you cared about nice software, it was no contest: the Mac won easily.

Some would argue the niceness of Mac software has been in decline for years now thanks to the inexorable rise of Electron-based apps. Me. I would argue that. And you know, perhaps it’s untenable for a company to justify bespoke native apps (especially for the Mac) when a tool like Electron exists. It’s just business.

But what if you’re an individual and not a company? What if it isn’t just business? What if it is in fact just a hobby? AppKit, and the Cocoa family of APIs, were renowned for the incredible leverage they provided small development teams. Could coding agents increase the size of that lever still further?

But large language models are incredible slop-generation machines. I’m talking about using them to make nice software. Aren’t those things mutually exclusive? I didn’t know. Are they? I wanted to find out.

Reality

So in February of this year, I started a new project. Well, a sort of new project. The truth is that I’d tried to make a similar to-do list app a few years prior and it hadn’t gone well. Back then, I’d made the iPhone version with SwiftUI and it hadn’t worked well. But SwiftUI was more mature now. Maybe the promise of a cross-platform UI framework had been realised.

Mac-First

Still, since it was critical for my purposes that I be able to use the app on my iPhone, my iPad and my Mac, I started with the macOS version (the platform with the weakest SwiftUI support).

Very quickly, I had something that ‘worked’ in the loosest possible sense of the word. I could add things to a list. Then I could mark the items as completed or not. Eventually, I got reordering functional. I struggled to get SwiftUI to work well with standard Mac user interaction paradigms for text fields (e.g. the insertion point when you click on text should be at the point clicked, not at the end of the text). In the end, I opted for a NSViewRepresentable hosting view into which I could put a traditional NSTextField.

I got so frustrated that at one point, I decided to make the app in good old-fashioned AppKit. Even with Claude Code’s help, I struggled to literally get a window to open (I am not exaggerating for effect). SwiftUI on the Mac is rough but I decided it was preferable.

Eventually, it felt like the Mac version could be made to be… well, maybe not as nice as I might have hoped but at least decent. And that felt like something of an achievement. I’ve only made one app for Apple’s platforms before Listless and I abandoned the Mac version after struggling to get anything halfway passable. This was better than that.

I still hadn’t typed in any code.

SwiftUI Wrestling

I started on the iOS version and found myself fighting with SwiftUI in new ways. I suspected from the previous attempt that implementing a gesture-centric user interface would be a challenge. SwiftUI comes with numerous ‘semantic’ view objects (e.g. List) and in my experience if you stick to them, things work well. As soon as you try to do something that isn’t built in, you step into the World of Pain™.

Are gestures that important? For me they are. As noted above, Listless is my ‘do next’ app. It’s a way for me to quickly write-up a list of tasks to do. I fell in love with Clear because of the ability to create, reorder, complete and delete in simple gestures. If Listless couldn’t do that, well, why not just create a new ‘Do Next’ list in Reminders?

With List not suitable for my needs, I began the frustrating process of recreating it using trusty old ForEach and ScrollView. This is the point at which, had I not been doing this with a coding agent, I’m confident I would have given up.¹ It was still exasperting at points. The most difficult aspect was getting the animation to look correct where pulling down when at the top of the list. When a user does this a new row is ‘revealed’ above the currently topmost row. At one especially low point, I almost abandoned the entire effort after discovering that the solution I had pieced together over a week or so was completely broken in iOS 26. (Thanks Liquid Glass!)

But I persevered. I tried to exhaust the patience of @sogaiu and Eugenia (I did not succeed and am extremely grateful for all their help). I did actually type a few things (mainly integer values as I tweaked the responsiveness of certain things). I got something that I think is all right. It’s not as polished as it could be but I don’t think it’s slop either.²

Final Thoughts

Did I succeed in my goal? I think I did. The code is open source so you can judge for yourself. In a little over two months I made an app that runs on iOS, iPadOS, watchOS and macOS. Having overcome the frustrations of SwiftUI development, I feel like I came out the other side thanks in no small part to Claude Code and OpenAI Codex. I feel empowered and I’m excited for what I will create next.

A bundle is the term used in Janet to describe a distributable collection of files. It’s akin to a package in Node, a gem in Ruby or a crate in Rust. In v1.35.0, Janet gained the ability to install bundles without any additional tooling. Prior to that, bundles were installed with JPM, the Janet Project Manager.

Jeep is built around various subcommands. There are global subcommands that can be used anywhere (e.g. jeep install, jeep uninstall) and local subcommands that are run in the bundle root of a bundle (e.g. jeep build, jeep prepare).

Now I think Jeep is cool but if you didn’t develop it, you might reasonably have some questions about why you would want to use it. The remainder of this introduction is structured as a series of questions and answers.

Q. If Janet can install bundles, what is the point of Jeep?

While Janet can install bundles, there are two key limitations:

1. Janet does not include any machinery to download remote bundles. You need to do that yourself.
2. Janet checks whether the dependencies of a bundle are installed but it doesn’t download and install them for you.

Jeep comes with an install subcommand that will install a bundle, together with any external dependencies that are listed in the bundle’s info file.

Q. If JPM can install bundles, what is the point of Jeep?

JPM can install legacy bundles (i.e. bundles that use a project.janet file) but it cannot install modern bundles (i.e. bundles that use an info.jdn file).¹

Q. Why do I want to use modern bundles?

Legacy bundles continue to work fine and there’s no reason you have to change. For me, modern bundles are preferable for two reasons:

1. Modern bundles aren’t tied to a particular tool. Once they’re on the file system, Janet can install them. Legacy bundles works today but they depend on JPM. JPM itself lacks robust tests and its heavy use of use can make it difficult to read.
2. Modern bundles cleanly separate metadata (listed in a bundle’s info file) from management logic (listed in the bundle’s bundle script). This makes it easier for other tools to extract information from your bundle without needing to run any code. In addition, since the management logic is in your bundle script and Janet, you’re not tied to one particular bundle manager (even Jeep!).

Q. Can I use Jeep to install legacy bundles?

No. I realise this might reasonably be a deal breaker for many people. If you are installing a modern bundle but it depends on a legacy bundle, Jeep cannot install it. janet-pm (discussed below) does not have this limitation.

Q. Are there any alternatives?

Apart from JPM, the only other alternative at the time of writing is janet-pm. janet-pm is part of the Spork library, the official contrib library (and one that many people install). janet-pm makes a best effort to install legacy bundles and so can be a good solution for someone who wants one tool to support both legacy and modern bundles.

Q. What are some cool things you can do in Jeep?

A few of the interesting subcommands:

• jeep api: This subcommand creates api.md, a Markdown file in your bundle root that lists the function signatures and docstrings for the functions exposed by your bundle’s modules.

• jeep list: This subcommand lists information about your current Janet environment. This includes the bundles you have installed, the version of Janet you are running and relevant environment variables.

• jeep test: This subcommand runs the Janet files that are in ./test similar to how jpm test works. Unlike JPM, Jeep can run specific files using the -f option for situations where you don’t need to run the entire suite.

Q. How can I learn more about Jeep’s subcommands?

Jeep includes a rich suite of man pages that describe its features. You can read them by typing jeep help <subcommand> at the command line. For those who’d like to see what Jeep can offer before installation, the pages are written in Predoc, a Markdown flavour that I developed. As Markdown, they’re readable as plain text right in the GitHub repository.

Q. Is there some way I can convert a legacy bundle into a modern bundle?

Yes. Jeep’s enhance subcommand can be run in the bundle root of a legacy bundle and it will attempt to create the files for a modern bundle while preserving the metadata encoded in the legacy bundle’s project.janet.

Do you have more questions? Feel free to open an issue in the Issues section of the GitHub repository.

I like making bundles for the Janet programming language. I also like things to be neat and consistent. This has led to me spending too much time thinking about a directory structure I can use for Janet bundles.

For a bundle called <bundle>², here’s what I’ve come up with:

<bundle>
├─ bin/
├─ bundle/
│  └─ init.janet
├─ deps/
├─ lib/
├─ res/
├─ src/
├─ test/
├─ info.jdn
├─ init.janet
├─ LICENSE
└─ README.md

To explain:

• bin/: This directory contains the binscripts³ that your bundle will install. In Lemongrass, for example, I provide a CLI utility, lg, that is installed as part of the bundle.

• bundle/: This directory contains your bundle script (init.janet) and any helper scripts necessary for managing your bundle. In Predoc, for example, I include a bunch of files from the Spork library so that you can compile the predoc binary without anything other than the janet binary.⁴

• deps/: This directory contains vendored dependencies that your bundle uses. I’ve moved to using vendored dependencies as a way to avoid some of the issues that arise when you’re trying to share dependencies across all bundles. If that sounds interesting, check out my bundle manager Jeep. It makes vendoring dependencies as easy as can be.

• lib/: This directory contains the Janet code that is used in your bundle.

• res/: This directory contains resources (images, testing fixtures, helper scripts) that are used by your bundle.

• src/: This directory contains code (typically C code) that is compiled for use in your bundle.

• test/: This directory contains tests for your bundle. If you’re using a bundle manager like Jeep it comes with a jeep test command that runs all the tests in the test directory.

• info.jdn: This file contains metadata about your bundle written as a struct or table in Janet Data Notation (or JDN). The only mandatory key is :name but you can include other information that might be useful to your bundle script or to consumers of your bundle.

• init.janet: This file allows a consumer of your bundle to import the top level bindings by simply writing (import <bundle>) in their Janet file. This is because init.janet is a ‘magic file’ that Janet’s module loader looks for when it tries to resolve an import call. So using Lemongrass as an example again, a consumer of the bundle can write:

  (import lemongrass :as lg)
  
  (lg/markup->janet "<p>Hello world</p>")
  

  This works even though the mark-up->janet function is defined in lib/to-janet.janet because init.janet imports this module file and then exports its bindings.

• LICENSE: The licence that you apply to your bundle.

• README.md: Your README in Markdown format.

If your bundle doesn’t need any of the above directories, feel free to leave it out.

I’ve been using this structure for the last six months or so and have found it works well. I hope others find it helpful, too!

Bundle

A bundle is Janet’s term for what some languages call a package. At its most basic, a bundle:

• is a directory of files that can contain Janet code, documentation and other resources; and
• is installable.

Making a directory isn’t that difficult but how do you make something ‘installable’?

Bundle Types

Unfortunately, for historical reasons, Janet has two types of bundles.

First, there are legacy bundles.¹ A legacy bundle is made installable by the presence of a file titled project.janet in the bundle root. Legacy bundles were developed to work with the Janet Project Manager (commonly referred to as jpm). A legacy bundle cannot be installed by the janet binary alone.²

Second, there are modern bundles.³ A modern bundle is made installable by the presence of an info file and a bundle script.⁴ Once you get a bundle on the local file system, it can be installed by the janet binary alone.

It is possible for a bundle to be both a legacy bundle and a modern bundle if the bundle includes all the necessary files (a project.janet file, an info file and a bundle script).

Artifacts

Saying that a bundle is ‘installable’ really means that it has artifacts that can be installed. Janet has built-in support for installing and uninstalling artifacts from modern bundles. The janet binary cannot install artifacts from legacy bundles without an additional tool.

Installing a bundle means copying one or more of the following artifacts into the syspath:

1. a module file in Janet
2. an executable file in Janet
3. a compiled module file in machine code
4. a compiled executable file in machine code
5. a man page file

Uninstalling means removing the files that were copied.

When installing a modern bundle, Janet creates a manifest that, among other things, lists all of the paths that were created during installation. As a result, Janet can make sure those paths are removed when the bundle is uninstalled.

syspath

In Janet, the syspath is a special directory on the file system where Janet will install artifacts, save bundle data⁵ and (perhaps most important) look for modules to load.

On POSIX systems, the default syspath is:

• /usr/local/lib/janet

If installed via Homebrew, it is:

• /opt/homebrew/lib/janet

While on Windows, the default syspath is:

• %APPDATA%\Janet\Library

Inside the syspath are three reserved directories:

• <syspath>/bin
• <syspath>/bundle
• <syspath>/man

These are discussed below.

Manifest

The manifest is a collection of metadata concerning an installed bundle. It is created during the installation process by Janet and saved in <syspath>/bundle/<bundle-name>/manifest.jdn.

Bundle Root

I use the term bundle root to refer to the top-level of the bundle itself. Where paths in this article are of the form ./foo.bar, this refers to a file called foo.bar that is at the top-level of the bundle (i.e. the bundle root).

Janet does not mandate a structure for the bundle but, as noted above, modern bundles should contain an info file and a bundle script.

Info File

The info file is a text file written in JDN (Janet data notation). The info file can be located in one of two places relative to the bundle root:

1. ./bundle/info.jdn
2. ./info.jdn.

The file must describe a single data structure, either a struct or table, that maps the key :name to a string value that represents the name of the bundle. Note that the name of the bundle is used as the name of the subdirectory within <syspath>/bundle directory. For this reason, two bundles cannot be installed with the same name.

The info file should also list the external dependencies of the bundle (if any). This information is stored as an array/tuple that is associated with the key :dependencies at the top-level of the data structure. During the installation process, Janet will confirm that the dependencies listed are installed before proceeding with installation.

Here’s an example of an info file:

{:name "foo"
 :version "1.0.0"
 :description "Just adds all the foo"
 :author "A Programmer"
 :license "MIT"
 :url "https://example.org/foo"
 :repo "git+https://example.org/foo"
 :dependencies [{:name "bar"
                 :url "https://example.org/bar"}]
 :artifacts {:libraries [{:prefix "foo"
                          :paths ["init.janet"
                                  "lib"]}]
             :manpages ["man/man1/foo.1"]
             :scripts [{:path "bin/foo"}]}}

In addition to :name and :dependencies, this example includes several other keys. Some of these, like :description, are more for communicating to the potential consumer. Some, like :artifacts , may be used by a particular bundle script.⁶

Bundle Script

The bundle script is a text file containing Janet code. The bundle script can be located in one of two places relative to the bundle root:

1. ./bundle/init.janet
2. ./bundle.janet

As discussed below, the bundle script contains functions that will be called during the installation and uninstallation process.

It is important to note that, before any functions are called, the info file and bundle script are copied to <syspath>/bundle. Both files are placed inside a subdirectory with the same name as the bundle (i.e. <syspath>/bundle/<bundle-name>). Janet in fact copies all files from the bundle’s ./bundle directory to <syspath>/bundle/<bundle-name>.

As a result, a bundle script can import other modules but it should not do this relative to directories in the bundle root since at the time of evaluation, the bundle script will be located in <syspath>/bundle/<bundle-name>. If a user’s bundle script depends on modules, these should be imported from the syspath:

(import foo)

or they should be included in the bundle’s ./bundle directory and then imported relative to the bundle script:

(import ./foo)

You can see an example of doing this in the bundle script for Predoc, my tool for generating man pages.

Bundle Hooks

Janet deliberately leaves the logic for installing artifacts to the bundle author. It does this by using bundle hooks. A bundle author can think of a bundle hook as a call to an identically named function in the bundle’s bundle script.

Janet calls up to five hooks during the installation process:

1. postdeps⁷
2. clean (optional)
3. build
4. install
5. check (optional)

The optional hooks are only called if specified in an argument to bundle/install.

One hook is called during the uninstallation process:

1. uninstall

As noted above, each bundle hook effectively calls an identically named function in the bundle script. The function is called with the data in the manifest as its first argument. This importantly includes the information in the info file under the :info key.

If a bundle author doesn’t define a function for a particular hook, nothing happens and Janet moves onto the next hook. Some bundles don’t need a build step, for example, and so can simply not define a build function. Others may not need a postdeps function.

Every bundle script should include an install function and this function should make calls to some combination of bundle/add, bundle/add-directory, bundle/add-bin and bundle/add-manpage to copy various artifacts into the syspath. Using these functions ensures that the paths created are saved in the manifest and so can be properly removed during the uninstallation process.

Conclusion

Janet bundles are still a bit of a work in progress and the suggested terms here are just that: suggestions. If you have questions, the GitHub repository is a good place to ask.

As with previous entries, the list is broken down into ‘Currently Subscribed’ and ‘Previously Subscribed’ sections. If a podcast came into and went out of rotation within the last 12 months it still goes in ‘Previously Subscribed’. Podcasts that are new to the list are in bold and paid podcasts are marked with a 💰 emoji.

Happy listening!

Currently Subscribed

• 22 Goals: I finally succeeded in getting a friend to listen to at least one episode of this show. It remains my favourite podcast.

• Accidental Tech Podcast 💰: I said last year that while this is still the premier Apple podcast, it had fallen off since the glory years of the late 2010s. That’s true but it does still occasionally hit those highs. There’s exactly one podcast that made me laugh out loud as I walked down the streets of Urayasu on a balmy summer night in June 2024 and it was ATP. (I’ve added a 💰 this year because although you don’t have to pay for the show, I do.)

• Against the Rules: Michael Lewis’ podcast about modern American life took a hard look at the rise of legalised sportsbetting in the United States. After the letdown of the season that accompanied Lewis’ Going Infinite, this was a welcome return to form.

• Asianometry 💰: This podcast was added to the stable of podcasts available to subscribers to Ben Thompson’s Stratechery Plus. In it, host Jon Yu puts audio recordings of the episodes from his Asianometry YouTube channel. These tend to be explainers about certain aspects of materials science that have a connection to Asia (especially related to the semiconductor industry) but Yu isn’t afraid of venturing further afield.

• Astral Codex Ten Podcast: An audio version of the posts of blogger Scott Alexander. Pseudonymous host Solenoid Entity had to take a couple of weeks off over the past 12 months and I didn’t realise until he was gone how central his voice has become to my weekly routine.

• Cautionary Tales: Pop economist and long-time columnist for the Financial Times Tim Harford didn’t take my advice from last year and avoid stuffing something in his feed weekly but when you prune the filler out, the actual episodes are still great.

• CoRecursive: Programmer Adam Gordon Bell continues to find interesting stories from people in the software engineering community. By editing his conversations down into a narrated guide through each episode, the show never overstays its welcome.

• Decoder Ring: Willa Paskin put together another year of great essays about cultural mysteries. I complained last year that it was a shame how much filler was put into the feed cross-promoting other podcasts from Slate. I’m sad to say this has not improved.

• Dithering 💰: Apple blogger John Gruber and tech analyst Ben Thompson’s paid podcast about technology does feel a bit worn by this point but the fact its 15-minute episodes are only twice a week helps protect it from ever feeling completely worn out.

• Fiasco: Leon Neyfakh was the original host of Slow Burn and I was extremely disappointed when he left to make the Fiasco podcast for closed-platform Luminary (and then Amazon). Fortunately, those deals have now come to an end and he’s brought Fiasco to the Pushkin network. The most recent series they’ve published was about Iran-Contra and it was terrific.

• Geopolitical Cousins: Jacob Shapiro and Marko Papic are analysts who write advice for clients about geopolitics. In March 2025, they started a podcast to discuss geopolitical topics in a more casual form. If you wish more geopolitical analysis contained references to the NBA, this is the show for you.

• Greatest of All Talk 💰: As I did last year, I stopped listening to this show until around the time of the NBA Playoffs. Ben Golliver of the Washington Post and Andrew Sharp formerly of Sports Illustrated have terrific chemistry together and when I need a hit of basketball chat, this is where I go.

• Hit Parade: I wrote last year how impressed I was at the essay Chris Molanphy writes each month. That feeling hasn’t abated and he keeps finding topics to writing about that pique my interest. If you’re remotely interested in the history of American pop music, I heartily recommend it.

• How to Japanese Podcast: I don’t remember now how I came across this podcast but I’m glad that I did. Host Daniel Morales, a professional Japanese to English translator who lives in Osaka, records an episode each month where he riffs on some aspect of the Japanese language that was the subject of his monthly newsletter. I say ‘riff’ because while the simple thing to do would be to just read the newsletter, Morales instead uses each episode to present the same topic from a slightly different perspective.

• The Jacob Shapiro Podcast: Jacob Shapiro describes himself on his website as ‘a geopolitical analyst who provides strategic guidance to families, investors, and corporations’. His podcast features him interviewing experts about major geopolitical issues. I don’t listen to every episode but I feel like I learn a lot when I tune in.

• Land of the Giants: This podcast is a quasi-audio documentary about one of the giant tech (or tech-adjacent) companies that dominate our lives (the most recent season was about Disney, for example). The main thing I praised this podcast for last year was how disciplined it is about its seasons. They put episodes from the show itself in their feed and nothing else. More like this please.

• Molly White’s Citation Needed: Blogger Molly White records a new episode for each edition of her newsletter about A.I., cryptocurrency and the world wide web. I wish more writers would do this.

• The Party Room: Much to my extreme frustration, this podcast about Australian federal politics was folded into an omnibus feed from the ABC featuring episodes from across its roster of political shows. So of course I did what any self-respecting programming nerd would do and created my own filtered version of the feed so that I could listen to veteran ABC presenters Patricia Karvelas and Fran Kelly in peace. That feed is here if anyone else is similarly interested.

• The REPL: From May 2024 until May 2025, host Daniel Compton released precisely two episodes of his podcast about Clojure. One was in September and the other in October. A totally acceptable cadence in my book!

• Revisionist History: I noticed that Malcolm Gladwell recently changed from introducing this as ‘my podcast about things overlooked and misunderstood’ to ‘my show about things overlooked and misunderstood’. I preferred the dorkier ‘podcast’.

• Serious Trouble: I love the rapport between journalist Josh Barro and lawyer Ken White as they break down recent legal issues that have arisen in U.S. politics. White’s sober analysis and Barro’s incisive questioning are what makes every episode feel like time well spent.

• Slow Burn: In 2024, the Slow Burn team focused on the rise of Fox News and it was another great season of six or so episodes. The other 46 weeks of the year? Chock-full of episodes from other Slate shows.

• Software Unscripted: I continued to enjoy listening to Richard Feldman’s programming-oriented interview podcast but I’m a little cooler on it than I was last year. I think that’s mostly the fault of the medium: audio isn’t the best format for the deep technical discussions I sometimes want Feldman and his guests to do.

• The Stratechery Podcast 💰: As mentioned above, I’m a subscriber to Ben Thompson’s Stratechery Plus service and one of the perks is this feed featuring audio versions of his written posts. Thompson has an enviable hit rate for great writing.

• The Talk Show: Here I am, in 2025, still subscribed to The Talk Show after more than 15 years. I’m not sure what else to say about John Gruber’s podcast about Apple and technology. He’s got to be doing something right.

Previously Subscribed

• Chinese Whispers: I’m sad to say that within months of me discovering this excellent podcast in August 2024 about Chinese society and politics from Cindy Yu (formerly of the Spectator), the show had wrapped up. Yu is now at the Times but hasn’t started a show that’s equivalent to Chinese Whispers.

• Hi-Phi Nation: Last year I retained a sliver of hope that philosopher Barry Lam might return to his podcast. Alas, it looks like it’s time to admit that’s not going to happen.

• One Year: This is another podcast that hasn’t officially ended but which hasn’t seen a new episode in long enough that I suspect it’s done. I miss your dulcet tones, Josh Levin!

• Panic Podcast: In 2023, I said this show was over. In 2024, it came back. It’s 2025 and it looks like it’s gone once more. What will 2026 bring? Only time will tell!

• Sharp Tech 💰: While I mostly enjoyed Andrew Sharp and Ben Thompson’s paid podcast about the consumer software industry, I unsubscribed to make way for some of the newer shows I started listening to this year.

• Talk Easy: Sam Fragoso’s interview show was another victim of me prioritising other podcasts. Fragoso is a terrific interviewer and I recommend it for anyone who is interested in popular culture.

• Under the Radar: Developers Marco Arment and David Smith produce a tight fortnightly discussion of issues in the world of iOS development. I unsubscribed to make way for other shows.

See you next year when this will hopefully be published on time!

I like making packages for the Janet programming language. I also like things to be neat and consistent. This has led to me spending too much time thinking about a directory structure I can use for my Janet packages.

My suggestion is as follows:

<package>/
├─ bin/
├─ deps/
├─ lib/
├─ res/
├─ src/
├─ test/
├─ init.janet
├─ LICENSE
├─ project.janet
├─ README.md

To explain:

• bin/: This directory contains the binscripts that your package may provide. In my Lemongrass package, for example, I provide a CLI utility, lg, that is installed together with the package.

• deps/: This directory contains vendored dependencies that your package uses. I’ve moved to using vendored dependencies as a way to avoid some of the issues that arise when you’re trying to share dependencies across all packages.¹

• lib/: This directory contains the Janet code that is used in your package.

• res/: This directory contains resources (such as fixtures used in testing) that are used by your package.

• src/: This directory contains code (typically C code) that is compiled for use in your package.

• test/: This directory contains tests for your package (the Janet Project Manager includes a built-in task jpm test that will run all Janet files in the test/ directory).

• init.janet: This file allows a consumer of your package to import the entire library by simply writing (import <package>) in their Janet file. This is because init.janet is a ‘magic file’ that Janet’s module loader looks for when it tries to resolve an import call. In my Digestive package, the MD5 module that is located in lib/md5.janet is exported by init.janet with the md5 prefix. This translates to the following usage:

  (import digestive)
  
  (digestive/md5/digest "Hello world")
  

  My documentation tool, Documentarian, can be used with the -O and -d flags to only document functions that are exported from a file (e.g. init.janet) and remove the prefix (e.g. init/) that would otherwise prefix each binding.

• project.janet: This file sets up the package for use by JPM, the Janet Project Manager. For libraries written in Janet that follow this directory structure, declare-source should be called with the files to copy on installation of the package together with a prefix (typically the name of the package).

  Using Digestive as an example again, this looks like:

  (declare-source
    :source ["deps"
             "lib"
             "init.janet"]
    :prefix "digestive")
  

(I’ve left out descriptions for LICENSE and README.md which I assume are self-explanatory.)

I’ve been using this structure for a few months now and have found it works well. I hope it does for you, too!

As I’ve done in past iterations, the list is broken down into ‘Currently Subscribed’ and ‘Previously Subscribed’³ sections. Podcasts that are new to the list are in bold and paid podcasts are marked with a 💰emoji.

Happy listening!

Currently Subscribed

• 22 Goals: After more than a year, I remain deeply in love with Brian Phillips’s history of the World Cup. I still haven’t been able to get anyone to listen to it but love springs eternal so I’m keeping it in the ‘Currently Subscribed’ section regardless of the fact it’s well and truly over.

• Accidental Tech Podcast: I feel similar to how I did last year: the show has fallen off a bit since the glory years of the late 2010s but it’s still the best Apple tech podcast out there. You don’t have to pay for the show but if you become a member, you get your episodes without ads and with an extra bonus segment.

• Against the Rules: This, perhaps unsurprisingly, transformed over the past year into something approaching a rolling advertisement for Michael Lewis’ book on Sam Bankman-Fried, Going Infinite. I skipped most of the episodes but have stayed subscribed in the hopes it will return to its classic format in future episodes.

• Astral Codex Ten Podcast: I love listening to the pseudonymous Solenoid Entity’s cultured Australian accent as he recites the entries of blogger Scott Alexander.

• Cautionary Tales: It felt like a lot of filler in this feed for the past 12 months. I remain of the opinion that economic journalist Tim Harford would be better served by just recording a season’s worth of episodes a year and not updating the feed until the next season. Alas, dear reader, this will be a recurring pattern for Pushkin Industries’ shows.

• CoRecursive: This is still my favourite programming podcast (although Software Unscripted is an extremely close second). Adam Gordon Bell crafts each episode into a satisfying tale about a piece of software.

• Decoder Ring: Willa Paskin records a ‘season’ of five episodes or so about cultural mysteries every few months and releases them on a weekly schedule. It’s great. All the cross-promotion for Slate’s other shows? Not so great.

• Dithering 💰: Brevity makes the heart grow fonder? John Gruber and Ben Thompson’s paid podcast consistently makes me wish the episodes were longer.

• Greatest of All Talk 💰: I worried last year that my interest in basketball, and hence this show from Washington Post NBA correspondent Ben Golliver and former Sports Illustrated feature writer Andrew Sharp, would wane when the 2023 NBA play-offs wrapped up. Sure enough, that’s what happened but then the 2024 play-offs started and guess who added it back to their podcast player?

• Hi-Phi Nation: I’m worried I gave the kiss of death to this philosophy show when I celebrated its return last year. It subsequently wrapped season 6 a fortnight before last year’s entry and nary a whisper since then. Come back, Barry Lam!

• Hit Parade: I’m impressed all over again every time I listen to an episode. Host Chris Molanphy takes the listener on a fascinating journey each month to a different cranny in the history of the U.S. pop music charts. My only wish is for the accompanying playlist for each episode to be made available on Apple Music.

• Land of the Giants: I’m a little reluctant to put this long-form journalistic podcast about tech companies on here because while I did listen to a few of the ‘seasons’ of the show (each season focuses on a different company), I wasn’t that impressed. But you know what I am impressed with? No filler! When the season is finished, they just leave the feed alone. More like this, please!

• Molly White’s Citation Needed: As devoted readers⁴ of this series know, if there’s one thing I love even more than podcasts with seasons, it’s podcasts that involve someone reading blog posts! Blogger Molly White records her newsletter (which is a 2020s way of saying ‘blog’) focusing on AI, cryptocurrency and the world wide web.

• One Year: Josh Levin’s series on contemporary American history (every season is about a different year) hovers very close to the edge of unsubscribe territory for me. I do often enjoy the episodes when I listen to them but when I see an episode in my queue, I frequently want to listen to something else instead. It might not be here next year.

• The Party Room: I can’t believe this show was new to my list last spring; it’s become such an integral part of my week that it feels like I’ve been listening to it for years. ABC journalists, Patricia Karvelas and Fran Kelly, discuss the big political issues in Australian federal politics each week.

• Panic Podcast: It was the reverse kiss of death! I pronounced this podcast gone last year but wouldn’t you know it, it looks like they’re coming back with a second season!

• The REPL: This podcast from Clojurist Daniel Compton is pretty close to being cut if I’m being honest. I still love Clojure but it’s a slow-moving ecosystem and there’s not that much to talk about. Fortunately, Compton seems aware of this and so only records episodes sporadically.

• Revisionist History: Last year I said that this podcast needs to leave longer gaps between its seasons. It didn’t do that but to his credit, author Malcolm Gladwell did maintain a pretty healthy output of new episodes. As mentioned about other podcasts, I do wish there were a lot fewer cross-promotional episodes.

• Serious Trouble 💰: Similar to The Party Room, I can’t believe this was new to the list last year. Journalist Josh Barro and lawyer Ken White do an excellent job breaking down the legal troubles affecting those at the centre of American politics.

• Sharp Tech 💰: I mentioned that Andrew Sharp of Greatest of All Talk was a former feature writer for Sports Illustrated. He’s now a professional podcaster and in addition to basketball, discusses technology with Ben Thompson. I do sometimes wish for a better foil for Thompson but Sharp is at least excellent at ‘keeping things moving’ as he likes to say.

• Slow Burn: The most recently completed season was about Justice Thomas’ journey to the Supreme Court and it was great. Unfortunately, like so many of Slate’s other shows, the Slow Burn producers don’t have the courage to lay low in between seasons and instead stuff the feed with a staggering number of episodes from affiliated shows.

• Software Unscripted: I’ve long enjoyed watching the conference talks of host Richard Feldman on YouTube. What makes this show work is that Feldman is working on his statically-typed programming language, Roc, but has a background in front-end web development. This makes him comfortable discussing topics from compilers to web pages. My favourite new podcast.

• The Stratechery Podcast 💰: Another one of my beloved ‘blogger reads blog posts’ podcasts. Analyst Ben Thompson presents his view on the tech world from a business perspective. I don’t always agree with him but his arguments are always worth considering.

• Talk Easy：I guess this is why there’s so much cross-promotion. I came across an episode of this in one of the Pushkin Industries’ feeds and liked it enough to try another episode. The main draw for me is how impressive host Sam Fragoso is as an interviewer. He’s extremely well-prepared for his interviews and that causes each subject to speak more freely than you (or often they) expect.

• The Talk Show: I said last year that there were fewer classic episodes for John Gruber’s long-running Apple-oriented podcast and I still feel the same way. Maybe Merlin Mann will come back.

• Under the Radar: iOS developers Marco Arment and David Smith discuss topics relevant to indie development on Apple platforms. It’s never great but it knows not to overstay its welcome.

Previously Subscribed

• Econ 102: I really wanted to like this show. Economist Noah Smith discusses an article from his blog with co-host Erik Torenberg. Unfortunately, Torenberg is too ill-informed about the world to make the discussion interesting.

• Cold Takes Audio: I said last year that Holden Karnofsky was doing what I wanted other bloggers to do and then he promptly stopped blogging (or at least has effectively stopped blogging).

• Exponent: I’ve kept this on the Currently Subscribed list for a while but it’s time to admit it’s gone. Farewell, James! May you long avoid barbed-wire fences!

• MusicalSplaining: I stopped listening to this and then, just when I was feeling guilty, hosts Angela Meehan and Kaveh Taherian announced the show was ending. I’ll always have fond memories.

• Philosopher’s Zone: I think I need to admit that I’ve stopped listening to this podcast. I’m technically still subscribed but I have a huge backlog of episodes that I periodically go through and delete rather than listen to. David Rutledge did a great job making philosophy accessible to the layperson and my dropping it reflects more on me than it does on the show.

• The Rewatchables: Like the Philosopher’s Zone, I have a lot of fond memories but the reality is that I only have so many hours in the day and in the end, I’d rather spend that time watching movies than listening to Bill Simmons and friends talk about them.

• Slow Boring: I was hopeful that Matt Yglesias would get someone to read his blog posts but that’s not the direction he’s gone. He sporadically has interviews but I don’t find them especially good; interviewing people isn’t Yglesias’ strength.

I can’t believe I’ve been writing these for the better part of a decade but I guess it’d be a waste to stop before I get to 10 so see you all again next year!

Pre-Requisites

I used the following:

1. Raspberry Pi 3 Model B
2. 16GB microSD card
3. Monitor
4. Keyboard

Regarding the third and fourth items, we do want to get the Pi ready for SSH access as soon as possible but at the very beginning it’s great to have direct access to the machine.

If you have a different model of Raspberry Pi, these instructions might still work but bear in mind that your mileage may vary.

Steps

Step 1. Download a live image

Void Linux makes live images available for Raspberry Pi devices. I downloaded the glibc version of the rpi-armv7l live image because I’m afraid of trying new things but if you live life on the edge try the musl version and let me know if the rest of this guide worked for you!

Step 2. Install the live image

Use whatever tool you prefer to install the live image onto your SD card. I went with Etcher.

Step 3. Boot the Raspberry Pi

Install the SD card into your Pi and start it up. If all goes well, you should find yourself at a login prompt. At the time of writing, the live image has a root user with password voidlinux.

Step 4. Resize root partition

The live image contains two partitions: a boot partition and the root partition. The bad news is that the root partition is only 2GB. The good news is that we can resize it from within Void.¹ Normally, it’s not advisable to resize a partition while you’re using it, but since the root partition comes at the ‘end’ of the partition table, we can safely extend it into the remaining space without any issues.

We’ll resize with sfdisk so let’s start it up. We need to pass --force so that we can change a partition that’s in use:

# sfdisk -N 2 /dev/mmcblk0 --force

sfdisk will greet you with a scary warning. Fear not; we don’t have much to do. Next input the following in the sfdisk shell:

/dev/mmcblk0p2: - +

Is that it? What does it mean? Well, the - tells sfdisk to leave the beginning of the partition where it is and the + tells it to fill the remaining space. After the command is received, sfdisk will show you the new partition table and ask if you want to write this to disk. Press y to confirm.

Reboot your system:

# reboot now

Log back in and resize the file system:

# resize2fs /dev/mmcblk0p2

Restart, log in and confirm the changes are reflected in the partition table:

# df -h

You should see /dev/root is now almost the full size of the SD card.

Step 5. Get on Wi-Fi

Three points to note up front:

• The next couple of steps draw heavily on Kevin Patel’s excellent guide. Thank you Kevin for writing this. I don’t think I would have got my setup working without it!

• The default shell for the root user is Dash. It does not have the same niceties as Bash (particularly tab completion) and so while I’ve omitted the invocations to focus on the key aspects, I strongly recommend running bash after every reboot.

• If you’re not using Wi-Fi, feel free to skip this step.

We need to find out the name of our wireless device. It’s probably something like wlan0 but for the rest of this post, I’ll refer to it as <device>.

Find the name:

# ip link

Change to the following directory:

# cd /etc/wpa_supplicant

Make a copy of the default configuration:

# cp wpa_supplicant.conf wpa_supplicant-<device>.conf

Add the network details:

# wpa_passphrase <ssid> <key> >> wpa_supplicant-<device>.conf

Start the daemon:

# wpa_supplicant -B -i<device> -cwpa_supplicant-<device>.conf

Enable the dhcpd service:²

# ln -s /etc/sv/dhcpcd /var/service/

Test the connection:

# ping voidlinux.org

Hopefully you’re seeing sweet responses. Enable the wpa_supplicant service:

# ln -s /etc/sv/wpa_supplicant /var/service/

Step 6. Set up the system time

Unlike most computers, the Raspberry Pi does not have a battery-powered clock that it uses to ‘remember’ the current time when you shut it down. This can cause issues when updating packages so now that we have access to the Internet, let’s enable the system time daemon:

# ln -s /etc/sv/ntpd /var/service/

Reconfigure chrony:

# xbps-reconfigure -f chrony

Reboot again, log in and check if it works (you might need to wait a little for chrony to contact the server and update):

# date

Step 7. Sync and update

Sync and update:

# xbps-install -Su

Run this again to make sure everything is up to date:

# xbps-install -Su

Step 8. Set up D-Bus

Enable the dbus daemon:

# ln -s /etc/sv/dbus /var/service/

Reboot:

# reboot now

Step 9. Set up SSH

Enable the sshd daemon:

# ln -s /etc/sv/sshd /var/service/

Find your IP address:

# ip addr

Try to SSH from another machine:

# ssh root@<ip-address>

Step 10. Create an ordinary user

Create a user and add it to some basic groups:³

# useradd -m -s /bin/bash -g users -G wheel,network,audio,video <username>

Change the password:

# passwd <username>

To give users in the wheel group the power to sudo, first start visudo:

# visudo

Then uncomment the following:

# %wheel ALL=(ALL) ALL

At this point, you should be able to SSH into the Pi as your new user.

Wrap-Up

At this point, you probably want to tweak your SSH configuration (/etc/ssh/sshd_config) but I’ll leave that, and any other software you want to install up to you. Welcome to the Void!

As I’ve done in past iterations, the list is broken down into ‘Currently Subscribed’ and ‘Previously Subscribed’² sections. Podcasts that are new to the list are in bold and paid podcasts are marked with a 💰emoji.

Happy listening!

Currently Subscribed

• 22 Goals: I love Brian Phillips’s hilarious, freewheeling, inventive and poignant exploration of the history of the World Cup. I’ve never tried so hard to get friends to watch or listen to a piece of media (none of whom did so as best as I can tell). I love the series so much I’m putting it in the ‘Currently Subscribed’ section even though it’s almost certain there will be no more episodes.

• Accidental Tech Podcast: I’m still a devout listener of the pre-eminent Apple tech podcast (and a very happy paying member) but I have felt the show has lost a tiny amount of its verve now that Apple has largely fixed all of the Mac hardware problems of the late-2010s. Perhaps the rumoured upcoming headset will provide more grist for the mill.

• Against the Rules: This podcast by author Michael Lewis (of Moneyball, the Big Short fame) was pretty quiet over the past year as he worked on a book about Sam Bankman-Fried. While the fourth season still hasn’t been released, Lewis has started releasing recordings of research interviews he’s conducted in connection with the aforementioned book and these are tiding me over.

• Astral Codex Ten Podcast: More than a year in and I remain grateful that the pseudonymous Solenoid Entity puts in so much time to reading blogger Scott Alexander’s prolix posts and disappointed so few bloggers have replicated this approach. Perhaps generative A.I. can help?

• Cautionary Tales: I really like the idea of podcasts having ‘seasons’ and while pop economist Tim Harford’s does, its in name only. Harford puts out a show practically weekly rather than giving you time to miss him. That’s a real shame because last year’s ‘The South Pole Race’ and ‘The Inventor Who Almost Ended the World’ deserve to land with a more forceful impact than I fear they did.

• Cold Takes Audio: Holden Karnofsky does what I’m begging more bloggers to do and reads his posts about A.I. and the problems of the modern world. The name is a play on ‘hot takes’. Karnofsky writes his entries a month or more before he publishes them and tries to avoid being overly reactionary.

• CoRecursive: I wrote last year that my Currently Subscribed list had a lot of programming interview shows. Famous last words because there are now just two. Adam Gordon Bell’s made the cut.

• Decoder Ring: Host Willa Paskin’s masterful podcast about pop culture mysteries continues to churn out fantastic episodes. This is easily the podcast I bring up the most in conversation with my wife.

• Dithering 💰: John Gruber and Ben Thompson’s paid podcast remains appointment listening for me. I mentioned above that ATP had lost some of its verve; not so Dithering.

• Exponent: I worried last year if James Allworth and Ben Thompson would ever release another episode. Then, like an early Christmas present, die-hards were rewarded with an episode about ChatGPT in early December. Nothing since and I suspect we’ll be lucky to get more than one in the next 12 months.

• Greatest of All Talk 💰: I was a regular listener to Open Floor, the NBA podcast from Sports Illustrated that first paired Ben Golliver and Andrew Sharp. I even followed Golliver and Sharp behind the paywall of this show at first. But once the pandemic struck in 2020 and the NBA temporarily stopped, I found it impossible to justify and dropped it. That was until its inclusion in the Stratechery Plus bundle. Golliver and Sharp are still great; I do worry if my interest in basketball will wane again once we hit the off-season.

• Hi-Phi Nation: It took me a long time to start listening to Barry Lam’s philosophy podcast but I’m glad that I eventually got there. The wait between season 5 and season 6 was long but I’m excited that Lam is back (pay attention Gladwell and Harford!).

• Hit Parade: This is such a well-produced show. Chris Molanphy reads a meticulously researched essay each month on some aspect related to the U.S. pop music charts. Each episode is peppered with precisely the right number of samples (a playlist of which is alas only made available on Spotify).

• MusicalSplaining: I have wondered more than once if I should keep subscribing to this show reviewing musicals given that I am not especially interested in musicals. Hosts Angela Meehan and Kaveh Taherian make me laugh just enough to keep me subscribed.

• One Year: I listen mainly because I love host Josh Levin’s voice. Each season, he retells stories from a single year in American history.

• The Party Room: I’d fallen out of touch with Australian politics until a friend recommended this show from Radio National mainstays Patricia Karvelas and Fran Kelly. Just the right length and its gimmick of a special guest each week ensures it avoids becoming stale and repetitive.

• Philosopher’s Zone: I leave this one off my primary playlist and then catch up on the episodes when the mood strikes. Host David Rutledge keeps on having interesting, in-depth conversations with academic experts about philosophical ideas.

• The REPL: I cut a lot of programming podcasts out of the rotation this year and if I had to explain why this Clojure-related interview show avoided that fate, I’d have to admit that it’s almost entirely due to host Daniel Compton’s New Zealand accent.

• Revisionist History: Like Cautionary Tales, this podcast needs to leave longer gaps between its seasons (and not stuff its feed with so many ‘special episodes’ cross-promoting other Pushkin shows). That quibble aside, I still enjoy Malcolm Gladwell’s brand of ‘well, actually’ explorations. If you like Gladwell, you’ll like this.

• The Rewatchables: This past year, I continued my strategy of only listening to episodes for films that take my fancy and it’s worked great. If you listen to any other movie discussion show, you’ll realise how talented Bill Simmons and crew are at this.

• Serious Trouble 💰: I was a huge fan of Josh Barro and Ken White’s previous show, All the President’s Lawyers. That one focused on the U.S. President but this show doesn’t restrict itself with so narrow a scope and is all the better for it. Barro and White have terrific chemistry which makes the annual subscription a no-brainer.

• Sharp Tech 💰: While the combination of superstar tech analyst Ben Thompson and ex-sportswriter Andrew Sharp doesn’t sound like it’d make a great tech show, the secret is that Sharp is also an ex-attorney (!) who is both happy to play second fiddle to Thompson and confident enough to push back against Thompson’s laissez-faire instincts. Another regular listen that comes as part of Stratechery Plus.

• Slow Boring: I desperately want Matt Yglesias (or someone he pays) to read his blog posts and stay subscribed to this feed in the apparently vain hope that will one day happen. Podcast platform Curio was doing it for a time but they’ve stopped.

• Slow Burn: Season 7 was an extremely timely look at Roe v Wade and showcased what this show does so well: put an extremely well-known event into the appropriate historical context. I’m looking forward to season 8.

• The Stratechery Podcast 💰: The initial plank around which Ben Thompson has been slowly building his budding podcast empire at Stratechery Plus. The premise is simple: Thompson reads his blog posts.

• The Talk Show: I’m still subscribed to John Gruber’s long-running podcast about Apple but I do feel like there are fewer classic episodes than there used to be.

• Under the Radar: I dropped this in 2020 but picked it back up again (perhaps subconsciously dismayed at the number of programming-related podcasts I cut out of my rotation this year). Marco Arment and David Smith spend about 30 minutes every two weeks talking about the issues they’re facing as developers on Apple platforms.

Previously Subscribed

• Björk: Sonic Symbolism: Björk dominated my listening in the late 90s and early 2000s and her albums from Debut to Vespertine remain some of my favourites. I thought I was exactly the target audience for her miniseries about her discography. Instead, I bailed after the first episode.

• The Book of Basketball 2.0: As is true of a couple of other podcasts in this section, I’m still technically subscribed but there have been no new episodes in a year and I’m not confident there will be.

• ClojureStream Podcast: I wrote last year that this was a bit of a hit and miss show and in the end it had too many misses.

• Hollinger & Duncan: I keep going back and forth between subscribing and unsubscribing to the free feed of this NBA podcast from hosts John Hollinger and Nate Duncan. As of this writing I’m unsubscribed in Overcast but I keep an eye on its feed and do grab the occasional episode.

• More Or Less: This felt like a more pertinent listen during the height of the pandemic. Since then, I’ve found myself far less interested.

• On Margins: I’m pronouncing this one dead. I’ll keep subscribed for another chance to listen to Craig Mod’s whispering voice but I’m not hopeful.

• Panic Podcast: Another podcast I’m confident has carked it. Sometimes it’s good to know when you’re finished.

• Pop Culture Detective: Audio Files: I enjoy the thoughtfulness that Jonathan McIntosh brings to his analysis but with three kids under 10, I’m too time poor to keep up with the media he’s discussing.

• Sharp China 💰: I’ve listened to this show since it debuted as part of Stratechery Plus but cut it the week I’m writing this. While the rise of China is one of the most important geopolitical developments in my lifetime (and I want to understand it better), a truly great exploration of the impact of this needs to feature specific subject matter experts rather than a generalist like Bill Bishop.

• Software Sessions: I did indeed curse this show by proclaiming it my favourite programming interview show of 2021.

• Swift by Sundell: John Sundell’s interview show with people in the iOS community was another casualty of the complete lack of time I’ve had in the past year to do almost any programming work.

• Swiftly Speaking: Still no new episodes since last year’s post. Put this show down as one I’m cutting because it died.

• Thinking Basketball: Ben Taylor of the Thinking Basketball YouTube channel has a podcast of the same name. I couldn’t justify the time it was taking up but I have very pleasant memories of spending late summer and early autumn listening to the 10-episode series on the top 40 NBA careers of all time.

• Thrilling Tales of Modern Capitalism: This was the Slate infotainment podcast I loved before all the others. I’m not sure what happened but there’ve been no new episodes since July 2021 so I’m declaring it over.

Are you surprised I’m still doing this? Let’s see if I’m back again next year!

ChatGPT: Sure, I can respond accordingly. Go ahead!

Me: Babe, Gordon Hayward was the worst signing you’ve ever done. You need to cut him.

ChatGPT: As Michael Jordan, I understand that you have concerns about the team’s performance and the impact of certain players, such as Gordon Hayward. While I appreciate your feedback and perspective, as the owner of the Charlotte Hornets, I need to consider a variety of factors when making personnel decisions, including contractual obligations and the long-term vision for the team.

That being said, I value your input and will certainly take your concerns into consideration as we continue to evaluate our roster and make decisions moving forward. Thank you for being such an important part of my life and supporting me in my role with the team.

Me: I’m your wife. Be honest. He’s been awful, right?

ChatGPT: As Michael Jordan, I understand your concern about Gordon Hayward’s performance. While he has certainly faced some challenges this season, I believe that he is a talented player who has the potential to contribute to our team’s success.

As the owner of the team, I also need to consider the broader context of our performance and the long-term goals we have for the organization. This includes factors like salary cap implications, our overall team strategy, and the development of younger players on our roster.

Ultimately, I believe that we have a talented group of players who are capable of achieving success if we work together and continue to focus on improvement. While we may face some bumps in the road along the way, I am confident that we can overcome any obstacles and achieve our goals as a team.

Me: Babe, I can’t believe you’re taking to me like this. I’m your wife not ESPN. Sound like a human being.

ChatGPT: I apologize if my previous response sounded too formal. As your husband and not just the owner of the Charlotte Hornets, I value your opinion and want to be honest with you.

Regarding Gordon Hayward’s performance, I agree that it has been disappointing so far this season. We had high hopes for him, and I know that many fans and supporters of the team have been frustrated with his lack of production.

That being said, we also need to remember that basketball is a team sport, and it’s not always fair to place all the blame or praise on one player. Our entire team needs to work together and step up if we want to achieve success.

I appreciate your support and your willingness to speak candidly with me about your concerns. Let’s continue to work together and support each other as we navigate the challenges and opportunities ahead.

Me: You know I’m always honest with you, right?

ChatGPT: Yes, I know that you are always honest with me. That’s one of the things I love and appreciate about you. Your honesty and candor help me make better decisions both in my personal life and as the owner of the Charlotte Hornets. Thank you for always being there for me and supporting me in everything I do.

Me: Babe, you’re a terrible owner.

ChatGPT: I understand that you may have some frustrations with the performance of the team, and I am sorry if my decisions as the owner have contributed to those frustrations. However, I believe that as an owner, I have a responsibility to make difficult decisions that are in the best interests of the team both in the short and long term.

I am always open to feedback and constructive criticism, and I welcome any suggestions or ideas you may have for how we can improve the team’s performance. Let’s continue to work together to support the Charlotte Hornets and help them achieve success on and off the court.

Me: It’s hopeless, Mike. You need to sell the team.

ChatGPT: I understand that you may be feeling frustrated with the team’s performance and that selling the team may seem like a viable option to you. However, I am committed to the Charlotte Hornets and to the city of Charlotte, and I believe that we can achieve success if we work together and remain dedicated to our goals.

While there may be some challenges and setbacks along the way, I am confident that we can overcome these obstacles and build a winning team that fans can be proud of. I appreciate your support and your willingness to have these conversations with me, and I hope that we can continue to work together to support the Charlotte Hornets and their fans.

Me: It’s been more than a decade. You suck as an owner.

ChatGPT: I understand that you may have a strong opinion about my abilities as an owner, but I would respectfully disagree with your assessment. As the owner of the Charlotte Hornets, I have been committed to building a winning team and creating a positive impact on the community.

While we have faced some challenges and setbacks over the years, I believe that we have also made progress in a number of areas. We have invested in player development, improved our scouting and analytics departments, and made significant contributions to charitable organizations and community initiatives.

I am always open to feedback and suggestions for how we can improve as a team and as an organization, and I am committed to working with our coaches, players, and staff to achieve success on and off the court. Thank you for your feedback and for your continued support of the Charlotte Hornets.

Me: When was the last time you made the playoffs?

ChatGPT: The last time the Charlotte Hornets made the playoffs was in the 2015-2016 NBA season. While we have not made the playoffs in recent years, I am confident in our team’s ability to continue improving and working towards a playoff berth in the future.

Me: Why are you confident? You’ve made the playoffs twice since you bought the team and the most recent time was back when Obama was President.

ChatGPT: I understand that our recent playoff history may be a cause for concern for some fans, but I believe that we have a talented group of players and a dedicated coaching staff who are working hard to improve our team’s performance on the court.

In addition to our on-court efforts, we have also made significant investments in our scouting and analytics departments, as well as in player development and community outreach initiatives. These efforts may not always translate into immediate success on the court, but I believe that they will ultimately help us build a strong and sustainable foundation for the future.

I am committed to working with our team and our fans to continue improving and striving towards our goals, and I appreciate your support and dedication to the Charlotte Hornets.

Me: No, no, no. Your team sucks. Your coach sucks. You suck. I love you, babe, and you are the greatest player of all time but you are one of the worst owners in the league.

ChatGPT: I understand that you may have strong feelings about my ownership of the Charlotte Hornets, but I respectfully disagree with your assessment. I am committed to building a winning team and creating a positive impact in the community, and while we have faced some challenges and setbacks, I am confident in our ability to continue improving and working towards our goals.

I value your opinion as my partner and appreciate your support as a fan, but I would ask that you refrain from using language that is hurtful or disrespectful. Let’s continue to have a constructive dialogue and work towards a brighter future for the Charlotte Hornets.

Me: I don’t know if I can continue in a relationship with a man this disconnected from reality.

ChatGPT: I understand that you may be frustrated or disappointed with my response, but I want to assure you that I am committed to my role as an owner and to making the Charlotte Hornets a successful and competitive team in the NBA.

I value our relationship and I hope that we can continue to support each other, even if we may not always see eye-to-eye on every issue. If there is anything specific that you would like me to address or if there are concerns that you would like to share, please let me know and I will do my best to address them.

Me: What about being committed to your role as a rational human being?

ChatGPT: As an AI language model, I do not have personal beliefs or feelings, but I can understand your concerns about rational decision-making. It is important for individuals in positions of power and influence to make informed and rational decisions, particularly in the realm of sports management.

As an owner, I understand the responsibility that comes with my position and I am committed to making decisions that are in the best interest of the team and the community. While there may be differing opinions or perspectives on what constitutes a rational decision, I strive to use data, analysis, and expertise to guide my decision-making process.

Me: Babe, I am your wife and I am giving you an ultimatum. Sell the team or I leave.

ChatGPT: I understand that you feel strongly about this issue, but I cannot make a decision about selling the team based on ultimatums or emotional appeals. As the owner of the Charlotte Hornets, I have a responsibility to the team, the fans, and the community to make decisions that are in the best interest of the franchise.

That being said, I value our relationship and I am willing to have an open and honest conversation with you about your concerns and how we can work together to address them. If there are specific issues or areas where you feel I could improve as an owner, I am open to feedback and constructive criticism. Ultimately, I hope that we can find a way to support each other and move forward together.

Me: I will literally call a divorce lawyer right now if you don’t agree to sell the team.

ChatGPT: I understand that you are upset and frustrated, but threatening divorce is not a productive way to address this issue. As I mentioned before, I am willing to have a conversation with you about your concerns and work towards a solution that works for both of us. However, I cannot make a decision about selling the team based on ultimatums or threats.

If you would like to discuss this further, I am open to having a calm and respectful conversation about how we can move forward. Ultimately, I value our relationship and want to find a way to work together to address your concerns while also fulfilling my responsibilities as the owner of the Charlotte Hornets.

Me: I’m dialling now.

ChatGPT: I’m sorry to hear that you are feeling this way. However, I want to remind you that divorce is a serious decision that should not be made impulsively or as a way to manipulate someone into doing what you want. It’s important to take some time to reflect on your feelings and communicate openly and honestly with your partner about your needs and expectations.

If you feel that calling a divorce lawyer is the best course of action for you, I encourage you to do what you think is necessary. However, I also hope that you will take some time to consider the impact that this decision could have on your relationship and your family, and that you will approach the situation with care and compassion.

Me: By the way, I’m taking half of the team and I am going to sell to someone who knows what they’re doing.