Tag: Software Architecture

Categories
AI

The Tempo of the Brake Pedal

Martin Casado said something this week that snapped a few loose thoughts into place. The frontier labs missed Jev, he argued, because they are building beings that speak. Software needed a model that chooses.

That reads like a product distinction. It is really a habit of mind.

For a few years we have taken a machine born in chat — text in, text out — and tried to cram it into ordinary programs. Parse the JSON. Retry when it rambles. Plead with it to stay inside the schema. Hope it does not invent a field. Casado’s word for this was right: janky.

Jev takes the other fork. Don’t generate the paragraph. Give the model a state and a menu. Let it pick, score, or answer yes or no, with a probability attached, in one pass, cheap enough and fast enough to live inside a loop. Train it for that job instead of training it to sound like someone worth talking to. The name winks at Jevons: make the unit of intelligence cheap enough and software will call it constantly. That is not a chatbot. That is a function.

I keep finding the same fork elsewhere.

Full self-driving is not AGI on wheels. AGI is the being. Driving is the chooser. The car does not need a meditation on the yellow light. It needs brake, hold, go, at a tempo no essay can match. Tesla and Waymo are not succeeding or failing as philosophers. They are succeeding or failing as systems that pick from a small set of actions in a messy world, millions of times a day.

Humanoid robots make the same confusion look even more like the story we want it to be. Two legs, two hands, tidy the kitchen. The demo is speech and generality. The work underneath is neither: a high-frequency controller choosing stance and contact, and a slower chooser deciding which mug, which drawer, abort or continue. Language is a compiler of intent. It is a poor motor cortex.

We blur the layers because the being is the story we want to tell. The chooser is the product that has to work.

There is a flattering counterargument: wait for the general model, and it will absorb the narrow jobs. Sometimes it will. But a lot of software’s value does not live there. It lives in the call that has to be right, cheap, and on time — route the ticket, score the lead, decide the grasp, stay in the lane. A being is optimized to continue. A chooser is optimized to decide. Different losses. Different machines.

None of this makes the labs foolish. If you are trying to build God, God speaks in natural language. That is a coherent ambition. It is just not the same ambition as making ordinary software reliable. We spent a few years pretending those were the same project. Jev is a reminder that they never were.

Labs build speakers. Software, cars, and robots need choosers. Speech is a wonderful interface and a miserable control loop.

I have been as taken as anyone by the being — the voice, the fluency, the sense that something is in there. Curiosity pulls that way. So does the stage. But the quieter question, the one Casado is actually pointing at, is whether most of the work was ever conversation at all. Maybe it was always a menu, a state, and a choice — and we were paying a novelist to raise his hand.

Somewhere right now a self-driving car is holding at a yellow light, saying nothing at all, deciding everything.

Categories
AI AI: Large Language Models Programming

The Era of the Synthesizer: How AI Is Liberating the Coder

For decades, being a programmer meant being a translator.

You stood in the gap between what someone wanted and what a machine could understand. You learned the syntax. You memorized the libraries. You once spent three hours hunting a missing semicolon that turned out to be hiding in line 847 of a file you were sure you’d already checked.

The New York Times Magazine recently ran a piece by Clive Thompson on what AI coding assistants — models like Claude and ChatGPT — are doing to that job. The anxiety in the piece is real. When you sit down with a modern AI assistant and watch it generate in seconds what used to take you days, it’s genuinely disorienting. Hard-won expertise suddenly feels less like a moat and more like a speed bump.

That reaction is honest. I’d be suspicious of anyone who didn’t feel it.

But here’s what I keep coming back to: what we’re losing is the translation layer. The boilerplate. The muscle memory of syntax. What we’re not losing is the part that was always the actual job — figuring out what to build and why it matters.

The soul of software was never in the code itself. The code was always just a means to an end.

Think about what happens when the mechanical friction of a craft disappears. Photographers stopped having to mix their own chemicals in the dark and started spending that time making better images. Musicians stopped having to hand-copy scores and started composing more. The freed-up capacity doesn’t evaporate — it gets redirected upward, toward the work that actually required a human all along.

The same shift is underway in software. When the AI handles the loops and the boilerplate and the database queries, what’s left is everything that required judgment in the first place. The architecture. The user experience. The question of whether this thing should exist at all, and in what form, and for whom.

We’re moving from the how to the why. That’s not a demotion.

It does ask something of us, though. The old identity — programmer as master of arcane syntax — has to be relinquished. And letting go of a hard-earned identity is genuinely hard, even when what’s replacing it is better. That quiet grief the Times piece captures is worth sitting with, not dismissing.

But after you sit with it for a minute: we are entering the era of the synthesizer.

The synthesizer’s job is to hold the vision, curate the logic, and direct the output toward something that actually resonates with another human being. Empathy. Intuition. The ability to sense when something is almost right and know which direction to push it. These aren’t soft skills. They’re the whole game now.

The clatter of keyboards is fading. But the music we’re about to make — with AI doing the heavy lifting on the mechanics — has a lot more room to breathe.

Categories
Computers FORTH IBM Programming

The Architecture of the Stack

Back in the early 1980’s when I worked for IBM, I was able to acquire my own IBM PC and experience my own form digital frontierism. Today I really wish I had a logbook at hand with a record of everything I did as my ability to recall those details has faded with age. A couple of those memories that still do remain with me involve two obscure languages: APL and FORTH. And then there was Borland Turbo Pascal.

In those early days of the 1980’s, memory wasn’t an infinite field; it was a precious, finite resource. While most of us were content living with the structured guardrails of BASIC, there was a subset of us drawn to the elegant, stripped-back world of FORTH.

Learning FORTH felt less like coding and more like learning a new way to breathe. It was lean. It was efficient. It stripped away the overhead of high-level syntax until it was just you, the dictionary, and the stack. There was an honesty to it—no hidden abstractions, just a direct conversation with the hardware.

Then, of course, there was the hurdle of Reverse Polish Notation (RPN). Grokking the stack meant rewiring your brain. You couldn’t just state an operation; you had to prepare the world for it first. You pushed your data onto the stack, one piece at a time, and only then did you call the action. It was a rhythmic, almost percussive way of thinking: Input, input, act.

“In FORTH, you don’t just write programs; you build a language to solve the problem.”

This “bottom-up” philosophy changed the relationship between the creator and the machine. You weren’t just a user; you were an architect of your own vocabulary. To define a new “word” in FORTH was to permanently expand the capabilities of your environment. It was a recursive journey where every small success became a building block for the next complexity.

Looking back, those days with the IBM PC and the stack weren’t just about efficiency. They were about the discipline of clarity. When resources are limited, your thinking must be precise. The difficulty of RPN wasn’t a bug—it was a feature that forced you to understand the flow of data at its most fundamental level.

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.