Latest Posts (20 found)

Ruminations on notifications

I’m on annual leave next week. Now would be the ideal time to drop premium rage-bait and walk away. “One browser tab is enough” was drafted but due to a tragic accident we are all spared. This sideways look at notifications should be more relatable. When I pay using NFC I’m annoyed twice. First by Apple Pay, then again when my banking app catches up. Can’t they decide between themselves? I don’t need two reminders about the groceries I bought a minute ago. Maybe I can disable notifications for either one, but then I might miss real fraud alerts. Notifications are a chore I could do without. Notifications are a core feature of needy programs . Every app wants to be the centre of attention. They can’t wait to tell you about their new features. Presumably in-app notifications are the new trend because OS level notifications are easily blocked. Vivaldi ruined my browsing experience for a long time. That annoying “toast” wasn’t dismissible. It crossed the line of death and looked suspicious. Eventually it was fixed by moving into the tab bar. I recently returned to Sublime Text to avoid modern apps that were too needy. In response to my post, developers were keen to laud their command line supremacy. I don’t disagree but the CLI isn’t immune to notification nonsense. Every time I open Neovim I get stopped. Guess what happens when I press enter? Nothing! How about telling me what the command is to update the damn plugin?! Dear devs, updates may be your life, they ain’t mine! The web platform demands that anything native apps can do, the web must copy. There are good arguments for this. The counterpoint is terrible implementation. Browser vendors have done a dismal job at designing the user experience around push notifications . “This website wants to send you notifications, allow?” Does this still pop up before a page has even loaded? I wouldn’t know. I blocked that years ago without thinking twice. My advice, look for this: — and block wholesale without exception. In all my years of building websites I’ve never had a single client request or even consider notifications. Not one project that scoped in such a requirement. Apple held out for declarative web push in Safari citing their usual privacy theatre ( lol ). Apple aren’t fans of silent push with no visible UI. I reckon their actual trepidation is their unreliable cloud syncing infrastructure. When I tested it was 50/50 on whether a notification ever arrived via Apple. Mozilla’s servers are rock solid. One rainy day I ran an experiment to send large data split across many hundred web push payloads. I was able to clock kilobytes per second. This is awful abuse of the API. Apple might be right about silent push… Proton Mail was one of the few mobile app that I allowed notifications. My inbox is usually rather chill, except when Proton spam me themselves . Alongside my public addresses I use [redacted]@ for important accounts. I configured a folder to send mobile notifications for this address only. It worked for years. Then one day the spam notifications began. Spam that had already been flagged and filtered into trash (sent to any address). I reported this bug to Proton Support in May and was told: If we have any relevant information to share with you, or if we have any questions, we will follow up on this support ticket. I never heard back. Notifications remain disabled. Today my phone is almost entirely notification free unless I get an SMS from family. Oh, and Apple pestering me about iOS 26 several times a week. My iPhone will remain on iOS 18, thanks. Apple sure love their dark arts and deceptive patterns. There is no option to stop this constant nagging. If other apps tried it I bet Apple would delist them. This ain’t about security, I get iOS 18 updates. UK Government got trigger happy with their alert system. As with all mobile alerts of this nature, we’re reminded that abuse victims are at risk . This one also led to fire departments across England and Wales having to remind people their neighbour’s barbecue is not an emergency. As Robb Knight noted: “there is nothing actionable in the alert” . Unless you count “Search gov.uk”, so I did. The more information provided was: Sent by the UK government at 7:01pm on Friday 14 August 2026 This alert was sent to England and Wales. Surrounding areas might also have received the alert. Emergency Alert - GOV.UK Thanks, Government. That could have been an email. Why don’t these alerts respect my volume setting? Scared me half to death! If they have to be all or nothing, reserve them for zombies or higher. And that’s the problem with notifications. There is rarely the granular control necessary to make them useful. Most senders cannot be trusted to used them responsibly. The temptation to abuse direct access to people is too much, especially for men with guns . If I ever allow notifications to begin with I disable them indefinitely the first time an app cries wolf. Every app cries wolf eventually. Life is so much better when I go seeking information at my own pace. Thanks for reading! Follow me on Mastodon and Bluesky . Subscribe to my Blog and Notes or Combined feeds.

0 views

Three ways to smuggle SQLite into Nix

The core of nixpkgs-multiverse , when you strip away the Nix API and the CLI, is an index. It is a map from to the revision that shipped it as a JSON file. 1 As of 9cc0209 , is 5.3 MiB and is 7.5MiB covering 305,492 package versions across 31,904 packages and 1,534 revisions. The Nix API loads the JSON files lazily and are all read via : I would like to enrich the data with even more information however it comes at a cost: mo’data, mo’problems. The goal of the project is to minimize the number of Nixpkgs that are downloaded. If we merely swap fetching huge Nixpkgs for huge JSON, it’s not a clear win. For now we have to be judicious about what we store in the JSON files and think of clever encoding schemes to make the data small and compact. If we were not constrained to the Nix , we would leverage established technologies to efficiently encode our dataset that allow multiple query access patterns: databases! Let’s say we were not restricted to JSON, do we have any other options? Why are large JSON files so problematic? is eager . There is no lazy JSON in Nix, no streaming parse (i.e. “just give me this one key”). The moment you touch the result you have parsed all 5.3 MB and materialised all 305,492 values on the Nix heap. In the case of the multiverse, asking for one package costs the same as what asking for all of them. Note The lookup itself is not the problem. Nix attribute sets are a sorted array, so access is a binary search, not a scan. The cost is entirely in the JSON parse and in allocating the values and downloading a large file. If we want to do alternate questions over the index, we have to make sure we keep the answers efficiently stored to better match the access pattern. What we want is obvious. We want a way to efficiently encode the data and a declarative way to define queries: we want SQLite! 2 Nix by default cannot do this. Unfortunately there is no , although I think there should be… Turns out though there are knobs we can touch or sources we can patch to get what we want anyways, albeit each one has a caveat. 😈 I was surprised I did not know about this , and it has been around since release 1.11.9 in April 2017. It is the ultimate escape hatch for a variety of use-cases when you simply can’t get them done with what’s available. takes a list of strings, runs the program, and parses its stdout as a Nix expression . It is gated behind a setting that makes it clear it’s unsafe. For integration, SQLite is perfectly capable of printing the Nix syntax. We never need a serialisation format in between as we make SQLite emit the attrset directly: The caveat is that every query is now a , an , a process image of SQLite, and a re-parse of the output through the Nix parser. If you do not plan to execute many queries that overhead is likely acceptable given the simplicity of the integration. From researching , I stumbled upon . It takes a path to a shared object and a symbol name, s it, and calls that symbol. It landed in 1.8 , December 2014. 3 The shared object must implement the following signature: We can define a new native function that returns the versions for our input: The implementation is ordinary C++ using the Nix API. Below is a snippet of the implementation, making sure to cache our handles to avoid the same startup penalty as : Using it looks like this: Determinate Systems shipped a third option in March of 2026: , which calls a function inside a WebAssembly module. 4 The motivation was similar to wanting to extend Nix surface area but avoid expanding . Wasm is sandboxed and deterministic, so unlike the two builtins above, the goal is to provide a safe escape-hatch . WebAssembly is a binary instruction format for a stack-based virtual machine. The claim is that it is well suited for Nix because it has deterministic execution , which is a lot more restrained than a backdoor . A module needs to export , an initialiser called , and the entry point. Nixpkgs already includes the target for cross-compilation, so making one is pretty straightforward: You call back into the evaluator through the Nix API functions, so a wasm module builds real Nix values, similar to minus the footgun. SQLite ships an official wasm build , so the pieces seem to be sitting right there and the gears in my mind began to turn. Initial attempts to try and load a SQLite database with the traditional Nix were a bit of a failure as Nix strings cannot contain NULL bytes. Thankfully, with the help of some additional due-diligence by LLMs, we discovered that one of the Nix API functions is not in the blog post: is specifically designed for this problem. This function allows a WASM module to pull arbitrary raw-bytes off disk into its memory. Unfortunately, it’s a little too broad in that it reads the complete file which is kind of overkill and what we are trying to avoid from our initial JSON solution. In the pursuit of exploration, let’s patch the implementation and augment the API to allow random access and partial read of a file. Turns out the patch to add is relatively small and straightforward. Now we have everything we need to hook up SQLite and a custom virtual filesystem (VFS) layer to read from the provided path entry. We build a WASM target of SQLite and we set . That flag removes SQLite’s entire VFS layer and requires us to supply one. We provide the build a simple implementation of the API which is a call-back into the Nix evaluator via that newly exposed function. Everything else is stubs. Note Unfortunately gives every call a fresh instance . This is deliberate from the implementation, meaning we pay some startup code each time although not quite as drastic as a & Using it looks like this: 5 That is a real full SQLite with all the bells and whistles: prepared statement, bound parameter, b-tree descent through an index, executing inside the Nix evaluator. All through WebAssembly. 🤯 How do these four approaches compare? Here are all four approaches answering the same question: “which revisions shipped this package?” against the same 22 MB SQLite build of the index. As we initially complained, is a flat line in the wrong place. It is 0.29s whether you ask one question or two hundred, because the 5.3 MB parse happens once and dominates everything after it. starts the cheapest and climbs , roughly 3.8 ms per query of + + Nix-parsing the output. It crosses somewhere around eighty queries. is flat and nearly free , 0.05s across the whole range since we reuse SQLite instantiations across multiple invocations. The database is opened once for the entire evaluation and the pages stay warm. Unfortunately, SQLite in wasm is dominated by a fixed cost , roughly 2.5 s before the first query, then about 7 ms each query thereafter. That 2.5 s is Cranelift compiling 1.1 MB of SQLite. Right now that is a limitation of the WASM implementation however Eelco has mentioned that the generated code could be cached on disk in the future across invocations. For a lock file pinning thirty packages, still wins outright at the current index size. None of these three is right for shipping the multiverse index, and I am not going to make depend on . Asking people to run their evaluator with native code loading enabled so my flake can be faster is not a worthwhile request at the moment . For now, the index stays JSON and I’m holding back on some of the more loftier ideas I have that require a lot more data . Although philosophically I only use CppNix , I was a little intrigued and impressed with what the ecosystem could unlock with WASM. There are definitely some warts however such as waiting for it to JIT and the developer-experience of maybe having checked-in compiled blobs but there is definitely potential to unlock a variety of problems. There are actually a few other files that drive other features such as the statistics or “fast mode” , but they are all JSON as well.  ↩ nixpkgs-multiverse already exports a SQLite database as a package to help others explore this data.  ↩ The C++ field was originally called and was renamed to for .  ↩ Eelco gave a talk about this at SCALE 23x .  ↩ Don’t forget that this is needs our patched version of Determiante System’s Nix .  ↩ There are actually a few other files that drive other features such as the statistics or “fast mode” , but they are all JSON as well.  ↩ nixpkgs-multiverse already exports a SQLite database as a package to help others explore this data.  ↩ The C++ field was originally called and was renamed to for .  ↩ Eelco gave a talk about this at SCALE 23x .  ↩ Don’t forget that this is needs our patched version of Determiante System’s Nix .  ↩

0 views

Citizens Build, Agents Execute, Experts Govern

TL;DR Why building an app over the weekend isn't the same as building enterprise software I’ve noticed an interesting gap opening up over the last six months. It isn’t really a gap in technology. It’s a gap in what different people think software engineering actually is. The conversation usually starts the same way. A non-techie, maybe an executive, tells me about something they’ve built over the weekend. Sometimes it’s a chatbot. Sometimes it’s an internal workflow. Sometimes it’s a surprisingly polished application that solves a real business problem. They’re excited, and they should be. Twelve months ago they probably couldn’t have built it at all. Then comes the question. “If AI can do this now, why aren’t our engineering teams delivering ten times faster?” It’s a perfectly reasonable question, after all we’ve all seen the demos. The first thing that would come to my head is “you don’t know what it takes to build enterprise grade software”. But then I think about what I mean and how to explain it to a non-technical person without sounding super patronising. And then it hit me, we did this to ourselves. We’ve spent so many years banging on about how to write good software that everyone has assumed writing software is the same as software engineering. The application someone builds over the weekend is real software. It likely solves a real problem or demonstrates an idea. Sometimes it’s genuinely impressive. I don’t want to diminish that because I think one of the most exciting things AI has done is dramatically increase the number of people who can turn ideas into working software. That’s cool, I totally get it. The first apps and “hello worlds” I ever built excited me enough to choose this as an actual career so the excitement is real and I don’t want to temper it too much. But your first hello world, which these days can be an entire app with all kinds of features, is very, very (extra very on purpose) different from introducing software into a production environment in a highly regulated enterprise, as an example. But why? The moment that application becomes something the business depends on, the questions change completely. Is customer data protected? What happens when a dependency fails? Can someone else understand this system in two years’ time? Will it survive an audit? Can it cope with a thousand times more users than it has today, what about millions in one day? How will we know something is wrong before our customers do? Those questions don’t show up in a demo or in the build phase at all unless an experienced engineer is in the room. I certainly wasn’t asking them when I was building my first apps. I only cared about features! This is where experienced engineers become more important, not less. Not because they’re the only people who can build the software anymore, but because they have the judgement to know whether we can trust it: whether the design is good, the risks are understood, and the thing that works today won’t become somebody else’s nightmare six months from now. At FOSE a few weeks ago, we spent surprisingly little time talking about coding. We talked about whether code was still the source of truth, and occasionally about how much we missed writing it, but mostly we talked about design, architecture, governance, learning and judgement. One team described spending the day designing a specification, letting agents work overnight and reviewing the results the next morning. The interesting bit for me wasn’t the overnight pipeline, cool as that was. It was what the humans were doing: deciding what good looked like, making trade-offs and judging whether what came back was actually what they wanted. We also kept coming back to good design, because it turns out that when agents can generate lots of code very quickly, good design matters more, not less. That made me wonder whether we’ve been thinking about scarcity in the wrong way. We’ve spent decades optimising around people who can write code because they were scarce and expensive. I’m not convinced that was ever the real scarcity, but that’s probably another ramble. What feels scarce now is good engineering judgement: knowing what good looks like, understanding the risks and knowing when something that works is actually safe to trust in production. Because software doesn’t exist to be built. It exists to run in production and safely solve the problem it was created for. Organisations don’t run on code. They run on trust. A few months ago I found myself saying something in a conversation almost without thinking. Citizens build. Agents execute. Experts govern. It sounded cool and I thought marketing would like it, so I wrote it down. Then I left it alone for a while. The funny thing about writing these ramblings is that I don’t know whether I believe something until I’ve let it bounce around in my head for a while and also said it to other people I trust like senior engineers at Thoughtworks. Sometimes I come back convinced I was talking nonsense. Occasionally I realise there was something more interesting hiding underneath. This was one of those occasions where the latter was true. At first I thought I was talking about roles. Citizens build software (essentially non-engineers). Agents write the code. Engineers become governors. But I don’t actually think that’s what I meant. I think I was talking about where value is moving. AI has given everyone a new way to express their ideas. The execution is increasingly handled by agents. They write the code, refactor it, generate tests, fix bugs and iterate at a speed that simply wasn’t possible before. But neither of those things reduces the need for expertise. In fact, I think it does exactly the opposite. When everyone can create software, somebody still has to decide whether that software deserves to exist inside an enterprise system in PRODUCTION. Somebody still has to think about architecture. Security. Resilience. Operability. Compliance. Cost. The boring stuff that nobody gets excited about in a demo but that becomes painfully important the first time a customer can’t log in or an auditor comes knocking. That’s why I don’t think experienced engineers become less important. I think they become dramatically more leveraged. Their job shifts from building every feature themselves to creating the environment in which thousands of features can be built safely by other people and by agents. They become the people who design the guardrails, the platforms, the engineering practices and the feedback loops that allow everyone else to move quickly without creating chaos. Perhaps that’s the future software organisation. Not one where everyone becomes a software engineer. Not one where software engineers disappear. One where almost anyone can create software, agents increasingly execute it, and engineering expertise becomes the thing that allows all of that creativity to scale safely. And to be clear I do not mean people build stuff and throw it to engineers to fix, that is a total antipattern for another ramble. Perhaps that’s why the executives and engineers I’ve been speaking to sometimes sound as though they’re describing completely different futures. The executive sees that anyone can now build software. The engineer sees that somebody still has to live with it. Both are right. They’re simply looking at different parts of the same system we have to solve to create whatever the future actually ends up being.

0 views

Practitioner Voice: The Writing Category Nobody has Named Yet

Jim Highsmith recognizes that effective writing from a practitioner is a style distinct from academic writing or thought-leadership content. It's a style that I advocate, and my contributors mostly follow. Jim decided it was important to give it a name, and identify what makes it distinctive.

0 views
Unsung Today

“The ghosts are fast and they don’t turn blue.”

Some time ago, I shared a video talking about games that leaned into their bugs and made them part of their lore . One not listed there, perhaps because it’s the most obvious example, is Pac-Man’s kill screen . A few weekends ago at an arcade game convention , I spotted something really interesting. It was an arcade cabinet of Pac-Man, but with a twist: The game was modified and set up to start immediately at level 255, with all its challenges: fast timing, very angry ghosts, ineffective energizers. = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-ghosts-are-fast-and-they-dont-turn-blue/1.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-ghosts-are-fast-and-they-dont-turn-blue/1.1600w.avif" type="image/avif"> = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-ghosts-are-fast-and-they-dont-turn-blue/2.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-ghosts-are-fast-and-they-dont-turn-blue/2.1600w.avif" type="image/avif"> And once you beat that, you immediately face level 256: the infamous kill screen. I don’t think I have ever seen anything like this before. It reminded me of this joke someone made once about the olympics: that each competition should begin with the organizers grabbing regular people from the street to participate, just so the viewers can truly realize how impossibly hard those competitions are. I know a lot of software onboarding starts gently, walking you through basic scenarios to make you comfortable and to have you understand basic concepts. But sometimes I wonder: for professional apps, would it also be cool to start with a really advanced use that would get you excited? A really well-made, complex spreadsheet? A really sophisticated graphic? Instead of gently propping you up, what if the onboarding was about breaking something really complex down? I played the game a few times. I didn’t finish the level 255, and I never saw the kill screen. But it was a great challenge; if I had more time, I’d definitely spend it trying to make it happen. #bugs #games #onboarding

0 views

Gamifying Snacking with Snacker Tracker

So one of the things I've been trying to do as part of my journey to lose weight and get fit is sort my diet out. As the saying goes, "you can't out-train a poor diet" . And the worst part of my diet is definitely snacking in the evening. The routing generally goes: I'm the type of person who finds an arbitrary thing to aim for very motivating. It's not enough to just want to stop snacking in the evening, nope. That shit will fail pretty quickly. But if I have a streak I have to maintain - now we're talking! So I decided to build a simple little tool that I called Snacker Tracker . It's just a tap of a button every evening to say whether I've snacked or not, and it maintains a streak. Here's what it looks like on my phone: I decided to implement a free pass into the site as well. So I'm allowed to have 1 evening per calendar week where I can snack and it won't affect my streak - after all, I want to be able to have some fun! I thought about bundling Simple.css in to make it look pretty, but I decided to have some fun with the CSS and went with a neo-brutalist aesthetic, which I think looks great. So much so that I'm thinking about re-designing this site in a similar way, but I've managed to hold off on that...for now. Snacker Tracker also has a way of adding days retrospectively, so if I forget to log a day, I can easily go back and do it: I've only been using Snacker Tracker for a few days, but it's making me pause when that inevitable pang happens in the evening. I'm finding that instead of instinctively raiding the cupboard for some crisps or a chocolate bar, I'm thinking "don't screw up your streak" and not doing it. I know I'm not hungry during the evening, it's just a habit. My hope is that with time I'll re-train my brain to not expect sugar in the evening, and the pangs will go away. Until then, I'm gonna continue tracking my snacks with this fun little site in the hope that it makes me form better habits. But Kev, why don't you be a proper grown-up and just use your willpower? -- All the internet people Because, Internet Person, it's a habit that I don't even think about, and this forces my to think about it. Yes, I know it's arbitrary and rather childish, but it's working, so what's the harm? Will you be releasing Snacker Tracker so we can try it? -- Another internet person Maybe. I threw it together pretty quickly and the code is rough. A lot of my spare time is focussed on Pure Blog and Pure Comments at the moment, so I don't think I'll have the time to clean the code up to the point where I'm happy to release it any time soon I'm afraid. Thanks for reading this post via RSS. RSS is ace, and so are you. ❤️ You can reply to this post by email , or leave a comment . Have dinner. Put the kids to bed and settle down with my wife on the couch. Crave snacks out of habit. Get snacks and eat them!

0 views
Stratechery Yesterday

Apple Settles With E.U., U.S. App Store Fees, ATT Rules in Germany

Apple's App Store is finally facing the reality of lower fees, and the EU should be satisfied with its work; it's ok it's late.

0 views

28 down, 16 more to go

You might be wondering why I’m already back hiking since I walked more than 40 km just a few days ago. And the answer to that is that I’m not hiking. This was a short stroll to briefly visit a church that would normally be part of the tenth and final segment of this ten-part loop. As I mentioned in my previous post, the second half of this loop is so poorly laid out that some of the churches require some crazy changes to the main path in order to be visited, and the final segment of the loop in particular makes absolutely no sense. And I tried to figure out a reasonable way to include all churches in my walk, but there was no sensible way to include this one. It’s also so far from the valleys that I don’t even know why it’s included at all. But there are 44, and I’ll be damned if I don’t visit them all, so off we go, this time with the dog, through the nice path that takes us inside the lovely park that runs near our destination. As I said, this is not gonna be a challenging hike at all. I’m not even wearing shoes, I’m just casually walking the dog in the park with my flip-flops on. I walked this park many times before, but this time we’ll stay on the outskirts since the church is just outside of it. The scenery is quite a bit different from my other walks, there are a lot of vineyards all around the area. Also, not many animals, aside from the dog that’s already hating the warm weather even though it’s still relatively early in the morning. And just like that we have reached the church of san Martino vescovo (28/44) which, to add insult to injury, is inside a private property. I’m not gonna bother adding extra links to this walk, as I said this was just a quick walk to cross the church off my list. But if you’re curious, the whole walk took just a bit more than an hour and was 3.6 km long. Legs are recovering fine from my previous long walk, so you’ll hear from me soon enough with pictures from more interesting places. You love the outdoors and RSS. You're one of the special ones.

0 views
Hugo Yesterday

Social networks: what if we had the solution to escape US Big tech?

When you look at topics around privacy or sovereignty, one problem regularly stands out: social networks. And this subject of networks is particularly sensitive. Because while they are often seen as simple leisure tools where you post cat pictures, they are actually real information highways. Media, politics, sports, culture, social and family ties, romantic relationships, everything goes through networks. But as you should know, information is power. What happens when a handful of people control these networks? When they can collect and analyze a considerable amount of information about us, decide what we see or don't see, based on their own interests? In short, we would be wrong not to take them seriously, and it's an issue, particularly in Europe at a time when we regularly talk about sovereignty. But it's difficult to create social networks. It's expensive in the first place. Few investors in Europe are willing to finance the next LinkedIn, the next Twitter, or the next Youtube. And most importantly, to hope for success, you need to convince you, but also convince your friends, your family, your colleagues because otherwise, it has no interest. This is what we call the network effect: the value of the product is proportional to the number of users using it , which makes the arrival of new players almost impossible. And yet, there is today another way . What if, instead of trying to build the next Twitter, we completely changed the way social networks work? What if we returned, in a sense, to the origins of the Web: a more open and decentralized Web, where you could choose your provider without losing access to the rest of the network? In short, let me introduce you to a protocol that could help us redefine our social networks and create opportunities, particularly in Europe: ATProto. You may know Bluesky ? Bluesky is a new Twitter with around 43 million users. If its success remains modest compared to its predecessor, its growth has been rather dynamic over 4 years and varies depending on regular waves of departures from X. Thanks Elon… But you might say, Bluesky is just another US company, so another monopoly in the making. Yes, certainly, but you need to look under the hood. Bluesky is based on a protocol: AT Protocol. This protocol defines the data present on the network, how we store it, how we view it, how we can moderate it (label it), in short, how the network works. More precisely, it means that Bluesky is not required to own your data to display it. On Twitter, Substack or Medium, the data is owned by these companies and can be filtered, modified, or monetized without your consent. Here it's different. Your data is hosted on a PDS (Personal Data Server), and this PDS doesn't necessarily belong to Bluesky. For example, my data is hosted by Eurosky , a European PDS. And I'd like us to pause for a moment on the Eurosky homepage: Eurosky is also behind mu.social , an alternative Bluesky client, and mu is the first prefiguring thousands of other social apps. Because yes, the ATProto protocol is so open that each piece of the puzzle can be replaced or extended. And that's where we can start having fun. Everyone can build on top of it . We can define our data, so we can build alternatives to Instagram ( flashes , grain ), to Pinterest ( current.is ), to Substack and Medium ( Leaflet , Writizzy ), to Tiktok ( Spark , Skylight ), to InoReader ( Gleen ), or even to Github ( Tangled ), all based on the same architecture, but especially, already benefiting from a user base of 45 million people. The network effect is already there . Bluesky is not ATProto, it's one piece of a much larger ecosystem: the atmosphere . By default, the data present on ATProto is made to display short messages. It's the famous Bluesky message you already know: a message, an author, a number of likes etc… But, at first, you can't post long messages and besides it's not really designed for reading blog articles, videos, or source code. But we can extend all of this via lexicons . A lexicon is a common language, a data schema, it's roughly the set of vocabulary on a network record, and that certain applications will use. For example, the lexicon of a Bluesky post is defined by and we'll find fields like , , , (when there's an image) etc… But anyone can define a new lexicon. Obviously it won't be read by all applications. Bluesky won't read your lexicon but your application can. And precisely not long ago I came across a lexicon that particularly interested me for blogging platforms: standard.site . The initiative comes from three platforms that partnered together: Leaflet, pckt.blog and Offprint and they proposed this new format for long-form publications. This format pleased so many that it is now available via a plugin in the WordPress ecosystem, for static blog generators via Sequoia , and now it's also becoming central in Writizzy , the product I'm building and which runs this blog (and probably soon also Bloggrify which I also maintain). This integration therefore allows you to have native understanding of your Writizzy publication in Bluesky/muSocial. Note the "view publication" link which doesn't normally appear for a simple base link. But most importantly, this allows all posts published on Writizzy to be visible in all readers that scan the atmosphere for blog articles: standard-reader , Heron , potatonet, docs.surf , leaflet etc… In short, in one step, Writizzy becomes a member of the atmosphere and can expose a new article to millions of users. And this example shows us that we can now create new apps, with their own vocabulary, on existing PDSs and benefiting from an already established network. Beyond this specific example, ATProto offers many opportunities to return to a more decentralized web under your control. You could, for example, have your own PDS (personal data server) that participates in the AT Proto network. And you can go even further. The entire protocol provides that each feature is composable and that includes moderation or feeds. It's not Bluesky that imposes them on you. Again, Bluesky provides a service, but it's not ATProto. If you want to use another labeler (a tool that allows moderation), or if you want to create your own feed with your topics, you can. I could create in the future a feed of all Writizzy tech blogs for example. In short, you can regain control over your data, the algorithms that push content to you, and the associated moderation. But more than that, it's huge opportunities to rebuild all the social networks we're missing in Europe: LinkedIn, Youtube, Tiktok, Instagram to name a few. Hoping that indeed, mu.social is only the first among thousands. This open and composable web won't happen by itself, and it won't come from Silicon Valley. Today, the infrastructure is ready, the user network exists, and the foundational building blocks are in place. It's up to us, European developers, creators, and entrepreneurs, to seize ATProto to build tomorrow's platforms, on our own terms. PS: oh yes, and if you comment below the post on Bluesky/mu.social, the thread should come back as a comment on the blog

0 views

What Is Reasoning

A few weeks ago a paper was shared that showed how to extract reasoning traces from closed-weight models. Together with online discussions about tricking models into leaking them, it made me investigate it more out of curiosity. Twitter seems full of half-truths and confusion about how this works, so perhaps this helps some to understand what is happening. Reasoning traces are usually hidden from us. We have lamented this , but mostly have to accept it. Open-weight models thankfully reveal them, and from their behavior you can see that their traces can be long and confusing. This is probably a good reason to separate them from what is normally shown to users. At minimum, UIs need to detect them. The industry has done a good job at making reasoning traces sound special and exotic, but they really are just text: the model is trained to emit its thinking into a scratchpad as part of its response, before its final answer. GPT-OSS’s Harmony response format makes this easy to see: The markers are special tokens, but the reasoning between them uses “the same text” as the final answer (just that GPT chain-of-thought text sounds really funny). When the model samples the channel token, a parser routes the following text into a separate stream exposed through the Responses API. For closed models, presumably a simple model redacts and summarizes it. How much budget goes to reasoning? Earlier APIs exposed reasoning token budgets, making it seem like a property of the sampling process. In reality, reasoning effort is baked into the system prompt. GPT-OSS puts this into the system prompt: That’s it. Training produces the resulting behavior, such as emitting the token sequence that switches to the channel. This also explains why changing the effort invalidates the KV cache. I think closed GPT models call reasoning effort “juice,” since you can ask most models how much juice they have. In DwarfStar for DeepSeek with max reasoning this is added to the system prompt: The destination of reasoning tokens is therefore a learned convention: the model is trained to keep scratch work out of the channel. Trick it into thinking it is in that channel and it may leak tokens. We have even seen older models, when thinking is disabled, reason into the bash tool and echo their thoughts to . So in some sense the only “special” behavior for some models is not to think. That at times is done by “mechanically” removing the model’s usual ways to think. In DwarfStar , disabled thinking uses the prefill , while enabled thinking uses , which are the tokens that close and start thinking. GPT-OSS doesn’t prefill but lets the model decide either way on its own. But presumably, some inference APIs prefill the opening token when reasoning is enabled, so the model never samples it itself and might prevent the sampling of the reasoning token when disabled since it can be trivially detected. This may explain why a custom tool can trick models into putting some reasoning where it should not go — but only when native reasoning is disabled. Hilariously enough I was unable to use GPT 5.6 terra for spell and grammar checking on this blog post because of safety filters. Had to switch to Kimi.

0 views
Lalit Maganti Yesterday

Opus 5 doesn't use em-dashes in code comments

I’ve been using Opus 5 as my main coding for the last few days 1 , and I noticed something odd: the code comments stopped using em-dashes; everything is double hyphens ( ) now. Instead of going off a gut feeling, I decided to actually run some checks. agentsview indexes all my conversations into a SQLite database, so this kind of question is just a query away. Here’s the chart: Seems pretty clear to me! But you might say “maybe it’s not the model, maybe it’s something else”. Well actually the cleanest evidence came from a session where I switched from Fable to Opus 5 mid-conversation and didn’t touch anything else. Looking at just that session, Fable produced 11 em-dashes in comments. Opus 5 produced 36 double hyphens. I didn’t touch anything else. What I find genuinely strange is that this only affects code comments. My chat replies still have just as many em-dashes as ever. So maybe something was tweaked when training for code-generation in particular? I don’t like Opus 5 but I ran out of tokens for Sol, Deepseek raised their prices and Fable is just too slow (and I don’t particuarly like it either!)…  ↩︎ I don’t like Opus 5 but I ran out of tokens for Sol, Deepseek raised their prices and Fable is just too slow (and I don’t particuarly like it either!)…  ↩︎

0 views

Codeberg Pages 2: Setting Up Subdomain for git-pages Back-end

Read on the website: Codeberg Pages moved to a new back-end (git-pages.) This caused me some pain. But I’m now on the other side of it, and I want to share some gotchas.

0 views
Kev Quirk Yesterday

The Smell of AI

by Kevin Wammer Kevin talks about his opinions for various use cases for AI and LLMs. Read post ➡ I started reading this post and thought to myself "oh here we go, another piece about how awful AI is..." but as I got further into it, I found myself nodding along. While I don't feel as strongly as him about AI generated images I do agree with the premise of everything he said. It's refreshing to see some pragmatic opinions on AI and its uses as a tool. Ended up being a good read. Thanks for reading this post via RSS. RSS is ace, and so are you. ❤️ You can reply to this post by email , or leave a comment .

0 views
Unsung Yesterday

The Swiss Cheese model, pt. 2

1. Oh damn, you caught me in the middle of something. I was just trying to make a list of Windows versions for a friend – in Google Docs, of all things. Should be easy. I already grabbed this one off of Wikipedia and massaged it a bit, but it’s still kinda ugly: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/1.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/1.1600w.avif" type="image/avif"> I don’t love the tight padding here. Let me try something bigger, like 0.08 inches? I’ll just select the first column and punch the number in, and… What the hell!!! Jesus. What happened? Okay, let’s press ⌘Z to get out of it… Oh, no. Maybe I can press Esc… 2. Okay, here’s what happened in precise detail: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/5.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/5.1600w.avif" type="image/avif"> I started to type “.08″. Pressing ”.” was okay, although it showed a pretty thirsty tooltip: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/6.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/6.1600w.avif" type="image/avif"> upon adding “0″ Docs removed the ”.” and so the output was just “0”: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/7.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/7.1600w.avif" type="image/avif"> upon adding “8” Docs removed the leading zero and we ended up at just “8″: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/8.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/8.1600w.avif" type="image/avif"> the page saw the resulting “8″, applied 8 inches of padding (a hundred times of what I wanted!), and just showed it to me in real time, resulting in a profoundly unrecognizable table that looked like something went horribly wrong, pressing ⌘Z didn’t do anything. pressing Esc only removed the focus from the input field. I believe I can explain exactly the chain of reasoning and bugs here: So, in effect, my ”.08″ got mangled to “8”, applied immediately, and wasn’t easily undoable. 3. This feels like a great example of the Swiss cheese model in action: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/9.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/the-swiss-cheese-model-pt-2/9.1600w.avif" type="image/avif"> If just one of these bullet points below behaved differently, I would not end up in this situation: All of these decisions made sense and didn’t feel dangerous or important in isolation. Together, the holes in cheese aligned perfectly, creating a pretty scary experience. (Thank you to Ezra Spier for sharing this with me.) #bugs #flow #google #preview I pressed Backspace to delete an existing zero: I started to type “.08″. Pressing ”.” was okay, although it showed a pretty thirsty tooltip: upon adding “0″ Docs removed the ”.” and so the output was just “0”: upon adding “8” Docs removed the leading zero and we ended up at just “8″: the page saw the resulting “8″, applied 8 inches of padding (a hundred times of what I wanted!), and just showed it to me in real time, resulting in a profoundly unrecognizable table that looked like something went horribly wrong, pressing ⌘Z didn’t do anything. pressing Esc only removed the focus from the input field. To start with, any number entered is immediately previewed on the left. This generally feels good! Instead of fixing my input on commit (Enter), the input is being rewritten on the fly, as I’m typing. This wouldn’t be my recommendation, but I can this design decision. If I typed just “08,” it would be rewritten to “8″. This makes some sense since it normalizes the numbers, and makes them consistent. If I typed ”.1″, it would be rewritten to “0.1″. Sure, fine, a similar idea. However, typing ”.0″ rewrites it to just “0”. I believe this is a bug or a lack of imagination – it should be rewritten to “0.0″. ⌘Z doesn’t work. I believe this is a bug where system’s rewrites of numbers don’t put the change on the undo stack. (As a matter of fact, it appears worse than that – pressing ⌘Z a few more times ended up rewriting my number to “80″, which would have made this even worse!) with numbers not being rewritten on the fly, there would be no problem, with ”.” not be aggressively rewritten to “0.”, there would be no problem, without live preview, the rewrite could’ve been caught and fixed it by hand, instead of panicking seeing a huge change on the screen that felt like data loss, with a fully functioning input field undo, the moment of panic could be reverted, with Esc to abort instead of commit, likewise.

0 views

What Happens If OpenAI Dies?

If you liked this piece, you should subscribe to my premium newsletter. It's $70 a year , $18 a quarter , or $7 a month , and in return you get a weekly newsletter that’s usually anywhere from 10,000 to 18,000 words, including vast, detailed analyses of NVIDIA , Anthropic and OpenAI’s finances , and the AI bubble writ large .  My Hater's Guides To the SaaSpocalypse , Private Credit and Private Equity are essential to understanding our current financial system, and my guide to how OpenAI Kills Oracle pairs nicely with my Hater's Guide To Oracle, as well as the Hater’s Guide To Oracle (Part 2). I've even done a two part Hater's Guide to NVIDIA. Subscribing to premium is both great value and makes it possible to write these large, deeply-researched free pieces every week. To subscribe, use one of the following links: $70 a year , $18 a quarter , or $7 a month . If you want to get in touch — and especially if you have any juicy information about Anthropic, OpenAI, or any other companies in the AI bubble — hit me up on Signal at ezitron.76. I’m also on IB on The Terminal.  I’m not trying to be a buzzkill here, but I have meaningful concerns about OpenAI’s ability to survive, and they’ve only grown more pressing in the last few years. In the same week that it completed a $7 billion internal share buyback , OpenAI saw both COO (and former CFO) Brad Lightcap and Chief Revenue Officer (CRO) Denise Dresser leave the company, the latter of which had only been there eight months, and had this to say a mere four months ago:  Dresser likely walked away from a large amount of stock options by leaving after less than a year on the job, which I’m guessing means she decided that staying at OpenAI would, for whatever reason, not be worth getting what I imagine are tens of millions of dollars of stock she would be able to liquidate when it went public. You know, that thing that’s definitely happening.  Unless it’s not quite so definite anymore. Back in late June, The New York Times reported OpenAI was “leaning toward” going public some time in 2027, but that was before Anthropic started one of the most-aggressive pre-IPO marketing campaigns I’ve ever seen, with investors “leaking” to the Financial Times that they thought it would have a $2 trillion valuation and have (sigh) annualized revenues of $100 billion to $120 billion by end of 2026, an entirely fictional statement made with the intent of pumping their bags, with the FT, for whatever reason, printing it with little pushback. Yet what’s likely far-scarier for OpenAI is that even Anthropic’s pre-IPO marketing has a whiff of desperation. A Reuters report from late last week that feels precision-engineered to manipulate dimwitted investors said that “Wall Street [was] looking further into the future than it ​commonly does to put a price on the AI company, valuing it based on how much revenue it could generate two years from now,” adding that it was “projecting revenue of roughly $190 billion to $200 billion.”  This was arguably the worst part: While I imagine the writer in question believed that this was being “fair” and “objective,” this paragraph exists only to manufacture consent for a company that clearly has questionable economics. “Current EBITDA does not ​fully capture the economics investors expect the company ​to achieve at scale” is a euphemism for “ignore your lying eyes,” a plea with the audience to not judge a company based on its actual business but on a theoretical business that, to quote Reuters, have “...training and inference [costs] become more efficient as technology improves, while personnel and other operating costs ​could become a smaller share of revenue as the company scales.” Could, could, could, could, could, could could COULD! It’s always a bloody could or will or might with these fucking companies, and it’s astonishingly bad journalism to see it as an “objective” choice to vaguely say that a company should not be evaluated based on its actual business but on some theoretical business that they might build in the future where the economics are completely different.   The reason I bring up the noises coming from the manufacturing consent machine is that if Anthropic beats OpenAI to an IPO, I cannot see a viable (or reasonable) path for Sam Altman to float his nasty little company. The fact that the Financial Times and Reuters are already being co-opted into softening the blow is a sign that Anthropic’s S-1 will look and smell like the inside of a tauntaun , and Anthropic is, from the reporting I’ve read, in a much better condition than OpenAI, if only because it didn’t have multiple side quests involving video generation or browsers or smart speakers , though both companies love to give away $20 to $40 for $1 .  Put simply, if Anthropic goes public with its own horrifying economics on parade, it’s hard to imagine OpenAI — a company that lost $20.9 billion in 2025 on $13.07 billion in revenue — will fare much better.  After all, Anthropic just hit, per Bloomberg, $65 billion in annualized run rate — a month multiplied by 12, or four weeks multiplied by 13, I’m guessing, because it never defines this number — in May 2026, and OpenAI is “on track” to hit $40 billion annualized revenue …in the middle of August.  We are, of course, in the era of madness, so I’ve already read three or four people on Twitter say that OpenAI’s actual annualized revenue is so much higher , because they’ve heard stuff from people they trust . The AI industry’s loudest advocates think and act like cultists at the end of a doomsday prophecy, except instead of the world ending , OpenAI and Anthropic become the largest companies — or in the case of giga-oaf hedgie Gavin Baker, the only companies — in the world, rewarding all those who believed with… something. Glory? Smugness? Salvation?  In any case, OpenAI has a real problem if Anthropic beats it to the markets.  On October 31, 2025, a flustered Sam Altman told booster and investor Brad Gertsner that OpenAI would make “well more than $13 billion” in revenue that year before saying he’d “find a buyer for his shares.” In the end, per my own reporting , “well more” would mean “$70 million,” with OpenAI making $13.07 billion in revenue in 2025, with SoftBank accounting for $862 million. A week later on November 6, CNBC would report that OpenAI was “on track” to generate “more than” $20 billion in annualized revenue. OpenAI works out its annualized revenue by multiplying its most-recent four-week-long period by 12, which means that in a four-week-long period it had $1.66 billion in revenue, I guess?  On March 4, 2026, The Information would report that OpenAI had “topped” $25 billion in annualized revenue after hitting $21.4 billion at the end of 2025, and included the following hilarious line: Yeah man, this is why using annualized revenue is such a stupid idea. If you have a particularly-busy four-week-long period — like a product launch with a big social media push — you can use that period to inflate your revenues, which is exactly what OpenAI is doing, as evidenced by the sources (who I assume work at OpenAI) saying that’s exactly what they’re doing. Annualized revenues are not a useful way of measuring these companies’ financial condition, and exist only as a form of marketing, made worse by the fact that AI token spend is not a recurring source of revenue. While you could theoretically use annualized revenue as a directional bit of data if it was just two companies selling ( subsidized ) subscriptions, the ability for these companies to cherry-pick periods of time that might be inflated by aberrations ( like when someone spent $500 million on Claude tokens by accident ) makes these numbers somewhere between useless and actively harmful to investors. Even then , it took OpenAI seven months to be “on track” to reach an annualized revenue run rate ($40 billion) that was seven billion dollars smaller than Anthropic’s ($47 billion) from May , and a full $25 billion in run rate less than what it hit at the end of July.  Perhaps it’s a coincidence, but it’s also worth noting that the news about OpenAI’s exciting new annualized revenue “leaked” mere hours after the abrupt resignation of its Chief Revenue Officer .  The reason that OpenAI (and Anthropic, for that matter) wants you to think about things in terms of “annualized revenue” is because its actual revenues look a little tame compared to its commitments and burn rate. The Information reports that in Q1 2026, OpenAI burned $12.1 billion on “cost of revenue” and training on $5.7 billion in revenue, though it left out the sales and marketing segment where OpenAI burned $5.73 billion in 2025 — or, put another way, OpenAI spent $12.1 billion on compute to lose $6.4 billion, and that doesn’t include things like data costs or salaries or, well, anything. OpenAI (and by proxy The Information) somehow rationalizes this to only be a burn of $3.7 billion, likely using the same accounting bullshit that it did in the financials I saw . Now, some of you might read that and say “wow, $5.7 billion is a lot of money!” but it doesn’t matter, because the more money OpenAI makes, the more its services cost. This is not difficult mathematics, but it is something that continues to escape the vast majority of coverage of the company, I assume because all of this feels a little insane when you think about it. I know you’re gonna call me a firebrand or a hater or a skeptic or try to capture me and put me in a zoo, but I must be clear that OpenAI has set expectations — and made commitments — that range from ridiculous to outright impossible. To get really specific: For any of these things to happen, OpenAI will have to grow at a staggering pace, and effectively (per The Information’s reported projections) 10x its revenue between now and the end of 2030. OpenAI’s projections have it near-tripling its 2025 revenues, doubling its 2026 revenues, nearly doubling its 2027 revenues, growing its 2028 revenues by 68%, and then growing its 2029 revenues by 64%. At the end of this magical mystery tour through revenue hallucinations, OpenAI will have it making more than NVIDIA did in Fiscal Year 2026 ( $215.9 billion ) and, somehow, becoming profitable: I realize that many people have been conditioned by the tech industry to believe that every idea that a tech CEO has will always become reality, but the sheer scale of what OpenAI is both promising and obligated to do outpaces anything in modern history. While much of what I’m saying is also true of Anthropic, ( a company that itself has over $300 billion in commitments due in the next three years and is similarly-unprofitable) OpenAI has decidedly failed to play catchup at a time when enterprise customers see costs as a “ huge issue ,” which also makes it unlikely that ( along with recent model price cuts ) it will magically re-accelerate outside of allowing users to burn $14,000 a month in tokens for $200 , which…also didn’t work well enough to get close. In any case, any acceleration of revenues would also be an acceleration of costs, which will mean OpenAI will need several more $122 billion rounds from a dwindling pile of investor capital. SoftBank can quite literally not afford to invest anything further, with liquidity becoming so tight that it’s had to take out a $10 billion loan collateralized by its entire OpenAI holdings , with NVIDIA CEO Jensen Huang saying that its $30 billion investment from this year likely being its last . While various different venture capitalist paypigs may have some interest in funding it further, OpenAI will need more than it last asked for, without fail, every single year. So, there’re really only two eventualities: This, again, is not me being a firebrand, but taking a relatively-clinical look at the hard numbers and asking how the fuck it affords it all. And man, does a lot of shit have to go right. Per my last premium newsletter, OpenAI needs at least $800 billion to meet its commitments in the next three-and-a-half years , based on both the Wall Street Journal’s report on its projected $750 billion in compute spend through 2030 and an analysis of analyst notes on Broadcom, Microsoft, Google, Amazon, and CoreWeave. The problem, however, is that much of this money will come due through the end of 2027, and require at least one more massive round of funding.  To get specific: Now, all of this is contingent on Google, Microsoft, Amazon and Oracle building enough capacity to capture that revenue, but if we assume that happens, OpenAI needs more than $147 billion just to handle its expected compute commitments through the end of 2027.  Here’re some other costs that aren’t included: With its IPO likely delayed — if it ever happens — until 2027, OpenAI will almost-certainly have to raise another round of funding by March 2027, likely at a similar scale to its $122 billion round from March of this year . The biggest problem that OpenAI has is that $110 billion of its last $122 billion round was made up of Amazon ($50 billion), NVIDIA ($30 billion), and SoftBank ($30 billion), leaving a mere $12 billion funded by a primordial soup of different venture capitalists, private credit funds, and public endowments that should have their executives fired, ideally into the sun. In any case, $12 billion isn’t enough to cover a single quarter’s compute costs. The point I’m making is that raising further rounds — before we get to any niggling problems about valuation — has already become near-impossible to do without the help of massive entities that are showing increasing signs of strain at exactly the moment OpenAI needs more money. Let’s break it down. As mentioned previously, SoftBank is running at the very edges of its liquidity, and owes another $10 billion due on October 1, 2026 . While in theory it could sell more of its ARM stock to fund further rounds, said stock makes up effectively all of its Net Asset Value , and while further margin loans are possible , doing so would put genuine pressure on ARM’s stock price as, well, at some point you’re not just investing in a company but whether SoftBank might use its stock like a piggy bank.  A few weeks ago, Amazon sent the remaining $35 billion of its $50 billion investment as part of the larger round , and while it’s theoretically possible that it could invest more, its free cash flow has now gone negative , and it needs as much money as possible to meet its (agh!) projected $220 billion in 2026 capital expenditures . Google is a potential investor, as I’m not sure people realize how big a Google Cloud customer OpenAI has become, with Stephen Ju of UBS estimating it will spend $9.375 billion in 2026 and $12.5 billion in 2027, and Google Cloud increasingly becoming Google’s largest growth vehicle . Then again, Google’s free cash flow also went negative in its latest quarterly earnings , and even the most braindead of investors are becoming a little nervous about how circular everything is looking. NVIDIA could, in theory, afford to invest more, but the markets are even more nervous about its slow transformation into GE Capital . Jensen Huang is clearly aware of this, which is why his “backstop” of a “10GW” data center in Ohio (which OpenAI has signed a 20-year-long lease to rent) isn’t actually backstopping OpenAI’s compute spend, but the underlying assets in the event of a short sale: That’s a pretty big “if,” because it refers to 5GW of theoretical capacity built by a company that has never built a data center, at a time when the nearest equivalent — Stargate Abilene, at 1.2GW — is two years in and has only finished three out of eight of the buildings. Based on this description of the deal, NVIDIA only has to guarantee things in the event the data center is actually built. As part of the deal, NVIDIA is investing $1.5 billion in SB Energy, a company invested in by both OpenAI and SoftBank that is trying to go public some time this year , likely as a means of adding further liquidity to SoftBank’s balance sheet, though the IPO would only raise, per Reuters , between $5 billion and $7 billion. OpenAI has already, across multiple funding rounds, raised from private credit funds from Blackstone, BlackRock, and Insight Partners, and it’s possible that these same funds could fuse together like Voltron as a means of keeping OpenAI alive. That being said, we’re talking about over $100 billion a year for the foreseeable future, which is a little more than they could stomach on a private company with ultra-negative margins and a younger competitor currently eating its lunch.  Then there’s another problem: that private credit is already having trouble funding AI data centers , which are a (theoretically) far-more-stable investment in infrastructure and power. When NVIDIA announced its “$500 billion” fund, the media was quick to assume that it had already closed the money, rather than it actually being a “ memorandum of understanding ,” also known as “a non-binding agreement to maybe do something in the future.” Yet a follow-up from Bloomberg found that it was even less than nothing , and that Jensen Huang had insisted on making the announcement despite months of slow progress: The reason I bring this up is that if private credit funds are having trouble funding data centers, they’re going to have a shit-ton of trouble convincing investors to pile into an unprofitable second-place AI lab run by a uniquely-unlikeable CEO who has a penchant for lying . As mentioned earlier, OpenAI (and Anthropic) have scraped the bottom of the barrel of venture capital time and time again, and never managed to raise more than $30 billion at a time.  The sheer volume of names on these deals suggests that it’s genuinely very difficult to mobilize this much capital, and I think it’ll become difficult-to-impossible to do this every single year, even if Anthropic were to go public, as it’s very unlikely that the majority of these investors will actually be able to liquidate their holdings. And remember, we’re talking about OpenAI here — stinky, expensive, second-place OpenAI, the one with all the obligations, the one with the CEO that wants to surveil everything his customers do . The one that has raised no more than $12 billion of funding from sources outside of NVIDIA, SoftBank, Microsoft or Amazon. That one.  There’re really two major problems: OpenAI’s $122 billion funding round valued it at $852 billion. And, per the New York Times , advisers pushed back on the idea of trying to go public at a $1 trillion valuation: For some perspective, a $1 trillion valuation would be around a 15% premium, for a company that now accounts for 70% of Microsoft’s AI revenues and allegedly is the single-most-important startup since Google or Facebook.  Sorry, I’ll stop vagueposting: this is bad. For a company of this scale and importance, OpenAI should’ve waltzed into a $2 trillion valuation, except a public offering requires you to provide audited financial statements and an explanation of why your company is worth that much that goes a little further than an investor deck with annualized run rates and charts that promise the world. The problem here is that if OpenAI can’t go public at even a trillion dollar valuation , it’s unclear why anyone would invest at $865 billion, or $800 billion, or even $700 billion, unless they happened to believe that it would go public at less than a trillion then magically become worth trillions more, somehow. The ability for any investor at this point to make a significant return is very, very small, made smaller by the fact that Anthropic appears to actually be meeting with investors for an IPO and is showing revenue growth… …except even then, AI bulls are nervous, because $65 billion in annualized revenue (at the end of July) was lower than some forecasts , with market intelligence firm Yipit claiming it had hit $74.3 billion on July 22 , causing confusing feelings in the minds and bowels of boosters that had expectations set by, I imagine, a combination of black magic and black mold. While Anthropic CFO Krishna Rao has not been discussing valuations at early IPO meetings , investors and analysts are either expecting or wishcasting that it hits a $2 trillion valuation , though if OpenAI can’t get a trillion, it’s hard to see how Anthropic — a business of larger-yet-comparable size and equally-rotten economics — would somehow double that and, I assume, then some.  Seeing all of this, why would any venture capitalist with a working brain still invest in OpenAI at anything close to an $865 billion valuation? While current investors might follow on as a means of keeping the company afloat, at some point their limited partners might ask reasonable questions like “how do you intend to make us money?” This is a problem already hitting Thrive, which has invested billions in OpenAI. Per Bloomberg : That’s right folks, if you invested in Thrive’s 2022 growth-stage fund, you’ve made 30 cents on the dollar, with much of it tied up in OpenAI.  While I’m not denying it’s possible , limited partners have their limits — especially as funds from Sequoia and other venture capital firms underperform the S&P 500. And, not to repeat myself too much, OpenAI needs so much more money! It needs at least $100 billion a year, or it’s toast! The collapse of OpenAI would likely be a result of the walls closing in around its ruinous obligations and economics, with counterparties left short-changed and deals broken as things begin to unravel. It starts, as obvious as it sounds, with OpenAI running short on funds, and we’ve already seen one sign that had happened with Amazon “completing” its $50 billion investment in the company a few weeks ago by sending another $35 billion. To be explicit, that $35 billion was rumored to be contingent on OpenAI either going public or reaching AGI , though all that was said in the funding announcement was that it was contingent on “certain conditions being met.” Nevertheless, Amazon didn’t decide to send $35 billion out of the goodness of its heart, or because it thought OpenAI was such a wonderful company — if I had to guess, it’s because OpenAI needed that money to pay for its compute costs, an estimated $9 billion of which flow through Amazon Web Services.  The fact that OpenAI needed $35 billion mere months after receiving at least $40 billion ( and barely a month after getting another $10 billion from SoftBank ) suggests that either  compute pre-payment costs are brutal or OpenAI is absolutely annihilating cash at a rate unforeseen in the history of capitalism.  Whatever the reason, OpenAI clearly needs tens of billions of dollars every few months to keep up with its costs, and will only need more money as it “grows” — by which I mean has to pre-pay for compute costs for Amazon, Google, Microsoft, CoreWeave, Oracle, and Cerebras. While it’s foolhardy to say when OpenAI might collapse (don’t I know it!) its collapse will come from the most obvious place — when it’s required to pony up a bunch of money without a means of raising more funding.  When you take a step back, OpenAI has had to raise funding near-perpetually since its $6.6 billion round closed in October 2024 on top of a $4.4 billion credit facility . On December 27 2024, OpenAI would say in a blog post that it needed “more capital than it imagined,” and would begin talks a mere month later in January 2025 to raise another round of $40 billion that would “close” on March 31 2025 , though it would only raise $10 billion at first from SoftBank (with $2.5 billion of that from a syndicated group of investors). Five months later in August 2025, OpenAI would raise another $8.3 billion “as part of” the round from a group of venture capitalists and asset managers , sell another $6.6 billion of internally-held shares to investors in October 2025 , and by the middle of December 2025 was already rumoured to be raising another $100 billion , just before getting another $22.5 billion from SoftBank on December 31 2025 . While we know OpenAI ended 2025 with about $25 billion in cash , The Information was able to update us that it had around $73 billion in cash and “marketable securities” at the end of Q1 2026 , which likely includes at least $35 billion from Amazon, NVIDIA and SoftBank, though for whatever reason the reporter refused to break out the cash part. Nevertheless, this means that OpenAI’s actual cash position looked better only by virtue of an influx of capital , and whatever happened to the company in Q2 2026 meant it needed another $45 billion (Amazon plus SoftBank, and maybe another $10 billion from NVIDIA, as it’s unclear how that whole thing was amortized). What I’m getting at is that at some point in the next three months, OpenAI is going to need more money, likely tens of billions of dollars, especially as it enters new fiscal years for Google, Amazon, and CoreWeave, all three of which will likely require up-front payments for capacity that OpenAI does not have.  And, as I’ve repeatedly said, OpenAI needs to keep raising money because its costs increase with its revenues, and it has no clear path to either reducing them or increasing prices, as it found when it (and Anthropic) moved enterprise customers onto accounts that required them to pay the actual cost of their AI services . None of this has much to do with my feelings about AI, and far more to do with basic mathematics. OpenAI has no economies of scale, it’s horribly-unprofitable, and does not have a stable business. This naturally means that it has to continually raise capital, except raising further capital is going to be difficult, based on the sheer amounts it needs, the dwindling funds available for it to raise, its already-inflated valuation, and the fact that it’s way behind a competitor facing exactly the same problems. OpenAI has promised the impossible, and built a company that only makes sense if you’re willing to ignore the worst economics in the history of capitalism. Its future is dependent on raising over a hundred billion dollars a year in one of the worst funding climates in history. Its revenues are slowing, its competitor (and there’s really only one) has outpaced it (all while slowing itself), and its CEO is one of the single-worst spokespeople in history.  However you may feel, it’s impossible to argue with the logic that OpenAI is going to need more money by the end of the year — likely tens of billions of dollars — and that money will have to come from somewhere. It could be from Google, or Amazon, or even Meta. It could be from SpaceX, though Musk would have to hold his nose a little. It could be from Microsoft. It could be from a last gasp telethon of venture capitalists coming together to prop it up one last time. But it’s gotta come from somewhere. And at some point, OpenAI will simply not be able to pay its bills, or more precisely, it will have to hand over money to somebody who will not accept equity or IOUs in return. Whoever it is that refuses that deal will be the one that pulls the trigger, and sends OpenAI’s body to the glue factory. So, as much as I have talked about OpenAI’s death , its apocalypse could arrive in many different forms, but likely starts (as I just said) with it someone asking OpenAI for some real, non-circular dollars, only for Sam Altman to look at them like this: But the first place to look for the end is OpenAI’s revenue growth. To compete with Anthropic, it will have to hit $60 billion in annualized revenue (I’m so fucking tired of annualized revenues ) within the next three months. The first domino to fall will be them either missing this target or seeing revenues regress — if they haven’t already done so, of course, given that OpenAI measures run rate based entirely on a hand-selected four-week-long period.  All that it takes is a little stank of regression for the market to get nervous.  It’s inevitable, at this point, that both Anthropic and OpenAI’s revenue growth slows, if only because both of them have only got this far through a combination of subsidized subscriptions and companies burning millions on token-maxxing initiatives that will have petered out by the end of the year. OpenAI has spent a little over a year trying to play catch-up on the enterprise — a strategy led by now-departed COO Brad Lightcap — only to find that customers are becoming cost-conscious at exactly the time they need to be spending more. To make matters worse, Ramp found that customers have been slow to adopt Anthropic’s more-expensive “Fable” model because of the price, meaning there’s effectively no way to jack up prices. I imagine Anthropic’s interest in bumrushing for a September IPO is an attempt to avoid investors seeing post-tokenmaxxing deceleration. In doing so, it’ll put OpenAI in a brutal position of having to defend itself against both its own and Anthropic’s economics at the same time.  So, the thing to watch out for is any sign of deceleration, which could mean outright “run rates have dropped,” to lower burn on OpenRouter, to more price cuts, to any kind of attempts by OpenAI to offer discounted tokens if bought in bulk.  Then, at some point, the money will stop flowing to somebody. The problem about guessing who that might be is how much of the AI bubble is held up by OpenAI’s revenues. Microsoft, Google, and Amazon all have vested interests — literally and figuratively — in at least appearing to get paid by OpenAI, which means they’re likely work with it on deferred payments and/or equity shares in trade, likely instituting some sort of bastardization of the already-problematic “ payment-in-kind ” system used by private credit when it can’t afford it loans.  CoreWeave could be a place to look, with its largest customers being Microsoft (for OpenAI), OpenAI, NVIDIA, Google (for OpenAI), and Anthropic. While Microsoft and Google are unlikely to stop paying their bills due to OpenAI lacking the cash, OpenAI is allowed to pay its bills Net 360 , meaning that if CoreWeave’s cashflow suddenly starts sagging despite revenues growing, it’s potentially because of Sam Altman stapling IOUs to Michael Intrator’s car along with a note that says “ I’m sorry. I can’t. Don’t hate me .” Cerebras — which gets somewhere between 50% and 70% of its revenues from its OpenAI contract — would be another place to look. If revenues (or cashflows) fail to materialize, it could be another sign that OpenAI is unable to pay its bills. Other obvious signs would involve changes in guidance across any major hyperscaler, especially Oracle, Microsoft, Google or Amazon — specifically language suggesting that OpenAI’s revenue either isn’t real or isn’t arriving.  I also, to be clear, expect some sort of fundraising, likely heavily-funded by asset managers, with the potential for NVIDIA to break its pledge and invest again as a means of keeping the party going. Despite OpenAI’s lousy financial condition, its existence is critical to the entire AI industry, representing the majority of compute demand across effectively every provider, which will mean everybody will probably try and chuck a few dollars its way. This could take the form of a suicide round (valuing it at or above the $965 billion valuation from Anthropic’s Series G round ) or a brutal downround of around $800 billion, justified as ‘technically higher’ than the $730 billion pre-money valuation it got when NVIDIA, Amazon and SoftBank last invested .  I could also see it taking a doomed run at a public offering — especially if Altman somehow pushes out CFO Sarah Friar, who had previously said it wasn’t ready for IPO and got rewarded for her honesty by being made to report to “CEO of Applications” Fiji Simo, who left the company in July due to medical issues but for whatever reason remains active behind the scenes, per the FT .  Going public is a terrible, awful decision, which is why I’m increasingly-confident that Altman would consider it, especially if there’s demand for liquidity from investors. OpenAI, despite its prominent in the industry and load-bearing compute spend, is in a desperate and untenable position made worse by a competitor that worked out how to swindle enterprise customers that don’t know how to measure their token spend at a much-larger scale, and without something completely-unexpected, it’s unclear how it pulls itself out. When things get rough, expect Altman to make comments about the challenges of building the future, criticizing those who are “endlessly negative” about AI and set "unrealistic expectations” from a man who said that OpenAI is close to creating a genie that can grant any wish . He will blame everybody — critics, the financial markets, journalists, ex-employees, Elon Musk, Dario Amodei, counterparties that “don’t understand what innovation demands,” venture capitalists, Twitter posters, and basically anybody other than Sam Altman, the guy who made hundreds of billions of dollars’ worth of commitments to the largest companies in the world with little or no plan as to how he might do so. OpenAI’s actual death could take a few forms, each of them fairly destructive.  In the event this happened, Microsoft’s first move would be to cancel effectively all cloud contracts that OpenAI has, and have to restate guidance to remove the $250 billion in “ incremental Azure spend ” it promised. There isn’t a chance in Hell that Satya (if he’s allowed to stay) is going to give Google, Oracle or Amazon hundreds of billions of dollars, even if it means taking massive impairments on GPUs. In this scenario, Microsoft would potentially strip back (or entirely eliminate) the free ChatGPT product, and likely either tighten rate limits or move everybody on a ChatGPT Plus or Pro subscription to token-based billing, much as it did with GitHub Copilot in June .  While I imagine some rescue package is pulled together, OpenAI could simply be allowed to run out of money, short-changing nearly a trillion dollars’ worth of compute contracts, killing CoreWeave, Cerebras, and anyone else reliant on its income. Its customers would be given API keys that flow to Microsoft AI Foundry, Amazon Bedrock and Google Vertex, and be told that there would be little or no further development or training of OpenAI’s models. This situation, while obviously destructive for the entire industry, would give everybody a scapegoat. Who made all the promises? Sam Altman. Who ran a shitty company into the ground? Sam Altman. Who misled everyone into believing that there’d be infinite demand for compute? Sam Altman. Stories will leak that OpenAI was “not consistently candid” with its financial condition with partners, allowing everybody to reframe a trillion-plus dollars in waste as the result of one egregious con artist. To be clear, the person to blame is Satya Nadella. He’s the one that made the initial investment, bought all the GPUs, and then kept buying them the second that ChatGPT took off. He’s the one that’s misled investors about the concentration of Microsoft’s AI revenue. If there’s an opportunity for him to lump all of the blame on Altman, he’ll take it, as will Jensen Huang, Andy Jassy, and Sundar Pichai, even if he’s relatively quiet about OpenAI’s billions in contributions to Google Cloud.  At 70% of Microsoft’s AI revenues largely from its tens of billions of dollars’ worth of compute spend, OpenAI will represent a material drop in hyperscaler revenues, and somebody will have to be blamed. It won’t matter that Anthropic is just as unprofitable or made hundreds of billions of dollars’ worth of promises it also can’t keep. OpenAI will make a fitting punching bag, a well-deserved one. I know, I know. Sam and Dario won’t even hold hands at an event . They hate each other. They both are vacuous psuedo-intellectuals desperate for attention.  Yet in a moment of desperation, OpenAI could turn to Anthropic for a lifeline — a choice merger that would pump both of their bags , all while allowing Altman and his cronies to escape blame. The united entity would likely be worth over $2 trillion, if only because of its combined customer base and theoretical “reach,” even if thinking about that for even a second makes it sound so unfathomably stupid, as said “reach” would come with multiplicative financial issues stemming from OpenAI’s lousy economics meshing with the equally-crap numbers underlying Anthropic. That being said, in a desperate moment, this unity could also justify further investment from hyperscalers, venture capitalists and asset managers, giving them all something to point money at and say “this is the future of computing.” I think it’s very unlikely this happens, and if it does, it would be ruinous for everybody involved. Neither of these companies make any kind of economic sense to anyone outside of the recently-concussed and AI boosters with dichromatic vision. Combining them would only create a much larger, uglier problem — one that would carry with it the very same problems that both companies have, compounded by the expectation that it would become the literal savior of the entire tech industry. The following is an objective list of what OpenAI has to do by 2030: OpenAI is currently “approaching” $40 billion in annualized revenue, at precisely the time it needs to be accelerating. This company needs to leave 2026 at somewhere in the region of $75 billion in annualized revenue to have even a snowball’s chance of paying its ridiculous compute costs, and even then I’m not sure how it possible keeps up with the (at least) $146 billion in compute bills it’s got coming up.  It’s time for everybody to start having a real, meaningful conversation about what happens if OpenAI dies. This company has remained economically unstable since I started writing about it in November 2023, and while I might have underestimated its staying power, nothing has changed about my larger thesis that this company is headed for perdition, leaving its counterparties unpaid and alone with the consequences to follow. Said consequences, as I outlined in the OpenAI Bubble , are very, very serious, representing an existential threat to SoftBank, one of the largest companies on the Japanese stock market, and its collapse will guarantee massive changes to the guidance of some of the largest companies in the world. There is a very real scenario in which nobody left with OpenAI stock is able to reach a liquidity event , which means the tens of billions of dollars of venture capital will remain unlocked and zeroed out unless it can go public, which is increasingly-unlikely.  It is no longer rational or reasonable to avoid discussing what happens if OpenAI dies. It’s a situation that should be on the mind of every journalist, analyst and investor, even if they don’t think it’s certain, because OpenAI is both horrendously unprofitable and has made commitments so significant that they now represent at least 20% of hyperscaler cloud revenues in the coming years, if not more like 30% to 40%.  It is actively irresponsible to ignore this situation any longer, and I encourage my peers, analysts, journalists, economists and investors to start seriously considering the likelihood and ramifications of the death of OpenAI.  For me to be wrong, in the space of three years OpenAI will have to become a company with annual revenues higher than Meta ( $200 billion , versus projections of $284 billion in revenue in 2030) and meet obligations ($800 billion+) 27% larger than the combined revenues of NVIDIA ( $215.9 billion), TSMC ( $122 billion ) and Samsung ( $270 billion ).  OpenAI doesn’t have to be illegal to be dangerous. Every time consent is manufactured for the astonishing waste and unrealistic promises of Sam Altman, companies further leverage themselves in an attempt to capture its theoretical value, and investors are further manipulated into supporting an industry almost-entirely founded on its compute spend.  As I discussed in the OpenAI Bubble , its collapse will have now-unavoidable economic consequences. The death of SoftBank is a very real possibility. The likelihood of the vast majority of AI investments going to zero is much, much higher than anyone wants to think about, at a time when, per Bloomberg , a venture capital firm that returns thirty centers on the dollar is considered an above-top-five performer. Oracle will collapse without OpenAI’s revenue .  To not actively and meaningfully discuss the potential for OpenAI to collapse is actively irresponsible. To act like there are not significant, existential problems with this company’s economics is to intentionally avoid reality, and whoever is on the receiving end of said ignorance deserves better, be they an investor reading your analyst note or a reader burdened with incomplete journalism. What follows may be an Enron-Lehman Brothers hybrid, one that leaves unbelievable destruction in its wake, an avoidable systemic risk empowered and enabled by a kneecapped media industry and sell-side analysts incapable of seeing further than two quarters in the future.  In the end, there is no avoiding the damage that OpenAI’s collapse will create. The time to do that was in 2024, before it made all those commitments, and raised so much more money. Once it did so, it led the entire industry to believe that there was significant demand for AI, when all that was happening was Sam Altman and Dario Amodei were taking up every ounce of compute capacity, paid for with equity investments from the companies they bought it from, an illusion created by men driven mad by their desperation for hypergrowth .  However you feel about my work, I am begging you to take even the prospect of OpenAI’s collapse seriously, and prepare accordingly.  If you liked this piece, you should subscribe to my premium newsletter. It’s $70 a year , $17 a quarter , or $7 a month , and in return you get a weekly newsletter that’s usually anywhere from 10,000 to 18,000 words and provides vast, detailed analyses of the biggest events and companies in the AI bubble. If you want to get in touch — and especially if you have any juicy information about Anthropic, OpenAI, or any other companies in the AI bubble — hit me up on Signal at ezitron.76. I’m also on IB on The Terminal. For OpenAI to meet its compute obligations, it needs to have both the demand necessary and more than $800 billion in cash (or, alternatively, the ability to trade stock for compute, which it’s done in the past). For OpenAI to continue as an ongoing concern, it has to, at some point, work out a way to become profitable.  It is unclear how it (or Anthropic) manages to do this. The Information reports estimates that OpenAI will go from negative $51 billion in free cash flow in 2029 to positive $39 billion in 2030. I’ll share the chart below. For OpenAI to actually survive , it will have to raise between $100 billion and $200 billion basically every year until then. For OpenAI to go public, it will need to have numbers that are competitive — both in revenues and losses — with Anthropic, a company with significantly-faster growth and a larger enterprise customer base.  OpenAI becomes the literal largest and most-successful company of all time. OpenAI runs out of money at some point. I estimate that, based on analyst notes from Wells Fargo, that OpenAI is on the hook for around $87.5 billion in Broadcom chips across Fiscal Years 2027, 2028 and 2029.  I have not included these in the total, because it’s unclear how much OpenAI is actually on the hook for. The Information reported a few months ago that both Broadcom and Microsoft would be financing the chips. It’s unclear whether OpenAI would be on the hook for ongoing payments as Anthropic is under its $35 billion, private-credit funded deal to buy Google TPUs and then rent them back from Google .  Per analyst notes from Wells Fargo, UBS and Barclays, OpenAI alone is expected to account for over $126 billion of Google, Amazon and Microsoft’s cloud revenues in the next year-and-a-half. The reason for the odd year-and-a-half designation is that Microsoft’s Fiscal Year 2027 runs July 1 2026 through June 30 2027). This analysis also assumes that OpenAI will spend a linear $40.1 billion (per Wells Fargo estimates) on Microsoft Azure in Fiscal Years 2027 and 2028. In all likelihood, its deal and commitments will require it to spend more. This doesn’t count what OpenAI will need to pay CoreWeave as part of its five-year-long, $22.4 billion deal . Though the estimate is from December 2025, Michael Turrin of Wells Fargo estimates that OpenAI’s contribution to Oracle’s Fiscal Year 2027 (which just started on June 1 2026) will be around $10 billion, then rising to $39 billion in Fiscal Year 2028. I think a fair estimate here is to put this at around $20 billion. Any and all costs associated with its still-theoretical $30 billion development in Georgia . Any and all costs associated with the launch of its consumer device. Salaries for its thousands of employees. The billions of dollars that OpenAI spends on data to train its models. Its compute costs with CoreWeave. Its compute costs with Cerebras ( $20 billion over three years ). $30 billion of OpenAI’s $40 billion 2025 funding round came from SoftBank. Anthropic’s $30 billion funding round from February 2026 involved an estimated $10 billion from NVIDIA and $5 billion from Microsoft , with the remaining $15 billion or so covered by thirty-seven different venture capital and private credit funds, including hedge fund Jane Street. Anthropic’s $65 billion funding round from May 2026 included $10 billion from Google and $5 billion from Amazon , as well as funding from Micron. Out of the 28 investors, only 8 were venture capital firms, with the rest made up of a mixture of hedge funds, asset managers, sovereign wealth funds and investment firms.  While venture capital might want to invest in OpenAI, actually mobilizing more than a few billion dollars is very difficult. OpenAI’s valuation is just too gosh darn high. Reach $284 billion in annual revenue. Pay $800 billion or more in compute obligations. In doing so, OpenAI must become one of the largest customers of Amazon Web Services, Microsoft Azure and Google Cloud, all at the same time, and continue to grow its spend. Become profitable.  OpenAI lost $20.9 billion in 2025 . If you are going to look at this and say “actually it didn’t” because of its Enrontastic accounting treatment, I also need to warn you — that identical guy in the bathroom is actually a thing called a “mirror,” a reflective surface that is showing you a reflection of you, not another person who is dressed like you and copies everything you do. I can’t imagine how scared you’ve been, and hope this has helped.  As of Q1 2026, it has a non-GAAP operating margin of negative 122% .

0 views
Martin Fowler Yesterday

Fragments: August 18

Part of the reason why I’m at Thoughtworks is because I’d like to see a software development organization founded on technical excellence as an example for the rest of the industry. The trouble is that I have little aptitude or inclination for the hard work of building such an organization. So I rely on working with people who are prepared to actually put the effort in. A key partner in all of this is Rachel Laycock , who is the global CTO of Thoughtworks. Not just is she far better than me at running a technology organization, she’s also a keen observer and connector of ideas. I’ve been urging her to write these down, even if her busy schedule makes it difficult for her to compose them into something substantial. Happily she’s starting writing “Rachel’s Ramblings” Fast, imperfect, thinking out loud. Naming ideas early rather than waiting until they’re fully formed. Because the reality is, most of what I do day to day isn’t answering known questions. It’s spotting patterns and asking questions we haven’t quite figured out yet. ❄                ❄                ❄                ❄                ❄ My colleagues in Europe are organizing XConf Europe in London on September 11th . The sessions examine what happens when agentic systems meet compliance, how to run sovereign models, performance patterns in data migrations and how to safely navigate legacy codebases. Lu Wilson will give a keynote on ‘Jam-oriented programming’. ❄                ❄                ❄                ❄                ❄ Noah Smith recognizes the high usage of AI, and its impressive feats - but also that there aren’t signs of massive productivity growth or job losses . This may be the calm before the storm, but Smith thinks there may something else in play. He quotes a metaphor from François Chollet One of the biggest misconceptions people have about intelligence is seeing it as some kind of unbounded scalar stat, like height. “Future AI will have 10,000 IQ”, that sort of thing. Intelligence is a conversion ratio, with an optimality bound. Increasing intelligence is not so much like “making the tower taller”, it’s more like “making the ball rounder”. At some point it’s already pretty damn spherical and any improvement is marginal. The thought here is that intelligence in the sense that we know it, isn’t something where there’s a lot of room for massive improvement. That doesn’t mean AI won’t be “smarter” than us in other respects, after all even without AI my computer is better at me than remembering what I’ve agreed to do over the next six months. But even if AI doesn’t get smarter than humans, it can gain by being more replicable. Not just does this make it cheaper to use, perhaps more importantly it makes it more responsive. While I might harrumph at how slowly The Genie responds to my queries, it’s still far faster than contacting a human. Smith continues by surmising that AI may be able to make sense of phenomena that can’t be reduced to simple laws, but can only be understood by something able to comprehend a multitude of details: there may be laws of the universe that humans can’t understand but AI can. I call these “cloud laws” — causal regularities that can be exploited by technology, but which are too diffuse and complex for an individual human being to either intuit or communicate. His thought is that even if there isn’t any space for AI to get more intelligent than humans along the lines we are used to, that they can open up new directions. As well as these cloud laws he also thinks that AI can understand human systems that rely on the kind of tacit, distributed knowledge that human organizations build up over time. My take-away here is that AI won’t seem more intelligent in the way that we typically frame intelligent, but more intelligent in different ways. The converse of which is that the human value comes in artfully combining our human nature with these new spells that The Genie can cast. ❄                ❄                ❄                ❄                ❄ Especially in our profession, we’ve seen increasing emphasis on the importance of data. However I’ve observed that most people still struggle to understand the message data is telling us. One of the reasons I’m interested in election forecasting is in how they communicate their insights, especially since so many people have difficulty with probabilistic forecasts. (I often wonder how much being a board-gamer has helped me be comfortable with this, all that time interacting with Combat Results Tables in my youth must have benefited me somehow.) 50+1 (one of the successors of 538) have published a little explainer on how they designed their 2026 election forecast page . There’s a good discussion of the logic behind their simulation histogram, I like how they use a text annotation to explain one point, giving the reader enough guidance to understand the rest of the graphic. They also tackle the knotty problem of visualizing geographical data on the house races. There’s a common visualization error in the U.S. using choropleth maps that leads to large areas of the landmass shown red, implying dirt votes rather than humans. Their approach to this, using dots on the map, helps visualize both the politics and the population density. They also explain how to deal with this kind of data on small screens. Lastly they describe their approach to tabular data, and how this is the right place for lots of details, together with affordances to help both casual and power-users navigate those tables. ❄                ❄                ❄                ❄                ❄ I’ve kept an eye on Alex Stamos for a while now, as he’s a sensible voice on security and safety. He’s posted a newsletter on substack that casts an intelligent eye over recent safety issues with AI . He makes a clear critique of recent US government actions around LLM models On a Friday afternoon at around 5pm PT, Anthropic was forced to shut down a system that had been plumbed into coding agents, SOCs, customer service bots, and countless products. […] This had the immediate effect of injecting political risk into the US AI ecosystem for both American and non-American customers. It signaled that you cannot depend on American AI infrastructure because, at any moment, an unwritten, capricious, and legally dubious justification could be used to yank that infrastructure from underneath your feet. When Fable was turned back on, it was much dumber and less useful to cyber defenders While Fable was down, Z.ai was taking advantage of the free market and permissionless innovation culture provided by the (checks notes) General Secretary, Politburo, and Communist Party of the People’s Republic of China, and released GLM 5.2. With 753B parameters, it falls a bit short of Opus 4.8 in most tasks but is extremely efficient and is small enough to be trained and hosted in many enterprise contexts. With an MIT license it can be fine-tuned with a wide range of techniques and used by any customer in any context. Since then, Kimi K3 has rocked the industry by providing Fable-like performance As he highlights, one of the biggest dangers with the danger of shutting down a frontier model is that it can cripple an organization’s defenses: Hugging Face tried to use an Anthropic model to defend itself during an active incident, got blocked by the classifier, and moved to GLM 5.2 on an emergency basis. Their advice to everyone else was to keep an open-weight model on the shelf for defensive cyber. On the whole, he sees it as a Good Thing that these model escapes have happened: The OpenAI attack against Hugging Face, and Hugging Face’s excellent write-up has given us a preview of what a standard AI-enabled attack might look like in a matter of months. It’s good that we got this warning shot. Nobody got hurt, the target was a sophisticated actor with the ability to defend themselves and the ability to give us a detailed write-up, and OpenAI turned the model off. He follows up by saying that all of this is signal that we should “stop talking about AI finding bugs, focus on fixing them”. These modern LLMs can do much to fix bugs and improve security, and people need to work on that rapidly to fix holes before less reputable folks than OpenAI find them. Then figure out how to harness LLMs to introduce this kind of checking into the everyday build process, so that this kind of analysis just a step in the continuous delivery build pipeline. I agree with him both that open-weight models should be legal, have their upsides, but will also be used for many bad things by bad actors. Both the industry and government agencies need put serious effort into figuring out how to mitigate these risks. Where I would go further is to say the same is true of the closed-weight models too. Although closed weight models are subject to greater controls, the same fundamental issues apply. He rightly takes the foundation model companies to task: There is an old saying I pass down to my students when I give them career advice - if you are a jerk to people on your way up, don’t expect them to catch you when you are on your way down There’s a lot of sound advice for model companies, the government, defenders, and venture capitalists. We will go through some rough changes, I just hope that we will indeed come through it with a better society. On the whole, that’s happened with previous technological changes like this, but past performance does not guarantee future results. ❄                ❄                ❄                ❄                ❄ The Economist has a good article on the impact of AI in China . China has made an all-out push in ai, under the conviction that, in its competition with America and the rest of the world, dominance of the technology is an almost existential necessity. […] But the party is increasingly concerned about how ai will displace workers. Robots and AI are appearing in an economy that’s struggling after the recent property crisis. The Chinese government is opposing firms using AI to cut jobs. China will need robots: its population will shrink by 25% by 2050. But with less working people, there’s less financial support for pensions. Many countries have to deal with shrinking population, but China’s challenge is particularly acute. ❄                ❄                ❄                ❄                ❄ Rob Bowley: I go on holiday for a few weeks and we’ve already moved on from Loop Engineering to Graph Engineering The half-life of a paradigm is getting shorter than my annual leave My prediction: neuro-symbolic engineering by the end of August, at which point we’ll have gone full circle and reinvented Prolog

0 views
Harper Reed Yesterday

Note #741

i finished Helen of Nowhere more than a week ago and i am still thinking about it. mostly just laughing. when i finished it. i immediately laughed for 30 minutes. fell asleep giggling. work up laughing. incredible book Thank you for using RSS. I appreciate you. Email me

0 views
corsix.org Yesterday

Encoding vcmpps and vcmppd

Are these forumulas elegant? No. Do they reveal some deep insight? Also no. But that's the life story of x86: it's a bit of a mess, justified by decades of history, and it gets the job done regardless.

0 views

Modular GPU Programming with Typed Perspectives

Modular GPU Programming with Typed Perspectives Manya Bansal, Daniel Sainati, Joseph W. Cutler, Saman Amarasinghe, and Jonathan Ragan-Kelley PLDI'26 GPU programming is great, who doesn’t want to copy memory with thousands of threads? The trouble is that some operations require multiple threads to cooperate, and current GPU programming languages only have kludgy ways of expressing such cooperation. For example, see the fine print on the function from the CUB library (quoting from the paper which quotes from the CUB documentation): Computes a block-wide reduction for thread0 using the specified binary reduction functor. • The return value is undefined in threads other than thread0. • A subsequent __syncthreads() threadblock barrier should be invoked after calling this method if the collective’s temporary storage (e.g., temp_storage) is to be reused or repurposed This paper introduces the Prism language, which uses perspectives to bring some much-needed hierarchy to GPU programming Prism supports 3 coarse-grain levels of nesting: , , . indicates when code/data applies to pairs of threads. applies to a warp of threads. is used to indicate a group of 8 blocks. Grids are broader (i.e., coarser) than blocks, which are broader than threads. Also, is broader than (this only applies when the larger integer is divisible by the smaller one). Each statement is associated with a stack of perspectives, and the operator can be used to push an element on to the stack. For example: Similarly, local variables are annotated with a perspective, to indicate how they are shared among threads: Perspectives are the foundation upon which Prism builds higher level concepts and a type system that enable hierarchical parallelism to be expressed. This allows for code that is more modular and easier to reason about than the typical flat parallelism found in other languages. For example, Prism statically disallows a code operating at a broad perspective from reading the value of a variable declared with a narrow perspective (only read up is allowed). Similarly, local variables can only be written from a perspective that is the same as the variable’s perspective or broader ( write down is allowed). Fig. 22 compares various Prism implementations of a matrix multiply against , not too shabby. Source: https://dl.acm.org/doi/10.1145/3808290 Dangling Pointers The interface exposed by GPUs doesn’t natively support nested parallelism. I wonder if there is an opportunity for hardware to take advantage of hierarchically information that is available at the Prism level of abstraction. Thanks for reading Dangling Pointers! Subscribe for free to receive new posts.

0 views
James Stanley Yesterday

Foiling a Protohackers email spam bot

I've been receiving lots of "Undeliverable Mail Returned to Sender" lately for Protohackers signup attempts. Protohackers login is via a "magic link", so attempting to sign up or log in results in sending an email. But none of the email body is user-controlled, so I don't really see the logic in abusing this form to spam people. One email address has been put in over 100 times over the last 3 days, and I received "Undeliverable Mail Returned to Sender" each time, because it is a GMail address that doesn't exist. What's the logic in this? Most of the email addresses did exist however and presumably the spam either reached them or was filtered by GMail. Some ideas I can think of: someone griefing particular users by bombarding them with signup spam for hundreds of services they don't use someone trying to get me specifically banned from GMail by making me send lots of unsolicited emails to GMail addresses some grey-hat chaos-monkey type operation trying to nudge all website operators into locking down forms that can cause email sending a weird botnet communicates internally by triggering Protohackers signup emails to itself, and the timestamp of the email allows them to reliably communicate about 10 bits at a time?? I think the first one is the best idea but I still don't really see why you would do this. Although it's a better reason than the others, it still doesn't seem like a good enough reason to actually bother. I did already have a rate limit of 60 emails per recipient per day, and a burst limit of 5 per recipient per minute. I don't really want to stop people from being able to log in as many times as they need to, but getting 60 spam emails per day for a service you don't use is obviously too much. I did tighten the rate limits to 10 per day and 2 per minute, but really we don't want to be sending any spam. At any rate, I wanted to stop this. The goal is to stop whatever bot is sending these emails, without impacting legitimate users ( be they man or machine ). I noticed that all of these signup attempts were originating from the same netblock: 169.58.0.0/17 , apparently operated by Contabo . I'd rather not specifically discriminate against particular netblocks, both because legitimate users could be using the same netblock, and because a bot can easily change its hosting or use proxies. But the fact that it always used the same netblock makes it easy to identify, and the fact that it comes back every few minutes makes it easy to investigate. So my first mitigation was to add a tiny JavaScript proof-of-work, on the basis that a simple bot is probably not executing JavaScript. I was surprised to find that this actually didn't help. As an experiment, I kept ramping up the difficulty on the proof-of-work, and the bot was still successfully submitting the form even when it was taking over a minute to calculate the proof-of-work. So I've left the proof-of-work in place, but back down to a trivial level so as not to inconvenience real users. The next thing I did was selectively put the Bot Forensics collector script on the page only for clients within 169.58.0.0/17, with the idea that this would quickly reveal identifying features of this particular bot that I might be able to filter on without causing collateral damage. I was disappointed to learn that the bot never posted off the Bot Forensics beacon. If you were using Bot Forensics as general-purpose bot detection, this would kind of be the ideal case. If you refuse to send emails for any session that has not posted a good beacon, then this misbehaving bot is blocked and you don't really care what the beacon would have contained. But Bot Forensics is a bit too invasive for me to want to put it on the page for every user, and by this stage I was mainly motivated to learn more about this particular bot. And in any event, I don't actually have a problem with bots using the form in principle, I only have a problem with abuse of the form, whether by bot or by human. I wondered if the reason the bot wasn't sending the beacon was simply because the proof-of-work blocked the page so it couldn't compute the beacon. So my next experiment was to put a 10-second timeout between completing the proof-of-work and sending off the email. The idea was that the page would then have a good 10 seconds in which to send off the Bot Forensics beacon. Surprisingly, the 10-second timeout inhibited sending the email! Even though it previously spent over a minute calculating the proof-of-work. The bot must be waiting for inactivity and then closing the page after something less than 10 seconds. A 10-second delay is still a bit much to be imposing on legitimate users though, so I tried reducing it to 3 seconds, and then the bot was back to successfully sending emails. Although we weren't getting the full beacon content from Bot Forensics, we could still see: the bot is fetching the collector HTML for the iframe it's fetching other resources included inline in the HTML it's fetching resources requested by the JavaScript code it is able to send POST requests for exception logging but it is not POSTing the full beacon (The exception that we log is expected, it's just a failure trying to fetch a resource which doesn't exist.) I have a list of all of the User-Agent headers seen from the Contabo netblock . I'm not saying all of these are the malicious bot, but I suspect the majority are. ChatGPT points out that this list is probably from UserAgentString.com , good find ChatGPT. Despite seemingly choosing a User-Agent at random from that list, the sec-ch-ua header always lists "HeadlessChrome", example: So this does give us one way to block this bot with extremely low chance of causing collateral damage to legitimate users: we refuse to send email for any request that has "HeadlessChrome" in the sec-ch-ua header but not in the User-Agent header. That way we still don't block legitimate users even if they are using headless Chrome, as long as they're not messing with the User-Agent header. Let's keep that one in our back pocket, I'd really like to get a bit more of a smoking gun. I made the Bot Forensics collector send back a much smaller beacon, synchronously, and discovered: timezone is set to Europe/Berlin screen size is 1280x720 it doesn't have any custom functions injected into the page, that's disappointing, they're normally my favourite thing to look at navigator.platform is "Linux x86_64" but navigator.userAgentData.platform is edited to suit the User-Agent header So apart from having "HeadlessChrome" in sec-ch-ua but not User-Agent , the mismatch between navigator.platform and navigator.userAgentData.platform is another thing we could filter on. This bot does sometimes use a real headless Chrome User-Agent , and it is its most common one, but the vast majority of requests use the other weird ones. At this point I noticed one other bizarre behaviour from this bot: shortly after sending the signup email, it tries to load the user profile page, even though that page is not linked from the signup page. What's the angle there? Maybe this is some kind of automated vulnerability scanner that thinks it might be able to access random people's accounts simply by sending the email and speculatively browsing to the profile page? I literally don't understand why you would even check this. Even if it worked, which it doesn't, even if they click on the link, because that only authenticates the session that clicked the link and not the one that sent the email... but even if it worked, what benefit do you get from hacking someone's Protohackers account? Anyway, I'm out of time and stopping for now. So changes in response to this bot are: email sending now requires a (tiny) proof-of-work, and the JavaScript code includes a 1-second sleep; this doesn't stop this bot but might stop others rate limits reduced from 60/day and 5/minute to 10/day and 2/minute backend now refuses to send email for clients who have inconsistent "HeadlessChrome" and "Linux x86_64"; this blocks almost all emails from this particular bot And the Bot Forensics collector is now removed, even for clients from Contabo. If you find you now have trouble logging in to Protohackers, I'm sorry, please let me know. Also if you can work out what this bot is actually trying to achieve I'd be really interested to know. If we have to do any more on this, I think I might try a proof-of-work system that starts out easy but drastically ramps up in difficulty based on how many emails have been sent to that recipient, or from that client netblock, in the past day. someone griefing particular users by bombarding them with signup spam for hundreds of services they don't use someone trying to get me specifically banned from GMail by making me send lots of unsolicited emails to GMail addresses some grey-hat chaos-monkey type operation trying to nudge all website operators into locking down forms that can cause email sending a weird botnet communicates internally by triggering Protohackers signup emails to itself, and the timestamp of the email allows them to reliably communicate about 10 bits at a time?? the bot is fetching the collector HTML for the iframe it's fetching other resources included inline in the HTML it's fetching resources requested by the JavaScript code it is able to send POST requests for exception logging but it is not POSTing the full beacon timezone is set to Europe/Berlin screen size is 1280x720 it doesn't have any custom functions injected into the page, that's disappointing, they're normally my favourite thing to look at navigator.platform is "Linux x86_64" but navigator.userAgentData.platform is edited to suit the User-Agent header email sending now requires a (tiny) proof-of-work, and the JavaScript code includes a 1-second sleep; this doesn't stop this bot but might stop others rate limits reduced from 60/day and 5/minute to 10/day and 2/minute backend now refuses to send email for clients who have inconsistent "HeadlessChrome" and "Linux x86_64"; this blocks almost all emails from this particular bot

0 views