From author to editor

In April 2026, without either of us noticing, Devin¹ passed me.

$ git shortlog -sn --all | head -2
  3921  Devin AI
  3843  Joakim Riedel

That is the repository behind Propstreet, the commercial real-estate platform I co-founded. For nine years I was its most prolific committer,² because I was the CTO and, for long stretches, the only developer. Then Devin produced more changes than I did, and I just signed the work.

The shortlog only counts commits. What actually changed is that I stopped typing code. The part of the job that was left was deciding: what should be built, when it is good enough, and what the agents must never be allowed to do.

I don’t write code anymore

When I say I don’t write code anymore, people assume there was a day, some Tuesday when the tools crossed a threshold and I pushed my keyboard away. It was gradual. I only see it clearly looking back.

In February 2025 I started using Claude Code,³ then a research preview, alongside the editor-and-autocomplete setup everyone had. Through that spring and summer about half of what I shipped was written by agents, and I still took the keyboard back whenever I could see one going the wrong way. I watched its reasoning scroll past in the console, and I could tell in a second when it had derailed, or was going round in circles on a symptom without finding the cause. Twenty-five years of habit said: when the reasoning goes wrong, do it yourself.

By August 2025 the agents wrote most of the code, and I stepped in less because they derailed less. Then, in December, they got noticeably better. I watched an agent find a fault deep in my own codebase in a few minutes, because it could read more of the code at once than I could keep in my head. It would have taken me a day.

That was the month I typed my last line of production code, though I have shipped plenty since. From then on the agents wrote the code and my job was to decide what we could trust.

The git history shows it. Pull requests⁴ that had been occasional now arrived every day, Devin’s from customer feedback and my local agents’ from feature work, and I merged them.

A fair share of that work exists because agents are cheap enough to write what I would never have bothered typing: exhaustive tests, defensive validation, documentation that matches the code. They write the code I always knew I should be writing and didn’t, because my hours were the scarcest thing in the company. They aren’t anymore.

Underneath all of this the models changed every few weeks, and I swapped them the way you change tyres. What stayed was the factory around them: the rules, gates and budgets the agents work inside.

The bottleneck moved. I was still responsible for everything that shipped, and now there was far more of it. The slow part was no longer writing the code but checking it.

The editor’s job

When I wrote the code myself, I knew what I had been trying to do. That made me a poor reader of what I had actually done. I would see the intention and miss the mistake.

With an agent it is different. What arrives is a proposal, faster than I can take it in, from a collaborator who knows an enormous amount, never gets tired and does not care in the slightest whether it is right. If I don’t read it the way an editor would, the speed simply carries me along.

The upside is distance. I didn’t write it, so I can ask whether it solves the right problem, whether its explanation is true, and what will happen when a customer uses it. I still have intentions. Now I have to check that they survived the trip from my request to the product.

At first I tried to keep up by adding more AI reviewers. It helped, but every question still landed on my desk at the end. What changed things was getting the factory to ask those questions while the agent was still working. Some of my judgment had moved out of my head and into the system around the agents.

These days my job looks like this. I set a goal and say what the limits are. I grant a permission or refuse it. I read summaries, diffs, test results and now and then a video of an agent clicking through the product it just changed. I no longer read every changed line. The tests check the promises we have written down, and the reviewers look for mistakes the tests can’t see. I decide where to look closer and whether the evidence is good enough. I can work that way because I built those checks myself, and because they are allowed to stop a change.

Judgment through systems

I could accept the new way of working before I could accept what it did to my pride.

Authors get bylines; editors get mastheads. If your pride lives in code you wrote yourself, as mine did for twenty-five years or so, this feels like a loss. I spent roughly a month in late 2025 feeling it: the strange emptiness of a working day in which I had made a hundred decisions and typed nothing.

But it is amazing to be able to just do things. Projects that had waited for years become possible, and an idea can turn into something I can try while I still want to try it. I miss the old work and I love the new. Neither feeling has cancelled the other.

In February 2026 Andrej Karpathy⁵ gave this a name: agentic engineering, because “you are not writing the code directly 99% of the time”. You direct the agents that do, and doing that well takes real skill. Much of the skill goes into the system around the agents, because a rule that lives in my head only works while I am watching. A rule built into the system still works when I am asleep, when the agent is confident and wrong, and after I have left.

I have disappeared before

In 1997, still in high school, I started a consultancy that put Swedish small businesses on the internet. The job was always the same: find a corner of a business where something was manual, slow and flaky, orders on fax paper, catalogues typed again into early web pages, automate it, teach people the software, and leave. Leaving was the point.

In 2007 I co-founded Boreda, which turned commercial-property valuation from a web of spreadsheets, phone calls and institutional memory into a product. Värderingsdata acquired the company in 2012, I stayed two years to integrate the product into theirs, and then I left. What we built is still running today, inside a platform now owned by MSCI. Almost nobody who uses it knows my name, which is exactly how automation is supposed to end.

It has been the same pattern every time: find the slow, manual process, automate it, and replace yourself with the automation. For thirty years the process belonged to someone else. In 2025 it was mine: the typing, and a good part of what I used to call craft.

Becoming the editor was only the start. I didn’t want to explain the same things to a new agent every morning, so I had to write down what I knew where the next one would find it. Most of it turned out to be plain English.

Interlude: The dream and the crocodile

There is a bug I fixed in my sleep. I do not remember the year, only that it had taken days and that I carried it everywhere: into the shower, out on runs, to dinners where I was poor company. One night I dreamed the fix, in the code, character by character, and woke up and typed it in, and it was right. I have told that story at dinners for years, because it is the best thing I know about the craft: a hard problem gets into you and works while you are not looking, and the moment it comes together is a physical pleasure, like a joint going back into place.

December 2025 was the first month without that. The fault the agent found that month, the one that ended my typing, was exactly the kind I used to carry into the shower for days, and it was found before lunch. A bug came in. An agent opened the product in a browser, reproduced it, found the line, fixed it, ran the tests, deployed it to staging, clicked through the screens it had changed and posted a summary. I read the summary. I said yes. The problem never got into me, because it never had time to. There was nothing to carry to the shower.

I miss getting my hands dirty in a complicated problem, so deep that time and space disappear. I liked solving it, and I liked being rewarded for wizardry nobody else understood. Part of it was pride in being one of the few who could. Part of it was just the pleasure of being completely absorbed.

Thirty years ago I made MEKA with some other nerds, an interpreter for AGI,⁶ the engine behind Sierra’s old adventure games. Now I wanted to recreate that engine and let an agent change the game while I was playing it. So I asked agents to build it.

Less than two hours later, I was playing King’s Quest in the browser. My reply began: “WOW! Thank you. This brings back so many childhood memories. I spot two bugs.” Graham faced the wrong way when I moved him, and the crocodiles wandered out of the moat.

By that evening, the project, agiagent, could also let an agent change the game live.

I can ask, “add a crocodile in the moat”, and it happens. The agent changes the game’s binary instructions while it is running. The game from my childhood changes while I play it, because I asked.

I can even export an authored game in the format we were writing for thirty years ago.⁷ I thought of something I wanted to try, asked, and was trying it the same day.

How cool is that?