No Going Back

I'm dictating this post through a Swift app I built over the last couple of weeks. Push a key, talk, post appears. I didn't write the code character by character. I described what I wanted and an AI wrote it.

I don't think we're coming back from this.

The back story

My first paid computer job was at 16. £2.50 an hour to run 'remove' commands that deleted leftover files from a typesetting system.

Looking back, that job should have been a cron job. I was literally paid to type commands that could have been automated in five minutes.

One Saturday morning, slightly hungover, I typed rm and got distracted. Came back, typed rm again, then the filename.

Hit enter: rm rm filename.txt

The first rm deleted the second rm. The command deleted itself.

I typed rm anotherfile.txt

Command not found.

Uhoh.

I briefly stared at the cursor wondering what to do. I had to go tell my boss I'd removed his custom 'remove' command. Fair to say the guy was unhappy. He said he didn't have a backup. Oops.

A script that could delete those files would not have been so unreliable. Stupid human.

Since then I've done freelance web design, studied music technology at uni, and worked for SMEs, startups and agencies. I built Java apps for Google Glass in 2013, wrote APIs and front ends, and created server rendering pipelines before Next.js existed. I worked on a whitelabel app platform for six years. I wrote a 12-week bootcamp curriculum that's now trained thousands of developers. I built a social network for music. I've been writing code my entire adult life.

I'm certain the job has changed. Writing code by hand is already becoming a smaller part of it.

What changed

For the last few years, AI has been useful but limited. Early on Copilot changed the game for things I was doing at the time like writing tutorials. I could explain a concept and it would write the example code. 95% accurate, maybe higher. It was impressive but not very disruptive.

Building anything substantial always hit a blocker. Eventually you'd fall into a loop where fixing one bug created another, and fixing that one recreated the first. You'd bounce back and forth without solving the whole problem.

Opus 4.5, combined with a more methodical process, was the first model that got me past that point.

The cost

I started on the simple $20 Pro plan. Then I was bouncing between Claude and GPT. Then Claude Code arrived. It escalated to the 5x plan. Now I pay for the 20x plan and I'm creating more software than I've ever been able to create in my life.

It sounds expensive until you see the output. I spent 30 days building something that would have taken previous teams I've worked with months. It isn't a rough prototype either. The software has more polish than I would ever have added manually for an MVP.

What the job becomes

I don't expect people to pay me to type slowly on a keyboard when they can generate thousands of lines of code in minutes. My feelings about that won't change what they value.

My time moves towards ideas, planning, spec writing and marketing. I need to know when to nudge the AI in the right direction and when to let it run. There is a lot of technique here, and knowing the technology still matters. So does understanding the trade-offs and making the right decisions. We're learning how to work with something that didn't exist two years ago.

I'm uneasy about how quickly things are rebalancing after spending 25 years honing the craft. My unease doesn't make the change any less real.

The project record

The biggest surprise has been the value of the documentation.

A good process can generate requirements documents, flesh out specs, identify risks and create implementation plans that reduce errors and hallucinations. We can log where a plan deviates or runs into trouble, then write verification reports against the original requirements. The problems, fixes and reasons for decisions are captured as part of the work.

Put this corpus into semantic search and the project's history becomes searchable: issues, fixes and the reasoning behind them. In my experience, that level of documentation would have been impractical even for a diligent team because the overhead was too high. Now much of it is produced along the way.

AI needs context, and this documentation supplies it. I'm starting to value the project record more than the code it helped to produce.

The future

For now, the models that produce good code are slow. The fast models can't quite match them yet. Both sides are improving, and we're watching the gap close in real time.

I don't know exactly what software development looks like in five years. But I know it doesn't look like me typing on a keyboard character by character.

We're not coming back from this.