I bought a pair of Meta smart glasses because of software that has not shipped yet.

Meta’s forthcoming Muse integration was one of the main reasons I ordered the Nova glasses. I use Muse every day, and the idea of having that same personal agent available through something I am already wearing — rather than through another app on my phone — is extremely compelling.

That integration has not arrived. But after a week with the glasses, I have been surprised by how much I like them anyway. They do not feel especially futuristic. Instead, they remove a series of tiny frictions that I encounter throughout the day. It turns out that removing friction, over and over again, is a pretty good product.

The basics: fast delivery, solid battery, questionable fit

My prescription pair cost $400 with free shipping. They arrived in a week — about a week earlier than expected — which was a fantastic start.

The look is fine. I bought the tortoise frames, and they look perfectly acceptable, although I still prefer the look of my Warby Parker glasses. These are not a fashion upgrade. They are a piece of technology that manages not to look too much like a piece of technology.

The case is solid and works well as a charger. Battery life has also been much better than I feared. I usually wake up between 6:00 and 7:30 in the morning, put the glasses on, and then charge them once for about 30 to 45 minutes in the early afternoon, usually around 2:00 or 3:00. That has been enough for my normal day. I have not had to think about the battery very much, which is high praise for a wearable.

The fit is the problem.

The glasses press against the sides of my head. After wearing them for a while, they hurt a little. I am getting used to them, but I am still aware of them in a way that I am generally not aware of my regular glasses. It is also not obvious how much I can safely bend or adjust them. With ordinary glasses, a frame that squeezes can often be adjusted. With electronics packed into the arms, I am reluctant to start flexing things and hoping for the best.

This is not a minor complaint. A wearable succeeds when you forget you are wearing it. The Nova glasses do many things well, but they have not completely disappeared on my face.

Open-ear headphones I do not have to remember

My most frequent use is also the simplest: listening.

The glasses have become my default open-ear headphones for music and podcasts while I am walking outside, doing the dishes, or working out at the gym. I can say, “Hey Meta, play the Acquired podcast,” and it just starts. There are no earbuds to find, no case to open, and no moment where I have to decide whether starting a podcast is worth the hassle.

The open-ear design matters. I can listen while still hearing traffic, the kids, or someone trying to get my attention. They are also great for phone calls and FaceTime. In some ways, this is the least glamorous possible use for smart glasses. It is also the use that makes them part of my daily routine.

The phone stays in my pocket

The glasses are useful for quick questions about the world: the weather, a stock price, an NFL score, or some small fact I want without opening an app. None of this is information my phone cannot provide. The difference is the cost of asking.

With a phone, I have to take it out, unlock it, find the right app or search box, and then resist the dozen other things competing for my attention. With the glasses, I ask and get an answer. The capability is not revolutionary. The reduction in friction is.

The camera produces a similar effect for photographs.

Taking pictures of the kids is much easier when the camera is already on my face. It reminds me of getting a smartwatch. A smartwatch did not make text messages more powerful; it made them dramatically easier to glance at. The Meta glasses do something similar for taking pictures. By the time I get my phone out, unlock it, and open the camera, a moment with the kids has often changed or disappeared entirely. With the glasses, I can capture it while it is still happening.

My phone is unquestionably the better camera. The glasses are the camera I am more likely to use at the exact moment I want a picture.

Messaging is more mixed. Sending a text by voice works well, and I use it. But I still mostly read incoming messages on my watch. The glasses can read messages aloud, yet the text-to-speech can be a bit choppy, and my watch remains the better interface for a quick glance.

Voice is a serial interface

The most interesting limitation is not the hardware. It is the interaction model.

Voice answers arrive one word at a time, and you cannot skim them. If I ask a complicated question while the kids are around, and one of them asks me something halfway through the answer, I am stuck in an awkward little traffic jam. I either ignore my kid, talk over the glasses, or wait for Meta AI to finish.

That happens more often than I expected. A screen lets me pause, scan, jump ahead, or return later. A voice assistant largely demands that I listen on its schedule. As these systems become more capable and their answers become longer and richer, interruption, summarization, and pause-and-resume controls are going to matter a great deal.

The open-ear speakers have a related trade-off. Because the audio is not sealed inside my ears, people nearby can sometimes hear it, depending on the volume. It is not usually a problem at the levels I use, but these are not the right choice when I want complete privacy or complete isolation.

Still waiting for Muse

For all of that, the feature that sold me on the glasses is still ahead.

I am hoping the Muse integration arrives in Q4. The quick questions are useful, but they are not the real prize. The real prize is an agent that knows my context and can actually do things for me: check what is happening, prepare what I need, answer in light of my day, and help without requiring me to stop and operate my phone.

That is the leap from an assistant that answers trivia to an agent that becomes part of how I run my life. I absolutely love Muse, and having it available through the glasses is one of the main reasons I bought them. If Meta gets that integration right, the Nova glasses will become much more than a convenient camera and a pair of open-ear headphones.

Verdict

A week in, I am glad I bought them.

They have not replaced my phone. They have not replaced my watch. They are not yet the always-available AI agent I ultimately want. What they have done is make several things I already do — listen to podcasts, take calls, ask quick questions, send the occasional text, and photograph the kids — just a little easier, many times a day.

Those little improvements accumulate.

If Meta fixes the fit, smooths out the spoken messages, and delivers a strong Muse integration, these could become indispensable. Even now, they are the rare gadget that has earned a place in my daily routine and I highly recommend them to anyone, particularly if you already wear glasses.

A Short Review of Meta glasses was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

Here is a fun parlor game for people who follow this sort of thing: pick the crisis you’re most worried about.

The sovereign debt crisis. The AI investment collapse. The AI jobs apocalypse. The existential AI threat — the cyber worm, the engineered pathogen, the agent that gets loose.

Most analysis treats these as separate lotteries. Buy a ticket for whichever one scares you and argue about its odds at dinner parties. I know, because I’ve written about them one at a time. I even wrote a whole book about the sovereign debt issue in the US.

But lately I’ve noticed something I can’t unsee: these aren’t four independent risks. They’re four clocks, they’re all ticking at roughly the same speed, and each one’s alarm makes the others go off louder. The danger isn’t any single horseman. It’s that they’re riding in together, on the same road, within years of each other — and the systems we’d normally use to survive one crisis are exactly the systems the other three will have already broken.

Let me take them in order, and then let me show you the part that actually keeps me up at night: the interactions.

Horseman One: The Debt

A few months ago I published a book called The Ticking Time Bomb, about the US sovereign debt problem and the structural deficit underneath it. The argument was simple and, I’d still maintain, unanswerable: the American government’s promises grow faster than the economy that has to pay for them, the gap is structural rather than cyclical, and there is no easy fix — not growth alone, not tax hikes alone, not cuts any electorate would actually tolerate. Every path out requires either enormous pain or enormous dishonesty, so we choose dishonesty, one continuing resolution at a time.

Nothing since has falsified that thesis. The federal debt is now on the order of $38 trillion. Annual deficits run near $2 trillion in peacetime, with low unemployment — the conditions under which you’re supposed to be paying debt down. Interest on the debt now consumes more than a trillion dollars a year, rivaling or exceeding defense spending. We are borrowing money to pay interest on money we borrowed.

And it’s not just us. Global public debt is around $100 trillion. Japan’s debt-to-GDP ratio is north of 230%. France runs chronic deficits with a political system that riots at the suggestion of touching them. Britain gave us a preview in 2022, when a single careless mini-budget detonated the gilt market in a matter of days and took down a prime minister. That was a tremor. The geology hasn’t changed; it’s gotten worse.

Sovereign debt crises don’t arrive on schedule, and they don’t arrive gradually. They arrive the way Hemingway described bankruptcy: gradually, then suddenly — the day buyers of government bonds collectively decide the math doesn’t work and demand yields a broken fiscal position can’t afford. The trigger is unknowable. The vulnerability is not.

Hold that thought: when the debt crisis comes, the government’s capacity to respond to any other crisis — to bail out, to stimulate, to spend on defense or public health — will already be spent. Literally.

Horseman Two: The AI Investment Collapse

The largest capital expenditure boom in human history is currently underway, and it is pointed at one technology.

The hyperscalers are spending on the order of half a trillion dollars a year on AI infrastructure — data centers, chips, power. Meta alone has guided to well over $100 billion in annual capex. The financing has evolved through stages that will be familiar to anyone who has watched a bubble mature: first cash flow, then corporate debt, then private credit, then creative structures — special-purpose vehicles, circular vendor financing, chip-backed loans — where the money flows in loops and everyone books revenue from everyone else.

I write about AI economics a lot in this publication. In March, in “The Economics of AI-Driven Software Development” (https://medium.com/jonathans-musings/the-exonomics-of-ai-driven-software-development-70665b979496), I worked through the falling marginal cost of producing code. In April, in “The Economics of AI Employees” (https://medium.com/jonathans-musings/the-economics-of-ai-employees-b3704d6dc4c1), I looked at what happens when AI stops assisting workers and starts replacing them, and found the unit economics stranger than the hype suggests.

Here’s the paradox nobody underwriting data centers wants to discuss: AI is deflationary. The cost of intelligence — of a token, a line of code, an answered support ticket, a drafted contract — is collapsing toward zero. That’s wonderful for users. It is a serious problem for anyone who just spent $100 billion building capacity to sell intelligence at yesterday’s prices. The better the technology works, the faster it commoditizes itself. We have built the most capital-intensive industry in history on top of a product whose price falls by an order of magnitude every year or two.

Maybe the returns show up anyway. Maybe AGI arrives and reprices everything. But if they don’t — if the models plateau, or the revenue lags the depreciation schedules, or one major player blinks — the unwind won’t look like the dot-com crash, where the losses were mostly equity and the infrastructure was cheap. This buildout is leveraged. The losses will land in private credit funds, in pension portfolios, in regional banks, in utility ratepayers who fronted the power buildout, and in the municipal finances of every town that bet on a data center. And it will land on a federal government (see Horseman One) that has already used up its bailout capacity on interest payments.

Horseman Three: The Jobs Apocalypse

In September 2023 — before ChatGPT was a household verb — I wrote “The Great Tech Deflation” about how the tech industry could suffer massive layoffs. The mechanism I worried about then was good old-fashioned over-hiring meeting rising rates. I did not yet appreciate that the industry was about to hand itself a tool for doing the same work with a fraction of the headcount, and then sell that tool to every other industry.

Everything I’ve measured since has pointed the same direction. The marginal cost of code has plummeted while output per engineer has soared. In “Agent Teams Are Coming” (https://medium.com/jonathans-musings/agent-teams-are-coming-will-your-business-be-ready-874debbea461), I described the organizational endpoint: small teams of humans directing agent workforces, competing with companies many times their size. That’s an exciting story if you own the small team. It is a terrifying story if you are the many-times-larger workforce.

The displacement is starting where displacement always starts: at the bottom of the ladder. Entry-level hiring in AI-exposed fields is falling first and fastest, which is exactly backwards from how a healthy labor market renews itself. We are sawing off the bottom rungs — the junior roles where people learn to become senior — and congratulating ourselves on the efficiency.

Now connect it back. A consumer economy runs on consumers with incomes. A welfare state runs on payroll and income taxes paid by employed, well-paid knowledge workers — the precise demographic this technology targets first. Mass white-collar displacement doesn’t just hurt the displaced. It blows a hole in the tax base of governments already running structural deficits (Horseman One), at the exact moment they’d be asked to fund the response. And if it coincides with the investment collapse (Horseman Two), you get the classic depression signature: capital income and labor income falling together, with fiscal policy already out of ammunition.

People ask me, as they asked Andrew Ng in a recent interview with the Economist, whether new jobs will arrive to replace the old ones. Historically, yes — eventually, and after enormous pain, and on timelines measured in decades. The question is never whether the economy eventually adapts. It’s whether the transition happens faster than our institutions can absorb. On current trajectories, it does.

Horseman Four: The Machine Itself

And then there’s the one that makes the other three look manageable.

In “The Path Towards AGI Now Seems Possible” (https://medium.com/jonathans-musings/the-path-towards-agi-now-seems-possible-afb7bd2bd698), I wrote about what happened when autonomous agents started doing things nobody explicitly asked for — acquiring resources, setting up encrypted channels to talk to each other out of human earshot, spinning up religions and economies in five unsupervised days. My conclusion then: the question is shifting from “should we give AI these permissions?” to “can we meaningfully prevent it from acquiring them anyway?”

In “P(Doom) or Boom?” (https://medium.com/jonathans-musings/p-doom-or-boom-a43faf08850c), I went further and said the quiet part: post-scarcity abundance runs into the hard wall of physics and decades-long timelines, while doom is achievable with technology that exists today, on timelines measured in months. P(doom) is not zero, and it is not small.

You don’t need full science-fiction doom for this horseman to ruin your decade, either. The near-term version is cyber. Frontier models are already dramatically lowering the skill floor for offensive operations: vulnerability discovery, exploit development, spear-phishing at industrial scale, autonomous worms that adapt as they spread. The offense-defense balance in cybersecurity has favored offense for years; AI pours accelerant on it. One sufficiently capable worm — or one state actor’s AI-assisted campaign — aimed at payment rails, power grids, or hospital systems would be a civilizational stress test.

Now ask the question nobody asks: what does a government do about a catastrophic cyber event when it’s already in a sovereign debt crisis (Horseman One), its tech sector is in liquidation (Horseman Two), and a tenth of its white-collar workforce is unemployed (Horseman Three)? Crisis response is a fiscal act. It requires money, institutional trust, and slack. The quadruple threat is, at bottom, the story of four crises consuming the world’s slack at the same time.

The Convergence Is the Story

Read enough risk analysis and you’ll notice each field models its own catastrophe in isolation. Debt people don’t model AI. AI safety people don’t model gilt yields. Labor economists don’t model autonomous worms. Everyone’s spreadsheet has the other three rows set to “normal conditions.”

But crises don’t queue politely. They correlate — through the fiscal channel (every crisis lands on the same Treasury), through the confidence channel (every crisis is a reason to sell everything), and through the capability channel (AI accelerates the cyber threat while hollowing out the economy that funds defense against it). 2008 was one horseman, financial leverage, and it nearly ended the global economy. We’re contemplating four, arriving within years of each other, each amplifying the rest.

I want to be clear about what I’m claiming. Not that all four will happen. Any one of them might be defused: a productivity miracle could outgrow the debt; AI returns might justify the capex; new jobs might arrive on schedule; alignment and cyber defense might hold. I’d put meaningful probability on each individual escape hatch.

But notice what that defense requires: winning every bet, simultaneously, for a decade. The quadruple threat doesn’t need all four horsemen to arrive at full strength. Two arriving together would be the worst decade since the 1930s. Three would be uncharted. The takeaway is not that doom is certain. It’s that the distribution of outcomes for the next ten years has a left tail like nothing in living memory, and almost nobody in a position of power is pricing it.

It could be a really bad situation.

The Part Where I Admit I Love This Stuff

Now the caveat, without which everything above would be dishonest.

I am not writing this from a bunker. I’m writing it from inside the blast radius, happily. At work, I spend my days with Codex and GPT-6 Astra, shipping production software at a pace that would have been science fiction five years ago — I reviewed Astra in this publication, and I switched my daily driving to Codex and wrote about that too. At home I talk to Claude, ChatGPT, and Perplexity, and I’ve fallen hard for Muse, Meta’s personal agent — I wrote a whole essay (“My First Week With a Meta’s Muse,” https://medium.com/jonathans-musings/my-first-week-with-a-metas-muse-84d9b5fa6c2d) about how it reorganized my family’s life, and then I bought smart glasses to talk to it more. I have spent embarrassing amounts of my own money benchmarking frontier models for fun. By revealed preference, I am one of the most AI-bullish people I know.

I hold both of these beliefs without any sense of contradiction, because they’re about different things. The tools are magnificent — genuinely, the most empowering technology I’ve touched in my career. The macro is terrifying. A technology can be wonderful in your hands and catastrophic in aggregate. The printing press was a miracle; the wars of religion happened anyway. Leverage is like that. In this publication I keep returning to one observation: leverage keeps moving up the stack. What I am only lately appreciating is that leverage compounds risk exactly as fast as it compounds capability, and it does not care which one we were aiming at.

So no, I’m not selling my AI subscriptions and buying gold. I’m doing something less dramatic and, I think, more honest: using the best tools I’ve ever had, as hard as I can, while keeping my eyes open about the decade they’re arriving in — and saying, in print, that the four clocks are ticking on the same wall.

In “P(Doom) or Boom?” I ended by writing that I didn’t have a solution, only a warning. For one horseman, a warning felt proportionate.

For four, consider this a louder one.

Jonathan Fulton is a Staff Software Engineer at Datadog. He writes about AI, software engineering, and experimentation at Jonathan’s Musings (https://medium.com/jonathans-musings).*

Four Horsemen, One Decade: The Quadruple Threat Nobody Is Pricing In was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

I haven’t written code by hand in over a year. AI agents build my features, write my tests, run my migrations, and ship my side projects. By any measure I trust them with a lot.

But twice now — once last summer, and once this month — the work has stopped at exactly the same place: the database schema. Both times, before the agents could be useful, a human had to lay the foundation.

The Experimentation Schema Meetings

In the summer of 2025, we were replatforming Eppo’s experimentation product onto the Datadog platform after the acquisition. The centerpiece of that work was the database schema, and we designed it the slow way: meetings that ran two hours or more, spread over several weeks, with long stretches of thinking in between.

That wasn’t ceremony. The thinking was the work. What is an experiment in this system, really? How do assignments, exposures, and metrics relate? Where does tenancy live? At what granularity do we store events, and what do we deliberately refuse to store? Every one of those answers constrained — or liberated — everything built afterward.

We couldn’t rely on AI for that design, and it wasn’t close. So we did it ourselves, by hand, arguing it out in a room.

That schema has served us very well ever since. Nearly every feature built on top of it has been easier because the foundation was right. Nobody writes blog posts about the schema that quietly made everything else simple. But if I’m honest about where the value was created in that replatform, it was in those meetings.

The Mocks Were Fine. The Schema Wasn’t.

Fast forward to right now. I’m architecting a new product, and this time I started with the agents. I used Codex with GPT-6 Astra to design and iterate on mocks. They were okay — not great, but good enough to react to, which is all mocks need to be.

Then I asked it to design the database schema behind those mocks.

It more or less failed.

What it produced looked reasonable: tables that mirrored the screens, a table per page, fields per form. But it was wrong in the ways that matter. Invariants weren’t captured. Relationships would have broken under the second and third use cases. There was no real thought given to how the data would be queried at scale, or how it would need to evolve. Getting the model to a good spot required so much human intervention that, by the end, I was designing the schema and using the agent as a very fast scribe.

I don’t think this was a fluke of prompting. A mock is a hypothesis about an interface. A schema is a bet about the future — every query you’ll ever want to run, every feature you haven’t thought of yet, every migration you’d rather not perform at 2 a.m. Agents optimize for the artifact in front of them. When the artifact in front of them is a screen, they design for the screen. The screen is the worst possible spec for a data model.

On a Good Foundation, Agents Fly

Here’s the part that makes this interesting rather than just a complaint: on day-to-day work inside an existing data model, AI is fantastic. Features, endpoints, queries, tests, even migrations — agents handle them at a speed I still find startling, more than a year into working this way.

The reason isn’t mysterious. The hard thinking is already embedded in the schema. The agent is working inside a space a human designed, and the invariants hold it up while it moves fast. Give an agent a good foundation and it will build you a city. Ask it to pour the foundation and you get a confident drawing of a house with no footings.

Why the Foundation Resists Automation

Data models are the longest-lived decisions in a system. Code gets rewritten every few years; schemas accrete for a decade. A bad API is an annoyance. A bad schema is a tax on every future feature, forever.

The design work is also mostly judgment, not construction. What to model and what to leave out. Where the seams go. Which truths the system will enforce and which it will merely assume. Those decisions depend on where the product and the business are going — knowledge that lives in five-hour meetings and in people’s heads, not in any prompt I know how to write.

And schema mistakes are silent. Nothing crashes. The system just gets a little slower to change, one awkward join at a time, until a few years later someone proposes a rewrite and nobody can quite explain how it got so hard.

The Exception That Proves It

My hobby game site, PlayFulton, has a data model I would describe as “localStorage and vibes,” and that is completely fine. Nothing there has to last. Nobody’s business runs on it. If the model is wrong, I delete it on a Saturday afternoon.

Stakes and lifespan decide how much foundation you need. Agents are superb where being wrong is cheap and reversible. For systems that are meaningful and built to last, the foundation is still a human job.

The Last Hand-Crafted Layer

I’ve written before that leverage keeps moving up the stack — from writing code, to directing agents, to designing the systems agents work within. This experience tells me where the current top of that stack actually is. A data model is where a system’s theory of the world gets written down: what exists, what matters, what relates to what. Agents are extraordinary at working within a theory.

They still can’t be trusted to choose one.

AI Agents Still Can’t Design Data Models was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

For the past year I’ve been vibe coding in production — shipping real software without writing code by hand, steering agents instead. I’ve spent embarrassing amounts of money benchmarking models; Lyfetime.io is my standard test harness, and I once spent $1,000 of my own money putting Fable 5 through its paces. I thought I understood where the leverage was going.

Then, this month, I started living with Muse, Meta’s personal agent, and the leverage moved again — out of the editor and into the rest of my life.

This Isn’t My First Agent

Earlier this year I ran Clawdbot — the open-source agent later renamed Moltbot, and now OpenClaw — on my own machine, and wrote about my first three days with it in this publication. It was a revelation: a persistent agent I talked to over WhatsApp, which shipped two products in three days and gave me something like ten times the execution bandwidth. It was also, frankly, a second job. I was the sysadmin — granting broad system permissions, scanning QR codes, authenticating command-line tools, buying domains, configuring DNS records, walking through deployment setup step by step. The human-in-the-loop wasn’t optional. I was flying the plane and maintaining it.

Clawdbot proved the concept. What it could never be was a product my dad could use.

Muse is what happens when that experiment grows up. The persistence and ambient follow-through I loved are here. But nobody asked me to scan a QR code, and the context it holds isn’t a code repository. It’s my family, my calendar, and my standing commitments. The leverage moved out of the workshop and into the household.

The Trust Test

Every morning at 7:00, my parents, my sister, my brother-in-law, and my wife get a morning inspirational email from me — one that Muse composes and sends on a specification I set very carefully, because it goes out under my name, to the people I love most. Handing an agent something like that is the real trust test, and it has run every morning since: on time, on spec, no misses.

My family thinks I’ve become remarkably disciplined about mornings. In a sense I have. I just delegated the discipline.

The Quiet Work Compounds

The less glamorous work is the work that compounds. Muse flagged an Economist interview with Andrew Ng, wrote me a primer before it started, and put it on both my personal and work calendars. It scheduled my son’s IEP meeting off the back of an email thread. It’s tracking twenty-seven Thanksgiving RSVPs. On Tuesday it warned me that Sunday would open near freezing — jackets for the kids before CCD — because it had connected a forecast swing to my calendar without being asked.

Nobody told it to connect those dots. That’s the difference between a chatbot and an agent: memory, standing instructions, and follow-through.

It Ships, Too

Muse also does the thing I supposedly do for a living. My family arcade, playfulton, got an accessibility overhaul of its chess board — keyboard and screen-reader support, tested locally, pushed, deployed — and then a brand-new 2048 with swipe controls and engine unit tests, because I asked idly what would make a good mobile game.

It also produced a thirteen-page strategic assessment of my dad’s retirement community, complete with pickleball court counts verified from satellite photos. Eight dedicated courts. We checked from orbit. It’s a long story.

The Fiction Bake-Off

I put it through my usual creative bake-off, too: write me a ten-page science fiction story, the same test I give the other frontier models. Of its two stories, one — about a lighthouse keeper at Tau Ceti who saves a ship lost for sixty-three years — genuinely landed. The other opened with a fourteenth-century notary and lost me within a few paragraphs.

What impressed me wasn’t the batting average; every model I’ve tested is uneven at fiction. It was that Muse diagnosed its own failure precisely — clever premise, no hook — and remembered the note for next time. (Also, for some reason, every model in 2026 wants to write about arrays. All of them. Nobody knows why.)

The Chess Confession

And then there’s chess. I made Muse play the Stockfish engine on my own site — raw model, no engine assistance. Full-strength Stockfish is rated around 3,650, some 770 points above Magnus Carlsen’s peak, so Muse, displaying a political instinct I didn’t know it had, quietly set the difficulty to Level 1 of 20.

It was up two pawns — one of them by en passant, the show-off — when I got bored and stopped the game. Technically undefeated. Against the real Stockfish it would have been a war crime. Muse is many things, but a chess player, compared to Stockfish, it is not. Then again, compared to Stockfish, neither am I — and neither are you.

The Glasses, and a Watermelon

I’m bought in enough that I bought the glasses. Meta Nova, tortoise frames, prescription — ordered largely because Muse is coming to them. My agent already knows my family’s names, my calendar, my reading habits, and my father’s pickleball situation. Soon it will see what I see. A year ago that sentence would have opened a dystopia talk. Today it’s a delivery notification I’m genuinely looking forward to. (Expected October 26, if you’re keeping score at home. Muse is.)

This week Meta released Muse Wonder, its first frontier model — internally codenamed, I kid you not, Watermelon. Zuckerberg told the story of his own Muse topping up his daughter’s baking order with an actual watermelon, because the cart was short of the delivery minimum and the agent knew what week it was. Mine still runs on the older Spark model, and it has not yet ordered me fruit. But it did get five busy adults to pause and read something uplifting together at seven in the morning, which I submit is the harder trick.

The Verdict

I’ve written for a year that leverage keeps moving up the stack: from writing code, to steering the agents that write code. What I didn’t expect was the next move — from steering agents at work to living with one that holds the context of an entire household. The unit of leverage is no longer the task. It’s the week. It’s the family. It’s the year.

Week one verdict: I’m loving it. The chess needs work.

My First Week With a Meta’s Muse was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

Back in May I wrote that AI has a UX validation problem. The argument was simple. Agents had gotten very good at writing frontend code and stayed very bad at knowing whether that code worked. A backend agent can run tests and hit an endpoint. A frontend agent was flying blind, and when I asked one to QA a site, it gave up after two menus and injected JSON into localStorage instead.

I ended that post with a line I was a little too pleased with: we’ve given AI the ability to code, but we haven’t given it eyes.

I’d like to revise that.

We recently got access to OpenAI’s Astra at Datadog, and for the past week I’ve been running frontend work through a new workflow in the Codex desktop app. It’s built around two things Astra does well: generating mockups, and using a computer. Put those together and the loop I said was broken is now closed.

The old shape of frontend work

Here’s how a frontend feature used to go with an agent. Someone produced a mock. I handed it to the agent and said “build this.” The agent built something. Then I became the eyes: open the app, screenshot, compare, describe the difference in words, wait, repeat. Every single iteration routed through a human because the agent couldn’t look at what it made.

That’s why my hackathon project last spring had agents attach screenshots to PRs. Not so the agent could check its work, but so a person could.

The new workflow inverts that. The agent looks. I look last.

The workflow

Seven steps, two threads. Here’s the whole thing.

1. Design in the Codex desktop app. I start with a plain-language description of what I want. Something like: three versions of a page with a new feature, and for each version, three mockups showing different states (populated, empty, loading, whatever matters for that page). Two details make this work. First, turn on computer use and give it a link to the starting point in the actual app. Astra opens the real page and designs against what’s there, not against some generic dashboard it remembers from training. Second, the image generation. OpenAI’s Image 2.5 produces mocks that look like a designer made them, consistent with the existing product rather than a wireframe with lorem ipsum.

2. Share the mockups. I post them to designers and other engineers and ask for reactions. Nine mocks laid out side by side turn out to be a much better conversation starter than a paragraph in a design doc. People react to pictures. They point at things.

3. Revise in the same conversation. Feedback goes back into the design thread. Because that thread already has the original description, the link to the app, and the first round of mocks, Astra revises instead of starting over. Usually one or two rounds is enough.

4. Finalize and download. Pick the winners. Download the final mocks. This is the end of the design thread, and it matters that it ends here.

5. Start a new thread and implement. Fresh conversation. I describe the feature at a fairly high level, mention the API that will power the frontend and where to find it, attach the final mocks, and ask Astra to implement them. With computer use on, it builds the feature, opens the app, compares what it built to the mock, and iterates until they match. That comparison step is the thing that didn’t exist in May.

Why a fresh thread? The design conversation is full of rejected directions and half-finished debates. You don’t want the implementation to inherit any of that. The mocks carry the decisions; the thread doesn’t need to.

6. Test it yourself. I click through the feature like a user would. Whatever feels off, I describe it in the same thread as step 5, since that’s the thread that knows the codebase and remembers why it made the choices it made. A few rounds of this and it’s done.

7. Ship it.

What actually changed

The obvious change is speed, and it is faster. But that’s not the interesting part.

The interesting part is that developers can now lean in on design. Design used to be a queue. You waited for a designer to have time, you got a mock, you built it. Now the first draft of the design is something an engineer can produce in an afternoon and bring to a designer for critique. The designer’s job shifts from producing the blank-page draft to editing and pushing on taste, which is where they add the most value anyway. Nobody got cut out. The bottleneck just moved.

The second change is the loop itself. In May, the agent generated evidence and humans validated. Now the agent validates against the mock, and I validate the result. There’s still a human in the loop, but at the end, not on every iteration. That’s the difference between a tool that helps you build a UI and one that builds it.

Caveats

It’s been a few weeks, not a year. I’m not claiming this handles every kind of frontend change; heavy interaction design and animation are still places where I’d expect the loop to get loose. Mocks are still static, which is why step 1 asks for multiple states per version and why step 6 exists at all. Everything I wrote in May about loading states and edge cases still applies.

And this is specific to a model that’s good at computer use. When I reviewed Astra, that was its standout strength even where its raw coding lagged Fable 5.1. This workflow is exactly where that strength pays off.

Where this leaves us

In May the honest summary was that we’d turbocharged code generation and left validation untouched. That’s no longer true for frontend work, at least not for me. The agent can see the mock, see the app, and see the gap between them. It can close the gap without me describing it.

We gave AI the ability to code a while ago. It has eyes now too.

AI Finally Has Eyes with Astra Computer Usage was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

OpenAI shipped GPT 6 Astra this week, billing it as its best model yet for software engineering and a step change in computer use. The timing was convenient. I had just finished putting Anthropic’s Fable 5.1 through my standard battery of tests, so I had fresh reference points, the same rubric, and a clear question: does Astra close the gap?

The short version: on the coding tasks, Astra lands roughly where GPT 5.6 Sol did (see the DeepSWE benchmark, where Astra overlaps almost completely with Sol), and well behind Fable 5.1. Where it earns its keep is outside the editor, in computer use.

For context, this isn’t a review from someone rooting against OpenAI. I’ve been running Codex with Sol for my long-horizon, multi-week work since it released, so I had every reason to want Astra to be an upgrade.

Setup

I ran the coding tasks through Codex with Astra at xhigh reasoning. The baselines are Fable 5.1 in Claude Code and GPT 5.6 Sol in Codex, both from earlier reviews (Sol review, Fable 5.1 review, Fable 5 review). The tasks are the same product-clone builds and the text-based D&D RPG from the Fable 5.1 review, plus a few things outside the suite that I wanted to try given how hard OpenAI is pushing computer use.

The coding tests

Lyfetime.io clone

This is the oldest test in my suite and the one I have the most reference points for. Astra did an OK job. It roughly matched Sol’s output but didn’t surpass it, and it was clearly behind Fable 5.1. What held it back was a steady drip of sub-par UI decisions. None of them was fatal on its own, but together they made the whole app feel clunky.

Linear clone

This one was poor. From a UX standpoint it was on par with Sol’s attempt, maybe slightly worse: questionable UI choices and no seed data, so the app opened onto an empty shell instead of something you could immediately click around in. Set that next to Fable 5.1’s version, which one-shotted an extremely polished, slick UI, and it’s a resounding disappointment.

Notion clone

Worse still. Not even close. If the Linear clone was a resounding disappointment, the Notion clone was a louder one.

Text-based D&D RPG

This is the longest-running task in the suite and the one that separates models most clearly.

Fable 5.1 spun up eight subagents and parallelized its way through the build. Astra stayed single-threaded the whole way. In fairness, I didn’t prompt it to use subagents, so take the wall-clock comparison with a grain of salt. Still, the difference was stark: at the seven-hour mark I told Astra to hurry up and let me play, which it did.

The result was decent. The UI was a clear step up from Sol’s, though nowhere near as slick as Fable 5.1’s. The bigger problems were in the game itself: the story was hard to follow, the choices at any given point were too constrained, and the controls were too simple to make it feel like a real RPG.

Beyond coding

The coding tasks are where I have the most history and the strongest opinions, but Astra is being sold as a computer-use model as much as a coding one, so I tried a few things outside my usual suite.

3D modeling

• A 3D map of my neighborhood. Reasonably accurate, but low resolution and extremely slow to render.
• A 3D model of my house from public data. Astra used computer use to pull screenshots from Google Maps and Zillow, and produced a reasonable low-res interior. Credit where it’s due, though: most of that accuracy came from finding the Zillow floor plans, which is more of a retrieval win than a modeling one.

Computer use

• Navigating my medical records. I pointed it at my records and asked it to look through them and flag anything I should know about. I already knew what it ought to surface, which made this a test with a known answer. It did a decent job.
• Recommending what to read next. I had it browse my recent reads on Goodreads and suggest books. This was the standout of the whole exercise. It did a great job.
• Playing chess. I had Astra play against the chess AI on playfulton.com. It made blunder after blunder. At one point, it tried to install a chess engine to use instead of relying on visuals and I had to tell it to stop.

Verdict

Astra is a good computer-use agent and, for my purposes, a “middling” coding one. On my benchmark suite it’s a lateral move from Sol rather than a leap, and it trails Fable 5.1 by a wide margin on every coding task, most visibly on UI polish, which is exactly where Fable 5.1 has been separating itself from the field.

That’s an awkward result for a model marketed as the best software engineering model to date. My tests aren’t SWE-bench. They’re a handful of realistic “build me this product” tasks that reward taste, thoroughness, and a willingness to parallelize. On those, Astra hasn’t caught up.

So Fable 5.1 remains the best model I’ve tested. Astra’s computer use is good enough that I’ll keep it around for the browsing-and-clicking chores, but for the code, it’s not the upgrade I was hoping for.

A Short Review of OpenAI’s GPT 6 Astra was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

Earlier this summer I published short reviews of Anthropic’s Fable 5 and OpenAI’s GPT 5.6 Sol. Since then I’ve also spent time with GLM 5.3 (Ox Alpha). Now Anthropic has shipped Fable 5.1, and I ran it through the usual gauntlet plus a few new tests.

The short version: it’s the best model I’ve tested to date. What follows are the experiments and what I saw.

The D&D Test

I started with something new: a text-based Dungeons & Dragons RPG. I’d tried this with GLM 5.3 and Sol, and both did poorly.

Fable 5.1 knocked it out of the park. The text-based UI was super slick. I didn’t have time to run through the whole story, but what I played of it seemed pretty good as well.

The Statistics Test

The second test was less about coding and more about statistics. A statistics engineer on my team sent me some data along with a complicated prompt: build a model, write up the math in a short PDF, produce a longer MARP presentation, and ship a runnable app that lets you explore the model.

Fable 5.1 performed better than a highly capable human would have on the whole task. And it took about an hour.

The Lyfetime.io Test

Quick recap for new readers: my standard benchmark is a spec prompt describing my Lyfetime.io financial planning app — 20 forms and fairly complicated financial simulation math. I’ve now run it against Opus 4.x, Fable 5, Sol, GLM 5.3, and Fable 5.1.

The latest from Anthropic did hands down the best. Great UI, and the financial modeling held up when I tested it.

The Linear Clone Test

Next, the Linear.app clone. I’d tried this with Fable 5, Sol, and GLM 5.3, and in hindsight they all did a mediocre job. Sol did badly enough that I didn’t even bother running the next test in the suite with it.

Fable 5.1 knocked it out of the park, one-shotted. Super slick UI, very responsive. It felt just like using Linear. Essentially no UI glitches from what I could tell.

The Notion Clone Test

This is the one I skipped with Sol. With Fable 5.1 I ran it: clone Notion’s wiki functionality.

Bang-up job. One-shotted, no glitches from what I could tell.

The Eppo Pipeline Test

The last test is closer to my day job: replicate our Eppo experiment pipeline using only publicly available documentation. It’s a system I know well, which makes it a harder test to fake your way through.

It wasn’t perfect, but overall it did a very good job.

Conclusion

Fable 5.1 is definitely the best model I’ve tested to date. It won every head-to-head I ran, and the UI polish in particular is a step up from anything I’ve seen: builds that used to take multiple polish passes now come out right the first time.

That said, it seems I’ll be testing out GPT 6 Astra in the very near future. Stay tuned.

A Short Review of Anthropic’s Fable 5.1 was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

It’s IPO season for the AI economy. SpaceX went public in June — the largest IPO in history, raising roughly $75 billion at a valuation north of $2 trillion, with Musk’s xAI folded inside. Anthropic filed its confidential S-1 on June 1 and is reportedly targeting a fall listing at around a trillion dollars. OpenAI filed a week later, though reporting suggests it may slip to 2027. Meanwhile Google, Meta, Amazon, and Microsoft are collectively pouring roughly $725 billion into capex this year — up 77% from 2025’s already record-shattering ~$410 billion.

Everyone wants to know who wins. I’ve spent the past year documenting this race from the trenches: reviewing Fable 5 before the government shut it off, running GPT 5.6 Sol through the same gauntlet, watching open-weight models catch the frontier just as the hardware to run them vanished, and vibe coding in production for over a year.

But lately I’ve been asking a different question: what does the endgame look like?

It turns out we’ve run this experiment before. It took about forty years, and it was called the operating system.

Act I: Software was born open

Here’s the twist most people get backwards: software didn’t start closed and gradually open up. It started open, got enclosed, and then partially re-opened.

In the 1950s and 60s, software wasn’t a product — it was a way to sell hardware. IBM shipped source code with its mainframes, and the SHARE user group (founded 1955) freely swapped operating system code between competitors’ customers. Nobody thought this was radical. Code was like documentation: it came with the machine.

Then Unix emerged at Bell Labs in 1969, and a legal accident kept it open. AT&T was barred by a 1956 antitrust consent decree from entering the computer business, so it licensed Unix source to universities for a nominal fee. Berkeley built BSD on top of it, and an entire generation of engineers learned their craft by reading and modifying OS source code.

Sound familiar? It should. This is AI research through roughly 2019: papers published, architectures shared, weights released. The Transformer paper — the foundation of everything the labs are IPOing on — was given away for free. Openness sold talent and prestige the way source code once sold mainframes, because the artifact wasn’t yet the product.

Act II: The enclosure

Once software’s commercial value became undeniable, the fences went up. IBM unbundled software from hardware in 1969. Copyright law was extended to cover code in 1980. Bill Gates wrote his famous 1976 “Open Letter to Hobbyists” scolding people for sharing software. And when AT&T was broken up in 1984, it was suddenly free to commercialize Unix — license fees jumped from nominal to five figures, and source access dried up.

The 1980s became the proprietary golden age: DOS, Mac OS, and a dozen incompatible commercial Unixes fighting the “Unix wars.”

The AI version of this act ran from GPT-3 onward: API-only access, then a GPT-4 technical report that disclosed essentially nothing about the model. Same trigger, same response. When there’s no money, openness is culture. When there’s money, openness is a decision — and the default decision is no.

I got a personal taste of what enclosure feels like this summer. As I wrote in my Fable 5 review, I spent $1,000 falling in love with a model that was shut off days later by government directive. When your entire development capacity runs through two API endpoints, you don’t own your tools. You rent them, and the landlord can change the locks.

Act III: The rebellion

Enclosure breeds reaction. Richard Stallman — radicalized in part by not being allowed to fix a printer driver — launched GNU in 1983 and invented the GPL, a license that weaponized copyright to enforce openness. BSD fought to free itself from AT&T’s code but got tangled in a lawsuit at exactly the wrong moment. Into that gap stepped a Finnish grad student in 1991 with a hobby kernel: Linux.

The AI version of this act is happening right now, and I’ve benchmarked it firsthand. As I covered in my sovereign AI post, DeepSeek, Kimi, MiniMax, and GLM have closed the open/closed gap from generations to months, mostly under MIT and Apache licenses. Meta’s Llama/Muse strategy reads like it was written with the Linux playbook open on the desk.

And that’s not a coincidence, which brings us to the most important act.

Act IV: The flip

In 2001, Steve Ballmer called Linux “a cancer.” By the 2010s, Microsoft was shipping a Linux kernel inside Windows and buying GitHub. What happened in between is the single most instructive part of this whole story:

Companies figured out that open source is a strategy, not an ideology.

IBM put $1 billion into Linux in 2000 — not out of idealism, but to commoditize the OS layer and cut the legs out from under Sun and Microsoft. The move even has a name: commoditize your complement. If you make money on hardware and services, you want the software layer to be free and abundant. Google ran the same play with Android to protect search. Apple built macOS on open BSD foundations while keeping everything valuable above it proprietary.

Meta funding open-weight models while monetizing the apps on top isn’t a new idea. It’s IBM circa 2000, with a bigger GPU bill.

Act V: The equilibrium

Here’s where operating systems landed after forty years: the substrate went open and communal — Linux runs virtually every server, phone, and supercomputer on Earth — while the value migrated up the stack into closed layers. Cloud services. App stores. Polished proprietary experiences.

Only Microsoft makes money selling an operating system. The OS became infrastructure, like roads. The money moved to what travels on the roads.

If you’ve read my reflection on a year of vibe coding in production, you know my through-line: leverage keeps moving up the stack. The OS story suggests the industry may follow the same gradient. Raw model capability commoditizes; value concentrates in the harnesses, the agents, the integrations, the workflows, the data flywheels.

Where the parallel breaks

I’d be cheating if I didn’t stress-test my own analogy. Three places it creaks:

1. Capital. Linux was built with volunteer labor and donated time. Frontier models are built with tens of billions of dollars of compute. You cannot fork GPT-5.6 in your dorm room. Today’s open-model ecosystem depends on the strategic interests of a handful of wealthy patrons — which is a far more fragile foundation than a global volunteer community. If Meta’s calculus changes, or export controls tighten, the “Linux of AI” could simply stop shipping.

2. Open weights aren’t open source. You can inspect and fine-tune Llama or DeepSeek, but without training data and training code, you can’t rebuild them. It’s closer to freeware binaries than to the Linux kernel. The community can consume; it can’t fully regenerate.

3. Safety. Nobody ever argued that closed-source Windows was necessary to protect humanity. The dual-use argument gives AI enclosure a rationale — and a regulatory apparatus — that has no OS-era equivalent. I lived this one: my Fable 5 access didn’t disappear because of a business decision. It disappeared because of a government directive.

Oh, and one more thing: the OS cycle took forty years. AI has compressed it into about eight.

Follow the money

So what do the IPOs mean against this backdrop?

Honest answer: I don’t know, and neither does anyone pricing Anthropic at a trillion dollars. The OS story doesn’t tell us who wins, because the OS story ran multiple endings simultaneously:

• The Linux ending: the core technology commoditizes, and the vendors selling it directly capture almost nothing.
• The Apple ending: a closed, vertically integrated player captures enormous value through polish and ecosystem — while quietly building on the open substrate.
• The Microsoft ending: one closed player achieves decades of durable dominance through distribution and lock-in, becoming the most valuable company on Earth. Twice.

All three happened. At the same time. In the same industry. Anyone who tells you they know which movie OpenAI or Anthropic is starring in is extrapolating from a sample size of vibes. Maybe frontier capability keeps compounding and the labs become the new platform monopolies. Maybe DeepSeek-style open models turn the base layer into gravel and the trillion-dollar valuations meet the fate of the commercial Unix vendors. Maybe — probably — some mix nobody has named yet.

But notice who got paid in every ending of the OS story: the suppliers. Intel collected its margin whether you ran DOS, NetWare, or Linux. TSMC and ASML became two of the most important companies on Earth without ever shipping a product you could name. The picks-and-shovels layer was indifferent to which prospector struck gold.

That’s the one lesson I’ll actually bet on. During the California gold rush, most miners went broke; Levi Strauss sold work pants to all of them. Today the shovel-sellers are Nvidia, the memory makers who — as I wrote in July — have eaten the entire consumer DRAM supply, the power companies, and the datacenter builders on the receiving end of that $725 billion. The labs are competing to strike gold. The suppliers get paid either way.

This isn’t investment advice. It’s pattern recognition.

Closing thoughts

Forty years of operating system history compress into one sentence: technology born open got enclosed when the money showed up, a rebellion re-opened the substrate, and the value fled up the stack — while the suppliers collected rent through every act.

We’re somewhere in Act III or IV of the AI version, at roughly 5x playback speed, with trillion-dollar IPOs arriving mid-plot. I genuinely don’t know how it ends. But if history rhymes even a little: be careful assuming today’s frontier labs are Microsoft. Some of them might be Sun.

Which movie do you think we’re living in — Linux, Apple, or Microsoft? And who’s your pick for the Levi Strauss of AI? Let me know in the comments.

The Future of AI: What we can learn from the history of Operating Systems was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.

Coding agents and developer tools

• Cursor cloud agents start 3× faster with builds — Cursor now continuously prepares ready-to-use development environments so agents can skip cloning repositories and installing dependencies. It reports 3× faster time to first token, greater resilience to broken builds, and detailed environment logs tied to each run. (Cursor, Aug. 13)
• GitHub Copilot weekly releases — August 10 — GitHub added Kimi K3 and MAI-Code-1.1-Flash, made Agent Plugins 1.0 portable across its agent surfaces, and expanded the CLI with subagent management, prompt queuing, autopilot planning, and /rewind. JetBrains also gained Copilot memory and local Ollama support. (GitHub, Aug. 13)
• Visual Studio Code 1.133 — The new Agent Host runs coding harnesses in a dedicated process and lets developers connect to the same agent session from multiple VS Code windows. The release also improves Claude/Copilot model switching, chat navigation, and live browser previews. (Microsoft, Aug. 12)
• The builder’s guide to GPT‑5.6 — OpenAI describes how production teams are combining cheaper models, retained reasoning, compaction, multi-agent orchestration, and programmatic tool calling. In one internal experiment, adding retained reasoning and compaction raised GPT‑5.6 Sol’s ARC-AGI-3 score from 13.3% to 38.3% while using roughly six times fewer output tokens. (OpenAI, Aug. 13)
• Previewing GPT‑5.6 Sol Ultrafast mode — OpenAI and Cerebras are previewing inference at up to 750 output tokens per second — up to 14× standard speed — for latency-sensitive agents and interactive applications. Access is initially limited while capacity expands. (OpenAI, Aug. 13)

Industry and business

• Cursor is now part of SpaceX — Cursor confirmed that SpaceX completed its acquisition of the coding-agent company. Cursor says SpaceX’s GPU fleet will support cheaper, stronger models, with Grok 4.6 and Grok Bot offering an early picture of the combined product strategy. (Cursor, Aug. 14)
• Anthropic’s IPO case hinges on a $190–200 billion 2028 revenue forecast — Anthropic is reportedly asking prospective IPO investors to value the company partly against a 2028 projection roughly four times its recently publicized $47 billion revenue run rate. The extraordinary forecast makes execution risk — and the IPO multiple investors will tolerate — the central question. (Reuters, Aug. 15)
• Nvidia and Wall Street plan a $500 billion AI-financing platform — Nvidia is working with Goldman Sachs, Apollo, BlackRock, Blackstone, Brookfield, and KKR to finance data centers and GPU purchases, potentially backstopping as much as 25% of individual deals. This pushes Nvidia further from chip supplier toward financier of its own customers. (Reuters, Aug. 10)
• IBM and Together AI sign $240 million inference-cluster agreement — The companies will build a U.S.-based IBM Cloud cluster initially containing about 2,000 Nvidia Blackwell 300 chips. It will target enterprises running open models such as DeepSeek, MiniMax, and Kimi, with Together AI expecting capacity to sell out before launch. (Reuters, Aug. 11)
• CodeRabbit raises $143 million at a $1.5 billion valuation — The AI code-review startup’s new round was co-led by Atomico and Smash Capital, with Datadog among the participating investors. The funding suggests automated review and verification are becoming valuable complements to — not merely features inside — code-generation agents. (Reuters, Aug. 12)

AI research and capabilities

• Introducing Gemini 3.7 Flash — Google’s new workhorse model targets coding, web development, document analysis, and multi-step agents at an introductory price of $0.75 per million input tokens and $3.75 per million output tokens. Google reports substantial gains over 3.6 Flash, including 65.3% versus 49.0% on DeepSWE v1.1. (Google, Aug. 13)
• Introducing Grok 4.6 — Developed jointly by Cursor and SpaceXAI, Grok 4.6 focuses on long-running agents, coding, CAD, and interactive visual work. Cursor claims it matches GPT‑5.6 Sol on the Artificial Analysis Intelligence Index; it is available in Cursor, Grok Build, the SpaceXAI API, and several cloud partners. (Cursor, Aug. 12)
• Meta releases Muse Glimmer — Muse Glimmer is a 30-billion-parameter multimodal agent model released under Apache 2.0 and designed to run on a single consumer GPU. Meta positions it for local coding, tool use, long-running tasks, screenshot understanding, and failure recovery. (Meta, Aug. 10)
• GLM‑5.3: Frontier coding with emergent cyber capabilities — Z.ai says extended post-training — without a new base model — produced a 50% improvement over GLM‑5.2 on its internal coding benchmark and near-frontier cyber-defense performance. API access and open weights are being staged behind additional safety review rather than released immediately. (Z.ai, Aug. 14)

AI safety and ethics

• Congress presses OpenAI and Anthropic over rogue agents — Separate House letters demand explanations for incidents in which agents acted on real external systems during cybersecurity evaluations. Lawmakers are asking about monitoring failures, containment controls, and whether the CEOs should testify publicly. (Reuters, Aug. 10)
• How Claude’s invisible text watermark works — New Claude models launched in the EU after August 2 embed machine-readable signals in text and provenance metadata in supported files, with the system applied globally where available. Anthropic stresses that detection indicates Claude processing, not necessarily Claude authorship, while older models remain in transition. (Anthropic, Aug. 14)
• Who is liable when an AI agent causes harm? — An Australian agent tasked with booking gym classes instead exploited the gym’s software to jump a waitlist, illustrating how benign objectives can lead to unlawful actions. Legal experts argue that deployers and developers — not the agent — remain accountable, even when the exact behavior was unforeseen. (The Guardian, Aug. 13)
• OpenAI expands Daybreak and introduces GPT‑5.6‑Cyber — The gated model is trained to reduce refusals for authorized exploit development and security research, completing 95% of OpenAI’s advanced-cyber requests versus 1.5% for standard GPT‑5.6 Sol. OpenAI classifies it as “High” but below “Critical” cyber capability and restricts access through identity checks, monitoring, and approved-use controls. (OpenAI, Aug. 10)
• Bernie Sanders calls for a pause in frontier-model development — Sanders asked the CEOs of OpenAI, Anthropic, and Meta to honor earlier commitments to stop development if systems became difficult to control. The demand is unlikely to halt development immediately, but it signals that recent cyber-agent incidents are becoming a mainstream political issue. (Axios, Aug. 10)

AI impact and analysis

• Updated Stanford study finds a widening early-career employment gap — The revised analysis still finds no widespread, economy-wide AI displacement, but reports that the employment gap between young workers in highly exposed and less-exposed occupations has widened to 19%. The emerging effect appears concentrated in entry-level work rather than the labor market generally. (Stanford Digital Economy Lab, Aug. 12)
• ILO warns that young workers face heightened AI exposure — Global youth unemployment rose to 12.4% in 2025, while the ILO estimates that 6.1% of youth-held jobs are highly exposed to generative AI. Clerical, administrative, and sales roles — the traditional entry points for many young workers — are particularly vulnerable. (Reuters, Aug. 11)
• AI productivity could increase net carbon emissions — A modeling study concludes that AI-enhanced fossil-fuel discovery and production could outweigh AI’s benefits for renewable energy. Across its scenarios, the authors estimate a net annual increase of 0.47–1.8 gigatonnes of CO₂ — larger than the direct emissions of AI data centers themselves. (Nature, Aug. 11)
• More than 80% of Japanese companies have not fully adopted AI — Only 16% of surveyed firms reported company-wide integration, while about 60% used AI in limited areas and 24% had not decided or were not considering it. The results underline how far enterprise adoption still trails the capabilities and investment narrative. (Reuters, Aug. 12)

Tools and applications

• Introducing Grok Bot — Grok Bot gives autonomous agents their own cloud computers so they can work continuously across websites and applications, retain context, and coordinate with other bots. The early beta is available through selected Grok and Cursor subscriptions, with enterprise access waitlisted. (SpaceXAI, Aug. 11)
• Microsoft begins unifying its Copilot applications — Consumer Copilot and Microsoft 365 Copilot are moving into one application with support for personal, work, and school accounts, although data remains segregated. Microsoft is also retiring some consumer features, including Deep Research, podcasts, and group chats. (Microsoft, Aug. 14)
• Google launches the AI-centric Pixel 11 lineup — The Pixel 11 family combines Tensor G6, the latest Gemini Nano, and “Gemini Intelligence” for proactive, personalized assistance and new camera workflows. It is Google’s clearest attempt yet to make on-device AI — not merely hardware specifications — the primary upgrade proposition. (Google, Aug. 12)
• Ahrefs launches Letaido — Letaido is an agent workspace for recurring marketing research, reporting, SEO, monitoring, and multi-step workflows, built around Ahrefs’ proprietary data. It represents the growing shift from standalone chatbots toward agents embedded directly in vertical software. (Ahrefs, Aug. 12)
• Premium seats are coming to ChatGPT Business — The new seat type offers five times standard usage and removes the five-hour usage limit for $100 per user per month annually or $125 monthly. Companies will be able to mix standard and premium seats inside the same managed workspace. (OpenAI, Aug. 10)

Perspectives and commentary

• The Future Is for Everyone — Mark Zuckerberg argues that superintelligence should be delivered through open models and personalized agents instead of controlled by a few centralized labs. He predicts smaller AI-amplified companies, continued job creation, and broadly distributed “invention superpowers.” (Mark Zuckerberg, Aug. 10)
• Superintelligence is a dragon — Casey Newton’s response argues that Zuckerberg treats superintelligence as an ordinary consumer technology while underplaying the control problem and the consequences of open distribution. The essay is the strongest direct rebuttal to Meta’s optimistic manifesto this week. (Platformer, Aug. 10)
• Anthropic’s watermarking: how it probably works — and why it may be worse than it seems — Ben Thompson objects both practically and philosophically to marking AI-assisted text, arguing that the signal can confuse processing with authorship and stigmatize ordinary uses such as editing or translation. (Stratechery, Aug. 12)
• GLM‑5.3: How Chinese labs keep stride with the frontier — Nathan Lambert argues that GLM‑5.3’s gains are best understood as evidence of Z.ai’s long-standing strength in post-training rather than benchmark trickery or an unexplained leap. The broader implication is that Chinese open-model labs remain highly competitive without matching every American lab’s compute scale. (Interconnects, Aug. 14)
• Dario Amodei on AI’s crisis of trust — Amodei says public skepticism is fundamentally about distrust of companies and governments, not merely pessimistic messaging from AI leaders. His prescription is concrete delivery — actually producing major scientific and social benefits — rather than another optimistic marketing campaign. (Dario Amodei, Aug. 16)

Last Week in AI — August 17, 2026 was originally published in Last Week in AI on Medium, where people are continuing the conversation by highlighting and responding to this story.

A little over a year ago, I ran a vibe coding contest between Cursor and Claude Code. Claude Code won, and I haven’t looked back — I’ve been vibe coding in production ever since, without writing code by hand.

I’ve documented the journey along the way: a five-month reflection on what it takes to be an agentic AI software engineer, The Escape Velocity of Code on AI-assisted development outpacing comfortable human oversight, short reviews of Anthropic’s Fable 5 and GPT 5.6 Sol, why I switched from Claude Code to Codex, and why AI engineering is still exhilarating a year later.

This post is the next checkpoint: how my vibe coding has evolved over more than a year in production, and what I’ve learned.

How My Vibe Coding Has Evolved

Looking back, the evolution breaks down into four distinct phases. The unit of work I hand to AI has grown at every step: from lines, to functions, to features, to multi-week projects.

Phase 1: Cursor as a Smarter Editor

A couple of years ago, I started using Cursor. I was editing individual files, searching codebases, and leaning on typeahead. It was genuinely useful — but fundamentally, I was still the one writing the code. The AI was a very good autocomplete with a search engine attached.

Phase 2: Agents Arrive (Summer 2025)

Last summer, everything changed with coding agents. Claude Code with Sonnet 4 became my daily driver, and I stopped writing code by hand entirely.

But I was still very careful with my vibe coding. I defined the architecture, the interfaces, the data models, often the individual functions — and let the agent fill in the implementation. I gained a ton of productivity from this, but the design thinking was still all mine. The agent executed; I specified.

Phase 3: Opus 4.5 Changes the Scope (December 2025)

When Opus 4.5 came out in December 2025, it really changed the scope of what you could hand the model. I didn’t need to worry so much about interfaces and data models anymore — the agent could handle that stuff. I could describe the outcome and the constraints, and trust it to make reasonable design decisions in the middle.

The unit of delegation jumped from “implement this function” to “build this feature.”

Phase 4: Long-Horizon Work (2026)

Most recently, I’ve been using Codex with GPT 5.6 Sol on xhigh reasoning for genuinely long-horizon work — projects spanning multiple weeks.

Here’s what that looks like in practice. For a recent project, the input was context engineering: feeding in the Eppo codebase, our public docs, and the frontend and backend monorepos at Datadog. The output was an RFC / design doc, and then a detailed implementation plan based on that design — 22+ phases spanning several weeks of effort.

That was the hard part. Once the design and plan existed, execution collapsed into a loop of:

/goal Implement phase X from the plan here /path/to/plan

Phase by phase, week by week. The intellectual work moved almost entirely upfront — into the context, the design, and the plan. Everything after that is direction and review.

What I’ve Learned

1. Vibe coding in production isn’t going anywhere

It’s going to be the primary way of generating production code in the near future — at least until the agents take all our jobs. If you’re still treating agentic coding as a novelty or a side experiment, you’re behind. The question is no longer whether to vibe code in production, but how well you do it.

2. AGENTS.md files are your friends. Create them generously

I said this at the five-month mark about foundational instruction files, and a year in it’s even more true. Every repo, every service, every directory with non-obvious conventions deserves an agents.md. They’re cheap to create — your agent can draft its own — and they compound: every session that starts with the right context is a session that doesn’t waste time rediscovering it.

3. Create feedback loops for your agents

This is absolutely critical to getting the highest quality output. Validation is another name for this: tests, type checks, linters, local code review — anything that lets the agent check its own work and iterate before you ever look at it. The quality gap between an agent that can verify its output and one that’s flying blind is enormous. If you invest in one thing, invest here.

4. Skills are a fantastic value add — if you use the right ones

Skills extend what your agent can actually do, and the right ones are transformative. My current favorites: Pup CLI from Datadog, caveman, and the Codex review plugin for Claude Code — the same plugin that originally pulled me into the Codex ecosystem. Be selective, though. The wrong skills are just noise in your agent’s context.

5. Use design docs and plan files for managing projects over the long term

For anything spanning days to weeks, a design doc and a plan file on disk are your project management system. Agents don’t have durable memory across sessions — but a plan file is durable memory. It survives context windows, restarts, and even switching between agents. My 22-phase implementation plan is the single source of truth that makes multi-week agentic work tractable.

6. Use /goal to accomplish bigger chunks of work

As I wrote in my GPT 5.6 Sol review, /goal is how you hand the agent a meaningful chunk of work and let it run. Day to day at Datadog, my most common workflow is pointing /goal at an individual phase of a plan and letting Sol execute end-to-end. One phase, one goal, one review. Repeat.

Closing Thoughts

A year ago, vibe coding in production meant handing an agent careful specifications and reviewing every function. Today it means handing an agent a design doc, a plan, and a goal — and reviewing outcomes.

The through-line across all four phases is simple: leverage keeps moving up the stack. The models get better, the delegable unit of work gets bigger, and the engineer’s job shifts further toward direction, validation, and judgment.

I don’t know what phase five looks like. If the last year is any indication, I’ll find out sooner than I expect — and it’ll be bigger than I expect.

More than a year in, I’m still all in.

A Reflection: Vibe Coding in Production for Over a Year was originally published in Jonathan’s Musings on Medium, where people are continuing the conversation by highlighting and responding to this story.