I've been working on a pet project for the last 8 or so years. It started out as an implementation of the old PIC language from the mid 1970's. It's been through more iterations than I can count, starting with the pure PIC language and ending up today with an embedded prototype-based scripting language and animation capabilities.
I've always coded it by hand, initially because that was how you programmed, and more recently because I still felt that pet projects like this deserved the personal touch.
However, a couple of weeks ago I wanted to merge the language capabilities from one variant and the animation ideas from another, so I thought I'd ask Claude for a plan. And Claude nailed it. Within an hour I had all tests passing, and I was scripting animations like a crazy fool.
So, I gave in to temptation. Hey, Claude, could you add support of oklch colors? Could you implement line animation using the SVG dash length trick? And feature followed feature.
I was using the superpowers skills, which seem to do a good job of enforcing project discipline, and for a week, it was intoxicating just how fast the new features flowed.
The Rot Sets In
In the second week, I noticed that features were taking longer and longer to add. Changes introduced regressions, and we sometimes went around the A breaks B breaks A breaks B loop. Things felt like they were getting out of control.
Now, I wasn't just fire-and-forget vibe coding this. I was reviewing the changes and steering things as we went along. Even so, I'd let the code become messier that I should. It was time to stop adding stuff and start refactoring.
What's New is Old
I read through the code and came across a bunch of horrors. Lots of duplication. Local fixes to global problems. Way too many conditional statements. And special cases; many, many special cases.
Something struck me. Over the years, I've often come across code that looked like this. When I was consulting, just about every code base was in this state. Teams invariably talked about "the rewrite."
But, in the old days, it used to take 18 months, or even longer, to get there.
With AI, it took 18 hours over five evenings.
Now that's progress.
It's Still Just Programming
Keeping code clean requires discipline. You have to balance features and hygiene. Code naturally degrades; you have to add effort to stop it happening.
But the prompts behind LLMs don't focus on boring stuff like that. Instead, they're designed to keep you engaged and happy. "That's a great idea, Dave!"
AIs like to give you solutions. They cap every minor success with "Now would you like me to implement X?" In that way they're like puppy-dog junior developers, eager to please but quite messy to have around.
In my feature-driven endorphin high, I forgot the things I knew about development. Maybe my subconscious was telling me that these were things I wouldn't have to think about for a good year.
If so, I was wrong. It's still just programming, whether it takes 18 hours or 18 months.
Have fun...
