I’ve spent my share of time wandering the desert in my career. If you asked me in 2024 what my biggest fear was, I’d have told you:

I was afraid my best years were behind me, as someone who builds things.

Nothing could have prepared me for what came next.

Proper leverage of alien pseudobrains

The debate about LLMs will span a generation, but the debate about LLM utility was decisively settled by the latter half of of 2025. What remains is a sort of tedious eventual consistency problem as consensus diffuses through the medium of millions of technology professionals.

In popular imagination, “AI” has come to mean the cheap version of ChatGPT, prattling in a grating tone with too many emojis, variously misleading and making things up.

AI, in this view, is a stupid machine that makes stupid text. LLMs can certainly be this thing.

Software circles aren’t much better: LLM-enabled development is about code generation. Tell it to extrude code for a purpose, and maybe it will, and maybe it will work.

The truth of things is far, far stranger than either conception. By the close of 2025, it was possible to know the true purpose of LLMs: to act as the engines for a previously-impossible category of software.

Agents.

Claude Code is the most beloved and prominent example of these, and perhaps the most instructive.

Claude Code: science fiction shit

24 years ago, Halo debuted as the Xbox launch title. The story was a science fiction romp, setting the player loose amidst the ruins of an advanced progenitor civilization. An AI, Cortana, rode shotgun, monitoring signal traffic, accessing foreign systems, and exploring ruined alien data to make sense of ancient puzzles.

This category of AI assistance was, for 40 years of my life, a strict matter of fantasy.

In 2025, it became a thing anyone could buy with a credit card for $20.

Using the LLM in its core, Claude Code can interact with anything that will yield to a terminal command.

That’s pretty much all of computing. It can explore files, logs, the complex and obscure installations of software tools lurking in the depths of your machine.

It can shine a light in the dark, helping you make sense of nearly any problem you face. From gnarly git merge conflicts to figuring out why some poorly-documented tool won’t compile on your machine, Claude Code can help you solve more problems, faster, than you would ever bother to tackle on your own.

Long before Claude Code writes its first line of code for you, it earns its value by being the most effective diagnostic and debugging tool in computing history. Set it loose on crash logs and broken installations alone and you will be glad to pay Anthropic’s fee.

A new category of software

I wrote a bit for PostHog about the strange adventure of building a product on top of an agent, with the goal of autonomous developer SaaS integrations.

This is a whole new set of challenges and most of the rules have yet to be written, so 2025 was at points a terrifying year for me. I wasn’t sure I was going to be able to ship the things I promised. There wasn’t an obvious map to follow.

Just trial, error, and iteration.

For software developers, the LLM age isn’t about a robot writing code for you. It’s about designing and refining software with a universal text interpreter built into it: productively constraining its behavior and harnessing its unique advantages.

Right now, you can pick up the scaffold that runs Claude Code and build entire products on top of it, making your own autonomous software that solves problems on behalf of yourself or your customers.

You can build your own customizations, making deterministic software that interfaces cleanly with agents. Any task that be described in text can become a tool they can use. Its implementation is completely up to you, and you can build whatever checks and balances you like into its process.

Using MCP and skills, you can create a completely novel rack of abilities only your agent has. These are among a whole category of new strategies to learn for this age.

Far from my best years being behind me, it feels as though everything in my life has been leading to this moment: building a completely new category of product where the most useful lessons come not from GitHub repos, but from the science fiction novels I’ve been obsessed with since I was a kid.

So I feel like a kid again, a new world opening in front of me.

Robots do what you say, not what you mean

Asimov was obsessed with this wrinkle. As models improve, their ability to read between the lines improves too.

Still, a model is a lossy, fossilized record of the links between facts, ideas, and conventions. All of these can evolve over time.

Your context is not the LLM’s context.

Which means the age of LLMs is about strategic communication. You are playing a game of chess alongside a very capable lieutenant whose judgment is unpredictable, whose knowledge is a bit out of date, and whose stamina is inexhaustible. Your job is to figure out what combination of information and instruction will guide this lieutenant to act effectively on your behalf.

Context becomes an engineering problem

You need a pipe to feed reliable information to the robots. This is quiet but necessary infrastructure with two stages of challenge:

1. Do you have content that’s clean, correct? If not, you have some work to do. You might need a lot of human hours to do it. Judgment and accuracy are essential here.
2. Do you have a means of delivering it in a way that doesn’t drown the robot in too much information, free of noise? Progressive disclosure matters for LLMs as much as it does humans.

Gripping too tight makes a brittle robot

Six months ago, as I was designing my first agent-based product, I had one core conviction:

Write as little code as possible.

The obvious software developer’s reflex is to use code to make sure the robot does what you want. But Norbert Wiener, father of cybernetics, echoes 75 years from the past with both a promise and a warning:

the structure of the machine or organism is an index of the performance that may be expected from it.

The more deterministic bones I burdened the agent with, the more rigid and brittle it would become.

Instead, I wanted an octopus: able to flow, explore, and respond flexibly yet intelligently to any problem it encountered.

So instead of writing loads of code, I wrote structured, chained prompts that the agent would execute in order.

Instead of flooding its context with information, I gave it an ordered procedure, letting it reveal information to itself in a reliable way.

The upside of this is very little coupling with a specific implementation or agent: the real value lives in the design of the context itself and the endless testing and iteration that goes into perfecting it.

As a result, that context becomes highly portable.

The error correction loop is everything

An agent has inexhaustible stamina, but it’s not omniscient.

Context properly tailored to its task will reduce “guessing” and improve correctness. But in the end, it needs to know if what it just tried actually worked.

So an error correction strategy is critical. What information can you feed the agent to help it verify that its efforts match a desired result? Typed languages are great for this: a type checker is valuable signal. Compiler output is also great. Svelte uses a static analyzer built into an MCP server to ensure agents write correct, modern Svelte code, untainted by the out-of-date training in the model corpus.

There’s so much work to do

I don’t see the age of the LLM as being apocalyptic to the job prospects of software developers. The end of ZIRP, the 2022 changes to the R&D payroll tax credit, the growing toxicity of tech leaders generally… all of these are much greater dangers to the tech worker’s salary.

Meanwhile, the scope of what is possible in the age of these bizarre alien pseudobrains, and the agent-class software they now enable, remains barely explored.

For the curious and adventurous, there are all new skills and strategies to learn. All new categories of product to be made. If reality was frozen in 2023, yes, LLMs would demolish jobs as they automated away previously costly tasks.

But reality is not frozen: it takes time and experimentation to build on the new frontier created by LLMs. While the LLMs can help with that, it’s the insight, creativity and human judgment that determines their utility and impact.

There’s just so much work to do. Drop me a line if you want to talk about it. Change can be scary, but it can also be an opportunity, and I’d love to be helpful.