The Falling Cost of Restarting Software

I went into software development wanting to solve things. Or at least, this is the story that I like to go with.

The beauty of software development, to me, has always been its potential to solve problems. It is one of the few professions where, without much access to capital or physical assets, the world can still feel like a canvas, provided, of course, that you can code for long enough.

Market research only gets you so far, and if you get past the “should I not do this?” phase of things, it’s natural to shift into the “learning by building” phase. So, in stints and bursts, I would start working on some new idea, hoping to build towards a solution.

The problem is that while building things can be fast, and you’re often left with at least something fun to show off, it’s rare that you’re going to solve any substantial issue with a burst of effort on the side.

Building is important. So is validation. So is figuring out whether anyone actually wants to use what you’re making. While finance may not be the limiting factor here, the clock very much is.

And attention. That thing too.

Perhaps this is why agentic AI has been so exciting.

There is only one me, and I may, in bursts, be willing and able to work for free. But I can have as many agents working on as many tasks as I can put my mind to. The obvious consequence is that it becomes much cheaper to start things. The less obvious consequence is that it also becomes much cheaper to come back to them.

Given that constraint has loosened, it’s kind of natural for my attention to spread across more ideas.

Why not spin up Lovable to develop a dating-card creation app if it’s only going to take a few hours? A sudden sharp drop in the cost of building things means: why not give things a shot?

But there’s still that attention thing.

The natural result is to go from one or two unfinished side projects to ten or twenty unfinished side projects.

Agentic AI doesn’t really solve the attention problem. In some ways, it makes it worse. It gives you more things worth paying attention to.

But a fun thing I’ve realized is that agentic AI is particularly good at fishing old ideas back out of storage.

Old conversation threads, design decisions, architecture discussions, requirements, rejected approaches, and service designs are things that previously would have been nearly impossible to reconstruct from memory.

But the beauty of having discussed these things in ChatGPT or elsewhere is that it creates little hardened supplies of information in text, a kind of accidental institutional memory for a one-person software shop.

These conversations were not necessarily written as documentation. But they contain the residue of the work: why something was designed a certain way, what alternatives were considered, what still needed to be done, and what I thought the project might eventually become.

And increasingly, that is only a prompt or two away from being summarized, organized into documentation, and handed to an eager bot army.

Once upon a time, in the distant year of 2025, restarting a project meant performing a miniature re-onboarding.

As a somewhat fun example, I wrote about this while reviving an old Android app of mine here: Reviving an Old Android App.

You’d open the repository. Stare at some code you vaguely remembered writing. Figure out what still worked. Rediscover why there were three similarly named services. Read old commits. Fix the development environment. Gradually rebuild the mental model you once had.

For sufficiently old projects, the first task was basically software archaeology.

But it is remarkable what a team of agents can accomplish.

I recently brought Spontaniius out of the back closet again. The difference was that this time I was armed with automated tests and a handful of Markdown files generated from past conversations.

With those in place, I was able to bring the entire thing back online in an afternoon, with perhaps ten bots quickly doing what once would have taken me a week of crawling through my own old code.

The agents weren’t magically reconstructing everything I once knew. They had evidence to work from: tests describing intended behaviour, version-controlled code describing what existed, and old conversations describing why it existed.

AI can recover recorded context remarkably well. It cannot recover context that never escaped your head.

That has made me think somewhat differently about documentation, testing, and even old chat logs. They aren’t just useful for the person working on the project today. They are increasingly machine-readable breadcrumbs for whoever, or whatever, has to understand the project tomorrow.

The interesting consequence is that the economics of abandoning a software project have changed.

Historically, putting down a side project had a hidden cost. Every month away from it meant more context disappearing. Eventually, picking it back up could require enough re-learning that starting something new felt easier.

Now, if I leave behind enough context, putting a project down doesn’t necessarily mean losing the investment I made in understanding it.

Your old ideas are no longer simply buried. They’re waiting out there to be dug into further.

Agentic AI hasn’t solved my attention problem. I still have too many ideas and too little time to properly pursue all of them.

But it has changed what abandonment means. A project I stop working on no longer has to become archaeological software. If I leave behind tests, conversations, and enough context, a future version of me can hand much of the excavation to a team of agents and be productive again within hours.

Making software has become cheaper. Funnily enough, that means it’s also become cheap enough not to throw away.