CYBERCAESAR

The thing to watch this week isn't whose model topped a few more benchmarks. It's who got their name engraved on the electricity meter.

Models are turning into power plants: several companies can generate the electricity. The one that reliably makes money is whoever stands at the door reading the meter and collecting rent. Look back at the week through that lens and a few unrelated-looking events turn out to be the same story.

OpenAI Dots

At DevDay on September 29, OpenAI launched Dots, an always-on AI assistant. The live demo fell over. More awkward still, an "always-on assistant" isn't even a new idea: Grok, Meta's Muse, and a mainland Chinese product with the same name all got there first.

A few years ago OpenAI was the one defining the race. Now it's walking a road others have already paved.

What it really cared about this time was pricing: a new $500/month Pro 500 tier. The product is a follow-up; the pricing is aggressive. OpenAI knows exactly what it's doing. It doesn't matter who built the assistant first. What matters is which app you open first when you wake up, and who auto-charges you every month. An always-on assistant is really a permanent front door that stays open in your life 24 hours a day. Once you own the front door, collecting rent comes naturally.

It reminds me of an old rule in the brokerage business: it's fine to cut commissions to the floor, as long as the account is opened with you. The margin lending, wealth products and premium services that follow are all yours. Opening the account is the business; trading is just the excuse. Dots is OpenAI opening accounts.

Gemini 4 Argon

The next day, September 30, Google released Gemini 4 Argon. The report card looks great: first place on 13 of 18 benchmarks. Look closer and it dominates knowledge work, while coding is uneven.

What I care about more is how it shipped. With a model this strong, Google didn't push it to everyone at once. It opened access to cybersecurity defenders first, and 3.5 Pro was effectively retired.

At this level of capability, "the strongest" is no longer a reason to launch; it's a risk to be contained. Giving it to defenders first means building the wall before opening the gate. Safety is no longer a patch applied after launch. It is the launch strategy.

Developers should remember the uneven coding results: topping a leaderboard doesn't mean it's best at the job in front of you. Pick a model by testing it on your own tasks.

Even a 13-out-of-18 model didn't generate as much discussion this week as the next item.

Google kills Gems and backs open Skills

To me, this is the most important story of the week.

Google shut down its own Gems and switched to open Skills, using Anthropic's format no less. On the question of "how you teach AI to do work", Google surrendered to Anthropic.

Holding a model that just won 13 benchmarks, it still chose to follow someone else on workflow format. That tells you Google ran the numbers: you can train a model yourself, but developers have already written piles of skills and built piles of workflows in a given format. Start your own, and you have to beg everyone to rewrite them.

The moat is moving. It used to be the model itself: highest score wins. Now the moat is the set of rules for how AI does work: how a skill is described, invoked and combined. Whoever sets those rules is like the companies that once set file formats and interface standards. Latecomers, however strong, can only be compatible with them.

Anthropic played this beautifully. It may not win every benchmark, but it got its biggest rival to adopt its format.

People who write code feel this most directly. I saw it while building wps-agent-skills: swapping models is routine, but once the way you write skills settles in, that's the asset that can't be moved.

ChatGPT personal finance opens to all US users

ChatGPT's personal finance features are now open to every tier in the US. Checking your accounts has moved from the banking app into a chat box.

I spent three years at a brokerage, so this move jumps out at me. The most valuable thing in finance has never been any particular product; it's where the customer sees their money. Whichever app you check your balance in every day is closest to your next decision. That seat used to belong to banks, brokers and budgeting apps. Now OpenAI wants it.

First it's checking balances. Anyone in the industry knows what comes next. Once you're used to asking the chat box "did I overspend this month?", the next line, "then move a bit over to…", is only a matter of time. Every tier gets it, even free users. OpenAI wants to be the front door to your money.

Put this next to Dots and it gets clearer: one watches your life, the other watches your wallet. Both legs are walking toward collecting rent.

How to read this week

Models are still improving, and fast; Argon is proof. But put these events together and they point to one conclusion: model strength is becoming the price of admission, and the deciding game is being played elsewhere.

OpenAI is grabbing front doors; a follow-up product is fine as long as the monthly fee is in place. Google has the strongest model but bowed on the rules. Anthropic may not have the top score, yet it got its rival to use its format.

It reminds me of a habit from looking at brokerage stocks: I don't focus much on how big trading volume was this quarter. I first check how many new accounts were opened and how much assets per account grew. Volume is temporary; accounts last.

Measure AI companies with that ruler and the question changes. It's no longer whose model ranks where, but how many people open it first thing every morning, how many people's money, files and workflows have grown into it, and how much effort it would take to move out.

The big companies report Q3 results at the end of this month. I'll look at paid users and subscription revenue first, and only then turn to the page about models.

This earnings season taught me one thing: pricing power over AI stocks has passed from launch events back to orders and cash flow.

A flashier launch no longer buys a rally automatically. Only companies that can show signed orders and margins you can actually calculate get to set their own price.

The day Alphabet released Gemini 4, the stock fell. Two years ago a flagship model launch was practically a guaranteed green candle; everyone rushed to tell stories and size the upside. Now, after the demo, the market is asking a different question: how much did this cost to train, when does it become revenue, and whose revenue?

Micron's Q4 revenue was $54.2 billion, up 379% year over year, with EPS of 33.42 and an 87% gross margin. In my three years at a brokerage I read plenty of memory-chip financials. The industry has always been deeply cyclical, a fight over capacity and price: margins spike at the top of the cycle and get smashed back down in the downturn. What does 87% mean? That no longer looks like selling a commodity. It looks like selling something scarce.

Gross margin is the first thing I look at in a report. Revenue can grow by pushing volume, cutting prices to win share, or stacking up acquisitions. Gross margin rises for basically one reason: buyers can't do without you.

What really made me sit up were the next two items: next-quarter guidance of $61.5 billion, above expectations, and $32 billion in supply commitments, plus management saying capacity will stay tight through 2028.

Guidance is a number management backs with its own credibility. Guide too high, miss next quarter, and the stock gets punished twice as hard, so guidance above expectations usually means the order book they can see is thick. Supply commitments are even harder: they're long-term supply agreements. When buyers are willing to lock in volume ahead of time, what they fear isn't paying too much; it's not getting supply at all. As for "tight capacity through 2028", in plain language: for the next two or three years, sellers set the price. That's what I mean by "orders". Not the addressable market on a roadshow slide, but customers who have already placed orders, or are lining up to.

Micron's stock ran to 1,100 and then pulled back. Some will say the good news was priced in, and that's one explanation. I'd rather see it this way: orders and cash flow taking back pricing power doesn't mean they only price upward. What they provide is an anchor. Near the anchor, when expectations are maxed out, people still take profits. The real problem of the launch-event era was the lack of an anchor: valuations floated as high as the story was big. Now at least there's something to calculate with.

Nike's Q1 FY2027 numbers would look ugly in any stock screener: Greater China down 26%. But a good chunk of that decline was self-inflicted. It deliberately tightened supply of hits like Dunk and Jordan. I call it a "self-destructive rebuild". Sell too many of a hit and it loses value; when it's everywhere, the brand premium is gone. Nike chose to trade short-term revenue for brand scarcity.

It has nothing to do with AI, but it answers a question no earnings season can avoid: what kind of bad numbers will the market actually pay for?

My view: bad numbers with a clear cause, ones that ultimately point to margins and cash flow, can be priced. If Nike's revenue decline buys fewer discounts and higher margins, it has simply moved money from this year into the next few, and the math works. Flip it around: an AI company with soaring revenue whose margins are eaten by compute costs and whose operating cash flow stays negative year after year has "good numbers" that don't hold up.

Micron is at the top of its cycle and Nike is deliberately finding a bottom. Opposite positions, same way of reading them: the number itself matters less than where it leads.

Here's roughly how I take apart a report now. Revenue growth is just the ticket in; right after, I ask whether the growth came from volume or from price. Gross margin answers that for you. Guidance matters more than the quarter's numbers, because the stock trades the future, and a number management stakes its credibility on says more than the assumptions in a sell-side model. Then I dig into anything binding: supply commitments, backlog, customer prepayments. That's the most honest evidence of demand. Saying you're bullish costs nothing; signing a contract costs money. Cash flow is the final check. Profit can be adjusted through accounting choices; whether cash actually came in is hard to fake.

For companies with falling revenue I run the same process and add one question: was the decline forced on them, or chosen? If chosen, did it buy better margins?

On September 30 the Nasdaq jumped 280 points, with all five big tech names up. On October 3 payrolls came in shockingly weak at just 29,000, and the Nasdaq hit a new high of 27,192 anyway. Weak jobs raise rate-cut expectations, funding costs fall, and growth-stock valuations get a floor. "Bad news is good news" is exactly the logic of this rate-cut trade.

But the rate-cut trade is the water level, and a rising tide lifts all boats. That's exactly why earnings season matters more: it's when you find out which boats have a hull and which are just being held up by the water.

Lately I write duetfolio (a portfolio tracker for US and Hong Kong stocks) during the day, and at night I switch to earnings reports, paging through to find which footnote the supply commitments and customer prepayments are hiding in.

This is just how I read things, not investment advice.

My most valuable coding habit has nothing to do with which framework I know well. It's a reflex drilled into me during my years at a brokerage: before spending money, ask whether it will come back.

That sounds obvious. But I've watched plenty of developer friends trip over it, including myself when I started building independent projects, and the falls looked respectable: beautiful code, clean architecture, neat tests. Nobody used it.

Back then I got hooked on one feature. I won't say what it was; it was one of those "users definitely need this" things. I spent nearly two weeks on it, rebuilt the data structures twice, polished the interaction down to every button animation, and felt pretty proud on launch day. Then I watched the dashboard for a week. Almost nobody clicked.

It felt less like disappointment and more like books that won't balance at month end. At the brokerage, any project going to committee had the same first page: how big is the market, who pays, why us, how long to break even. Nobody approved money because a model looked pretty. Yet when it came to my own code, I skipped that page entirely, because coding is so much fun it makes you forget it's an investment too.

Development costs are easy to underestimate because they never hit the books. Spend two weeks on a feature and your bank balance doesn't drop a cent, so it doesn't hurt. But time is the principal.

Since then I've had a slightly old-fashioned rule: before any build longer than three days, write a one-page "project memo". Nothing formal, just a few questions: who will use it, how they get by today, why they'd switch to mine, and how I know they really want it. That last one is the toughest, because "I think so" doesn't count as an answer.

In finance, "how do I know they really want it" is called due diligence. You can't judge from management's story; you look at cash flow, customers, channels. For indie development, due diligence is actually simple: go where users hang out and see what they complain about, post a question, put up a one-screen landing page and see if anyone leaves an email, or just do the job by hand for a few people the clumsy way and see whether they come back.

That's how duetfolio started. I hold both US and Hong Kong stocks: two markets, two currencies, offset trading hours. Existing tools always felt a bit off, so I tracked things myself the clumsy way first. I got by like that for a long while, and only after confirming the friction showed up every day, not on a whim, did I seriously build it into a product. When I started, I was confident, because the need wasn't something I'd imagined sitting at my desk.

It's the same as doing research. A good investment thesis is rarely derived behind closed doors. Usually you spot a gap between price and value somewhere, then go verify it. Building products works the same way.

What the engineering half gave me matters just as much, and it's something finance never could. Finance people share a common flaw: deep analysis, little doing. I could write dozens of pages of industry research with crystal-clear conclusions, but I had never built a single thing for anyone to use.

The engineering idea I've gained most from is "small steps, fast, always able to roll back". At a brokerage a wrong call is expensive, so people are used to thinking it through before moving. Software is different: you can push the cost of trial and error very low. Take an idea, have a working version in half a day, ship it, see the feedback, delete it if it doesn't work. It's really finance's "limit the downside" taken to the extreme: many small bets, capped losses, uncapped upside.

The two sides keep pulling on each other. The finance half hits the brakes and asks whether it's worth it; the engineering half hits the gas and says build the smallest version and try.

My habit now goes roughly like this. When an idea pops up, I run it through the finance brain first: will anyone pay for it with money or time, can I reach those people, what's the opportunity cost? If it passes, I switch to the engineering brain: what's the smallest version that tests the demand, can I finish it in a weekend, what can I hard-code, do by hand, or leave unoptimized for now?

Since AI arrived, this accounting matters even more. Coding used to be slow, and slowness itself was a filter: things you couldn't be bothered to build simply didn't get built. Now AI can put together a complete-looking app in an afternoon, and building has almost no barrier. Without the barrier, the temptation to build for the sake of building grows. I went through a stretch of starting a new project every few days. Every one of them ran, none of them had users, and my repo list kept growing, like a retail investor who buys a pile of stocks and never looks at the fundamentals.

That period made me rethink my own motto: "Leave repetition to machines, keep the time for yourself." I used to read it wrong, thinking the point was to make machines do more work. The point is actually the second half: the time is yours, so every piece of it should go somewhere worthwhile. AI has driven down the cost of writing code. If the time it saves goes into building wheels nobody wants, you've lost the savings right back.

These days I start projects a little more slowly, but I abandon far fewer. wps-agent-skills and muse-file-bridge followed the same path: the same annoyance bugged me many times in my daily routine, and only once I was sure it would keep coming back did I start building. renqing-ledger solves a small problem, but small is fine. What matters is that I know someone needs it.

Whenever I'm about to stay up late building a feature "everyone will definitely need", I stop for half an hour and write that one-page project memo in my notes app. If the "how do I know they really want it" line is still blank, I close the laptop.