Faster Than I Could Think

Two people, one AI, and every mistake I didn't see coming.

At the end of 2025, I left my CTO job without a plan. What I had was a feeling that if I took the next obvious role at the next obvious company, I’d regret it for a long time.

Cansu, my wife, had been off work intentionally for a couple of years. When I told her I wanted to build something, she didn’t hesitate. She’s a UX designer by trade, had never written code, and didn’t care. We’d figure it out. What mattered was that it was ours. The purpose, the decisions, the risk. All of it.

We built a cycling coaching app called Steady. Just the two of us and Claude Code, no team, no funding, no meetings beyond a daily standup (unless you count product discussions over lunch and dinner). We launched it on March 23.

I want to tell you about what happened next. Not the polished version. The real one.

What’s possible now

I need to say this first, because it’s true and I don’t want it to get lost in what follows: the speed is something else.

We went from an empty repo to a launched product in about eight weeks. The codebase is well north of 50,000 lines (not that lines of code are the metric to optimize for, but it gives a sense of the surface area). Custom-generated training plans, workout and weekly reviews, a coaching chat, Strava integration, the works. This is not a weekend project that got a landing page. It’s a real product with real infrastructure. Two years ago, this would easily have been a year of work for a small team.

Cansu went from UX designer to shipping production code. Not tweaking CSS, but building features, implementing flows, writing logic. She’d never touched code before this project.

It’s the best work experience of my life. I’d wanted to build something like this for years and never did. I’d been in leadership roles, away from the code, and the cost of warming back up always felt too steep. So it stayed in the “someday” pile. Claude Code collapsed that barrier — not just for writing code, but for the surrounding infrastructure: hosting, deployments, security concerns that come with LLM-generated code. The tooling today makes all of that accessible in a way it simply wasn’t before.

It gave me back the autonomy, the pace, building something real with someone I love. I’ve led teams of fifty. You’d expect two people to feel simpler. It didn’t. The complexity was different, but surprisingly comparable. That part I wasn’t ready for.

So what I’m about to tell you is not a story about AI failing. It’s about what happens when it works so well that you stop noticing the problems you’re creating for yourself.

The scope trap

When building is expensive, you validate before you build. You have to. The cost of getting it wrong is weeks of engineering time, and you can feel that cost in your gut every time you commit to a feature. Same for the opportunity cost.

When building is nearly free, that forcing function disappears. And I walked right into it.

I actually did talk to users. I had three athletes on a proof of concept before building, and I learned a lot from them. The problem was that they each had different types of goals, different training backgrounds, different needs. And because Claude Code made building feel like a superpower, instead of being ruthless about what to cut and who to focus on first, I just decided to build for all of them. And more.

The scope grew. Each feature was buildable in a day or two, so I built it. “Should we build this?” became “we can build this, why wouldn’t we?” over and over, quietly, without me noticing. We launched broader than we needed to be and thinner than we should have been. And honestly, a lot of this was driven by fear of missing out on certain cohorts of users and the launch being a “nothingburger” because of it.

The cognitive debt

The second trap was quieter and took me longer to see.

Claude Code can generate code faster than my brain can absorb the complexity of what it generated. That sounds obvious when I write it down. It was not obvious while it was happening.

Every coding session added business logic, and every session the system got a little bigger than my mental model of it. Not because I had twenty agents running in parallel. Because each individual session produced more than I could fully hold in my head, and the compound effect crept up on me.

I’d review the code and understand each piece. But the interactions between pieces, the subtle assumptions baked into one module that affected another... that part kept slipping. We threw away fourteen hundred lines of onboarding code two weeks after launch. The AI wrote them in hours. Knowing they had to go took watching real people struggle.

The tool extended my hands but not my head. That’s the sentence I keep coming back to.

The wrong dashboard

Here’s the thing. I wasn’t careless. I had Claude Code writing unit tests diligently. I had CodeScene monitoring complexity and flagging technical debt. The metrics were green. Tests passed, complexity stayed in check, and I felt like I was doing the responsible thing.

But I was watching insufficient signals. What I missed was the layer underneath: domain architecture. Boundaries between concerns, keeping entities focused, making sure the athlete object didn’t become a dumping ground for every piece of data the system needed. The kind of structural decisions that a more experienced developer enforces from day one because they’ve been burned by what happens when you don’t.

I hadn’t been burned by it, so I didn’t think to watch for it. And Claude Code won’t push back on a bloated domain model. It’ll happily add another field, another method, another concern, and write perfectly clean code on top of a structure that’s slowly, insidiously collapsing. The tests pass. The complexity score looks fine. The architecture rots underneath.

The consequence was brutal: bugs that were hard to isolate because everything was tangled together, and Claude Code spinning its wheels on fixes because every change touched too many things. The quality tools I’d set up were telling me everything was fine while the foundation was cracking.

AI tools will enforce whatever standards you set. They won’t set the standards you forgot to set. And the gap between the standards you think to ask for and the ones you don’t is exactly the gap between where you are and where you need to be.

What this is about now

I’ve been writing The Hagakure on and off since April 2020 (six years this month), going quiet every time I went deep into a new role. The pattern held: I left Resquared, went quiet, and built something.

I’m not quiet anymore. The Hagakure was always a place where I worked through what I was learning, and that hasn’t changed. What changed is the subject. I’m building with AI every day now, and I want to write about what I’m finding: what actually works, what doesn’t, and what gets drowned out by the noise of people calling everything a revolution.

And it’s not just about the tools. AI is reshaping how teams work, how organizations are structured, and what leadership has to look like. The Hagakure was always about craft, judgment, and how people grow in their work. Those questions don’t go away in this new world — they get sharper. I’ll keep writing about them too.

I’m glad to be back.