A year with agents

In May 2025 I stepped out of the day-to-day of the startup I had been working at for three years. Midnight Club kept shipping websites on the side, but what I wanted to hold on to was product: apps, webapps, that is what excites me. I had time ahead of me. It was the right moment to dig into AI properly, and see what I could produce with it entirely on my own. The best way to learn is a real project.

I had one to hand: diaradio.live, a community radio a few of us run with the Collectif Moï Moï. The project was running out of steam, and we had no way of paying for the tools we needed. I wanted tools on the level of nts.live, to get the station going again, and maybe one day to make it pay for itself. Above all, a system that takes more shows and more residents without us having to be more people to run them.

The question I asked myself as I started: can I ship an app on my own, without going to developers? iOS and Android app, backend, website. Just me on product, and ChatGPT. Worst case I spend a few months on it and I will have learned something. Let's go, whatever happens.

The question is worth asking because I am not a full-stack developer. I turn a mockup into code, I can read a technical decision, talk to developers, set up simple infrastructure. Write an API, keep a backend standing: no.

An iPad and a holiday

I went on holiday first, without a computer. It all started in the ChatGPT app on an iPad: exploring, defining the scope, choosing a stack, taking stock of what was possible. Trying to sort the real from the rest, because ChatGPT is enthusiastic by nature. Can I import my thousands of Soundcloud archives? Yes, no problem. Move it all into a CMS, link it all up, build a player that streams from Soundcloud? Yes, no problem. A cross-platform app? A native player, with the controls on the iPhone lock screen and playback resuming after a phone call? Yes, no problem.

It said yes to everything. I had not yet worked out what that was going to cost me.

I am the transport

I came back from holiday overexcited. The foundations were laid, the technology chosen, an MVP scope that obviously never stopped moving afterwards. I had made a first commit before leaving, to launch the project officially: "Initial commit – Dia Radio SPA", on 22 May. The real work started when I got back.

The process fits in one sentence: I talk, it writes, I paste. ChatGPT gave me terminal commands to install Vue, told me create this file, name it that, and handed me the code I copied into it. I tested, I came back with the console error. The code went through my hands to get from one window to the other.

And I was blown away. Fairly quickly we got to a working prototype of a webapp with an audio player that played. The Vue interface I could have built alone, more slowly, but I would have got there. The player in JS, no: that was past the edge of what I knew. And the player worked. Without calling a developer.

I am the memory

The next problem arrived fast: ChatGPT in the browser chokes as the conversation gets longer. It crawls, and you have to start a new one, losing everything you did. I ended up installing a Chrome plugin that exported the conversation to markdown so I could feed it into the next one. A nightmare. I spent my days moving memory around by hand.

That is where my setup took the shape it would keep. I opened several chats. One for management: organisation, advice, technical choices, with defined roles, senior dev, devops, product manager. That one held the whole picture, the decisions and the reasons behind them. And others, aimed at coding sessions, where I carried on copy-pasting into VS Code, testing, reporting errors. Long and tedious, seen from today. At the time, it worked.

Without really deciding it, I had just drawn the architecture that would hold all year: a brain that directs, workers that produce, and me in between. Everything that changed afterwards was only ever who sits in which chair.

I had also just run into the central problem of working with LLMs: memory. My answer at the time was markdown exports, and me doing the shuttle run.

The festival

The deadline was our festival, in August. I was putting the pressure on myself, it was all I did. The app was not ready, and it would not reach the App Store until March. But there was a demo: the live stream, part of the archive, search, favourites, an account. Very well received by the radio team.

Reading back through the history of those weeks, a commit from 15 August made me smile: "Backup before playback control fixes". A manual backup, committed, before daring to touch the player. That is exactly where my confidence was.

I am the translator

Cursor had been on my radar for weeks. A friend kept bringing it up: you should try it. But I had a process that worked, I was making progress, and I could not bring myself to stop and try another tool.

When I finally installed it: a slap in the face. Cursor has access to all of the code. It writes several files at once to make a feature work, it sees how the files connect. Ten thousand times more efficient than asking ChatGPT for code. Adopted immediately.

In the architecture, Cursor had just taken the worker's chair. The management chat stayed project manager and senior dev: we decide together what we are doing, and we have it carried out. Me, I was no longer carrying code from one window to the other. I was carrying audits, briefs and instructions.

Carefully, at first. Because early on, Cursor is thick. A request that is not framed tightly enough sends it into a frenzy of code creation you have to stop mid-flight. A bug, and it patches, over-patches, re-patches, sometimes a bug it created itself by going too fast. The number of times I had to stop it and go back with git.

So I looked for a way to drive it, and ended up formalising a mode I had called cursor prompt architect. Explain what you want, ask Cursor for an audit, read the audit back with ChatGPT, decide, have changes proposed, read those, and only then execute.

I found the instructions from back then. Here they are:

The main difficulty: keeping each tool in its role. ChatGPT could not stop itself producing code ("cursor is the coder, you are not! stop outputting code for god sake"), and Cursor would launch into major building work when all it had been asked for was an audit.

Three weeks against a plugin

From the start of the project I knew the hard part would be the native iOS audio player. Lock-screen controls, resuming after a phone call, switching audio output: the phone, Bluetooth headphones, the car, an AirPlay speaker. I kept pushing it back by finishing everything else. It was September, three months of active work in, and it had to happen.

And then it all went to hell.

I let ChatGPT look for Capacitor plugins. Nothing spectacular, one candidate that looked decent. We went with it. The integration commit on 4 September reads, without irony at the time: "by-the-book @mediagrid/capacitor-native-audio integration".

The three weeks that follow read, in the commit messages, like a ship's log going wrong: nil player crashes, RCC crash, a scrubber yo-yoing up and down, "deterministic seek (1 retry + revert)", "kill spinner loops", "revert-to-last-good on failure". At first it looks like it works, then playback stops after twenty minutes, then something genuinely blocking. We search, we patch, we over-patch, and my plugin turns into a monster. There are small wins, just enough to keep going. ChatGPT dangles carrots: ah, that's the problem, we found it, patch it like this and you're good. And it is never good. I stopped sleeping, it was all I did, I got aggressive with my AIs, I spoke to them badly. I was completely saturated.

At some point I said stop. I asked ChatGPT to check the plugins again, and above all to go and properly read Apple's native audio documentation. Which we had never done. I expected it to do that on its own; back then, it did not. It invented solutions and asserted we had no choice. Its answer after reading: ah yes, I did not have all that information, now I understand better.

Its new plugin search turned up nothing. I looked myself, found a good candidate very quickly, handed the repo to ChatGPT, it confirmed. We cleaned the bad plugin out of the app, planned properly from Apple's docs and the new plugin's codebase, a series of well-aimed prompts to Cursor.

Migration committed on 29 September. On the 30th: "Merge iOS native playback", resuming after a phone call working, and ten builds in the day. In twenty-four hours, it worked. After three weeks of banging my head against a wall.

The fault is not the tool's: I approved a structural choice without checking it, trusting ChatGPT to read documentation it was not reading. It cost me a month. That particular mistake I cannot make again today: the verification has moved into the process. No structural choice goes ahead without the docs having been read and the plan challenged, and it is no longer me who has to remember. But I am getting ahead of myself. At the time, I learned a couple of things, and we got more efficient. I say "we", because there really is a team logic in all this.

I pass the plan around

From September to November, we moved fast. I checked choices better up front, the prompt architect was running well. Its only flaw: the endless back and forth between ChatGPT and Cursor. Ask for the audit, paste the result, re-audit, instructions, report, test.

In November, Cursor shipped plan mode. What I was doing by shuttling between two windows, the tool now did on its own, in one place. We decide with ChatGPT what we are doing, Cursor produces a plan, the plan goes back to ChatGPT, corrections, a few rounds, and we let Cursor execute. This time, no resistance to adopting it: I saw the update, tested it, adopted it the same day. The tool had arrived exactly at the workflow I had built for myself: audit, plan, verify, and only then execute.

My role changed again: I was no longer passing on instructions, I was passing a plan around until it held up. And it started working first time, on more complex things, with more files created or changed at once. We commit the plans into the repo for the record, next to the changelogs, buglogs and backlogs I had already had Cursor keeping since August. The repo was becoming the project's memory. I had not decided that, I noticed it afterwards.

The chairs merge

Claude Code had been going off for months and I had it in the corner of my eye, thinking: at some point I need to test this. The same resistance as before Cursor. I had a highly efficient workflow, the app was about to ship, the radio's new season needed preparing, and I was afraid of losing time adopting yet another technology.

In the meantime the documentation logic had thickened. In March, an .ai/ manual per project: architecture, domain, flows, rules, recipes. To stop explaining everything again. With the infrastructure in place, the agent knew what to do on the server, how to restart it without cutting the stream, the crons, how all of it worked. MCPs, tested at the end of 2025, already connected the agents to my services: the CMS, analytics, Gmail, GitHub, DNS.

Then I tested Claude Code, opening my DIA production folder. What really got me was skills: a process written once, replayed identically. Other people's first, then ours, and every repetitive task becomes a skill.

But the real shift is the whole. A short CLAUDE.md pointing at the .ai/, the connectors, the skills, and the workspace I had started organising around it. You open a session: just by reading the documentation and the git history, the agent knows what we are doing and where we are.

A consequence I had not anticipated: I no longer use Cursor, and I no longer use ChatGPT. The brain that directs and the worker that produces, the two chairs of 2025, now sit in one chat, which sends out agents and sub-agents in parallel when the task calls for it. And the challenger still exists, but it is no longer me doing the shuttle run: a Claude model writes the plan, Codex, at OpenAI, reads it back in a read-only sandbox under instructions to tear it apart, and we loop until it passes. The same gesture as the prompt architect. It is just a skill that handles it instead of me.

And at roughly the same time, the second brain. It lives at the root of the workspace, I feed it, it watches the projects' git. One day I started a session in some folder or other and realised Claude knew. It knew what we were doing, where we were, and when I asked for something it referred to other projects, to problems we had already hit, to solutions we had already found. That floored me. If I ask "set me up a new client, showcase site project", it creates the client folder, the working folder, it already knows we do Astro with Sanity. It asks anyway, just in case.

Today

A typical day. I open a session in a project folder, and it starts with a state of play: where we are, what has moved, and it goes beyond the code, the session reads my email too. We prioritise, answer two or three messages, go and find what is needed for the next thing to build. Then as before: right, we are doing this. A small plan, we challenge it, and Claude executes. In parallel I start other sessions on other projects. I run several at once, and I get told when a decision is waiting for me.

I spend my days talking with my team, really. It is all I do.