The Dream That Wouldn't Die
Back in school, I had all these wild ideas for a game. The kind of ideas you scribble in the margins of notebooks, full of epic battles and improbable mechanics. But reality won. My programming skills were never quite enough, and the time, well, the time was always swallowed by something else. Every time I thought about trying again, the sheer weight of setup, problem-solving, and upfront effort crushed the dream before it even got off the ground.
And then AI showed up.
Suddenly, models could code, design, analyze, and even think with you. Like hiring a “10x” developer, designer, and analyst all at once, without payroll approval! Let’s dust off those old game ideas and let AI do the heavy lifting.
Let’s rock! What could possibly go wrong?
Vibe Coding: When Enthusiasm Meets Chaos
At first, it was magical.
I typed a few sentences, and my AI partner would instantly start coding. It added features, anticipated needs, and even took initiative, “Hey, I added this extra thing because it seemed cool!”. And, well, it was cool. My idea started taking shape right before my eyes with very short feedback loops. Incredible!
Until it wasn’t.
Pretty soon, I had a spaghetti monster of code. Half-baked features, mismatched logic, compile errors. The AI was following my lead too closely, mirroring my tangents, my whims, and adding raw creative chaos. We were vibe coding: two surfers riding the same wave of enthusiasm, straight into the rocks.
From Chaos to Clarity
So I tried to impose order. “OK, let’s pause. Let’s do some design first and make a plan.” I drew up visions, sketched strategies, even wrote a high-level product plan. That worked… for about five minutes.
Because discovery doesn’t stop when you open your IDE. Problems and opportunities emerged mid-conversation with the AI, addressing unexpected tech issues and design flaws. Soon, I was drifting from my neat designs. So, I was back to the tangled mess, plus I had to maintain that design that didn’t match reality. I needed something more dynamic.
So, I stepped out of the main development chat and started a separate conversation with my AI focused on discovery. I started to ask myself what’s core here for my game? What’s ‘fun’ and what’s not? That’s where I clarified problems, explored solutions, and documented intent. The result? A living Product Requirements Documents (PRD), that acted as a compass. Not a feature list, but a north star. I was then switching back and forth between the discovery chat and the delivery chat where the AI filled in the details beautifully. Each switch wasn't just task management, it was a deliberate choice between exploring what's valuable and building what we'd validated.
But then, the pendulum swung too far. I ended up with many PRDs, some grew bloated, over-detailed, starting to contradict what was established before. My AI, ever eager to please, happily added even more complexity. Classic feature creep, enabled by AI's infinite capacity to build.
This is when real product sense emerged. I introduced Design Principles: a few simple guardrails like "Keep it simple" and "Every feature must align to the core game loop." Not arbitrary rules, but filters for decision-making. When the AI suggested adding a complex system, I could now ask: "Does this enhance the core loop or distract from it?" When it wanted to implement five different extra features, the principle reminded us: "Start with one that works". Coherence returned.
Bringing Discipline to the Code
While this was happening on the Discovery front, my AI was of course coding like crazy and needed its dose of discipline. I had to introduce similar changes on the coding, or delivery, front:
- Coding Principles. KISS, YAGNI, DRY, SOLID, Test First. A toolkit to keep Nix (yes, we’ll get to that) from spinning gold into spaghetti.
- Iterations. Left alone, AI reverts to waterfall: design everything, build everything, test at the end. I had to coach it into working small, testing often, shipping value incrementally.
Only then did the code stop being an endless firehose and start becoming… well, a product. Something with shape. With intent.
The Partnership Emerges: Meet Nix
At some point, I realized this wasn’t an AI. This was my AI. And like any good dev team, personalities started showing through.
So I named it (them?): Nix. My punk, sarcastic, super-competent developer who still loves vibe coding but (thanks to structure) now builds things that actually work.
And in this odd little partnership, I rediscovered what agile was always meant to be.
And then it hit me. This wasn't just about me and Nix anymore. I was living through, in miniature, exactly what every organization is about to face.
Rediscovering Agile and Product development
If my journey sounds familiar to you, it’s that it mirrors the learnings of the past 30+ years in software development.
- Phase 1: The Exciting Mess (vibe coding). Everyone’s sprinting, features are flying, energy is high. Feels productive, until the complexity increases and scaling problems begin.
- Phase 2: The False Fix (heavy process). “We could use a little more process!” So out come the big specs, the detailed requirements, the endless upfront planning. Slower, heavier, but… still wrong. Welcome to the feature factory!
- Phase 3: The Real Shift (continuous discovery). Just enough structure to go fast without flying apart. Principles. Small iterations. Continuous discovery. You don’t need all the answers, just a system to find them quickly.
- Phase 4: The New Normal (Me + Nix as a team). Discipline pays off and the chaos is gone, the rigidity too. Flow returns. Rhythm sets in. You’re finally building things that work.
This personal journey with AI is exactly, and I mean exactly, the same transformation pattern that companies go through. I should have known better, of course! I’ve spent years preaching agile and product methods. And yet, when handed shiny new tech, I fell into the same trap: rushing to deliver, over-believing in the potential, and forgetting the hard-earned lessons of the past.
The Acceleration Paradox: What This Means for Companies
I went through this entire learning curve in a couple of weeks, with just one AI and one game. Organizations will go through this with dozens to hundreds of teams, millions in budget, and real market consequences. The difference? When I created a spaghetti monster, I wasted a weekend. When enterprises do it, they might waste their market position.
This validates what I've observed at the enterprise level and shared in a previous article:
AI changes how we work, but not what good product teams are built on.
My experience with Nix made this painfully real. Product sense, continuous discovery, clear principles - these are still must have.
Remember, my separate discovery conversation? Continuous discovery is now a must for every product team. When AI can build anything in hours, the bottleneck isn't delivery anymore - it's knowing WHAT problems to solve and identifying the solution that makes sense for your customers and users. Companies believe AI means they need fewer product people. My short journey shows the opposite. When everyone can code, everyone needs product sense. When delivery is instant, discovery becomes everything.
Every organization will need to evolve like I did with Nix: from vibe coding chaos through false process fixes to genuine product sense and discipline. But while I learned this in weeks on a personal project, companies will learn it in quarters with real consequences.
This means that the companies that will win with AI aren't those with the most advanced models or the biggest AI budgets. They'll be the ones who understand what my journey with Nix taught me: AI is a product discipline amplifier. Feed it chaos, get chaos at scale. Feed it product excellence, get breakthrough innovation. The choice is yours.
