Six Months of Writing Code Exclusively with Agents

In February of this year, I made a norm for myself: I wasn’t going to constitute codification by manus anymore. I’ve been surviving by that norm for six months.

The strategy lived successful my head

Back successful 2024, earlier AI, my superpower was knowing really the full strategy worked, particularly the interfaces betwixt its different components.

If personification came to maine pinch a characteristic they wanted to build aliases a bug they were trying to fix, I could usually constituent them to the nonstop statement of codification that mattered and show them what needed to change. I besides remembered why the strange-looking decisions existed and which assumptions were ne'er written down.

This was knowledge I’d built complete months and years of moving successful the codebase. It was hard-earned and invaluable. It fto maine build features quickly and, much importantly, safely.

The costs was that I had to support up pinch everything. As much group contributed, I spent much and much clip reference changes conscionable to support that intelligence model.

The bigger costs was the typing. Every clip I wanted to build something, I could spot the codification successful my head. I conscionable couldn’t type it retired accelerated enough.

Typing velocity was only portion of the problem: a characteristic was almost ne'er 1 edit. Even a mini alteration spanned aggregate layers and touched handlers, schema, tests, and docs. And those edits weren’t equal: a bad handler could beryllium reverted, but a bad migration could time off a messiness behind. So penning the codification by manus meant carrying 1 determination safely done each spot it touched.

Copilot autocomplete helped immediately: a doc remark became a first draft, often wrong, but thumps editing a blank file. Cursor’s tab complete helped more. The models were intelligibly improving fast.

Claude Code changed a ton. I could picture the alteration once, and the supplier would edit a bunch of files astatine once.

As a result, I typed a batch less. But typing little didn’t mean moving less: I publication each alteration the exemplary generated to lucifer it against the desired authorities I had successful my head. Agents would still beryllium incorrect rather a batch and make changes that weren’t required. Working incrementally kept them connected track. This meant manus editing immoderate of the generated code. After all, I was still responsible for each statement that merged. The exemplary wasn’t going to beryllium held accountable.

Then, early this year, the models sewage really good, almost each astatine once. GPT-5.3 and Opus 4.6 could abruptly grip larger changes pinch overmuch little steering, and the results were yet bully capable to build on.

So successful February I made the rule: nary much codification by hand. If an supplier sewage stuck, I wasn’t allowed to decorativeness the codification myself. I had to fig retired what the supplier was missing - and hole that instead.

I didn’t get bully astatine coding by reference astir coding. I sewage bully by penning a batch of code, moving it, seeing it fail, fixing it, and doing it again.

AI agents are conscionable software, aft all. I wasn’t going to understand them by reference punctual guides. I had to usage them for existent work, spot wherever they failed, alteration the prompts, tools, aliases environment, and effort again.

The norm forced maine to get those reps.

I collapsed it once, for 3 minutes. I opened the codification and wrote a fewer lines, and it felt great. I had missed this. Right up until I realized really overmuch I still had to type. I noped out.

One supplier became a dozen

Once I stopped typing the codification myself, I started uncovering these pockets of free time. I would springiness an supplier a task, and past location was thing for maine to do while it worked.

Instead of waiting, I spun up different supplier to do thing else. Then I did it again.

I wasn’t intentionally building a parallel system. I was conscionable filling the clip betwixt tasks. I person ADHD. I sewage distracted.

It’s easy to ideate what would hap if you shared a azygous dev container betwixt colleagues. Now ideate they don’t talk to each different and they’re each moving astatine the aforesaid time.

That was my first parallel setup. The agents changed the aforesaid files and Git state, installed dependencies, fought complete ports, and near processes running. I besides had to coordinate erstwhile each supplier could test, push, aliases deploy. Worse, I often ended up waiting for the longest-running supplier earlier the others could move forward. I had started much agents to debar waiting and someway created a caller measurement to wait.

I asked friends and colleagues really they dealt pinch this, and everyone had a workaround.

Worktrees came up first. Each supplier sewage its ain checkout and branch, and the root collisions mostly went away, but worktrees only solved the Git part. The agents still shared databases, ports, processes, and the remainder of the machine.

So group patched astir that pinch AGENTS.md: usage a random port, create an ephemeral database, don’t touch different agent’s process. Every conflict became different instruction, and the agents burned discourse figuring retired really not to measurement connected each different alternatively of doing the task.

Containers sewage closer: abstracted ports, processes, and section state. But the bound was leaky: immoderate my laptop could reach, the instrumentality could perchance scope too. The blast radius of a bad bid wasn’t contained, truthful I was still approving commands. And worst of all, my laptop had to enactment awake. If I closed it, each of the activity stopped.

I closed my laptop. The activity kept going.

By this point, I had joined exe.dev. We make Linux VMs that travel up successful a mates of seconds pinch SSH and HTTPS already group up, truthful moving the agents disconnected my laptop was the earthy adjacent step.

Each task sewage its ain machine. I could adjacent my laptop, locomotion away, and the activity kept running.

But now I had a caller problem: really do I reliably bring up a complete improvement situation for immoderate I want the supplier to activity on?

So, staying existent to not penning code, I asked Claude to constitute a startup script. I told it what I wanted and instructed it to loop until things worked. It installed our toolchains, cloned the repositories, configured Claude Code and Codex, and did everything needed to move a caller VM into a improvement environment. Then it ran the validation loop: bring up a caller box, tally the script, spot what broke, hole the script, and effort again.

The supplier boxes worked, but each supplier still had its ain tmux session. I ended up keeping a twelve terminal windows unfastened conscionable to spot what each supplier was doing. I had to jump betwixt them to find which supplier had finished, which 1 was stuck, and which 1 needed thing from me. I needed 1 spot to negociate each of them.

So I built botd.

I gave it 3 rules. First, it had to tally location different than my laptop (the agents should support moving erstwhile I closed it). Second, mobile had to beryllium first-class. Managing agents shouldn’t require sitting successful beforehand of a terminal. Third, it had to sphere each speech truthful I could look backmost crossed agents and understand wherever they sewage stuck, which instructions worked, and which problems kept repeating.

botd provisioned and deprovisioned the supplier boxes, drove the agents underneath, and kept way of each task. It showed maine which agents were working, which were stuck, and which were waiting for me. From my telephone aliases laptop, I could inspect the conversation, nonstop follow-up instructions, and reappraisal the diff.

Instead of managing a twelve terminal sessions, I had 1 spot to negociate the work.

None of this worked if I had to o.k. each instrumentality call. That would conscionable move maine into the queue again. Each supplier was moving wrong an isolated, disposable VM, truthful I fto it tally successful YOLO mode. It could tally bash commands, instal packages, commencement services, and alteration immoderate it needed. A trashed situation costs maine thing but the VM.

But an supplier that tin only touch its ain VM isn’t very interesting. I still wanted agents to publication logs, propulsion from Git, telephone Anthropic aliases OpenAI, and inspect things successful Stripe.

That entree is wherever the existent consequence lived, and the VM did thing to bound it. An supplier sounds untrusted contented and tin beryllium prompt-injected by it; immoderate it tin reach, an injected supplier tin leak aliases corrupt. There were holes I knew I hadn’t filled. So each portion of outer entree sewage the aforesaid question: what’s the worst that tin hap done this? Reading mostly passed: agents sewage read-only access. Writing didn’t, truthful constitute entree was constricted to trial environments, wherever the worst lawsuit was corrupted trial data.

I besides didn’t want the credentials wrong the VM. With exe.dev integrations, the supplier sends its petition done a proxy, the proxy adds the credential, and the supplier receives the consequence without ever seeing the secret.

Everything passed. I still didn’t want it.

At highest I was moving astir 20 VMs astatine a time. Not each of them were active. Some tasks sewage started, sat untouched for weeks, and were yet abandoned because the cognitive overhead was excessively overmuch and the activity was ne'er urgent aliases important capable to survive.

Validation sucked astatine that scale. I couldn’t manually rebuild each branch, rerun its tests, and cheque the exertion myself. But wrong their isolated boxes, agents could tally the tests, trigger the afloat CI suite, commencement the application, and thrust it done a browser. They would nonstop maine screenshots of the completed work.

But the supplier was still grading its ain work. If it misunderstood what I wanted, it could build the incorrect thing, constitute tests for the incorrect thing, and past confidently show maine that everything passed.

That’s why being capable to unfastened the moving situation mattered. I could usage it myself, thrust the caller UI extremity to end, and make judge it worked the measurement I wanted, not conscionable the measurement the supplier said it worked.

Then location was the reviewing. When I wrote the codification myself, I understood the alteration by the clip it was fresh for review. After all, I had made the decisions on the way. With an agent, the full diff appeared astatine once. It mightiness person passing tests and screenshots, but it was still unfamiliar code. And erstwhile respective agents vanished astir the aforesaid time, I had a queue of complete changes to load into my caput earlier I could merge immoderate of them.

Having other agents reappraisal the code worked amazingly well. They occasionally caught existent bugs, and it was inexpensive capable to tally respective reviews. But I couldn’t merge thing conscionable because the agents approved it. I still had to understand the change. I was still responsible for the codification that sewage merged.

And sometimes I understood it. The tests were green, the screenshots looked good, the UI did what I had asked for, moreover the schema looked bully and the codification was approved by each the reappraisal agents.

I threw it distant anyway.

Maybe cipher needed it. Maybe it introduced a 2nd measurement to do thing we already supported. Maybe a mini convenience added complexity we would transportation for years.

The devices could show maine that the alteration worked. They couldn’t show maine whether it was worthy adding to the system.

Unshipping thing is truthful overmuch harder than shipping it. Hyrum’s Law kicks in: erstwhile capable group usage a system, personification depends connected each observable behavior, moreover behaviour you ne'er intended to beryllium a contract. Removing thing breaks users, scripts, and workflows you didn’t cognize existed.

Shipping sewage easy. Deciding what to vessel sewage important.

Not each agents constitute code

Everything truthful acold has been astir shipping code. But some of the astir useful agents we run don’t vessel codification astatine all.

It’s worthy pausing connected what an supplier really is, because the connection sounds heavier than it deserves. An supplier is a exemplary successful a loop pinch tools. Send the exemplary a message; if it asks for a instrumentality call, tally the instrumentality and nonstop the consequence back; repeat. That’s the full thing.

The exemplary is what makes the loop capable. Give it bash connected a existent computer, and it tin instal what’s missing, accommodate erstwhile your grep has different flags, and support going until the occupation is done.

The loop ne'er changes. The devices determine what an supplier tin be. A improvement supplier needs a afloat computer: shell, compilers, browsers, the state to instal things. Hold those backmost and the supplier is useless, and you’re backmost to approving each action.

My starting point: springiness the supplier immoderate I’d springiness a developer. Good developer devices person turned retired to beryllium bully supplier tools. Whether the champion supplier devices extremity up being developer devices astatine all, clip will tell.

And the point to fearfulness isn’t immoderate azygous tool. It’s combinations. Private data, untrusted content, outer communication: immoderate 2 are manageable. All 3 successful 1 supplier is really your secrets locomotion retired the door. That’s what Simon Willison calls the lethal trifecta. So I don’t minimize devices blindly: I isolate the situation and I watch the combinations.

Here’s the first example: investigation. When a customer reports a problem, I person a punctual I use, and it’s embarrassingly simple:

“Customer reports: <their report, verbatim>. Please fig retired what happened utilizing the ClickHouse logs.”

Verbatim matters. If I summarize the report, the supplier inherits my mentation - and my unsighted spots. Given the customer’s ain words, it queries the logs, sounds the applicable code, and reconstructs what really happened.

Then the determination is mine. Sometimes I inquire for options and prime one. Sometimes the grounds says working-as-intended, and the hole is simply a doc aliases an email, not code. Either measurement I’m deciding from evidence, not guessing from a bug report.

The 2nd job: attack. Our red-team supplier has 1 instruction: effort to break into our systems.

And it worked. It recovered unfastened web paths we thought we had restricted, and showed america precisely really they were still reachable. We patched them earlier anyone extracurricular ever noticed.

That’s much useful than a database of theoretical vulnerabilities. It took an presumption we were relying connected and tested it against the moving system, and the presumption was wrong.

The 3rd job: watch. Deployments are scary, but not deploying is worse. We deploy successful waves, and penning cleanable rules for erstwhile to proceed is fundamentally impossible: accumulation fails successful weird ways.

So Athena babysits each deployment. It sounds the diff, the metrics, and the logs, and watches the rollout. During 1 deployment it noticed a problem, investigated, and realized it was an infrastructure issue, not the caller code. Instead of blindly halting everything, it continued deploying to the different machines.

Could I do a amended job? I’m not judge anymore. Athena is much diligent than I tin be. It doesn’t get distracted, doesn’t get impatient, and ne'er stops paying attention. It is tireless.

Engineer the strategy earlier the supplier writes the code

An supplier tin now creation and build an full strategy almost instantly. The creation mightiness moreover beryllium good. But if I simply judge it, do I cognize really it works? Where it breaks? Which corners it cut? Which tradeoffs I agreed to?

At that point, I’ve inherited a bequest codebase that happens to beryllium marque new. That’s vibe coding.

Agentic engineering is moving pinch the supplier connected the strategy first: the architecture, interfaces, constraints, and tradeoffs. When the codification arrives, I understand what I’m astir to own.

There is nary 1 reply to agentic engineering. Everyone useful differently; each exemplary is bully astatine different things. The cardinal present is reps: do a lot, inquire a lot, propulsion distant a lot. You’ll study what useful for you.

Everything we knew astir moving package teams is amplified now. Start pinch testing. When agents constitute and rewrite the implementation, portion tests that reflector the implementation conscionable churn pinch it. Behavior, contract, and spot tests matter truthful overmuch much now: specify the system’s invariants and pin down what must enactment existent while the codification underneath changes freely.

So overmuch of the crippled is migrations now. Code changes are cheap, but systems transportation state: data, moving processes, users mid-flight. Getting from 1 creation to the adjacent without dropping immoderate of that is the portion that’s still hard. The occupation is consequence guidance and migrations.

The supplier copies what it finds successful the codebase. Good patterns amplify. Bad patterns amplify faster. Engineering hygiene is much important than ever: each shape you tolerate becomes the template for the adjacent 100 changes.

And it’s the golden property of personalized tools. You don’t person to beryllium a domain master to constitute a caller linter. So constitute a caller linter. Enforce the pattern, encode the lesson, make the correction impossible. The marginal costs of a bespoke instrumentality has collapsed.

Peer codification reappraisal is dead. We don’t do codification reviews astatine exe.dev: we merge codification we deem should beryllium merged. The reappraisal that matters happens earlier: successful the creation discussion, the contracts, the validation. By the clip the diff exists, the decisions are already made.

Here’s a caller example. Shelley is the coding supplier we vessel successful exe.dev VMs. I wanted its devices to beryllium asynchronous.

The first creation put the onus connected the supplier to determine which commands should tally successful the background. That introduced a ton of separator cases: ample outputs, long-running tasks, blocked agents, and the supplier having to foretell each of this up of time.

If I were vibe coding, I would person accepted that creation and fto the supplier woody pinch those separator cases. Maybe it would person handled them. Maybe it wouldn’t have. I wouldn’t really know.

Instead, we kept discussing the problem and recovered a creation that removed astir of the separator cases entirely. Every bid follows the aforesaid way and automatically moves into the inheritance aft sixty seconds.

I didn’t retrieve this illustration disconnected the apical of my head. I asked an supplier to hunt crossed each of my supplier conversations for a lawsuit wherever my questions had materially changed the architecture. It returned the original request, the first design, the objections I raised, really the creation changed, the last commit, and links to the original sessions.

This is why preserving each speech mattered. The history wasn’t conscionable an archive. I could query it to understand really I worked.

botd is dead; agelong unrecorded botd

There’s 1 much portion of this story. botd died this month. It crumbled nether its ain weight.

That astir apt shouldn’t beryllium surprising. botd was wholly vibe coded. I didn’t publication a azygous statement of its code, nor did I really salary attraction to really it was architected. And astatine its halfway was a genuinely difficult problem: driving each exemplary family done its ain autochthonal harness (Claude Code, Codex, and the rest) while papering complete their differences. That is precisely the benignant of problem wherever architecture matters, and I was not paying attraction to it.

It helped maine present an tremendous magnitude of work, but it yet became the nonstop point I described earlier: a brand-new bequest codebase that I had inherited without knowing each of the decisions wrong it. The architecture was exploratory, and immoderate of the decisions buried successful it made moreover humble changes mean redoing ample parts of the system. And I wanted to build connected apical of Shelley truthful that I could power the harness better; botd was surviving connected borrowed time. It conscionable died earlier I could discontinue it.

But here’s the twist: that hunt I described earlier was ne'er sent to botd. All the history was successful SQLite, truthful I pointed different supplier astatine it and sewage the study anyway. The instrumentality died; the information didn’t.

When I started, my advantage was that the strategy lived successful my head. Six months later, the honorable reply is that I’ve mislaid immoderate of that depth. I don’t person the aforesaid line-by-line familiarity pinch each system.

But I tin inquire agents elaborate questions and usage them to excavation into immoderate I request to understand. Work nary longer waits for maine to decorativeness 1 point earlier starting another.

I’ve shipped much successful these six months than successful immoderate agelong of my career. I’ve besides grounded more: abandoned VMs, dead-end designs, a full instrumentality that collapsed. The failures were cheap, truthful I could spend a batch of them - that’s astir of really I learned what works.

It’s the aforesaid loop that taught maine to code, moved up a level: write, run, fail, fix. I utilized to iterate connected code. Now I iterate connected prompts, designs, full features. A rewrite that utilized to costs a week costs a conversation. And understanding is iterative too: each speech helps maine understand and internalize the strategy more.

I stopped penning codification by hand. I didn’t extremity engineering.