You know the drill. It’s time for the daily stand-up.
The sort you’ve been in a hundred times before. 9:15 on a grey Tuesday. The team gathers round a screen, cameras flicker on, boards are shared, and someone says they’ve "almost finished" the thing they’ve definitely only just started. It’s all so familiar. Work ticks forward in tidy little increments, boxed in by sprints and coloured cards. The game hasn’t changed in a decade. Ship fast. Learn fast. Do it all again next week.
... in a world where everyone ships fast, that’s no longer the edge. Velocity has become the baseline as every team moves quickly and everyone is capable of building something. Which means the only thing that matters now is whether you’re building the right thing.
The truth is, most teams aren’t solving problems. They’re solving the process. They’re untangling workflows. They’re working around constraints. They’re fighting blockers and dependencies and tools that almost do what you need, but not quite. And in that world, speed was everything. Whoever shipped first, won. Whoever could get more people doing more things more quickly, took the lead.
That’s where the bot came in.
The Bot
Not the cute ones on websites that pretend to chat. The real bots that run behind the scenes. The scripts. The process runners. They didn’t think or ask or learn but they do move fast and they are reliable. Bots were built for one thing: to execute. If you could predict the pattern, you could automate the action. They were great at repeating steps and in a world where repetition was reality, they scaled.
They ran on rails and it is their predictability that makes them powerful. Removing human error and inefficiency.
Then something changed.
The Prompt
What started as a playground for clever writers and experimental coders suddenly became serious. Large Language Models turned text into a superpower. You could ask a question and get an answer. A good one. You could write a line and get a paragraph. A rough idea became a structured plan in seconds. This is more than automation now, this is acceleration.
But it was still you doing the work.
You needed to know what to ask and how to spot the gaps and misinformation. The prompt didn’t replace your activity, it just made you better at it. You could move faster and be much more efficient with your time. You didn’t have more people on your team, but you felt like you did.
That’s when we started calling it “AI-powered”. Dashboards got prompt inputs, chat widgets were everywhere, and documentation wrote itself. Sort of.
Then, something else entirely different emerged.
Something which doesn’t simply make you faster, more efficient or more reliable. This was the agent, and it does the work for you.
The Agent
Agents don’t wait for instruction. They don’t just respond to inputs or follow a flowchart. They observe. They act. They try. They fail. They try again. They make decisions you didn’t script and take actions you didn’t design. They use tools with intent, just the way people use tools. They navigate APIs, schedule meetings, update records, send emails, analyse data, and adjust their own plans based on what happens next.
They aren’t following rails. You give them a destination and they find their own way there.
👉 What is Agentic Computing?
Work is no longer scarce. It's abundant, it’s cheap, and it’s fast.
When Tools Start to Think
Most teams started by adding AI to their product in the same way they use mobile web views in 2012 to create an app.
Stick a GPT model behind the search. Add a chatbot to handle basic support and FAQ’s. Throw in a prompt interface so users can type what they need instead of clicking through five menus. It made sense from a marketing point of view and it was important to experiment with technology and tooling. The user experience even improved, to a point. The feedback was mostly good. But the structure stayed the same.
All of it still required someone to show up, navigate, decide, instruct, wait, repeat. We weren’t building intelligence into the system. We were just making it easier for humans to be more effective within the system. This was useful and could be considered an upgrade but you’re still designing for a user. Still assuming interaction. Still building interfaces. Still enabling work.
The arrival of agents forced a different question.
What if the user never had to show up at all?
What if the job of the product isn’t to make a task easier, but to make it disappear entirely?
You don’t need a faster form if the agent already filled it in. You don’t need a better dashboard if the agent already acted on the insight. You don’t need clearer buttons or a stronger CTA if the agent already triggered the action.
This is where most product teams start to feel uneasy. We’re used to crafting elegant flows which reduce friction or mastering the details of copy and colour and layout to enhance the experience. We measure time-on-page and funnel conversion. We obsess over how the product feels and even seek to delight.
But agents don’t care about your interface or any of that. Their only metric is outcomes.
The evolution here is that the Agent wants the goal to be achieved without anyone touching your interface at all.
The agent asks: what are people trying to do? And then it does it.
No prompts. No buttons. No best-practices UX.
Just the result.
What It Means to Build What Comes Next
A next-gen product doesn’t just look different. It starts in a different place.
You don’t begin with user stories, instead you understand the user goals. You stop asking how someone will use your software, and start asking what they want your software to do for them; with as little input as possible.
Interfaces become optional. Onboarding becomes irrelevant. Feature sets become capabilities exposed only when needed; not to a user in a tab, but via an execution pathway for the Agent. Your product is no longer a thing someone uses but a system that acts on their behalf.
Which means your team and structures have to be rethought and changed too.
Product managers become something more like goal engineers. They think about outcomes, not screens and interfaces. They define intent and consider boundaries. They work with ambiguity because agents thrive in ambiguity.
Engineers stop hard-coding logic and start designing orchestration layers. They give agents the tools, not the answers. System resilience is important to them as are the constraints that need to be placed on how agents can act and what they have access to.
Designers start thinking less about layout and more about clarity for systems that interpret human intent. The job becomes making meaning, machine-readable.
Even support and operations shift. Instead of considering users they are supporting agents. Debugging behaviours. Intervening only when something doesn’t go to plan. Managing systems that manage other systems.
That’s a new kind of product that doesn’t just help people do things better. It helps people stop doing them entirely.
The Work of Building Has Changed Too
I think that you can see where this is going. This shift isn’t just about what we build but also how we build it.
Because agents don’t just live inside the product they’re embedded in the process of making the product itself. This is actually where your journey with Agents will begin. They’re scoping tasks, writing test cases, generating code, composing marketing copy, mocking up interfaces, rewriting documentation. All in a fraction of the time that it would take your teams to function now. The cost of work that your teams are doing is trending to zero.
The long, expensive arc of product delivery has snapped.
Work is no longer scarce. It's abundant, it’s cheap, and it’s fast. This means that the barrier to success is no longer access to skilled labour or expensive tooling. This is the old currency that was once scarce and is now the default. Everyone now has access to world-class capability on demand at marginal cost whenever they need it. This is what agents provide.
The old belief was that speed was a differentiator. Whoever shipped first, won.
But in a world where everyone ships fast, that’s no longer the edge. Velocity has become the baseline as every team moves quickly and everyone is capable of building something. Which means the only thing that matters now is whether you’re building the right thing.
That is the new strategic imperative. And that is the product manager’s job.
You bring clarity and simplicity and say stop when all the team wants to do is to build more, ship more. It is time to stop mistaking activity for progress and deliver outcomes that actually make a difference.
In this new world, vision becomes more valuable than execution. Not because execution is unimportant but because execution is now easy.
The Tools Use Themselves
We came from a world where the only way to win was to add more people which enabled us to go faster and ship sooner. We learned to do more with less by offshoring and nearshoring but the fundamentals were the same. More people means more output.
Bots helped. Prompts supercharged. But they were still tools for people to use.
Agents bring us into a world where the tools now use themselves.
So if you’re still building like you’re waiting for someone to click a button, you’re building for a user that very soon will no longer exist.
And if you are building like there is always more work to do you will lose to those who are not doing the work at all.
