Over the last ~30 days, I spent time building a SaaS product using AI. Not a prototype — a working system.

It was an idea I had over 15 years ago, but I never had the time or capacity to build it. AI has made it practical to do so now.

What I didn’t expect wasn’t just how fast things would move. It was how little the fundamentals changed.

Building Got Faster. A Lot Faster.

For most of my career, building software followed a familiar pattern: understand the problem → validate → build → validate again.

That sequence made sense when building was expensive. You didn’t want to invest weeks or months into something without confidence that it mattered.

AI changes that.

What used to take weeks can now take hours. What used to take months can now take days. A working system can now be faster — and cheaper — than a research study.

Which creates a real shift: building can become part of discovery — not just the output of it.

But Validation Didn’t Go Away

One of the first reactions I got when I shared what I was doing was:

“Are we just building things without validation now?”

That’s not what’s happening.

Validation still matters — but it moves. You don’t always have to validate before you build. But you still have to validate before you scale.

The difference is that you’re now validating with real behavior rather than projected behavior. Users interacting with a working system tell you things that interviews and surveys don’t.

The feedback loop tightens considerably.

But only if you’re disciplined enough to treat what you’ve built as a hypothesis rather than a conclusion.

The Real Trap Isn’t What It Used to Be

In the past, one of the biggest risk was wasting engineering time.

That constraint is largely gone. The new risk is different: building things that are easy — but don’t matter.

When something takes minutes instead of days, the friction that used to force prioritization disappears. I found myself adding things simply because I could — and then removing them later.

Not because they didn’t work, but because they didn’t improve the product.

(Although I’ll admit I may have left one or two in for fun… including a flux capacitor.)

Some Things Didn’t Get Easier

Despite the speed gains, a few things didn’t change much.

Product judgment didn’t get easier. If anything, it became more important. When building is cheap, it’s easier to build the wrong thing — or too many things.

UI/UX still requires taste. The models are very good at generating interfaces that look reasonable in isolation, but they often combine patterns that don’t quite fit together. Consistency still requires a human eye.

Engineering oversight still matters. AI will generate solutions that work — but not always efficiently. In one case, a geocoding implementation would have made three API requests per address lookup. It worked. It wouldn’t have scaled.

It only got caught because I paused and asked:

“Are you sure that’s efficient?”

That question changed the implementation.

We still live in a trust, but verify world. The difference is that now the trust covers a larger surface area, which makes verification more important, not less.

And Some Things Got Harder

The biggest surprise was this: it’s easier than ever to lose discipline.

When building is fast, it’s easy to jump between ideas, run multiple threads in parallel, and keep adding without consolidating. Without structure, things get messy quickly. You lose track of what changed, introduce regressions, and build things that don’t quite connect.

Once you have multiple AI agents contributing in different roles — implementation, review, second opinions — the coding gets faster, but the need to keep work coherent doesn’t disappear. It just changes shape.

AI doesn’t remove the need for structure.

It makes it more important.

What Actually Changed

After going through this, I think the biggest shift is this: the constraint has moved.

It’s no longer: can we build this?

It’s: should this exist at all?

That decision used to be partially enforced by cost and time. Now it’s almost entirely a matter of judgment.

Which means the core responsibility of product leadership hasn’t diminished. It’s more important.

When execution is no longer the bottleneck, the only real differentiator is the quality of your decisions about what to build, what to cut, and what to skip altogether.

That’s not a technical skill. It never was.

Next: what this actually looked like in practice — the architecture decisions, the multi-agent workflow, and where things went wrong.