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.
The Complete AI Development Revolution: 7-Part Series
This is the index page for the whole series. Seven parts, written over a few months while I was actually doing the work, not after. Most of it came out of journal entries and git histories, so the dates and the mistakes are real. If you only read one thing, 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.
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. This is the practical one if you want to start.
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.
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.
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.
Covers: working solo across every role, design trade-offs, cross-browser production testing, and what the site does now.
Part 6: Future Implications
Less about what I built and more about what it cost: the cognitive load, one brain holding every role, how the skills flipped, and where I think it goes.
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.
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:
If you have done a lot of this already, skip to Part 7.
What actually came out of it
The numbers below are from the projects in the series, not from a benchmark. Take them as a record, not a 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:
- Prototyping, to get to a first working version fast
- Debugging, to find root causes quicker
- Code review, to catch things before they shipped
- Architecture, to think through the harder systems
- Learning, to pick up a new tool when I needed one
The patterns under all of them are the same. Manage context, which is the skill that matters most. Keep your own judgment on quality. Refine in conversation instead of expecting one prompt to nail it. Verify in production. And do the architecture yourself; the model assists, it does not decide.
The workflows in full are in Agentic Development.
Who this is for
This is written for working developers. Software engineers trying the tools, people working solo who want to do more, technical leads trying to understand the change, and anyone shipping real software.
It is not written for people hoping the model will do everything, or looking for a no-code shortcut, or trying to skip the technical parts. The more development experience you bring, the more useful this 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, 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.
Related reading
Practical guides:
More reflective pieces:
- The Multithreaded Mind
- Living Through the AI Revolution
- Layers of Abstraction
- I AM AI SLOP: Confessions from the Forge, on owning AI collaboration and what separates craft from waste
Reading order
For the whole thing in order: 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.
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 series runs about seven parts and a few hours of reading. It was written across a few months of real work, and it reads like that, with the false starts left in.