- Modern engineering productivity is no longer limited by code generation alone; the bigger challenge is giving AI tools the right cross-system context from code, tickets, incidents, docs, logs, and collaboration tools so engineers can work effectively and safely.
- The strongest AI stack for engineering teams combines multiple tool categories, including coding assistants, enterprise context platforms, AIOps or observability tools, and general AI platforms, rather than relying on a single vendor or product to do everything.
- Engineering organizations need a two-layer model: coding surfaces where work happens, and a shared context layer that unifies knowledge, governance, permissions, and security so AI can scale from isolated experiments into trusted enterprise infrastructure.
As AI becomes a fundamental component of software engineering workflows, the way engineers work is shifting. With tools like GitHub Copilot now writing half of the average developer's code, raw coding output has become less important than ensuring that developers have the right information to move forward. Chasing context across GitHub, Jira, incident tools, wikis, logs, and Slack has become the real drag on productivity. It's also becoming increasingly clear that an open, composable, model-agnostic platform that can plug and play multiple assistants and agents is a necessity in today's landscape—filled with ever-evolving models, new and better tools, and changing preferences that vary by organization.
These shifts have also led to more distributed systems, causing further incidents and security risks across each new surface. Combined with higher product expectations in an increasingly competitive market, along with the pressure to adopt more AI tools and workflows, most organizations are realizing that the bottleneck is no longer whether they have AI in the IDE—it’s whether their systems themselves can successfully support broad AI integration. It’ll require the right tooling stack capable of assembling the right context, guardrails, and workflows around code to ensure AI output is correct, safe, and aligned with the right architecture.
Tackling pressures with the right tooling
Today, the emerging AI tooling landscape for engineers no longer resides in a single model or product ecosystem. With a plethora of challenges and pressures facing engineering teams and their leadership, building the right AI stack and toolset is essential to closing the gaps. Doing so enables teams to guarantee real productivity gains, foster trust and reliance on AI assistance, and iron out security flaws as AI integration and use scale over time.
Most engineering teams are building a portfolio with tools that fall into four broad categories:
- Coding assistants in the IDE: Coding assistants include Cursor, Claude Code, GitHub Copilot, Windsurf, and others. Personal productivity tools are good for debugging and general tasks like inline completions and small refactors. No unified view across repos, services, and tools with governance that varies by vendor.
- Enterprise context and knowledge platforms: Connects artifacts and the people behind the code, rather than editing or building the code itself. These systems understand the engineering organization as a whole and are responsible for providing the context that enables AI tools to provide usable results for enterprise work.
- AIOps, observability, and incident assistants: These tools live within and improve monitoring and incident response platforms. Capable of summarizing alerts, traces, and logs, highlighting incidents, and providing runbook steps or fixes, they're most powerful when they can call into a broader context layer. In isolation, they're scoped to a single substrate, unaware of workflows stored elsewhere, and can't answer questions that span systems.
- General-purpose AI platforms and agent frameworks: These tools include hosted LLMs and model hubs, agent building frameworks, orchestration runtimes, and no-code builders for internal assistants and workflows. They help teams centralize, monitor, and manage AI deployment usage.
All four of these categories are essential components of an engineer's AI toolkit. Most engineering teams will need elements of each—ideally combined into and supported by a shared, trusted layer that unifies enterprise context, governance, and architecture.
The two-layer model: Bringing context & coding surfaces together
Across all the tools in the stack, two distinct sets emerge. The first set of tools is where engineers do the work. This includes:
- IDEs and AI-forward coding environments (Cursor, Claude Code, Copilot, etc.)
- GitHub and other code hosts
- Jira and work tracking
- Slack, Teams, and other collaboration tools
They're powerful tools that power productivity through automation and new workflows, but can't access existing enterprise context in isolation.
The other set focuses on understanding the work. They pull together code, tickets, incidents, docs, logs, and people into a coherent picture. This layer indexes and provides information across teams and repos, details like incidents, tickets, and design docs tied to changes, system ownership information, and more. They form the foundational context layer—a shared, trusted view of your engineering environment that the coding layer relies on to provide better, context-rich results for enterprise work.
Layering guardrails and permissioning rules directly into the context layer enables the tools that understand your work to also understand the security and privacy policies your organization needs. This makes it possible to apply these policies at the foundational level when using a full AI tooling stack, which is essential to building trust and confidence in the AI tools engineering teams use daily.
Enterprise work requires a secure, open platform with deep context
Building an AI stack fit for today’s engineering needs requires a two-layer model—with a foundational context surface that also ensures compliance with security policies, and an open environment that enables long-term scalability and flexibility. For teams looking to move beyond simply increasing the AI footprint in the IDE to building a system that truly supports broader scalability, it's essential to keep these three trends in mind as they do so:
- AI is moving from experiments to infrastructure: Teams that standardize on a context layer and a small number of well-understood workflows will move faster than those running disconnected pilots in individual tools.
- Strong stacks blend tools, not vendors: Coding assistants, observability AI, and enterprise context platforms solve different problems. The winning pattern is a portfolio wired around shared context and governance, not a bet on a single product doing everything.
- Security, governance, and explainability are now table stakes: Where AI runs, what it can see, how it’s audited, and whether engineers can see why it gave a particular answer will matter as much as raw model quality.
Learn more about what it takes to build your own two-layer model and what capabilities a complete context layer needs to have in our latest guide—and sign up for a free Glean demo today.
