RSI might already be here. In August alone @claudeai had 731 changelog entries, the busiest month in its 17-month public record. I (ahem.. Fable/Opus in Claude Code) read all 4,919 entries as a syllabus and asked: what was the tool trying to teach its users? A thread.

I'm seeing a lot of euphoria about how Opus 5.5 is good at TLA+, and this means that all software will soon be formally verified. As a person who loves TLA+ so much he wrote a book on it, I want to throw a particular cold shower on people's enthusiasm by talking about the limits of what you can actually verified with it. The high level simplification is that TLA+ sees a system as a set of "behaviors", or possible sequences of states. For example, the pseudocode "pick a random number from 1-3 and decrement it to 1" has three behaviors: `{3 -> 2 -> 1, 2 -> 1, 1}`. From here, there are two basic kinds of TLA+ properties: - `[]P` means that `P` is true in *all states* of *every behavior*. - `<>P` means that `P` is true in *at least one state* of *every behavior*. `[]P` is immediately useful as an **invariant**, or something that always be true of your system. This is things like "your data is never corrupt" or "there's always at least one server online." `<>P` is a little more abstract, but for technical math reasons I won't get into here, can be stacked with `[]` to create really complex and useful properties. `<>[]P` represents things like "the algorithm eventually converges on the right answer", `[]<>P` things like "if two data stores desync, they will eventually resync", and `[](P => <>Q)` things like "If a message is put on the queue, it's eventually processed by a worker". Really cool stuff! These primitives were chosen to make a wide array of properties useful. And if we're clever, we can do all sorts of more complex properties, like bounded time constraints and history properties. But we're always constrained to 1) define a logical formula 2) over individual behaviors, and 3) check that all behaviors satisfy that formula. So some things that we *cannot* express in TLA+: - Possibility and reachability properties: that it's always possible to *make* P true, even if you don't actually decide to. Things like "I can always shut down the computer" or "A user can always change their password". These can't be expressed with `<>P` because that's "for all behaviors, P happens at least once", we actually want "for all behavior prefixes, there is at least one behavior where P happens at least once". - Hyperproperties: properties that are defined over two or more traces. These are things like "painting a car red doesn't make it faster" or "users cannot infer secret data by observing public data". We can't do these because TLA+ only looks at one behavior at a time. - Statistical properties: 95% latency is 1ms. Impossible because most of these are hyperproperties. - Properties about if a system is robust against code changes. Impossible because, uh, you have new behaviors now. Some of these are solvable in different logical formalisms. CTL can do reachability, PRISM can do statistical properties, etc. Those have their own tradeoffs and limitations, though, and no system can do everything. Others are solvable with a lot of cleverness tailored to the specific spec, like lifting a model into a hypermodel. But these are insanely inefficient and make your "clever spec" diverge significantly from the real world system, so introduce a lot more opportunity for things to go wrong. The core problem, though, is (1): properties are logical formula. If we don't know how to express a system property as a logical formula, we can't verify it. 99% of the properties we care about fall under this. The information on the site is easy for a user to find. Our LLMs behave as we expect them to. Our application can't be used to break the law. TLA+ (and Quint and Lean and Rocq) are near-useless here, no matter how clever you are. Don't get me wrong: `[]P` and `<>P` represent a huge range of useful properties and TLA+ is incredible at finding awful concurrency bugs. But there's a lot it fundamentally can't do and we shouldn't believe that it will solve all our worries about software bugs. And the same goes for all other formal verification languages, too.

If new models are going to drop every week (almost) and newer models work better than the older ones, all workarounds,controls, memories(auto or explicit), gotcha-fixes and such we have from earlier need to be reviewed each week and cleaned up. This is a new form of tech debt that cumulates over time. There are workarounds that people (often from the frontier firms themselves) recommend, but I often have no idea if their approaches will work and I dont have time to have evals for my own workflows 🥵 Help needed...

I did not expect to see this on a Claude max $200 plan

agent.run()

Read all x thousand words at 4 in the morning. Soooo good

I like Fable 5.1 in @herdrdev

This is brilliant. opusfived.dev

Live action with real robots instead of animation: episode 3! This was the very first take. Pretty much everything went wrong and I almost stopped filming. Then I realized Microduck was giving an Oscar-winning performance. Enjoy!

A personal note and then off to work: @dhh I want to thank you for your unhinged enthusiasm. It's truly infectious. Watching you share your vision for Omarchy with hope and optimism and passion has been a breath of fresh air. Even your handling of the doubters. Positive, undeterred, open. It's prompted me to reflect on what it is that I want to do that I can get this excited for. I've been reminded of a time when I was similarly stoked and undeterred. Your passion has created a space of permission for others to have a similarly unhinged enthusiasm. As much as Rails and Omarchy will be massive pieces of your legacy, I hope that people will also remember you for your enthusiasm and undeterred passion. It's so much easier to be stoked than to be cynical. There are always problems to solve. Such is life. And the fun really. The celebration of what is good, what is possible, now that, that is an attitude worth adopting. We can fix everything.

Omarchy is blowing up. I've never been involved with anything in my career that has grown this fast. With Ruby on Rails, we had years to build solid institutions, teams, and relationships. With Omarchy, we've been forced to figure it all out in twelve days. It's exhausting, but also incredibly exciting. It was never sustainable with just Ryan and me running everything. That's how it was, more or less, up until Quattro. Lots of other contributors, but all the responsibility was on us to make sure the ship stayed afloat, the servers didn't crash, and fixes got pushed out quickly. Now it's time to build a proper institution. Durable, resilient, and competent. That's what we're doing here on Basecamp now. I'm spinning up teams for every facet of responsible distro management, and I'm getting an absolute outpouring of interest for all of them. Everyone wants to be part of this. We're winning hearts, minds, and volunteers at an astounding rate. Great! We need all of it to succeed. Because make no mistake: There are many people who'd love to see this rocket blow up before it reaches the moon. Aggrieved Linux users who don't like the sudden attention their exclusive hobby has received. Competing Linux distributions that are seeing our numbers explode. Mac stans who've sunk their identity into an apple. And, of course, any of the haters I've picked up in my quarter-century career speaking bluntly on the internet. They're not going to succeed. Because we've already become unstoppable. There's too much momentum, too much money, and too much support now backing this effort. We're living the Mandate From Heaven meme at the moment. And we are here to fulfill the prophecy: The Year of Linux on the Desktop! That has been a joke for two decades. But by the end of the year, nobody at Apple or Microsoft is going to be laughing. They're going to be scrambling. Because neither of these proud organizations currently has any method to counter the speed, vision, or ambition with which we're going to accelerate into the future of personal computing. This is the moment. This is the opening. This is our chance. For thirty years, we've been subject to one OS overlord or another. Dictating how we compute. Choking off competitors through platform malfeasance. Tollboothing the distribution. That ends now. Because Linux is going to win. And Linux is free. As in beer, speech, and source. But just because it's inevitable doesn't mean it's going to be easy. We have a lot of work in front of us if we actually want to make our mark. But there's never been a better time for this kind of delusional ambition. The age of agents is the unlocking factor. It sounds like a LinkedIn slogan, but it's true. Where the application of tokens goes, the innovation follows. We can fix everything. Let's do it together. Let's go. --- This is what I sent to the dozens of new volunteers who've signed up for teams within the new Omarchy organization yesterday. But we might as well broadcast our mission and intentions to the world too.

someone trained microduck to do somersaults 😭