Tag: Software Engineering

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.