Tag: Claude Code

Categories
AI Books Writing

The Tax We No Longer Have to Pay

When Carol Coye Benson and I sat down to write Payments Systems in the U.S., one of the first problems we had to solve wasn’t about payments. It was about history.

To understand why the ACH network works the way it does, or why checks persisted decades longer than anyone expected, you need the institutional sediment underneath — the regulatory decisions, the failed experiments, the path dependencies baked in by choices made in the 1970s that nobody thought would still matter in the 2000s. The history is the explanation. Strip it out and you have a description of current practice with no account of why it exists or what it cost to get there.

But history takes pages. And pages test a reader’s patience. So you compress. You make judgment calls about what survives the cut and what gets left behind, and you make those calls knowing that every omission is a bet — a bet that the reader can follow without it, that the thread holds without that particular knot.

Writing it taught me something. The act of compressing, of finding the minimum sufficient version of a complex thing, forces a clarity that living inside the complexity never quite delivers. You don’t fully know what you understand until you have to say it precisely enough for someone else to follow.

But compression is always a loss. You feel it as you write. The version in the book is thinner than the thing you know.

Garry Tan uses a term — “tokenmaxxing” — that initially sounds like jargon from a performance optimization thread. The idea is simple: don’t be stingy with context. Give the model everything. Every source document, every relevant article, every piece of background that a human reader would never sit still for. Let it synthesize rather than guess.

The instinct it runs against is deep. We have spent decades building information systems around compression — search engines that retrieve rather than ingest, executive summaries that stand in for reports, one-pagers that distill months of work into something a decision-maker can absorb in four minutes. All of it was a rational response to a real constraint: human attention is finite and expensive. You couldn’t afford to read everything, so you built filters. The whole architecture of how organizations manage information was designed around that limit.

Tokenmaxxing is a bet that the limit has moved.

The model can read everything. The cost of giving it full context — the uncompressed history, the original sources, the institutional sediment — is low enough now that filtering before the model sees it may introduce more error than it prevents. You’re potentially discarding signal when you summarize for the model the way you’d summarize for a human. The model doesn’t need the one-pager. It can handle the report.

This doesn’t dissolve the need for curation entirely. More context isn’t always better — models can lose the thread in noise the same way humans do, just differently. The skill shifts from summarizing to selecting: not what’s the minimum version of this but what’s actually worth including. Different judgment, still essential.

But the deeper change is upstream of any particular project. The compression we built into every research process, every briefing, every book — that was never the goal. It was the tax we paid for human cognitive limits. Part of the process doesn’t pay that tax anymore.

When I think about writing that payments book today, I don’t think the book itself would change much — it still has human readers with finite patience. But the map we drew before writing it, the synthesis work, the “what connects to what across fifty years of regulatory history” work — that could happen at a different depth now. The understanding you bring to the writing can be informed by everything, not just the subset you had time to read.

The payments book was written entirely for humans, with all the compression that implies. But Tyler Cowen just published what he calls a “generative book” — 40,000 words released free online, paired on the same screen with a Claude interface so readers can discuss, interrogate, and extend it in real time. He’s writing for both audiences simultaneously now. The human reader and the model that will help that reader go deeper. The text is optimized not just to be understood but to be used — as context, as a jumping-off point, as raw material for a conversation that the author won’t be in.

That’s a different kind of writing. Not better or worse. Different. The compression decisions change when one of your readers has no patience to protect.

Writing still clarifies thinking. That part hasn’t changed. But what you’re clarifying, and who you’re clarifying it for, is quietly expanding.

Categories
AI Programming Software Work

The Scarcest Thing

Garry Tan woke up at 8 a.m. after sleeping at 4. Not because he had to. Because he wanted to see what his workers had done overnight.

The workers are AI agents. Ten of them, running in parallel across three projects. And something about that sentence — wanted to see what they’d done — keeps stopping me. That’s not the language of someone using a tool. That’s the language of someone managing a team.

Tan gave a name to the state this puts him in: “cyber psychosis.” He said it as a joke. But the joke has an insight in it. He’s not describing addiction to a productivity app. He’s describing a shift in what it means to do creative work — the strange vertigo of becoming a director when you’d always been a laborer.

I’m retired. I watch this from the outside now, which is its own kind of vantage point. For most of my career, the path from idea to working product ran through people — through hiring and managing and the slow accretion of execution capacity. You had the vision or you didn’t, but either way you needed the team. The idea and the means of making it real were, structurally, separate things. The gap between them was where companies lived.

What Tan is describing is that gap closing.

The thing he built — gstack, his open-sourced Claude Code configuration — got dismissed in some quarters as “just prompts.” And it is just prompts, in the same way that a conductor’s score is just notation. The abstraction is the invention. What he encoded is a model of how a startup team thinks: the CEO who interrogates the why before a line of code gets written, the engineer who builds, the paranoid staff reviewer who looks for what breaks. Each role blocks a different failure mode. Blurring them together produces, as his documentation puts it, “a mediocre blend of all four.”

That’s an organizational insight. It has nothing to do with code.

Tan described being a “time billionaire” — not because his biological clock had slowed, but because he can now purchase machine-consciousness-hours. The bottleneck of implementation, which has governed every creative project since the beginning of creative projects, is dissolving for those who know how to direct.

The scarcest thing is shifting. It’s no longer the hours of execution. It’s the clarity of intent — knowing what you want to build and why the journey matters, before any of the workers start moving. That’s harder than it sounds. For decades, most of us could muddle through in the making of it. The act of building taught you what you were building. Now the making is cheap, and that shortcut is gone.

For someone watching from retirement, that’s not a small thing to absorb. The model I internalized over a long career — that ideas become real through sustained organizational effort, through teams and timelines and the grinding work of execution — is being revised faster than I expected. Not invalidated. Revised. The judgment still matters. The taste still matters. The why matters more than ever.

It’s just that the how has found new hands. Many of them. More than any team I ever assembled, available the moment the intent is clear enough to direct them, gone when the work is done. The constraint was always the hands. It turns out it was always the knowing.

Categories
AI AI: Large Language Models Anthropic

Breakout

Jack Clark doesn’t panic easily. He spent years at OpenAI watching capabilities inch upward, then left to co-found Anthropic, and has been writing his Import AI newsletter long enough to have developed — and been wrong about — many priors. So when he publishes an essay saying he has reluctantly arrived at a 60% probability that fully automated AI R&D happens by the end of 2028, the word “reluctantly” deserves some weight.

His essay, published last week and titled “Automating AI Research,” isn’t a press release or a fundraising pitch. It reads more like a man thinking out loud at the edge of something large. “I don’t know how to wrap my head around it,” he writes, which is a notable thing to say publicly when you are one of the architects of the thing you can’t wrap your head around.

The argument is built from benchmarks — not any single one, but a mosaic of them assembled to reveal a trend. SWE-Bench, the test that measures an AI’s ability to solve real GitHub issues, was at roughly 2% when it launched in late 2023. A recent Anthropic model sits at 93.9%, effectively saturating it. METR’s time-horizon plot tracks how long an AI can work independently before needing human recalibration: 30 seconds in 2022, 4 minutes in 2023, 40 minutes in 2024, 6 hours in 2025, 12 hours today. The trajectory, if it holds, suggests 100-hour autonomous work sessions by the end of this year.

Clark marshals similar progressions across AI fine-tuning, kernel design, scientific paper replication, and even alignment research itself. His throughline is the same in each: AI is now genuinely competent at the unglamorous scaffolding of AI development — the debugging, the experiment runs, the parameter sweeps, the code reviews. And crucially, it can now do these things not just faster than humans, but for longer, with less supervision.

There’s a Thomas Edison quote at the center of the essay: “Genius is 1% inspiration and 99% perspiration.” Clark’s claim is that AI has become very good at the perspiration. The question of whether it can supply the inspiration — the paradigm-shifting insight, the Move 37 — remains open. But he argues it may not need to. Most of what has moved the AI field forward has been sustained, methodical work, not lone flashes of genius. If you can automate the 99%, you have something that compounds.

There’s a data point that makes Clark’s argument feel less like forecast and more like dispatch. Last month Boris Cherny, who runs Anthropic’s Claude Code, disclosed that he hasn’t written a line of code by hand in more than two months. Every pull request — 22 one day, 27 the next — written entirely by Claude. Company-wide, roughly 70–90% of Anthropic’s code is now AI-generated. Anthropic’s stated position: “We build Claude with Claude.” The loop Clark is describing as a probability by 2028 is already running, at least partially, today.

The word Clark uses for the threshold he’s describing is not “singularity” or “AGI.” It’s quieter than that. He calls it “automated AI R&D” — the point at which a frontier model can autonomously train its own successor. It’s a specific, falsifiable thing. And he puts a number on it: 60% by end of 2028, 30% by end of 2027.

I’ve been writing about the dark software factory and the 3D printer that prints better printers, finding metaphors for what seems like an inexorable process. Clark’s essay is a different kind of writing about the same thing — the primary source document, the engineer’s log, the inventory of evidence. Reading it is a little like watching someone carefully pack boxes before a move. Each individual item seems manageable. But there are a lot of boxes.

What he’s describing — if the trend holds — is not a feature or a product launch. It’s a breakout. The moment the loop closes and the system starts building itself. He’s not certain it happens. He just thinks it’s more likely than not, and he thought you should know.

Categories
AI Programming Prompt Engineering Software Work

The Great Inversion

For twenty years, the “Developer Experience” was a war against distraction. We treated the engineer’s focus like a fragile glass sculpture. The goal was simple: maximize the number of minutes a human spent with their fingers on a keyboard.

But as Michael Bloch (@michaelxbloch) recently pointed out, that playbook is officially obsolete.

Bloch shared a story of a startup that reached a breaking point. With the introduction of Claude Code, their old way of working broke. They realized that when the machine can write code faster than a human can think it, the bottleneck is no longer “typing speed.” The bottleneck is clarity of intent.

They called a war room and emerged with a radical new rule: No coding before 10 AM.

From Peer Programming to Peer Prompting

In the old world, this would be heresy. In the new world, it is the only way to survive. The morning is for what Bloch describes as the “Peer Prompt.” Engineers sit together, not to debug, but to define the objective function.

“Agents, not engineers, now do the work. Engineers make sure the agents can do the work well.” — Michael Bloch

Agent-First Engineering Playbook

What Bloch witnessed is the clearest version of the future of engineering. Here is the core of that “Agent-First” philosophy:

  • Agents Are the Primary User: Every system and naming convention is designed for an AI agent as the primary consumer.
  • Code is Context: We optimize for agent comprehensibility. Code itself is the documentation.
  • Data is the Interface: Clean data artifacts allow agents to compose systems without being told how.
  • Maximize Utilization: The most expensive thing in the system is an agent sitting idle while it waits for a human.

Spec the Outcome, Not the Process

When you shift to an agent-led workflow, you stop writing implementation plans and start writing objective functions.

“Review the output, not the code. Don’t read every line an agent writes. Test code against the objective. If it passes, ship it.” — Michael Bloch

The Six-Month Horizon

Six months from now, there will be two kinds of engineering teams: ones that rebuilt how they work from first principles, and ones still trying to make agents fit into their old playbook.

If you haven’t had your version of the Michael Bloch “war room” yet, have the meeting. Throw out the playbook. Write the new one.

Categories
AI AI: Large Language Models

The Shipping Manifest

“Recursive self-improvement has graduated from a safety paper to a shipping manifest.”

For years, “recursive self-improvement”—the idea of AI building better versions of itself—was a concept relegated to academic safety papers and late-night philosophy forums. It was a theoretical horizon event, something to be modeled, debated, and perhaps feared.

But this morning, the tone shifted. As noted in a briefing this morning from @alexwg, recursive self-improvement has graduated from a safety paper to a shipping manifest.

The evidence is tangible. Anthropic confirmed that their new “Claude Code” wrote the entire Claude Cowork desktop app in a mere week and a half. This isn’t just code completion; it is code creation at a structural level. More importantly, this app grants the AI direct access to the file system. It is no longer trapped in a chat window, floating in the abstract void of the cloud. It has touched down. It can sort downloads, generate reports, and effectively reorganize “local reality.”

Simultaneously, the definition of “colleague” is dissolving. The CEO of McKinsey dropped a quiet bombshell, revealing that the firm now counts AI agents as “people” that the firm “employs.” The current census? 40,000 humans and 20,000 agents. The goal is parity within 18 months.

We are witnessing a fundamental agentic shift. When a consultancy firm—the bastion of human capital and billable hours—begins to view synthetic agents not as tools (CAPEX) but as employees (OPEX), the psychological contract of work changes. We are moving away from a world where we use software to a world where we manage it.

The org chart is no longer a biological tree; it is becoming a hybrid network. The recursive loop isn’t coming; it’s already clocked in.