Last week one of our product managers (PM) built and shipped a feature. Not defined. He did not submit a ticket for this. He built it, tested it and sent it into production. In one day.
A few days ago, our designer noticed that the visual appearance of our IDE plugins was moving away from the design system. In the old world, this meant screenshots, a JIRA ticket, a chat to explain the intent, and a sprint slot. Instead, he opened the agent, tuned the layout himself, tested, iterated and tuned in real-time, then pushed the fix. The person with the strongest design intuition directs the design. No translation layer required.
None of this is theoretically new. Vibe coding has opened the doors of software creation to millions of people. It was a dream. When I shared the information How our engineers doubled throughput, went from coding to validation, and brought design to the fore for rapid experimentation was still an engineering story. The translation of theory into practice has changed. Here’s how it actually played out.
The bottleneck has moved
In 2025, when we first went to AI, the implementation value collapsed. Agents captured scaffolding, tests, and repetitive sticky code that ate up half of the sprint. Cycle times fell from weeks to days, from days to hours. Engineers began to think less about files and functions and more about architecture, constraints, and implementation plans.
But once engineering capability stopped being a bottleneck, we noticed something: Decision-making speed. All the coordination mechanisms we had built to save engineering time (specifications, tickets, commits, rollbacks) were now the slowest part of the system. We were optimizing for a constraint that no longer exists.
What happens during construction is cheaper than coordination
We started asking a different question: What would it look like if the people closest to the intent could ship software directly?
The bosses are already thinking about the specifications. Designers already define structure, structure and behavior. They don’t think in syntax. They think about the consequences. When the cost of converting an intent into a working program was reduced enough, these roles became unnecessary "learn to code." Implementation costs simply fell to their level.
I asked one of our prime ministers, Dmitri, to describe what has changed from his perspective. He told me: "While agents are creating tasks in Zenflow, there are a few minutes of downtime. Just dead air. I wanted to make a little game, something to interact with while you wait."
If you’ve ever managed a product team, you know this kind of idea. It does not move the KPI. This cannot be justified in a prioritization meeting. It is postponed forever. But it adds personality. It makes the product feel like someone paid attention to the little details. These are the things optimized from each backlog maintenance session and the things users remember.
He built it in one day.
In the past, this idea would have died on the prioritization chart. Not because it’s bad, but because the implementation cost makes it illogical to pursue it. When this cost drops close to zero, the calculation changes completely.
Shipping was cheaper than explaining
As more people started building directly, all the layers of the process quietly disappeared. Fewer tickets. Less delivery. Less "can you explain what you mean…" conversations. Fewer moments lost in translation.
For a meaningful class of tasks, it’s been faster to just build something rather than describe what you want and wait for someone else to build it. Think about that for a second. Every modern software organization is built around the assumption that implementation is an expensive part. When this assumption is broken, the organization must change with it.
Our plugin UI designer is a perfect example. The old workflow (screenshot issue, submit ticket, explain gap between intent and execution, wait for sprint slot, review result, request fixes) existed entirely to conserve engineering bandwidth. When a person with design intuition can act directly on it, the whole pile disappears. Not because we eliminated the process for ourselves, but because the process was solving a problem that no longer existed.
Composition effect
What surprises me the most is this: it comes together.
When PMs build their ideas, their specifications become sharper because they now understand what an agent needs to do well. Sharper features produce better agent output. Better output means fewer iteration cycles. We’re seeing a compounding of momentum throughout the week, not only because the models are improving, but because the people using them are getting closer to work.
Dmitri put it well: The feedback loop between intention and outcome went from weeks to minutes. When you can immediately see the result of your specification, you learn what precision the system needs and instinctively begin to provide it.
There’s a secondary effect that’s harder to measure but can’t be missed: Ownership. People stop waiting. They just stop giving tickets for things they can fix. "Builder" ceased to be a job title. This has become standard behavior.
What this means for the industry
A lot "anyone can code" Last year, the story was theoretical or focused on solo founders and small teams. What we experience is different. We have ~50 engineers working on a complex brownfield code base: Multiple surfaces and programming languages, enterprise integrations, full weight of a real production system.
I don’t think we are unique. I think we are fast. And with each new generation of models, the gap between who can build and who can’t is closing faster than most organizations realize. Every software company is about to discover that their PMs and designers are sitting on unrealized build opportunities that are blocked by implementation costs, not capabilities. As these costs continue to decline, the organizational implications are profound.
We started with the intention of accelerating software engineering. What we’ve become is something different: The company everyone sends to.
Andrew Filev is the founder and CEO of Zencoder.
