Still Waiting for AI to Transform How You Code? You May be Missing the Bigger Picture
Software development is at an inflection point: speed, quality, and cost are all being rewritten by AI. AI isn’t just learning to code like humans; it’s dismantling the human-first model of software development and rebuilding it as machine-first. OpenAI’s Sam Altman predicts that by the end of 2025, AI will likely be better at coding than any human. Meta CEO Mark Zuckerberg expects AI to handle half of all software development at Meta within a year. Anthropic CEO Dario Amodei says we may be only three to six months away from AI writing 90% of code, and within a year, nearly all of it. Microsoft CTO Kevin Scott projects that 95% of all code will be AI-generated by 2030, while Satya Nadella notes that at Microsoft, 20–30% of code is already written by AI today. The message is clear: AI isn’t a plugin for developers; it’s the new foundation of software itself. But here’s the reality: adoption remains limited. A 2025 McKinsey survey found that only 17% of organizations report regularly using generative AI in IT, even though IT is one of the leading functions for deployment.1 That is not because the technology isn’t capable, but because they’re applying it in the wrong way – too narrow, too tacit, without explicit culture change, and with challenges in measuring the progress. Instead of focusing on the handful of recurring friction points that cause the most delay and waste in end-to-end software development, teams focus on coding only, leaving the core bottlenecks untouched. The fastest way to realize AI’s promise is to target those high-impact areas and truly think end-to-end, and measure progress relentlessly. And once that’s in place, your outsourcing partners should be held accountable for meeting and proving the expected results. Leaders Are Getting There. Most Aren’t. A handful of organizations are already showing what’s possible. They’ve embedded AI across the entire software development lifecycle (SDLC), not just in code generation. They’re also driving adoption through management and culture change, and they can measure improvements in speed, quality, and cost. Agents help them prioritize backlogs, keep documentation current, expand test coverage, and make retrospectives actionable. Leaders like Airbnb have demonstrated what’s possible when AI is embedded where it counts. Airbnb compressed 18 months of test migration work into just six weeks using large language models. Beyond single-company examples, research backs this up: GitHub reports that Copilot users complete coding tasks up to 55% faster, and McKinsey’s findings show generative AI can cut development time by nearly half. But for most teams, adoption is limited. Efforts stall after coding experiments, while bottlenecks in testing, maintenance, and deployment go untouched. Tool sprawl compounds delays, making core workflows like backlog grooming and reviews slower and more error prone. The issue isn’t whether AI works. It’s whether you’re applying it to the work that matters most. From Blockers to Breakthroughs The real breakthrough isn’t adding AI to coding tasks — it’s rethinking the entire SDLC as AI-first. Instead of human-first workflows patched with tools, teams need to flip the model: let AI handle the repetitive flow and bring humans in for judgment and creativity. Breakthrough comes when AI is measured not at the task level but across delivery speed, quality, and cost end to end. It also depends on applying AI continuously from the first requirements through coding, testing, and deployment in one consistent flow. That transformation depends on four dimensions: Mindset Shift: Put AI first, human validation second. Flip the model: let AI handle the routine flow, and reserve human effort for refinement and oversight. In regulated sectors like healthcare, finance, and defense, this shift must be grounded in rigorous human review. Measurement Discipline: Track delivery speed, quality, and cost end-to-end, not just isolated productivity gains. Strong validation is essential to prevent over-reliance as AI adoption scales. Lifecycle Coverage: Extend AI beyond code into planning, testing, deployment, and retrospectives. Sustained Improvement: Bake AI into governance so every sprint compounds learning and efficiency. This framework elevates adoption from experiments to systemic transformation. Each blocker in the SDLC is more than just a pain point, it’s a starting line. The exhibit below shows how those blockers, when reframed with the right AI interventions, become the raw material for measurable improvements in speed, quality, and cost. SDLC Stage Common Friction Points & Bottlenecks Generative AI/Agentic AI Application Key Metrics to Measure Impact Plan & Design Vague or incomplete requirements. Inefficient backlog grooming. Time-consuming user story creation AI-Assisted Requirements Analysis: Refine raw ideas into structured user stories and acceptance criteria Automated Backlog Prioritization: Suggest priorities based on historical data and business impact Speed: Reduced planning cycle time Quality: Improved story point accuracy; fewer requirement-related bugs Cost: Less time spent by product managers on manual tasks. Development Slow code generation for boilerplate tasks. Inconsistent coding standards. Outdated or missing documentation. Code Generation & Autocompletion: AI agents write routine code, functions, and unit tests. Automated Code Refactoring: Suggest improvements for readability, performance, and maintainability. Real-time Documentation Generation: Create and update documentation (e.g., READMEs, API docs) as code is written. Speed: Increased developer velocity; reduced time-to-first commit. • Benchmark: Good = 26–80 hours cycle time (LinearB, 2025a). Quality: Lower code churn; better adherence to standards. • Benchmark: Good = 225–400 lines of code per PR (LinearB, 2025b).Cost: Fewer developer hours spent on boilerplate code and documentation Review & Test Manual, time-consuming code reviews. Inadequate test coverage. Difficulty identifying security flaws. Longer test cycles and lack of complete test automation AI-Powered Code Reviews: Automatically scan for bugs, style issues, and security vulnerabilities. Automated Test Case & Script Generation: Create comprehensive unit, integration, and E2E tests based on code and requirements. Intelligent Test Execution: Prioritize which tests to run based on code changes. Speed: Faster code review and test execution cycles. • Benchmark: Good = 4–12 hours review time (LinearB, 2025c). Quality: Increased test coverage; lower defect escape rate; improved security posture. • Benchmark: Good = 1–4% change failure rate (LinearB, 2025d). Cost: Reduced manual QA effort; lower cost of fixing
Your Data Isn’t Perfect. Deploy Anyway: Unstructured Data is no longer a problem
Enterprise AI efforts stall for many reasons: uncertain use cases, unclear ROI, and organizational inertia. But one blocker still dominates the conversation: “Our data isn’t ready.” It’s scattered across internal and external systems, inconsistent and difficult to extract, riddled with quality and compliance issues, and often too incomplete to support reliable automation. It sounds responsible. Sensible, even. But in 2025, that assumption is no longer true. Yet, according to Gartner’s 2025 Hype Cycle for Artificial Intelligence1, 57% of organizations believe their data isn’t AI-ready to deliver business objectives”. In a separate survey by Digitalisation World 2, over 60% of IT leaders named poor data quality and governance as the top barriers to AI adoption, above skills gaps or infrastructure concerns. For decades, enterprise leaders were taught that you couldn’t modernize analytics until you modernized infrastructure. You couldn’t deploy AI until your data was fully structured and centralized. That mindset made sense when automation tools required consistent schemas and predictable inputs. But that’s changed. There’s now light at the end of the data readiness tunnel, especially when it comes to inconsistent formats and unstructured data. Agentic AI thrives in messy, fragmented, and unstructured data environments, overcoming the need for harmonization and centralization before AI can unfold its power. You don’t need perfectly processed data to begin – it happens in real time and in the flow of work. Agents can replace data extraction and harmonization teams, make centralization efforts unnecessary, and eliminate time spent searching for and cleaning data. So how do you break the “Our data isn’t ready” mindset? Let’s explore. There is Light on the Data Readiness Horizon In our experience, data readiness issues tend to fall into four main categories: Provisioning Complexity: Data is scattered across systems. It takes a long time to give data scientists access to the data their models need Format Friction: Data arrives in many formats and data models, making it hard to extract and harmonize before AI can consume it and progress work Quality Reluctance: Data is not complete, consistent, or accurate to assure reliable AI outputs and may pose compliance risks Missing Data: Valuable information is either uncaptured or only available from third parties, leading to blind spots in decision-making and reporting Each of these pose real challenges, but progress is happening, particularly around format friction, where Agentic AI thrives. Powered by large language models (LLMs), Agents can extract data, validate it, harmonize it, and trigger actions across PDFs, emails, system exports, handwritten notes, and more – even when the data structure is inconsistent. What once required manual data extraction and key-in is now handled in-flow, as agents navigate across systems and data models with minimal friction. Emerging standards like Model Context Protocol (MCP) are also reducing integration overhead, allowing agents to act on data across sources without heavy engineering. They don’t just surface issues, they resolve them, flagging anomalies and improving quality in real time. The old barriers around format are fading fast, and that means some long-held assumptions about data readiness deserve a closer look. Three Signs Your Data is More Ready than You Think Yet despite this progress, in many organizations format friction is still addressed by small armies that manually extract data from forms and put them into common data models. Customer service staff read pages of emails to find one useful detail. Workflows are being held up. In response, many organizations have large-scale centralization efforts underway to clean and standardize data before applying AI. Or AI is not being deployed because data harmonization and extraction is too hard. This causes cost and holds up progress on better user and customer experiences, and on unlocking the power of AI. In our experience, there are three “data readiness” related efforts no longer required: Old Mindset Example Use Case New Mindset 1. Lots of people deployed to extract, clean and harmonize data Offshore teams at an Agri-coop manually entering handwritten invoices into systems Replace humans through agents Position those agents right where source formats enter the organization Real estate analysts interpreting freeform lease agreements across regions Business analysts manually pulling KPIs from reports and system exports Dispatch operations slowed by manual ticket triage 2. People spend a lot of time aggregating and cleaning data before interpreting and acting on it Support agents at a global gaming company manually reviewing fragmented chat, email, and forums Give these roles data aggregation and decision support agents Systematically eliminate local data stores Field engineers reviewing handwritten maintenance logs before dispatch Lending teams assessing borrower income via uploaded PDFs Mortgage applications delayed by repetitive document review 3. Many data centralization and data harmonization efforts underway Inconsistent metadata delaying asset publication at a media company Reevaluate the need in light of Agentic AI Provide aggregation agents rather than single data sources Automate the creation of data platforms Finance analysts create their own data marts to aggregate and manipulate data Data Lakes are being constructed and data model and architecture harmonization investments are underway Start Shifting the Mindset and Accelerate AI Progress How do you get going? Systematically catalogue these signals and get a new, Agentic AI mindset about unstructured data readiness underway. The impact can be tremendous. In sectors like media, entertainment, and consumer technology, agents are removing content bottlenecks by enriching metadata and automating validation as soon as assets are ingested, cutting delays both in production and time-to-publish. Fragmented inputs no longer stand in the way: gaming platforms use AI to unify customer support threads scattered across chat, email, and forums, while agricultural teams rely on agents to convert handwritten invoices into structured data on arrival, reducing both manual effort and turnaround time. And in energy and sustainability, where diverse utility formats once slowed compliance workflows, AI now harmonizes incoming data in real time, accelerating processing and improving audit accuracy. These aren’t edge cases; they’re tangible proof that the barriers once slowing AI adoption are already being cleared. Format friction, once a blocker, is now solvable. If you’re still treating it like a
From Friction to Flow: The value of Agentic enterprise process automation may not be where you think it is
We have all heard about the promise of Agentic AI revolutionizing enterprise process automation. But Agentic AI isn’t here to take over your workflows – it’s here to make them move faster. By accelerating decisions, surfacing the proper context at the right time, offloading small but frequent tasks, connecting the dots across enterprise silos, and intelligently avoiding rework, Agentic AI helps restore flow. It removes the friction that traditional workflow tools, rules engines, and RPA often leave behind. The result: better experience, high productivity, focus, and lower cost. The business case is becoming more concrete. Kimberly-Clark, the maker of Kleenex and Huggies, unlocked over $140 million in business value through intelligent automation across departments like sales, finance, HR, and customer service. By automating over 260 processes and saving 1.6 million hours of manual effort, they didn’t just cut inefficiencies; they improved customer satisfaction, boosted employee focus, and enhanced forecasting and personalization at scale.1 As enterprises adopt Agentic AI, the question has shifted: it’s not “what can we automate?” but “where does intelligence remove friction that other tools couldn’t?” It’s about augmentation in the right places, not replacement. A Guide to Finding the Friction Friction refers to inefficiencies, bottlenecks, and repetitive tasks that slow workflow and, therefore, limit user delight and productivity. Traditional automation often struggles with five core types of friction, each of which can be resolved by applying the right agentic approach. Decision Delays: Decision latency slows workflows when rules change often, engines either lack flexibility, or judgment calls are too complex to code. Agents act as accelerators; extracting context, comparing against dynamic rules, and packaging recommendations that help people move faster without giving up oversight. Example: Consider the mortgage industry, decisions hinge on a complex mix of state and federal regulations, investor guidelines, borrower variability, and risk thresholds. Profiles vary by income, geography, credit history, and more. Underwriters are essential for managing complexity and attempts to replicate their art of judgement through rules often lack trust. Agents can help by adapting in real time and applying reasoning to decisions, pulling required documentation, skipping unnecessary steps, and assembling context-aware recommendations. This reduces exception handling, speeds up approvals, and helps underwriters focus on edge cases where human oversight adds the most value. Context Surface Constraints: Work slows when data is scattered across systems, dashboards, and emails, or when too little information can be accessed. Agents solve this by assembling and summarizing relevant real-time insights from multiple platforms and can deal with vast amounts of information and sources dynamically, so people don’t have to dig. Example: At a global media entertainment company, support teams handle complex inquiries, like royalties, tax deductions, or payment schedules—where data is often fragmented across contract systems, billing platforms, and communication threads. Agents can unify these sources quickly, structuring information into clear, modular context blocks. This eliminates delays from manual lookups and helps support staff deliver faster, more accurate responses with less effort. Micro-Judgment and Task Delegation: Small, repetitive decisions and documentation tasks add up quickly. Agents can triage requests, complete forms, capture notes, and recommend actions, keeping workflows moving without human delay. Example: In a corporate IT helpdesk, incoming requests range from simple password resets to more involved technical issues. Previously, all tickets were queued for human review, slowing resolution and overwhelming staff. With agents in place, routine tickets are triaged automatically, forms are filled, steps are logged, and common issues are resolved instantly. For edge cases, agents escalate with complete context, enabling IT teams to focus on higher-impact work and reduce backlog. Cross-Silo Fragmentation: Workflows that span departments, teams, and systems often get bogged down in handoffs and the complexity of systems integration. Agents operate across those silos, interpreting context and triggering actions without waiting on humans. Example: Agriculture provides a strong use case: agents deployed across grower, distributor, and retailer systems align production and delivery in real time by bridging fragmented systems and surfacing dynamic signals. For example, agents can ingest weather forecasts, demand signals, and logistics updates to adjust harvest timing, labor planning, and transportation coordination. This enables producers to avoid spoilage, reduce labor inefficiencies, and match supply with market needs, all without manual re-planning or delays across siloed teams. Rework and Discovery Loops: When information doesn’t surface at the right time and proactively, tasks must be repeated or escalated for human intervention. Agents close the loop between insights and actions, predicting what is needed to ensure that workflows get completed the first time. Example: Field service teams offer another compelling example; delays often stem from missing parts, inaccurate diagnostics, or surprises on-site. Agents help prevent repeat visits by analyzing sensor data, service history, and technician notes to flag potential issues and recommend actions in advance. This minimizes rework by ensuring technicians arrive with the right parts, context, and instructions—enabling first-time resolution and reducing service backlog. Summary of Friction Types and Agentic AI Applications Friction Lens Signs You See This Friction Agentic AI Role Example Process Decision Acceleration Manual exceptions, policy uncertainty, decision lag times Packages recommendations for review Complex approvals Context Surface Expansion Information scattered across tools/systems, or not comprehensive Aggregates and presents key context Inquiry resolution Micro-Judgment and Task Delegation Repetitive approvals, forms, triage, administrative tasks Automates small decisions and tasks Internal request handling Cross-Silo Coordination Delays at handoffs across teams, fragmented systems that are hard to integrate Orchestrates workflows across silos Multi-team process flow Rework and Discovery Loops Repeat visits, escalations, callbacks Predicts what is needed for resolution before follow-ups Recurring issue resolution From Framework to Action: Putting Agentic Friction Resolution to Work Step 1: Spot the Friction Start by identifying where work slows down. Map your important processes and score them against a few questions: Are complex decisions stuck in manual review? Are support agents piecing together data from multiple systems? Do simple approvals still require human effort? Are workflows stalling across departments? Are you seeing rework loops frequently? These patterns are symptoms of deeper friction; decision latency, fragmented context, micro-tasks, cross-silo gaps, and inability to predict resolution.
From Demos to Impact: Three Principles That Make Sure Your AI Agents Scale
We’ve all seen the show: an AI agent that parses and rapidly summarizes documents, drafts responses, and flags risks live on stage in seconds. It’s impressive and polished. But often, it’s built to impress a room, not to withstand the realities of production environments and scale. Why? Because the design doesn’t survive outside the lab. The demo was built for applause, not for sustainability and scale. Flashy agents that perform in tightly controlled settings frequently collapse when faced with messy data, legacy system constraints, regulatory requirements, unpredictable edge cases, or production workloads, and the governance required for change control and trust. But it doesn’t have to be this way. It’s time to stop judging agents by how clever they look – and start designing them to work. REAL DEPLOYMENT: WHAT IT LOOKS LIKE According to Gartner, over 40% of agentic AI projects will be canceled by the end of 2027 due to escalating costs, unclear business value, or inadequate risk controls.1 This isn’t about better tools – it’s about better design. So, what does it take to make agents that are truly ready for production and scale? There are three powerful principles to ensure that agents scale and sustainably deliver the impact the demo promised. Let’s dive in. Principles for Scalability and Sustainability FROM: Demo-first AI TO: Deployment-ready AI 1. Create Modular Agents Aligned to Granular Process Steps Rigid, end-to-end agents with tightly coupled logic Modular agents aligned to specific business functions and fine-granular process steps 2. Design for Headless Operation with Structured Inputs and Outputs Natural language output and manual triggers Machine-readable outputs powering headless agents embedded in system workflows 3. Build on Infrastructure That Makes Agents Trustworthy No audit trails, version control, or shared libraries Governed infrastructure with change control, centralized observability, and repeatable, auditable outputs Let’s break these differences down individually – and look at what matters when the lights come up and it’s time to go live. 1. Create Modular Agents Aligned to Granular Process Steps Agents designed as rigid, all-in-one workflows with tightly coupled logic often break down in real-world environments. Production environments demand agents that are modular, testable, and mapped to real-world business steps. Scalability and maintainability benefit from fine granular design. Instead of building linear agents that try to do everything, decompose Agents into smaller, reusable components aligned to process steps. Think of agents that verify lien data in a title search, not ones that “analyze entire title reports.” This makes workflows testable, improvable, and scalable. Modular agents can be orchestrated, retried independently, and embedded flexibly across enterprise environments. What to do: Break your processes into individual steps. Design modular agents around individual steps. Create scalability and the ability to maintain and evolve processes. 2. Design for Headless Operation with Structured Inputs and Outputs The full power of automation comes from “Headless Agents” – those that run without user prompts or UI and consume, produce and act on structured, machine-readable data. Even if you start with human assisted agents, design for full automation benefits. Natural language is useful in demos, but real automation requires structure. In production environments, agents shouldn’t be built to chat; they should be built to act on their own. That means outputs must be machine-readable from the start, with standardized formats, consistent fields, and output that downstream systems or other agents can ingest without interpretation. This is the foundation for headless agents and the full benefit from automation: systems that do not wait for a user prompt but instead operate behind the scenes, triggered by system events, and embedded directly into workflows. When agents consume structured data and produce structured results, they can collaborate with each other, orchestrate multi-step processes, and drive automation at scale. We’re already seeing this in practice: headless agents that verify insurance claims, validate loan data, or flag quality issues on the factory floor. Each task is modular, embedded, and aligned to operational rules, not UI layers. What to do: Design outputs in consistent, machine-readable formats that downstream systems can use without human interpretation. Build headless agents that run on system triggers, operate within workflows, and rely on modular logic aligned to operational needs, enabling orchestration, reuse, and scale. 3. Build on Infrastructure That Makes Agents Trustworthy Trust doesn’t come from agents sounding human – it comes from being consistent, observable, and governed. Infrastructure is what earns that trust. Every prompt, output, and version must be logged. Templates and models should operate under strict change control. Outputs must be repeatable under consistent conditions, and every decision path should leave behind an auditable trail. This is what makes agents reliable and what protects teams from systems that can’t be verified or improved. But trust alone isn’t the goal – scale is. And scale depends on infrastructure. Without shared libraries, deployment controls, monitoring, and rollback paths, you’re left with fragile, one-off agents that can’t grow beyond their creators. The infrastructure is the backbone. What to do: Build on infrastructure that enforces versioning, change control, and observability from day one. Use compliance-reviewed templates, track agent behavior centrally, and ensure every decision is explainable, auditable, and repeatable to build trust. FINAL THOUGHTS DEMOS GET APPLAUSE. SCALABLE INFRASTRUCTURE WINS. Scaling AI agents isn’t about more compute or fancier prompts; it’s about better, durable design. That means building agents as modular, composable units that align with real business logic and process steps. It requires prioritizing structured, machine-readable output so systems can act on results. The most impactful agents are headless, embedded deep into systems, quietly executing real work without the need for a user interface. Trust comes from traceable and transparent agent behavior, where every action is logged and governed. This requires repeatable and scalable infrastructure with versioning, rollback, observability, and shared libraries that make large-scale deployments safe and repeatable. When these three principles come together, agents stop being demos and start delivering results. Demos are for applause. Deployment is for results. Real results come from agents engineered for the real world, designed to operate, evolve, and endure. Gartner Press