# AI will reduce developer productivity before it unlocks faster delivery | LinearB Blog

> LinearB CEO Ori Keren shares why AI adoption will temporarily reduce developer productivity before unlocking faster delivery. Learn why senior engineers are transforming into multi-agent teams, how to navigate the 2025 productivity paradox, and how engineering intelligence connects real-time signals to delivery outcomes.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "AI will reduce developer productivity before it unlocks faster delivery",
      "item": "https://linearb.io/blog/ai-developer-productivity-paradox-linearb-ori-keren"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

AI will reduce developer productivity before it unlocks faster delivery

# AI will reduce developer productivity before it unlocks faster delivery

![Photo of Ben Lloyd Pearson](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/blp_headshot_1_ee25d527aa?_a=BAVMn6ID0)

By [Ben Lloyd Pearson](https://linearb.io/blog/ai-developer-productivity-paradox-linearb-ori-keren#ben-lloyd-pearson)

|

December 11, 2024

![Blog_Dev_prod_will_decline_2400x1256_928f03efec](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Dev_prod_will_decline_2400x1256_928f03efec?_a=BAVMn6ID0)

During a recent episode of the Dev Interrupted podcast featuring [LinearB CEO Ori Keren](https://linearb.io/dev-interrupted/podcast/developer-productivity-will-decline-in-2025), one thing became abundantly clear. As engineering leaders map their 2025 roadmaps, AI stands as the defining trend, but not in the way many expect. The maturation of AI will unfold along two distinct tracks, each with its own timeline and implications for how teams operate. Preparing for this shift requires an understanding of how new tools will alter daily workflows, impact developer experience, and ultimately [reshape the definition of productivity itself](https://linearb.io/resources/engineering-leader-guide-to-accelerating-developer-productivity).

## **AI coding tools will mature before autonomous delivery agents**

The first track involves AI-assisted coding tools embedded directly into IDEs. These technologies, think Copilot, Cursor, and similar platforms, are poised to move from early adoption into mainstream maturity. For junior developers especially, proficiency with these tools will create a measurable productivity gap. Those who learn to leverage AI assistance effectively will accelerate their output dramatically, while those who do not risk falling behind.

> "I think the senior developers are very interesting because these folks, if they are able to leverage the entire potential that AI has to offer here, they could become small teams."

Senior engineers represent a different opportunity entirely. With the right orchestration, experienced developers could deploy multiple specialized agents across their workflow. One agent might handle basic code reviews, another could monitor pipeline health, and a third might identify and fix flaky tests. This multi-agent approach could transform individual contributors into what effectively functions as a small team, amplifying their scope across review, debugging, and delivery optimization.

The second track, fully agentic workflows that autonomously move from ticket to pull request, remains in an earlier experimentation phase. While the promise is compelling, the practical challenges of embedding these systems into production environments are substantial. The central hurdle is not replacing engineers but determining orchestration. Teams will need time to figure out exactly how to embed these technologies, when to rely on human intervention, and when it is safe to let autonomous agents run their course. As these capabilities mature, governance becomes critical, especially when agentic behavior intersects with compliance requirements, security protocols, and [standardized CI/CD pipeline practices](https://linearb.io/blog/how-agentic-ai-will-disrupt-your-software-delivery-lifecycle). Organizations that establish clear frameworks now will be better positioned to scale these technologies when they stabilize.

## **Real-time developer signals expose friction teams can fix**

[Developer experience measurement](https://linearb.io/resources/software-engineering-benchmarks-report) stands at a crossroads. The traditional survey-heavy approach, often semi-academic in tone and detached from daily work, is proving insufficient for organizations that need to move quickly on experience improvements. The evolution requires a fundamental shift: moving from infrequent, abstract questionnaires toward a hybrid model that combines qualitative and quantitative signals captured in the flow of work.

Context-aware feedback mechanisms that prompt developers immediately after completing a task yield richer, more actionable data than periodic surveys asking them to recall experiences from weeks prior. Capturing insights literally seconds after a task is completed provides incredible visibility into the exact problems a developer is facing. This shift from passive to active measurement creates opportunities to identify friction points with absolute precision.

But measurement alone is not enough. The real innovation in developer experience will come from platforms that not only surface problems but also provide tools to solve them. Build times, test determinism, environment availability, and CI stability materially shape daily experience, and they are measurable. More importantly, they are fixable.

Organizations that treat developer experience measurement as a continuous practice rather than a periodic diagnostic exercise gain the foundation needed to justify investment. When leaders can connect specific friction points like excessive wait times for environments, unstable test suites, and inefficient handoffs to delivery outcomes, the business case for platform improvements becomes clear. Measurement creates the evidence base that transforms developer experience from a nice-to-have into a strategic priority.

## **AI adoption will lower productivity before teams see gains**

The term "developer productivity" carries baggage. Unlike "sales efficiency," which focuses on optimizing a process, developer productivity centers on individuals, and worse, on individual developers rather than teams. This framing invites misinterpretation, suggesting surveillance and stack-ranking when the actual objective is improving the efficiency of the software delivery process.

> "I predict that productivity will go down next year. It will decrease."

This prediction, bold and counterintuitive, reflects the reality that every significant technology adoption follows a learning curve. Organizations absorbing new AI tools, navigating resistance, and adapting workflows will experience an initial dip before realizing gains. The path to 10x productivity runs through a valley of experimentation, adjustment, and cultural change.

Current productivity debates reflect deep polarization across multiple dimensions, weighing AI adoption against control, hybrid work against office mandates, and standardization against developer freedom. These contrasts create tension that engineering leaders must navigate without clear playbooks.

The connection between productivity and experience is direct. Poor experience does not just frustrate developers; it actively degrades productivity. Excessive waiting on environments, unstable test suites, and inefficient workflows transform normal workload into sustained overwork, creating the conditions for burnout.

Addressing productivity requires treating it as what it actually is: a team sport shaped by process quality, tooling, and organizational choices. Leaders must define a clear philosophy, decide what matters, measure it consistently, and use those [metrics to drive improvement](https://linearb.io/blog/software-development-metrics-guide). Productivity cannot remain an abstract aspiration. It requires operational rigor, as it is impossible to optimize a process you are not actively measuring.

The recommendation is straightforward. Choose metrics intentionally based on strategy and philosophy, measure them continuously, and deploy frameworks that enable action, not just observation. Sales leaders would not dream of operating without funnel metrics and conversion data. Engineering leaders need equivalent discipline around their delivery pipeline.

## **Engineering intelligence turns pipeline visibility into faster delivery**

[Software engineering intelligence](https://linearb.io/blog/software-engineering-intelligence-101) has emerged as one of the core frameworks for understanding developer experience, sitting alongside surveys and internal developer platforms as a foundational capability. At its essence, engineering intelligence makes the development pipeline observable. It surfaces where bottlenecks occur, where instability creeps in, and where inefficient handoffs slow delivery. This visibility creates the context needed to intervene effectively.

> "We believe not just in showing you where the problems are, but in giving you tools to actually go and solve these problems."

The distinction between passive observation and active intervention defines the next generation of engineering intelligence platforms. Identifying that build times are excessive or tests are flaky is valuable, but only if teams can then shorten those builds, stabilize those tests, and improve operational flow.

This capability becomes especially critical as organizations deploy AI and automation. Engineering intelligence provides the context layer that helps teams identify where agents or automation can have measurable impact. Without pipeline-level insight, automation decisions rely on intuition, a risky foundation for significant investment.

The goal is to move beyond dashboards that report problems toward integrated platforms that help teams fix root causes. When engineering intelligence connects directly to remediation capabilities, it transforms from a diagnostic tool into a delivery accelerator.

## **Data-driven engineering leaders tie delivery health to business results**

Engineering leadership may be the toughest role in technology organizations. The dual mandate, translating between technical and business contexts, balancing people and process, optimizing for both speed and quality, requires fluency in multiple languages and the judgment to know when to prioritize which concern.

[Data-driven leadership](https://linearb.io/platform/goals-and-reporting) provides a framework for navigating this complexity. Just as sales organizations map their funnel with precision, engineering leaders must map their delivery pipeline with equivalent rigor, identifying where handoffs slow down, where work queues up, and where quality issues emerge.

This is not about measuring everything. It is about choosing metrics intentionally, based on a clear philosophy and strategy, then measuring them continuously so optimization becomes possible. One-time diagnostics do not create lasting change; continuous measurement does.

The connection to business objectives is non-negotiable. Engineering leaders who can draw clear lines between technical metrics and business outcomes, showing how delivery health, speed, and quality connect to organizational goals, gain the credibility needed to secure investment in platform improvements and developer experience initiatives.

## **Navigating the 2025 Productivity Paradox**

For leaders new to the role or stepping into new organizations, the advice is consistent: define your philosophy, choose what you will measure based on that philosophy, adopt systems that help you measure continuously, and use those insights to drive improvement. Do not assume you can optimize systems you are not observing.

The human element remains central. Even in an era of increasing automation and AI assistance, engineering leaders work with people who face resistance to change, concern about job security, and the daily friction of imperfect tools. Data provides the foundation for better decisions, but leadership remains fundamentally about people navigating change together.

As organizations enter 2025, the leaders who balance people, process, and product, using data to guide investment without losing sight of human concerns, will be best positioned to navigate the productivity paradox, harness AI effectively, and [build the developer experience](https://linearb.io/blog/developer-experience) that attracts and retains exceptional talent.

Listen to Ori's full conversation on the Dev Interrupted podcast for a deeper dive into his predictions for the future of developer productivity and AI orchestration.

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![blp_headshot_1_ee25d527aa](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/blp_headshot_1_ee25d527aa?_a=BAVMn6ID0)

## Ben Lloyd Pearson

Ben hosts Dev Interrupted, a podcast and newsletter for engineering leaders, and is Director of DevEx Strategy at LinearB. Ben has spent the last decade working in platform engineering and developer advocacy to help teams improve workflows, foster internal and external communities, and deliver better developer experiences.

### Connect with

[](https://www.linkedin.com/in/benlloydpearson)
[](https://substack.com/@benlloydpearson)

## Your next read

[![Cover image for Your software factory needs a context layer](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/unnamed_4_b35455ae7a?_a=BAVMn6ID0)](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

AI

[Your software factory needs a context layer](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption...

[![Cover image for You can now measure AI ROI with LinearB](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_1_dd1f47bae7?_a=BAVMn6ID0)](https://linearb.io/blog/ai-roi-dashboard)

AI

[You can now measure AI ROI with LinearB](https://linearb.io/blog/ai-roi-dashboard)

Today, we're launching the AI ROI dashboard in LinearB, live now for every customer with metrics builder enabled.

[![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

AI

[AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "AI will reduce developer productivity before it unlocks faster delivery",
  "url": "https://linearb.io/blog/ai-developer-productivity-paradox-linearb-ori-keren",
  "author": {
    "@type": "Person",
    "name": "Ben Lloyd Pearson"
  },
  "datePublished": "2024-12-11T08:00:00.000Z",
  "dateModified": "2024-12-11T08:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1785886726/Blog_Dev_prod_will_decline_2400x1256_928f03efec.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "LinearB CEO Ori Keren shares why AI adoption will temporarily reduce developer productivity before unlocking faster delivery. Learn why senior engineers are transforming into multi-agent teams, how to navigate the 2025 productivity paradox, and how engineering intelligence connects real-time signals to delivery outcomes."
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/resources/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)