What Stays When the Agent Leaves

I typed my first program into an Atari 800XL when I was eight. It was BASIC — a PRINT statement, a FOR loop, the small electric feeling of making something out of nothing. I have been typing into machines ever since. Twenty-five years telling brands what they were. Ten of those telling servers what to run. Another ten telling codebases how to behave. Now I spend most afternoons telling an agent what I want — and watching it ship, in twenty minutes, what used to take me a week.

It should feel like a gift. It mostly feels like a question.

The question has a clean shape: what happens when the agent disappears? Not in some speculative AGI-doom way. In the ordinary way. The API changes. The price triples. The model regresses. The company pivots. The thing I built my Tuesday afternoon around stops being there on Wednesday. I have had this conversation before — thirty years ago, with a different cast. Photoshop was new in my life. Thirty years later it is still on my dock, and it is the longest continuous relationship I have had with any tool. It is also the one that taught me what dependency actually costs.

Three lives

Between that first BASIC program and this agent, I was several different people.

I was a sysadmin for nearly a decade overlapping with that. I started on Novell Netware, moved through Windows NT — 3, then 3.1, then 3.11, then 4.x — and learned Unix alongside Linux as they fought for the same rooms. I looked after a roughly forty-person government building, then a local internet provider — one of the first ISPs to run a laser-optic link in production, free-space optics, a beam between two rooftops, in the early 2000s — then a three-hundred-user multinational with several companies under one roof and several languages in the hallway. At every threshold — new OS, new scale, new stakes — I had the same small panic: this is different enough that everything I know about keeping servers alive might turn out to be knowledge about the wrong servers. It never was. The mental model transferred. The specific commands were mostly useless.

I was a developer long before I was anything else professional. BASIC on the Atari, then Pascal, then the entire Borland family. Fortran for a job I did not enjoy. Lisp and assembler because it was cool to know. C, C++, C#, the long slow march through versions. FoxPro when FoxPro was a thing. PHP before PHP was something you apologized for, and enough JavaScript to develop strong opinions about frameworks. A dozen languages. Twelve professional years of it as the main thing I got paid for. At every threshold — jQuery to React, callbacks to promises, monoliths to microservices, and a dozen shifts before those — I had the same small panic: this is different enough that the skill I just spent three years sharpening might be dull now. It was never dull. It was just slower than the new thing.

I am a marketer — still, after twenty-five years, the one life on this list I never actually left. It started in print, moved into digital, and for most of two decades it has meant marketing operations for a B2B SaaS company: the creative and the ops, the content and the campaigns, the CRM the campaigns run on. I have built the same thing — attention, turned into a decision — in print, in display, in performance, in email, in whatever the platform of the month insisted was the future. The channels changed every few years. The verb did not.

Now there is the agent. I notice I do not reach for a new title for it — agentic engineer is just a label for the same verb holding a newer tool, and I would rather not be repositioned as something new every time the tool is. A year and a half in. Long enough to have watched the asymptote move every quarter. Long enough to have built the muscle to trust outputs I did not type, to specify intent clearly enough that a probabilistic machine can run with it. Short enough that the same small panic still arrives right on cue: what if this is the skill that actually turns out to be specific to the tool?

The Adobe parable

I stayed inside Photoshop and their ecosystem for thirty years the way you stay in a city where you know which coffee shop has the good chairs. I learned it young. I learned it on agency work. I learned it on clients I am no longer allowed to name. Somewhere in the middle Adobe went subscription and I paid the rent because the alternative was to be slower than everyone around me who was also paying the rent. The boxed Master Collection — the last one Adobe sold before it all went subscription — is still on a shelf in my office. I do not need it. I have not thrown it out.

Switching hurt in a specific way. Not the muscle memory — that is recoverable within weeks. What hurt was discovering, after decades, that I had been confusing tool-mastery for taste. The taste survived the switch fine. It moved with me. The mastery of where menus lived, which shortcut opened which dialog, how to coax a specific filter into doing what the previous version of that filter did — that was gone, and mourning it was a process.

Here is what I did not know while I was locked in: the lock-in was not the file format. PSDs are just containers. The lock-in was not the subscription — that was a tax, not a cage. The lock-in was the velocity. Once you have trained your hands to produce output at a certain speed inside a certain tool, stepping back to any slower motion feels like amputation. You do not notice it when you are inside. You only feel it when you try to leave.

Which is exactly the conversation I am now having with the agent on my laptop.

Dependency, reframed

The question I keep returning to, usually around eleven at night with a long task running in the background, is whether I am dependent on the agent.

The honest answer is yes. The more useful answer is: and so what.

I was dependent on Photoshop. I was dependent on bash — still am, really, and I will not apologize for it. I was dependent on WordPress’s block model, on Google’s ad algorithm, on MailChimp’s deliverability, on whatever framework I happened to have three years of in my fingers. Every tool mastery I have ever earned looks, in retrospect, like a dependency. The word is just a retroactive description of the bargain I made when I picked up the tool in the first place.

So dependency is not the question. The question underneath it is whether I have taste independent of the tool.

Taste is the thing you cannot outsource. It is knowing when a layout is alive. Knowing when a headline is lying. Knowing when a server is about to fall over before the graphs admit it. Knowing when a piece of code will be regretted in six months. The agent cannot give you taste. The agent can only act on the taste you already have. If you could produce the same output ten times slower by hand — just without the velocity — you are a craftsman who is using a tool. If you could not produce it at all without the tool, you are an operator.

The difference matters because agents will keep changing. Models will regress. APIs will get expensive. Companies will pivot. But if the taste is yours, the tool is replaceable. That is the part that travels.

The invariant

There is something that has repeated across every career I have had, and I only noticed it recently. The job title changed — marketer, developer, sysadmin, agentic engineer. The artifact changed — campaign, feature, uptime, shipped code. The tool stack changed — Adobe Suite for design, Claude Code for anything else. But the verb never did.

Take a fuzzy strategic intent. Turn it into a shipped artifact. Do it again tomorrow, a little better.

That verb has survived every tool transition I have ever made. It survived the move from print to digital. It survived the move from bare metal to containers. It survived the move from classical dev to agentic dev. I expect it will survive the next thing, whatever the next thing turns out to be. What makes me still recognizable as myself across thirty years of tools is not the tools. It is that verb.

This, I think, is the thing to hold onto when the ground is moving. Not the tool you love. Not the career you have built. The verb underneath both. Everything else is a way to rent time on that verb.

A decision frame

When I get the stay-or-move question — and I have been getting it weekly for about a year now — I run it through four questions. They are the same questions I should have had when I was deciding whether to learn Photoshop or Corel. I did not have them then. I have them now. They work at every scale: tool choice, career choice, the much-larger choice of what to bet the next decade on.

What is the invariant here? Not the title. Not the artifact. The verb underneath. If the verb stays steady, the move is smaller than it looks.

What kind of dependency am I defending? Taste-dependency is fine. It travels. Tool-dependency only matters if the tool can actually disappear — and the tools that truly can are rarer than we tell ourselves.

What do I actually lose if I am wrong? A year. Maybe two. Some muscle memory I did not know I would miss. Almost never a career. The recovery window, in every shift I have lived through, has been shorter than the anticipatory dread.

What do I lose if I do not move? This is the question nobody asks loudly enough. Staying has a cost too. The wave compounds past you. The verb gets performed by someone else, faster, for a fraction of the price. Standing still in a moving landscape is a decision. It is just one we pretend is not one.

Close

The agent on my laptop finishes the task. The progress bar fills. I look at what it produced and I make the small adjustments only I would make — the voice thing, the unprinted thing, the one sentence that needed the em-dash and not the colon. Those are the parts that stay mine. Those are the parts that traveled — from the first PRINT statement, through Photoshop, through everything between. Those are the parts I will still have when the agent is something else.

I close the laptop. I already know I will do this again tomorrow. The dependency is real. So was every other one. The tool keeps changing. The small electric feeling of making something out of nothing does not. The move was never about the tool.