Tag: Software Engineering

Categories
AI

Hands He Can’t Feel

Note: a fictional story exploring how software development is changing in the world of Claude Code, Antigravity, etc.

The cursor blinks for maybe two seconds. Then the code appears, all of it, a function Pete Callahan had been turning over in his head for the better part of a morning, just there, complete and correct and formatted the way he would have formatted it himself. He reads it the way you read something you’re looking for an error in. There isn’t one. He leans back in his chair in a way that isn’t quite satisfaction and isn’t quite anything else he has a word for.

Bewildered, maybe.

Outside his window, Dayton is doing what Dayton does in February, which is endure. The city has always been good at that. The Wright Brothers built their first serious wind tunnel a few miles from here in a room above a bicycle shop, testing wing shapes that didn’t exist yet, failing in ways that taught them something. Pete grew up knowing that story the way you know the streets of the neighborhood you grew up in — not as history exactly, more as weather. Just a thing that was true about where you were from.

His father would have understood the wind tunnel. You build the thing to test the thing. You put in the hours. That’s how knowledge works.

Pete is no longer sure that’s how knowledge works.

His father, Ron Callahan, spent thirty-one years at Wright-Patterson keeping F-16s in the air. Not designing them, not flying them. Maintaining them. There is a difference and Ron has always understood it as a moral one. The pilot trusts you with his life in a way that is not metaphorical. You either know what you’re doing or you don’t. There is no almost.

He lives twenty minutes from Pete in a house that smells like coffee and WD-40, a combination Pete has never encountered anywhere else and that means, without his being able to say exactly why, that everything is okay. Ron is seventy-one now, still straight, still with the unhurried precision in his hands that Pete watched as a boy and tried to understand as a kind of language. On Sundays Pete drives over. They watch whatever game is on. Ron sets a mug in front of him without asking.

This particular Sunday Ron asks how work is going the way he always asks, with genuine interest and the slight remove of a man who has never quite been able to picture what his son actually does all day.

It’s great Dad. But it’s changing faster than ever before.

Ron nods. He has seen the F-4 give way to the F-16 give way to systems so sophisticated the maintenance manuals run to thousands of pages. He knows about change. You learn the new thing, he has always believed, or the new thing leaves you behind. Simple as that.

He hears his son’s sentence as a version of something he has said himself.

He’s not wrong, exactly. He’s just not quite right either.

Driving home Pete thinks about the kids he came up with, the ones from places like Dayton who found in code what the world didn’t always offer elsewhere — a domain where being right was demonstrable, where quality was real, where the machine didn’t care about your intentions. It had shaped him the way Dayton shaped him. Not as ideology. Just as weather.

He still believes that, mostly.

It’s just that the machine has changed its mind about what knowing means.

What Pete cannot explain, what he doesn’t have the language for yet, is that the change he is living through is not like learning a new aircraft. When the F-16 replaced the F-4, the mechanic’s relationship to the machine stayed intact. Hands on metal. Knowledge earned through repetition, through failure, through the slow accumulation of understanding what the thing wanted to do and what it didn’t. The new plane was more complex but the posture was the same. Man serving machine serving pilot. The chain held.

What is happening to Pete is something else. Something that doesn’t have a clean analogy in Ron’s world, or in the history of Dayton, or in the mythology of the American craftsman that Pete absorbed so completely he doesn’t even know he’s carrying it.

He is still building things. He is building better things, faster, than he ever has. But somewhere in the last eighteen months the relationship changed in a way he is still trying to locate. He used to be the one who knew. Now he is the one who directs something that knows, which sounds like a promotion and feels like something more complicated than that.

His father’s hands always knew what to do.

Pete is learning, at thirty-eight, to work with hands he can’t feel.

By ten o’clock the house has the particular quiet of a place that is usually fuller than this. Sarah’s coffee cup from this morning still on the counter. Her shoes by the door. The small evidence of a life that will resume at midnight when he hears her key in the lock, and until then it’s just Pete and the screen and whatever this is that he’s trying to figure out.

What he does, alone in the house on these nights, is push. He takes the thing further than the task requires. Asks harder questions. Builds something more complex than anyone asked for just to see where the edges are, just to understand what he’s actually working with. It is the same impulse that kept his father an extra hour on a Friday, checking something that had already been checked, because almost certain was not the same thing as certain and a pilot was going to trust this machine with his life.

The ethic transferred even when the medium changed.

Even now, when the medium is changing again.

He thinks about his father’s hands sometimes, late like this. The way they moved with that unhurried precision, never rushed, never uncertain, each motion the product of so much repetition it had passed through knowledge into something that lived below knowledge. Pete watched those hands as a boy the way you watch something you are trying to learn without knowing you are learning it.

He used to think he had built something like that himself. The ability to hold a system in his head, to feel where it wanted to go, to know. The hands that knew what to do.

What he is building now he cannot quite name yet. It is not that the knowledge is gone — if anything it matters more, sits heavier, earns its keep in ways it didn’t before. But the relationship is different in a way he is still trying to locate, still turning over on these quiet nights while Dayton endures outside the window and Sarah’s shoes wait by the door and the cursor blinks with the particular patience of something that does not need him to be ready.

He types. The code appears.

He reads it the way his father checked what had already been checked.

Not because he doesn’t trust it.

Because that’s what you do when it matters.

Categories
AI AI: Large Language Models China

Cranes on the Horizon

In 2005, during my first trip to Shanghai and Beijing, the most striking feature of the skyline wasn’t the architecture—it was the cranes. More than I could possibly count, perched atop half-finished skyscrapers like a mechanical forest. Entire districts seemed to be mid-construction simultaneously, as if someone had pressed a button and the whole country decided to build everything at once. Dan Wang in his book “Breakneck” described China as the “engineering state” that approaches national problems with physical solutions. Back in 2005, coming from Silicon Valley, I thought I understood what growth looked like. I didn’t.

I’ve been thinking about that trip while reading Nathan Lambert’s recent piece, “Notes from Inside China’s AI Labs.” Lambert — who runs the Interconnects newsletter and does serious work tracking the open-weight LLM ecosystem — just returned from visiting essentially every major AI lab in China. Moonshot, Zhipu, Meituan, Xiaomi, Qwen, Ant Ling, 01.ai. He went in with genuine curiosity and came back with humility. That combination is rarer than it should be.

What he found was the cranes. Different domain, same energy.

Lambert’s central observation is about culture, not capability. The Chinese labs aren’t winning on any single technical breakthrough — they’re winning on execution discipline. He describes researchers, many of them active students, who bring no ego to the work. They absorb context fast, drop assumptions faster, and seem genuinely unbothered by the philosophical debates that seem to swirl constantly in the American AI community. When he tried to engage Chinese researchers on the long-term social risks of models or the ethics of AI behavior, those questions “hung in the air with a simple confusion. It’s a category error to them.” Their role is to build the best model. Full stop. To them, an LLM isn’t a philosophical entity to be interrogated; it’s a piece of infrastructure to be optimized.

That description landed for me. Not as a criticism of American research culture, but as a real observation about what the moment demands. Building good LLMs today is, as Lambert puts it, meticulous work across the entire stack — “all points of the model can give some improvements, and fitting them in together is a complex process.”

The work that matters most right now isn’t the 0-to-1 creative leap; it’s the thousand unglamorous decisions executed without complaint. Students who haven’t yet learned to lobby for their own ideas turn out to be well-suited for exactly this.

Lambert ends on a note that’s hard to shake. Looking up from his laptop on a high-speed train, he keeps seeing cranes on the horizon. He draws the same connection I did, though from the inside: the construction everywhere fits the broader culture and energy around building. “When I look up from my laptop and always see bunches of cranes on the horizon, it obviously fits in with the broader culture and energy around building in China.”

Twenty years after my first visit, the cranes are still there. They’ve just moved indoors — into server rooms and training runs and model releases that land every few months with quiet confidence. In 2005, what China was building was obvious: you could see the steel frames going up. What’s being built now is harder to see, which may be exactly why it keeps surprising us.

Check out Lambert’s essay – it’s remarkable. If the 20th century was defined by who could move the most earth, the 21st will be defined by who can move the most tokens. And right now, the cranes are moving faster than we think.

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
AI Programming Work

The Currency of Restlessness

There is a specific kind of vertigo that comes from watching a machine effortlessly perform your life’s work. For Aditya Agarwal, an early Facebook engineer and former CTO of Dropbox, that vertigo hit after a weekend of coding with an AI assistant. His realization was absolute: we will never write code by hand again.

When the specialized skills we have spent decades mastering become free and abundant, the foundation of our professional identity inevitably trembles. Agarwal captures the duality of this moment perfectly, describing it as a mixture of “wonder with a profound sadness.”

“There’s something deeply disorienting about watching the pillars of your professional identity, what you built and how you built it, get reproduced in a weekend by a tool that doesn’t need to eat or sleep.”

The conversation around AI tends to flatten this emotional reality into two distinct camps: the doomers who foresee total replacement, and the boosters who promise a frictionless utopia.

But lived experience is messier. We are capable of holding grief and wonder in the same hand.

We can mourn the craftsmen we were, even as we sprint toward the architects we are about to become.

Because here is the secret about the disorientation of progress: it passes.

Once the initial shock fades, what replaces it is a wild, unconstrained energy.

When the mechanical friction of creation vanishes—when a week’s worth of coding can be accomplished in an afternoon—the scope of our ambition expands. We are no longer limited by the keystrokes we can manage in a day, but by the edges of our imagination. We aren’t watching ourselves become obsolete; we are watching our lifelong constraints dissolve.

This shift is rewriting the social contract of knowledge work, starting with how we evaluate human potential. For decades, the corporate world has relied on a calcified heuristic for hiring: brand-name universities, FAANG experience, and years of tenure. We worshipped the resume.

Now, that playbook is breaking down. In evaluating engineers and founders navigating this transition, Agarwal notes that traditional pedigrees predict almost nothing about a person’s ability to thrive. The new dividing line isn’t generational, and it certainly isn’t educational. It is entirely dispositional.

“The trait that matters most isn’t intelligence, or credentials or years of experience. It’s someone’s relationship with change—not whether they’ve seen change before, but whether they run toward it.”

The new currency of the working world is restlessness.

Restlessness is the refusal to settle into the comfort of the way things used to be. It is the constitution of a builder who cannot stop tinkering, who treats every new AI tool as a puzzle to be solved before the day is out. In an economy where the “how” of knowledge work is increasingly automated, the premium shifts entirely to adaptability, curiosity, and vision.

This democratization of capability forces a deeply uncomfortable, deeply human reckoning. We have to let go of the identities we forged under old paradigms to become whatever comes next.

The technology didn’t create this human challenge—it merely made it impossible to ignore.

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 Anthropic Claude Cybersecurity

The End of Obscurity

There is a particular kind of silence that surrounds a zero-day vulnerability. It is the silence of something waiting—a flaw in the logic, a gap in the armor, sitting unnoticed in the codebase for years, perhaps decades. We have slept soundly while these digital fault lines ran beneath our feet, largely because we assumed that finding them required a brute force that no one possessed, or a level of human genius that is incredibly rare.

But the silence is breaking.

I was reading Anthropic’s Red Team report from earlier this week (triggered by reading Bruce Schneier’s amazement), specifically their findings on the new Opus 4.6 model. The technical details are impressive, but the philosophical implication is what stopped me, like Bruce, cold.

For years, digital security has relied on “fuzzers”—programs that throw millions of random inputs at a system, banging on the doors to see if one accidentally opens. It is a noisy, chaotic, brute-force approach.

The new reality is different. As the report notes:

“Opus 4.6 reads and reasons about code the way a human researcher would—looking at past fixes to find similar bugs that weren’t addressed, spotting patterns that tend to cause problems.”

This is a fundamental phase shift. We are moving from the era of the Battering Ram to the era of the Jeweler’s Loupe. The machine is no longer guessing; it is understanding.

There is something deeply humbling, and slightly terrifying, about this. We have spent the last half-century building a digital civilization on top of code that we believed was “secure enough” because it had survived the test of time. We trusted the friction of complexity and the visibility of open source to keep us safe. We assumed that if a bug had existed in a core library for twenty years, surely it would have been found by now.

But the AI doesn’t care about time. It doesn’t get tired. It doesn’t have “developer bias” that assumes a certain function is safe because “that’s how we’ve always done it.” It simply looks at the structure, reasons through the logic, and points out the crack in the foundation that we’ve been walking over every day.

We are entering a period of forced transparency. The “security by obscurity” that held the internet together is evaporating. When intelligence becomes commoditized, vulnerabilities become commodities too. The question is no longer “is my code secure?” but rather, “what happens when the machine sees the flaws I cannot?”

It’s a reminder that complexity is a loan we take out against the future. Eventually, the bill comes due. We are just lucky that, for now, the entity collecting the debt is one we built ourselves, designed to tell us where the cracks are before the ceiling collapses. Let’s hope that we are out far enough in front of it.