AI isn’t just changing how we write code. It’s changing how software evolves.

Most people think AI is making software development faster.

I think they’re looking at the wrong change.

The real transformation isn’t that AI writes code in seconds instead of hours.

It’s that software development is no longer a linear process.

For decades, we built software like a relay race.

A product manager wrote requirements.

A designer created mockups.

Developers built features.

QA found bugs.

Customers eventually provided feedback.

The process repeated.

Everything moved in one direction.

Idea → Build → Test → Release

That model worked.

But it wasn’t built for AI.

Today, the fastest engineering teams don’t build software in a straight line.

They build through continuous learning loops.

Instead of waiting until the end to discover mistakes, they continuously improve their product at three different speeds.

I call them the Three Product Development Loops.

Together, they change not only how software gets built, but also how teams learn.

---

The Three Product Development Loops

The framework is surprisingly simple.

AI Builds.

Humans Direct.

Users Decide.

Each loop happens on a different timescale.

• Minutes: AI improves the implementation.
• Hours: Humans improve the product.
• Days or weeks: Customers improve the vision.

The companies that shorten these loops won’t simply ship software faster.

They’ll discover better products faster.

Let’s look at each one.

---

Loop 1: The Agentic Coding Loop

Runs every few minutes

This is the fastest loop.

The AI receives a goal, a product specification, and ideally a set of tests or evaluations that define success.

Then it gets to work.

It writes code.

Runs tests.

Finds bugs.

Fixes bugs.

Runs the tests again.

Refactors the solution.

Repeats.

Again.

And again.

Sometimes for an hour or more without asking for help.

That’s very different from how AI coding assistants worked just a year ago.

Back then, developers acted as the QA team.

We found bugs manually.

We copied error messages back into ChatGPT or Claude.

We asked the model to try again.

Today’s coding agents increasingly perform that entire cycle themselves.

For enterprise software, this is a massive shift.

In banking and financial services, software isn’t difficult because of the happy path.

It’s difficult because of thousands of exception scenarios.

A customer uploads the wrong document.

A compliance rule changes.

An approval skips a mandatory review.

One workflow suddenly branches into six.

These are exactly the kinds of repetitive problems AI excels at exploring.

Instead of waiting for humans to uncover every edge case, the agent continuously searches for them on its own.

The result is simple.

Humans stop spending their time fixing code.

They start spending their time improving products.

---

Loop 2: The Developer Feedback Loop

Runs every few hours

Every few hours, the developer steps back into the process.

Not to debug.

Not to fix syntax errors.

But to make decisions.

The questions change completely.

Instead of asking:

“Why doesn’t this work?”

You start asking:

• Is this actually the right feature?
• Does this workflow feel natural?
• Is the onboarding too complicated?
• Are we solving the right customer problem?
• Should this feature even exist?

This is where AI changes the role of software engineers.

Developers become product architects.

Many people describe this as “taste.”

I think there’s a better way to think about it.

It’s context.

Humans possess knowledge AI doesn’t.

We understand our customers.

We understand business priorities.

We understand company politics.

We understand regulations.

We understand trade-offs.

In regulated industries, this context advantage becomes even more important.

An AI agent doesn’t know your organisation’s risk appetite.

It doesn’t understand why an auditor may ask for evidence two years from now.

It doesn’t recognise that a clever optimisation in a lending workflow could unintentionally introduce bias.

Humans do.

That’s why I don’t think “human in the loop” is simply about oversight.

It’s about injecting context into the system.

Every decision the developer makes improves the specification.

A better specification produces a better AI.

A better AI produces a better product.

---

Loop 3: The External Feedback Loop

Runs every few days or weeks

Eventually, every product meets reality.

And reality always wins.

Customers rarely use software the way we expect.

They ignore features we thought were essential.

They request features we almost removed.

They discover workflows nobody designed.

That’s why no amount of AI can replace the final feedback loop.

Real users.

Real transactions.

Real analytics.

Real conversations.

Whether you’re running a pilot programme, an alpha release, A/B testing, or simply talking to customers, every interaction teaches you something your team didn’t know before.

In enterprise automation, this loop is critical.

You don’t immediately automate production decisions.

You observe.

You measure.

You validate.

You monitor fairness.

You verify compliance.

You learn.

Every insight updates your product vision.

That updated vision changes the specification.

The new specification guides the AI.

The AI builds a better product.

The cycle begins again.

---

The Real Competitive Advantage Isn’t AI

Most discussions about AI focus on models.

Which model writes better code?

Which model is faster?

Which model is cheaper?

I think that’s becoming the wrong question.

The real competitive advantage isn’t the model.

It’s the learning system built around it.

A team with average AI and exceptional feedback loops will consistently outperform a team with the best AI and poor feedback.

Because AI accelerates implementation.

Feedback accelerates understanding.

Understanding is what creates great products.

---

Engineers Are Quietly Becoming Product Leaders

One of the biggest changes AI is creating has nothing to do with code.

It’s changing what engineers spend their time thinking about.

Less debugging.

Less boilerplate.

Less repetitive implementation.

More customer conversations.

More product thinking.

More strategic decisions.

More experimentation.

The best engineer in the next decade may not be the person who writes the cleanest code.

It may be the person who asks the best questions.

Because once implementation becomes inexpensive, decisions become expensive.

Knowing what to build becomes more valuable than knowing how to build it.

---

One More Loop That Enterprise Teams Can’t Ignore

Most discussions stop at three loops.

In enterprise software, I believe there’s a fourth.

The Governance Loop.

In regulated industries, building the right product isn’t enough.

You also need to prove that it’s secure.

Explainable.

Compliant.

Auditable.

Fair.

Governance isn’t something that happens after development.

It has to evolve alongside every other loop.

The sooner organisations realise this, the easier it becomes to scale AI responsibly.

---

Final Thoughts

For the last thirty years, software companies competed on engineering speed.

Over the next decade, they’ll compete on learning speed.

AI has dramatically reduced the cost of writing software.

The new bottleneck isn’t implementation.

It’s learning.

The teams that learn the fastest will build the best products.

And the fastest learners won’t be the ones with the smartest AI.

They’ll be the ones running the best loops.

Build.

Learn.

Improve.

Repeat.

Because software is no longer built in a straight line.

It’s evolved through continuous learning.