The Blurred Lines

Lately I’ve noticed something happening on our team that would have felt strange a few years ago.

Me, our CTO, and our Director of Engineering are all doing essentially the same thing.

Not identical work. Different strengths. Different lenses. But overlapping execution in a very real way.

Steve, our CTO, is deep in the weeds testing tools, pushing on new skills, and experimenting with fully autonomous agents. I’m focused more on product feel, interactions, and how things actually come together in the experience. Bryan is dialed in on security, consistency, and quality.

But we’re all pushing code.

And the truth is, I don’t think we could be shipping nearly as fast right now if we tried to keep the lines clean.

This would have been weird before

Historically, there were clear boundaries for a reason.

Product defined the problem.
Engineering built the solution.
CTO focused on architecture, systems, and long-term direction.

And honestly, there was a time when engineering not wanting product anywhere near the code made total sense. It protected quality. It protected consistency. It kept ownership clear.

But AI-assisted development is changing the cost of contribution.

Now a product leader can meaningfully contribute to real implementation. Engineers are shaping product decisions in real time, not just reacting to specs. The CTO is in the tools every day, testing what’s possible and pushing the edge of how we build.

The distance between idea and execution is collapsing.

And with that, the old boundaries start to get in the way.

We’re faster because the lines are blurred

The biggest realization for me has been this:

We could not be moving at this pace if we tried to preserve traditional role separation.

Agentic development thrives on momentum. It rewards people who can see a problem, take a swing at it, and move it forward without waiting for a handoff.

If every idea has to travel through a clean chain of:
Product → Spec → Engineering → Review → Ship

You lose time. You lose context. You lose energy.

But when the same group of people can:

• spot the problem
• sketch the solution
• try something
• refine it
• and ship it

You compress weeks into days.

That’s what we’re seeing right now.

It takes trust. And it’s uncomfortable.

This only works because there’s a lot of trust.

We’ve worked together across multiple companies for 15+ years. We know how each other thinks. We know each other’s strengths. We know when to push and when to step back.

And if I’m being honest, it takes some uncomfortable acceptance. Especially on the engineering side.

Letting a product person contribute to the codebase isn’t a small shift. It challenges old instincts. It can feel risky. It can feel messy.

But the reality is, the best ideas have always come from when the lines blur a bit.

At Wondr, one of our engineers, Chase, had ideas that directly improved mobile app adoption. Not theoretical improvements. Measurable impact. Those ideas didn’t come from a spec. They came from being close to the problem and thinking like a product person while building like an engineer.

That kind of cross-pollination isn’t new.

What’s new is that now we’re not just sharing goals.

We’re sharing execution.

This isn’t for everyone

I don’t think this model works everywhere. At least not yet.

It probably breaks down in:

• Large organizations
• Low-trust environments
• Teams that haven’t worked together long
• Places without strong systems and safeguards

If you don’t have maturity, clear workflows, and mutual respect, blurred lines can quickly turn into chaos.

But for small, experienced, high-trust teams, the upside is massive.

You get:

• More velocity
• Faster learning loops
• Better ideas
• More ownership
• Less waiting

And if you have the right guardrails in place around security, quality, and consistency, you can move fast without breaking everything.

The future feels different

This is one of the bigger shifts I’m seeing up close.

It’s not just that AI helps engineers code faster.

It’s that the definition of who builds is starting to change.

Product leaders can execute.
Engineers can shape product in real time.
CTOs are experimenting directly in the tools.

The roles don’t disappear. The strengths still matter. The lenses are still different.

But the lines between them are getting harder to see.

And in the right environment, that’s a good thing.

The best small teams aren’t just aligned on goals anymore.

They’re aligned in execution.