Past the basics: what comes after adoption

Most orgs we talk to are still in the thick of the basics: getting people to actually use the tools, untangling workflows built for a pre-agent world, winning over the skeptics one at a time. If that's you, you're not behind. That's where most of the industry is, and honestly the basics are most of the game right now.

But a few established players spent this week publishing unusually concrete writeups of what comes next: how to measure AI once token spend has gone vertical, how to build the skills your agents actually run on, and what a data agent slams into the moment you point it at real tables. None of it is the finished version. Nobody has that yet. But if you've cleared the adoption bar, or you just want to see the road a little further out, this week is a good look at the questions waiting on the other side.

Here's what we've been reading this week.

DORA on the era of "tokenmaxxing"

Token bills exploded this year, and it isn't really waste. Harnesses learned that more tool calls and longer autonomous runs produce better work, so spend went vertical right alongside the quality. Uber burned its entire 2026 AI coding budget in four months. The frontier question stopped being should we spend and became what did the spend buy us, and two pieces this week took that question from opposite sides.

DORA's is about "tokenmaxxing": some of the most competitive companies now run internal leaderboards that reward whoever burns the most tokens. DORA's read is that this is lines-of-code with a fresh coat of paint. Roughly 30% of developers still trust AI output "a little or not at all," and rewarding raw consumption just optimizes the one number that's trivial to game. Their fix isn't to spend less; it's to measure cost per accepted change and rework rates, sliced by team and use case, instead of crowning whoever brr'd the most tokens.

Arvind Jain, Glean's CEO, names the metric that's missing: token yield, the useful outcome you get per token rather than the tokens you burn. His sharper point is where those tokens actually come from. Most of them aren't typed by anyone. They're generated by the scaffolding around the task: system prompts, tool schemas, retrieved docs, reasoning traces, memory. So runaway spend is usually an architecture problem, not just a model problem, and the levers that fix it are architectural too: context quality, model routing, reusing prior work instead of re-deriving it, and harness design that scopes context to the step instead of letting it pile up. Same instinct as DORA from the other side. Spend isn't the enemy; unaccountable spend is. If your dashboard tracks consumption and seat count and nothing about what those tokens produced, you're watching the easy number.

Anthropic on how they actually use skills

Anthropic catalogued the skills they run internally and found they cluster into nine categories: library and API reference, product verification, data fetching, business-process automation, code review, CI/CD, runbooks, infra ops, and scaffolding. The finding worth circling: verification skills "have had the most measurable impact on Claude's output quality internally." Their advice is unusually blunt for a company blog: "it can be worth having an engineer spend a week just making your verification skills excellent."

Skills are the operating layer for your agents, the institutional knowledge that turns a general model into one that knows how your stack actually behaves. Deploy Claude Code or anything like it with no skills library and the agent is improvising on everything specific to you. And the highest-return place to start isn't the clever automation. It's giving the agent a reliable way to check its own work before it tells you it's done.

How OpenAI built its data agent

OpenAI's internal data agent reasons over 1.5 exabytes and roughly 90,000 datasets for about 4,000 employees. The surprising part is the agent itself, which they describe as "pretty vanilla." All the intelligence lives in the scaffolding: six layers of context, including past queries ranked by how trustworthy they are, human-written annotations, and table definitions derived straight from the pipeline code. Their bet was infrastructure first (one data lake, clean tables, a rich semantic layer) and a deliberately simple agent on top.

Anthropic shipped their own version the same week and landed somewhere different. They automated 95% of business analytics queries at about 95% accuracy, but without skills their accuracy on evals never cleared 21%. Their conclusion: accuracy is a context and verification problem, not a code-generation one. So they colocated skill docs in the same repo as the data models (a review hook fails any model change that doesn't update its doc), and they watched accuracy drift from 95% to 65% over a month before they started treating it like an engineering problem.

OpenAI bet on clean infrastructure; Anthropic bet on skills and verification to work inside messier reality. Different bets, same root cause: the bottleneck was never the model, it was the data and the context wrapped around it. So before you point an agent at your warehouse, the useful question isn't which model. It's what will this thing immediately run into, and the answer is almost always your data.

Thorsten Ball: Building Software Is Learning

A note Thorsten Ball wrote for the Amp team and published after a friend pushed him to. The argument: building new software is a learning process. You can't fully specify what you want up front, because the act of building is what teaches you what you want. "You will learn what exactly it is that you're building as you're doing it."

It's the foundation under everything above. The reason tight feedback loops matter, the reason verification is the highest-leverage skill, the reason measuring beats predicting: it's all the same wager. The faster you get from "let me try something" to, in his words, "getting your ass whooped by reality," the faster you learn. AI doesn't change that truth. It just compresses the loop. The teams winning right now aren't the ones with the best prompts. They're the ones with the shortest distance to reality.

One thing to try this week

Pick the one thing your agents get wrong most often (the test they skip, the migration they fumble, the API they confidently hallucinate) and write a verification skill for it this week. Just one file so the agent checks that specific thing before it claims it's done.

(If this doesn't apply to you, grab your nearest engineer or engineering leader and do it together!)

Anthropic's whole point is that this is the highest-return skill you can build, and you'll know inside a day whether it moves anything. Ship the small version, watch it fail on something you didn't expect, fix it. That's the loop.

Have fun out there!

— Claire + Zach