> ## Content Index
> Fetch the complete content index at: https://www.productledalliance.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Loop speed is the new  shipping speed
- URL: https://www.productledalliance.com/loop-speed-is-the-new-shipping-speed/
- Published: 2026-11-16T12:00:00.000Z
- Updated: 2026-11-16T11:59:59.000Z
- Description: Discover the new bottlenecks of product development, as Martin Felcman of Productboard teases his upcoming CPO Summit session.
- Author: Martin Felcman
- Tags: Chief Product Officer, AI & Machine Learning, Articles, #productboard

Coding agents have made the process of building products much faster. But for Martin Felcman, VP of Product & Design at Productboard, that's only raised the stakes on everything else product teams do.

Ahead of his session at [Chief Product Officer Summit London](https://world.productledalliance.com/location/cpolondon) on December 1, Martin shares what building Productboard Spark taught him about what agents need to work across the whole product lifecycle.

And why loop speed, not shipping speed, is the advantage that matters now.

## The bottleneck has changed

When I spoke at Product Operations Summit in Amsterdam earlier this year, I made one point: writing code is no longer the slow part; deciding what to build is. So [product managers (PMs) became the bottleneck](https://www.productledalliance.com/how-product-operations-can-unlock-ais-true-potential/), and the fix was to give them better context to decide with. I still believe that.

What changed is that I stopped seeing it as one problem and started seeing it as a chain of problems, one that loops all the way from spotting a problem to measuring the result. A CPO told us recently: "We've made great progress on agentic coding; now I need to figure out how to feed the beast." That line captures it.

Once building got fast, it didn't just move the slow part one step back to [writing specs](https://www.productledalliance.com/why-product-specs-are-more-important-than-ever/). It made every other step matter more. If you bet on the wrong thing, you now build it at full speed. And when so much gets shipped, nobody notices the things that didn't work out.

The second shift came from asking why coding agents worked so well in the first place. Two and a half years ago, the best AI systems could solve about 2% of real coding tasks on a standard test. Today, it's close to 80%.

Most of that jump didn't come from smarter models. In fact, it came from what sits around the model: one shared codebase every agent can read and write, tests that tell it immediately when it's wrong, and tools to act with.

Planning and learning have none of that. Their information lives in slides, spreadsheets, and people's heads. So my question moved from "how do we give PMs better context?" to "what would it take to give the whole loop the same kind of foundation coding agents have?"

That's what my upcoming London talk is about.

## What building Spark taught me about AI agents

A year ago, I’d have said that how good an AI agent is depends mostly on the model behind it. You build for the next model, wait for it to get smarter, and most of the quality problems go away on their own.

Building [Spark](https://www.productboard.com/product/spark/), our AI agent at Productboard, taught me that's only half true.

Yes, the model matters, but what you build around it matters just as much. For us, that meant the data structure underneath: how a feature connects to the bigger piece of work it belongs to, how that connects to the customer feedback behind it, and how all of it fits together.

These days it's not enough to hand the agent a pile of information. It needs a map of how things relate, and a clear picture of what a good feature or a good initiative looks like. How the work gets defined turned out to matter far more than I expected.

The proof isn't just Spark. Go back to coding agents. On that same coding test, AI systems with nothing built around the model got stuck at about 20%. The ones that reached nearly 80% had the same kind of model, plus the three things I mentioned earlier: a shared codebase, tests, and tools.

Same brains, four times the result, and the difference was the structure.

Spark is the same story for product work. Its structure is the scaffolding around the model, and above all, the data model: features linked to the work they belong to, that work linked to the customer feedback behind it, the feedback linked to the customers and revenue it came from.

A generic agent with a list of instructions has nothing like that to stand on, so every time you ask it something, it has to piece the context together again, or guess.

One of our customers said it better than I can: when he tried prototyping in a general AI tool, he kept having to rebuild the context about customers and feedback every time. In Spark, it was already organized and connected from earlier work.

That's the difference. Not a smarter model, but a structure the model can stand on.

## Rethinking how product teams are structured

If building is no longer the main constraint, should CPOs rethink how their teams are structured? Yes, but the ratio is the wrong place to start.

When something that used to take a whole team three months now takes two engineers a few days, the question is no longer how many engineers you need per product manager.

The question is how fast the team can decide what to build next and find out whether it worked. So I'd organize teams around that, not around headcount.

In practice, that means moving away from fixed teams that own an area forever, toward teams that come together for one funded piece of work and disband once the result is in. We made that change at Productboard this year. It also means the product operations team stops policing process and starts owning the shared information and tools that every PM and every agent works from.

On hiring, the kind of person changes more than the number. I'd hire fewer, more senior PMs who can look at the business and say what's actually wrong, write a description of a feature so clear that an AI agent can build it without asking questions, and check the quality of what AI produces. I'd hire designers who build working prototypes with agents instead of handing over pixels.

The skill that got PMs promoted for ten years, keeping the delivery process running smoothly, is now the part agents do best.

## Who's accountable when agents do the work

Accountability should sit with the same person who was accountable before: the human who said yes.

Agents do the work, people approve it at set points, and that's how the system should be designed, not a legal disclaimer. Every step has a moment where a person signs off. The PM is the author of the feature description and makes the final call on scope.

The leadership team owns the decision about what gets funded and what doesn't. If an agent recommended the wrong thing and someone approved it, the agent didn't fail; the decision did.

Agents change the volume and confidence of what lands on your desk, making it tempting to say yes without really looking. So the real risk isn't agents making decisions. It's people approving things they didn't read.

The practical fix is to write ownership into the work itself, not into a policy document. When you fund something, write down who owns it, what number it's supposed to move, and what evidence the decision was based on.

Then when it misses, you can trace back where it went wrong:

- Did we misread the problem?
- Did we pick the wrong thing to fund?
- Did we describe it badly?
- Or did we build it badly?

Without that trail, accountability falls on whoever happens to be in the room when the numbers turn red, which is usually nobody.

## The most underestimated piece: The glue between agents

Besides context, the thing teams underestimate most is the glue between the agents. Most teams buy or build one good agent for each job: one that reads customer feedback, one that looks at usage data, one that helps with planning, one that writes code. Then they expect those agents to work together as a system. They don't.

Each agent sees its own slice of the world, and none of them talk to each other. The feedback agent knows what customers said, the analytics agent knows what customers did, and nothing connects the two to the thing you decided to build.

The value isn't in any single agent. It's in the links: this piece of customer evidence led to this initiative, this initiative led to this spec, this release produced this result. Without those links, you can't tell whether the pieces agree with each other, and you can't check a result against what you expected.

This is exactly why coding agents worked, and nothing else has yet. Coding agents all share one thing: the codebase. The agents for planning and learning share nothing.

## Three questions before you build your own

The prototype is free, and the bill arrives around month six. So before you decide to build your own agentic product system rather than buy one, ask three questions.

### 1\. Are we building one agent, or a whole system?

One agent that summarizes a pile of customer feedback is a weekend project now. A system where that summary is connected to your customers, your revenue, your roadmap, and your results, with quality checks and a shared data model underneath, is a full platform team. Most teams start a conversation about the first and end up paying for the second.

Those quality checks aren't a one-off, either. The output gets worse over time as models change, prompts change, and the data changes. Without a maintained set of tests (or evals), nobody notices until a PM walks into a product review meeting with a confident recommendation that's wrong. Keeping those tests current is a permanent job.

### 2\. Who owns the shared data?

If the answer is "we'll connect the tools to each other," ask who owns the one place where all that data meets, and who fixes it when one of the tools changes. Lots of agents with no shared place to meet don't work.

This is where most of the hidden work sits. The [prototype](https://www.productledalliance.com/why-fast-ai-prototyping-is-becoming-a-core-pm-skill/) worked because it ran on one clean export. Six months in, you're matching up customer records across your CRM, your feedback tools, and your product analytics, working out which customers are new, growing, or at risk, and discovering that every system names your features differently. None of that shows up in the prototype demo, and it's most of the project.

### 3\. Is this where we want our best people to spend their time?

The engineers who can build this well are the same engineers you want on the product. And once the internal system matters, it needs an owner, a roadmap, and someone on call when it breaks.

You've created a second product with exactly one customer, and that customer is you. That's time and money you chose not to spend on the market.

### The quick test

Can you name the number this is supposed to improve, and the date you'll check it? That's the same test I'd apply to any project we fund. If the team can't say what gets better once the internal system exists, they're building it because it's interesting, not because it matters.

## Stop asking how to build faster

Shipping faster doesn't make you better at product management. It means you reach the end of a wrong decision sooner, with more code to unwind.

Most product teams have already won the coding-agent race, and so has everyone they compete with. The advantage is no longer how fast you ship.

It's how fast you learn, decide, and reallocate: loop speed. The companies that win the next few years will be the ones who can go from a signal in the market to a funded change to a measured result in weeks instead of a year.

So the mindset shift is to stop asking "how do we build faster?" and start asking "how long is our loop, and where is it stuck?"

If you can't state your cycle time from evidence to funded change to measured outcome, you're running a calendar, not a loop.

## Where to start: Write the prediction down

The part of the loop teams often miss is the back half: checking whether what they shipped actually worked.

Analytics tools are mature, so teams assume this part is covered. But knowing how many people used a feature this week isn't the same as knowing whether it moved the number you funded it to move.

You can only check that if you wrote the prediction down when you decided to fund the work, and almost nobody does. Orchestration and evals get all the attention. The boring question, "did we write down what we expected to happen?", is where most systems fail.

So if your company plans once a year, the smallest change you can make next quarter is this: before any initiative gets funded, require one line. What number is this supposed to move, by how much, and by when?

No new tool, no new process, no reorganization. It takes an afternoon, and it does two things at once. It forces a real yes or no on initiatives that can't state their outcome. And it gives you something to check against three months later, which almost nobody does because there was never anything to check against.

**Try this:** Run the retrospective version on last year. Pick three initiatives you funded, and ask what number each was supposed to move and whether it did. If that takes more than an afternoon to answer, you've found your cycle time, and it's a year.

The goal of the smallest change isn't to automate anything yet. It's to turn a calendar into a loop, so that when you do add agents, they have something to shorten.

## Join Martin in London on December 1

In his session at[ Chief Product Officer Summit London](https://world.productledalliance.com/location/cpolondon) on December 1, Martin will go further, walking through the architecture that closes the gap between fast building and everything else. You'll learn:

- How to tell real gains in decision quality from superficial AI productivity
- What a dependable agentic product system is made of, and why each part is easy to underestimate
- How to frame build vs. buy for AI, and why "we'll build it ourselves" is harder than it looks
- Why loop speed, not shipping speed, is the real competitive advantage

[Request your invite](https://world.productledalliance.com/location/cpolondon/register)