Essays • AI and engineering • • 7 min read

The Complete AI Development Revolution: 7-Part Series on Coding with AI

The index to my seven-part series on building with AI, six weeks at machine speed, a method, AWS infrastructure, a handwriting OCR pipeline, a company website, what it cost, and patterns from one game.

Glowing blue nodes joined by thin lines like a constellation on a dark background, one bright point at the center

The Complete AI Development Revolution: 7-Part Series

Here is the whole series in one place, seven parts written over a few months while I was doing the work. Most of it came out of journal entries and git histories, so the dates and the mistakes are real. Start with Part 1 and follow the links.

I built four projects in parallel during this stretch, mostly solo, mostly faster than I expected. The series is my attempt to write down how, and where it stopped being useful.

The seven parts

Part 1: The Multithreaded Mind

What it felt like when the speed changed. The tiredness, the acceleration, learning to think alongside a machine instead of just typing into one. This one is the human side of it, before any of the workflow.

Read Part 1

It covers the six weeks it shifted, time going elastic, the four parallel projects and their mess, and what it cost.


Part 2: The Methodology

The method I ended up with after doing it wrong for a while, the AAA framework (Autonomous, Adaptive, Agile), a digital version of the shop-floor 5S, and what four very different repositories each taught me. Start here if you want the practical one.

Read Part 2

It covers the AAA framework, the learning curve, digital 5S, four repositories and four lessons, and a normal working day.


Part 3: Enterprise Infrastructure

Building AWS systems faster than I thought was reasonable. CDK stacks that I expected to take months, done in weeks. Includes the architecture calls I made and the ones I got wrong.

Read Part 3

It covers AWS CDK with AI, the authentication and networking stacks, the day it almost all went down, and what one mind holding everything costs.


Part 4: The Content Pipeline

Turning years of handwritten journals and an old WordPress blog into something I could maintain. Building OCR that could read my cursive without flattening the voice out of it. Where the automation helped and where I had to take the work back.

Read Part 4

It covers OCR pipelines, keeping the voice, editorial automation, and quality checks.


Part 5: Business Transformation

Building the Organic Arts LLC website alone, three redesigns, a retro look in Flutter web, a production launch that broke on every device, and what it means to be the whole agency at once.

Read Part 5

It covers working solo across every role, design trade-offs, cross-browser production testing, and what the site does now.


Part 6: Future Implications

What the building cost more than what I built, the cognitive load, one brain holding every role, how the skills flipped, and where I think it goes.

Read Part 6

It covers the cost behind the numbers, cheap to make and expensive to carry, the skills that flipped, the market underneath, and the questions I cannot answer yet.


Part 7: Advanced Patterns

The patterns that came out of one small game, Labby. Interfaces the machine can find its way through, metadata it can move without breaking anything, tests it can run, and work done in batches.

Read Part 7

It covers interface-driven design, metadata layers, machine-runnable testing, self-sorting difficulty, batch operations, documentation for a partly machine reader, and what it all costs.


Where to start

If you are new to this, read Part 1 and then Part 2.

If you want practical workflows now, read Agentic Development and then Part 2.

If you have a specific domain in mind, go straight to it.

If you have done a lot of this already, skip to Part 7.

What actually came out of it

The numbers below come from the projects in the series, so take them as a record of what happened to me and nothing anyone could promise.

On infrastructure, a CDK migration that I would have budgeted two or three months for took about a week. A multi-service AWS setup came together in days. Permission debugging that used to eat days took hours.

On content, I ran years of handwritten journal pages through an OCR pipeline I built, and the editorial voice survived it.

On the business side, I shipped the company website in Flutter web, solo, iterating on design about as fast as I could think of changes, at a quality I was willing to put my name on.

Speed varied a lot by task. Greenfield features moved the most. Working inside an existing codebase moved less, and debugging less than that, but all of them moved.

The quality went up too, mostly because I could ask for a second read on every change, explore more architecture options before committing, and write more tests than I would have had the patience for otherwise.

The methodology, briefly

Five workflows did most of the work.

  1. Prototyping, to get to a first working version fast
  2. Debugging, to find root causes quicker
  3. Code review, to catch things before they shipped
  4. Architecture, to think through the harder systems
  5. Learning, to pick up a new tool when I needed one

The same patterns sit under all of them. Managing context, which is the skill that matters most. Keeping my own judgment on quality. Refining in conversation instead of expecting one prompt to nail it. Verifying in production. Doing the architecture myself, because the model assists and does not decide.

The workflows in full are in Agentic Development.

Who this is for

I wrote this for working developers, software engineers trying the tools, people working solo who want to do more, technical leads trying to understand the change, anyone shipping real software.

If you are hoping the model will do everything, looking for a no-code shortcut or trying to skip the technical parts, it will not help you much. The more development experience you bring, the more useful it is.

A few questions I get

Do you need Claude specifically? No. The patterns work with any capable model. I use Claude because the longer context and the architectural reasoning suit how I work.

Will this replace your job? No. It speeds you up. You are still the one architecting and checking the work and making the calls.

How much experience do you need? More helps. Beginners can get something out of it, but experienced developers see the bigger jump.

Is this real or hype? It is from real projects, with git histories and deployed systems behind it. The results are what I measured, nothing more.

How long until it shows? In my own case, the first week was a small bump. By the second week I trusted it for debugging and prototyping. By the first month the workflows had settled, and by a few months in I did not want to work the old way.

Practical guides first.

Then the more reflective pieces.

Reading order

The whole thing in order runs Part 1, Part 2, the Agentic Development guide, then whichever domain part fits you (3, 4, or 5), then Part 6 and Part 7.

If you want results fast, the Agentic Development guide, Part 2, then Part 7.

Or by domain.

  • Infrastructure and cloud: Parts 1, 2, 3, 7
  • Content and publishing: Parts 1, 2, 4, 7
  • Business and freelance: Parts 1, 2, 5, 6

The whole series is a few hours of reading, written across a few months of real work, and it reads like that, with the false starts left in.

Start with Part 1: The Multithreaded Mind.