The Hidden Bottleneck: Why AI Productivity Requires Infrastructure, Not Just Models

Amos Haviv, who leads Developer Workflow at Booking.com, argues that the current industry-wide AI budget burn stems from a misunderstanding. Teams are optimizing for code generation speed while ignoring the upstream and downstream constraints that actually define delivery. The hidden consequence is a reliance on static dashboards that create the very metrics they measure, leading to the Cobra Effect where teams optimize for the wrong outcome and mask genuine bottlenecks. The real competitive advantage in the AI era belongs to organizations that treat their Software Development Life Cycle (SDLC) as an event-driven system, separating business as usual from actual feature delivery. For engineering leaders, this conversation shows that the path to ROI is not through more tokens, but through building the observational foundation required to identify where the system is actually stalling.

The Illusion of Velocity

Most organizations are falling into the trap of copycat architecture, mimicking the release patterns of companies like OpenAI or Google without possessing their underlying operational reality. Haviv notes that while these companies operate at massive scale, they often tolerate different uptime requirements than a standard e-commerce business.

"I used to say to my engineers when it was the Google days we are not Google. I cannot afford to be like Claude. I cannot have downtime. So quality of code is also important."

-- Amos Haviv

When teams prioritize fast releases without the guardrails of high-uptime reliability, they are not gaining speed. They are simply shifting the cost of debugging from the development phase to the operational phase. The downstream effect is a system that feels faster in the sprint planning meeting but compounds technical debt and operational overhead every subsequent quarter.

The Cobra Effect in Engineering Metrics

The most dangerous trend in current developer experience is the reliance on static metrics like deployment frequency or lines of code. Haviv warns that when a measurement becomes a target, it ceases to be a useful metric. He points to the historical Cobra Effect, where incentivizing the removal of snakes led people to farm them. In software, this manifests as teams gaming their CI/CD pipelines to inflate deployment numbers while ignoring actual feature value.

The systems-thinking alternative is to stop treating the SDLC as a linear pipeline and start treating it as an event-driven data store. By collecting granular events, from Jira ticket movement to deployment metadata, teams can investigate bottlenecks rather than enforcing arbitrary targets. This requires a shift from dashboard-driven management to investigative data literacy, where leaders query the system based on the specific context of their domain, acknowledging that an iOS developer workflow is fundamentally incomparable to a backend web developer workflow.

The 18-Month Payoff: Why Foundation Matters

Haviv’s team spent four years building an event-based SDLC debugging system long before AI reached its current hype cycle. This delayed payoff is why they are now capable of answering whether AI is actually shipping more features, a question most of their peers cannot answer.

"If you concentrate on what business value you actually create and what your customers actually need. Then, you just see AI as another tool in your toolbox. And then it's important, it's a technical revolution and yet it does not distract me from the value I would like to create."

-- Amos Haviv

This approach requires patience that most modern engineering organizations lack. While others burn through AI budgets chasing immediate productivity gains, teams that invest in the boring work of data reliability and workflow transparency gain a long-term moat. They are not just using AI; they are measuring the impact of AI against a baseline of actual business value.

Key Action Items

• Build an Event Store (Immediate): Stop relying on static dashboards. Start piping CI/CD, deployment, and ticketing metadata into a central event store. This is a foundational investment that pays off in 6 to 12 months when you need to prove ROI.
• Audit Your Cobra Metrics (Next Quarter): Evaluate your current KPIs. If your team is optimizing for number of commits or deployment frequency, you are likely incentivizing the wrong behaviors. Shift toward measuring feature delivery versus keeping the lights on (KTLO).
• Decouple Ownership of Agent Skills (12 to 18 Months): Do not centralize all AI agents. Build a central platform for registries or harnesses, but force domain experts to own the specific skills (MCPs) for their area (e.g., the GitLab team owns the review agent).
• Prioritize Developer Experience Over Raw Speed: Treat Developer Experience as a proxy for velocity. Use regular, high-response-rate surveys to identify where engineers feel blocked, then build the specific tools they request to remove those blocks.
• Stop Token Maxing (Immediate): Stop obsessing over model costs or token usage. Focus on effectiveness. An engineer who delivers a high-quality feature with 500 tokens is more valuable than one who generates 50,000 tokens of slop.