The 6 reasons why your AI strategy is stalling
The window for experimentation-only AI strategies is closing
Your engineering team has been experimenting with AI tools for months. You've seen the demos, read the case studies, and maybe even rolled out a few coding assistants. Yet despite the investment and excitement, you're not seeing the transformative productivity gains everyone promised.
Sound familiar? You're not alone.
Many engineering organizations fall into the trap of treating AI as just another tool to bolt onto existing workflows rather than fundamentally rethinking how software gets built. While teams focus on code generation and chat-based assistance, the fundamental transformation is happening elsewhere: in knowledge management, infrastructure orchestration, governance frameworks, and human-AI collaboration patterns.
We tapped into our community of engineering leaders to learn about what’s blocking their AI strategy. Our community helped us create a list of common roadblocks teams encounter when applying AI to improve developer productivity and DevEx, and help you take the next step towards AI-driven software development.
1. The real problem isn't your tools, it's your foundation
The most common misstep engineering leaders make when approaching AI adoption is treating it primarily as a tooling decision. They often focus on evaluating coding assistants, comparing feature sets, and using metrics like tool adoption rates or developer satisfaction scores to define success. This practice sometimes coincides with top-down mandates to use AI for software development regularly and leads to deep misalignment between upper management and rank-and-file engineering teams.
However, this perspective overlooks a deeper issue: for AI agents to be effective, they require robust context, accurate information sources, and well-defined quality policies. Unfortunately, many companies face significant challenges in this area. Their internal knowledge tends to be fragmented, with outdated or incomplete documentation, and critical know-how often locked away in chat threads, individual team members' heads, or dispersed across numerous platforms. Without deliberate efforts to centralize and curate this information, even the most advanced AI models will deliver inconsistent and unreliable results.
A key principle remains unchanged: even in the era of generative AI, output quality depends heavily on input quality. I.e., bad data in, bad data out. If an organization’s data and knowledge practices are weak, AI will reflect that weakness. Inconsistent or poor data will lead to equally flawed AI behavior.
Most organizations struggle with fragmented knowledge, outdated documentation, and inaccessible tribal wisdom. Critical information lives in Slack threads, individual developer minds, or across dozens of tools. Even sophisticated AI models will produce inconsistent, unreliable results without curated, high-quality context.
2. You didn’t build your infrastructure for autonomous agents
Your current infrastructure can't support the AI workflows you're trying to implement. That’s not because you made a mistake when building your engineering org. It’s because the world has evolved around you faster than those decisions were made.
Most software teams still rely on manual operations, ticket-based workflows, and infrastructure setups that require developers to be experts in everything from cloud configuration to security compliance. Further, the industry has seen a steady decline in operations expertise, partly because of the influx of developers entering the field through boot camps and college programs that don’t always train students on cloud infrastructure or operational best practices.
These requirements create a bottleneck as you move toward more autonomous AI systems. Agentic AI requires new layers of tooling: agent observability, sandboxed testing environments, and AI-native CI/CD pipelines. Without these foundations, your AI experiments will remain vastly disparate.
The solution isn't to make every developer an infrastructure expert. Instead, your platform engineering team should have goals to abstract complexity and create self-service experiences. Measure success by asking: "Are developers happy with how things work? Are the tools solving real problems for them?"
AI is like a tourist who has just learned about your code, and will disappear once its desires have been satisfied. It will face the same challenges a new engineer faces when making their first contribution, except that AI enables it to happen at scale. If a human can’t quickly scale into your organization, neither will AI. Prioritize getting new hires to deploy code on their first day and reduce the time from writing code to seeing it in production.
3. You're avoiding the governance conversation
As AI agents become more autonomous for tasks like merging pull requests, triggering deployments, and responding to production incidents, many engineering leaders are discovering an uncomfortable truth: governance isn't optional. The probabilistic nature of large language models makes explainability and auditability difficult but essential.
Yet, most organizations approach governance as an afterthought or, worse, as a barrier to innovation. This approach is backwards. Effective governance should be an enabler that creates enough trust to adopt AI at scale. For AI to drive meaningful impact in enterprise environments, people must have confidence that its outputs are accurate, reliable, and grounded in beneficial outcomes, not systems riddled with risks or unintended consequences.
A good governance practice achieves the following:
Visibility into where AI is being deployed and how it’s impacting quality and efficiency.
Automated oversight for security, compliance, and best practices to take the guesswork out of doing the right thing.
Clear definitions of developers’ ownership and responsibilities in the code review process, and well-defined hand-off paths for escalation.
AI workflows will require implementing human-in-the-loop mechanisms, building clear audit trails, and creating explainability features that help users understand AI reasoning. It means designing governance frameworks that show developers the most straightforward path forward rather than shifting compliance responsibility onto them.
4. You focus on tools instead of systems
Most AI implementations today are isolated point solutions. A coding assistant here, an automated testing tool there, a documentation generator somewhere else. This approach fundamentally misunderstands where AI's transformative potential lies. The real breakthrough happens when agents communicate, delegate, and reason across the software development lifecycle stages. Instead of being in the middle of workflows, AI enables humans to be at the top of workflows, providing high-level direction while AI handles complex reasoning and execution.
This shift also requires a new way of thinking about engineering roles that move from a mindset centered on hands-on execution to one focused on designing systems that can, in turn, create other systems. The orchestration of AI capabilities is emerging in layers: starting with foundational components, followed by retrieval-augmented generation (RAG), short-term memory layers, and ultimately, agentic frameworks that enable higher-order collaboration and automation.
The challenge is that most developer environments lack native autonomy or inter-agent communication support. No standardized protocol has emerged for agent communication, forcing teams to build bespoke integration layers for each use case. Earlier this year, Google announced the A2A protocol to fill this gap, but this industry effort is in a very early stage, and platforms built upon it are still in the future.
You can start today by focusing on low-hanging fruit: tasks that consume large amounts of time, have strong API integrations, and follow standardized usage patterns. Build custom integration layers that connect your most critical systems. The comprehensive products will come later, but early movers who can build these bridges today will have a significant advantage.
5. Your developers aren't ready for two-way AI collaboration
Most current AI workflows are built around a familiar pattern: a developer prompts an AI service for help, usually a chat bot. Whether it’s generating code, debugging, or summarizing documentation, the AI acts as a responsive assistant, waiting for a human to take the first step.
Over time, that dynamic will reverse. In the near future, AI systems won’t wait for instructions. They’ll initiate tasks, suggest changes, and even take autonomous action. They’ll prompt your developers for help when they get stuck or need guidance. This evolution from passive automation to active autonomy introduces a radically different mode of collaboration.
Developers aren’t used to bots that make decisions independently, and may find themselves constantly reviewing or correcting actions taken by agents that don’t fully understand the broader context or team priorities. The cognitive load increases as developers shift from being decision-makers to validators, particularly when they lack sufficient visibility into the agent’s logic or intentions.
Even subtle misalignments can cascade into inefficiencies: a bot that spams the team with half-baked pull requests or triggers workflows at the wrong time can create an instant negative perception of your AI initiative.
When autonomous agents act unpredictably, especially without clear boundaries, they can derail the very workflows they were meant to optimize. That’s why it’s essential to build systems where the correct path is the path of least resistance, and where best practices are embedded directly into the workflow.
It’s unrealistic to expect developers to babysit autonomous agents while managing their regular workload. The most effective AI-enhanced workflows will rely on invisible safeguards and automated guardrails that keep agents aligned with team goals while minimizing human oversight. By reducing the need for constant review and making the right behaviors easy to follow, you enable AI collaboration where autonomy enhances developer productivity rather than undermining it.
6. Your feedback loops are broken
AI-generated output is only as good as the feedback that follows. Most teams lack the structured, signal-rich environments agents need to refine their behavior over time. Metrics are often noisy, inconsistent, or misaligned with business value.
Measuring the quality of agentic decisions beyond short-term metrics like developer satisfaction or pull requests per engineer is particularly challenging. As AI generates more code, the need for human feedback for challenges like code reviews, validation, and evaluation increases. Without robust feedback mechanisms, AI systems can't learn and improve effectively.
One of the initial hurdles is achieving consistency in defining and calculating metrics. For example, comparing results becomes meaningless if different teams compute cycle times in two distinctly different ways. This same issue arises in AI adoption, where inconsistent measurement leads to noisy feedback that hinders learning and improvement.
The solution is implementing structured rituals that institutionalize feedback loops: regular model performance reviews, data quality assessments, and cross-functional postmortems when AI systems produce unexpected results.
The DevEx guide to AI-driven software development
Want to see how over 400 engineering leaders are really using AI in software development? The DevEx Guide to AI-Driven Software Development introduces the AI collaboration matrix: your new framework for mapping, measuring, and accelerating AI adoption across the SDLC. From code orchestration to workflow automation, this guide shows what’s working, what’s not, and how to avoid the pitfalls that stall AI strategy.
Start doing these things today to get your AI strategy back on track
The primary gap between AI experimentation and AI transformation isn't technical; it's organizational. Here's your action plan:
Build your knowledge foundation. Establish data hygiene practices across your engineering organization. Create and maintain high-quality training datasets. Work toward centralizing knowledge that's currently fragmented or exists only as tribal knowledge. Create "golden repositories" of your best code examples, architectural decisions, and team standards, assign ownership for maintaining these knowledge bases, and set up automated workflows to keep documentation current.
Future-proof your infrastructure. Build dedicated platform engineering capabilities to abstract complexity. Enable developers to ship code without infrastructure overhead. Invest in mature pipelines and test coverage to ensure AI adoption improves velocity without amplifying risk. Prioritize self-service infrastructure to reduce dependencies on specialized teams.
Enable better work with governance, not in spite of it. Build better audit trails and trustworthy data sources for validating agent decisions. Map out the decisions your AI systems currently make or will soon make, then design approval workflows for each risk level. Start with simple guardrails: require human approval for production deployments, implement automated code quality checks before merging AI-generated pull requests, and create audit logs for all AI actions. Build these as automated gates, not manual checklists that slow down development.
Start orchestrating those tiny time killers. Identify repetitive, time-consuming tasks in your development workflow with well-defined APIs and consistent patterns, such as automated testing, code review assignments, or status updates. Map the data flow between the tools involved in these processes and build simple scripts to centralize data critical to providing context to AI. Don't aim for perfection yet. This foundational work will position you to leverage more sophisticated orchestration tools as they mature.
Establish collaboration patterns. Define clear interaction patterns between agents and developers. Create simple rules like "agents propose, humans approve" for critical decisions and "agents execute, humans monitor" for routine tasks. Implement notification systems that alert developers only when agent actions require attention, not for every automated task. Test these patterns with a small pilot team, then refine them based on feedback before rolling them out more broadly.
Nurture those feedback systems. Standardize engineering productivity metrics across teams and institutionalize data-driven rituals. Establish a regular AI performance review practice where you analyze the quality and impact of AI-generated outputs. Create feedback collection mechanisms that capture your developers' quantitative data and qualitative insights. Use this data to continuously tune your AI systems and identify patterns that indicate when AI is helping versus hindering productivity.
The window for experimentation-only AI strategies is closing
AI-driven development is actively reshaping software engineering, and it’s time to start moving beyond simple experimentations. The teams that address these foundational challenges today will be positioned to realize AI-driven development's full potential tomorrow. Those who continue treating AI as another tool will find themselves increasingly left behind.
The shift requires more than integrating new technologies. It demands rethinking how teams work, how systems communicate, and how organizations build trust in automation. However, the opportunity is unprecedented for engineering leaders willing to make these changes. The question isn't whether AI will transform software development, it's whether your organization will be ready when it does.