How Agentic Development Is Transforming Software Engineering
In the last few years, we’ve seen artificial intelligence (AI) models grow exponentially more powerful. At the same time, these large language models (LLMs) are becoming increasingly commoditized, with new players entering the market almost every month. As a result, the true competitive advantage no longer lies in the raw capabilities of an LLM. Instead, it’s about how effectively we integrate AI into our software development workflows. This is the new moat - the combined collection of practices, tools, and cultural shifts that determine which organizations can harness AI to gain a decisive edge.
The key insight is that AI isn’t just about generating code or giving quick answers to debugging questions. It’s about transforming the entire development process. Over the past couple of years, we’ve seen clear stages of evolution in how teams adopt AI. Some operate on the lowest rung, plugging code snippets into web-based AI tools without context, to going “all in” now with the introduction of sophisticated agentic development platforms. Today, we’ll walk through the four different “stages of AI Engineering” as we see them, how they are currently aligned to the tools in the space, and discuss why building a strong enablement strategy for your teams is the only way to drive innovation.
How AI Engineering Has Progressed: From Remedial to Agentic Workflows
Stage 1: Remedial (Low/No Context Tools)
The current norm in many organizations is using tools everyone is familiar with like ChatGPT in a simple, ad-hoc fashion. A developer or engineer who needs a quick snippet of code might copy-paste a function into ChatGPT’s web interface to see if the AI can spot a bug or optimize performance. While this approach can be useful in a pinch, it’s also full of limitations:
- Security and Compliance Risks: Without explicit approval, many engineers circumvent enterprise security policies by pasting proprietary code into external tools—raising data leakage concerns.
- Lack of Codebase Awareness: The AI sees only the code snippet provided, not the broader context of an application’s architecture or dependencies.
- Poor User Experience: Constantly switching between a browser tab and the IDE disrupts workflow and slows down real collaboration.
Ultimately, this remedial stage offers minimal productivity gains and often creates friction with enterprise guidelines. It’s the digital equivalent of scribbling notes on the back of a napkin rather than drafting formal documentation.
Stage 2: Basic to Intermediate (IDE Integration with GitHub Copilot)
The next level involves integrating AI capabilities directly into a developer’s Integrated Development Environment (IDE). GitHub Copilot is one of the most well-known examples here and we’ve been huge fans (and heavy users) since it launched:
- Native IDE Assistance: Copilot can auto-complete code based on your existing context, making it far more seamless than copy-pasting into a web tool.
- Chat-Oriented Programming: Some “CHOP” workflows emerge here, where developers can ask questions or prompt Copilot within the IDE.
- Enterprise Licensing: Many companies are eager to purchase Copilot licenses in the hope of boosting developer productivity by 10% or more.
Yet, while this approach is a definite step up from remedial usage, the results are varied at best. Why? Because many organizations lack a coherent enablement strategy. They hand developers a license and expect immediate magic. Without governance, best practices, or a baseline of AI readiness across teams, Copilot’s promises may not materialize. It’s like handing everyone a musical instrument without forming a band—you’ll get noise, not harmony.
I will add that Copilot Enterprise shows promise in building a moat for enterprise development orgs, thanks to features such as organizational policy controls, better data privacy, and the potential for shared AI “learning” across teams. With proper enablement and standardization, it becomes much easier to scale AI’s benefits and keep developers aligned. It is effectively an umbrella product at this point that means several things so unfortunately the term “Copilot” has become overloaded and hard to pin down when you’re trying to understand where the most value is. Regardless of which tools you’re using for local development, GitHub Copilot Enterprise is still something we’d recommend. Built in features in the SCM side like automated Pull Request detail are worth the price of the license alone.
Stage 3: Intermediate to Advanced (AI-First Approach with Tools Like Cursor)
Moving beyond basic AI assistance means adopting an “AI-first” development approach - where everything from brainstorming to refactoring is deeply intertwined with AI capabilities. Cursor is a prime example of a development tool designed specifically for AI-driven coding:
- Integrated Environment: Cursor works hand-in-hand with popular editors like VSCode and supports most of its extensions.
- Intentional Workflow: Users who adopt Cursor are typically committed to weaving AI into their daily routines. This encourages more consistent usage and well-defined processes.
- Broad Market Adoption: Cursor gained early traction among developers craving a more immersive AI experience. Consequently, it has influenced a number of best practices around adopting AI-first strategies.
While some of the same advantages can be achieved with Copilot or other VSCode-based setups, the difference lies in deliberate integration. If you simply add an AI plugin to your workflow and leave developers to figure it out, you risk getting random results. Cursor, however, guides teams toward consistent AI usage, making it an easier migration path for those ready to step up their game.
We’ve had several engineers on our team using Cursor for months, with great success. The ability to swap out models, use local LLMs easily with the Ollama integration (also available with other bespoke VSCode extensions), has enabled us to use AI as a pair programmer without being attached to a cloud/external source. The ability to use local or self-hosted LLMs has provided our teams the ability to use AI when we need to be extra sensitive about the data we’re working with. We’re seeing Cursor advance and will stay abreast of the changes as it continues to progress and build new agentic features.
Stage 4: Advanced (Agentic Development with Tools Like Windsurf, GitHub Copilot Workspace)
Agentic development is where things get truly exciting - and truly transformative. In this advanced stage, AI isn’t just giving suggestions or filling in boilerplate code. Instead, we see the emergence of coding agents that work autonomously on your codebase. Windsurf by Codeium stands out here today, enabling advanced agentic workflows with minimal setup. Our Liatrio engineers are seeing a ton of success and gravitating to this new approach of using an agentic workflow. We have already committed to beginning each new app modernization project using this approach to learn about existing codebases and develop POCs in hours or days that would previously take weeks to complete.
What Is a Coding Agent?
Think of a coding agent as your super-powered IDE companion but far beyond just autocomplete. While you might have experienced prompting a large language model with code snippets, an agent is deeply integrated into your development environment:
- It can read your entire codebase in real time.
- It has direct file system access.
- It can run tests, debug code, and execute commands in your terminal.
- It has memory and context across the entire development session, acting like a teammate fully versed in your project’s history and structure.
This is powerful for several reasons:
- Function Calling: Agents can be instructed to create files, run tests, or modify code in a targeted fashion. When built to pair with a developer, this can be true orchestration of work.
- Tool Integration: Agents interact seamlessly with version control, continuous integration (CI) pipelines, and other dev tools.
- Keeping Context Awareness: By maintaining a deep understanding of the entire codebase, these agents can offer suggestions and automate tasks that are highly relevant, significantly reducing the need for human intervention on repetitive tasks.
Windsurf’s “Cascade” feature is representative of this new wave (ok pun intended there). It lets teams automate complex workflows and orchestrate them across multiple files or services. Instead of reviewing countless PRs manually, developers can rely on AI to handle much of the grunt work, from test runs to code cleanup, so that human energy can be redirected towards higher-level architecture and innovation. Similar workflows can be built in other tools but getting everyone on the team to work in the same way requires much more overhead/time and may not be sustainable.
GitHub Copilot Workspace is in “preview” at the time of this post and is 95% web-based. It isn’t meeting developers where they are. While it’s well-presented and part of the “Copilot” umbrella, more work will need to be done to bridge the gap here.
For agentic workflows in general, we expect to see rapid advancement in this area as it appears to truly be the future way of working for all software development going forward..
Why Enablement Is Everything
What will separate organizations (and individuals) that thrive with AI from those that are left behind is enablement. It’s not enough to buy licenses for Copilot or install Cursor plugins and call it a day. Teams need a holistic strategy and support to move along this maturity curve:
- Security & Compliance: Early stages often see developers bypassing security controls to use AI. Enterprises must provide secure and approved tools—and guidelines for sensitive data handling.
- Cultural Shift: AI-first development is a mindset shift. Encourage experimentation while establishing clear guardrails and shared best practices.
- Collaboration & Standards: The biggest gains occur when teams adopt consistent processes. Copilot Enterprise, Cursor, or Windsurf’s agentic workflows each benefit exponentially from uniform usage across the team.
- Skills Development: Provide workshops and ongoing support so that developers understand not just how to press the “AI button,” but why certain code changes are recommended and how to shape those suggestions into optimal solutions.
It’s this process of aligning technology, processes, and people that creates a real moat. With it, you can rapidly innovate, experiment, and adapt as LLMs continue to evolve.
The Future Is Agentic
As we look ahead, agentic development will likely dominate discussions around AI engineering. Tools like Windsurf are rewriting the playbook for how code is generated, reviewed, and deployed. Instead of routine manual tasks, developers can focus on creative problem-solving, system design, and user experience - while AI agents handle the heavy lifting behind the scenes.
This doesn’t mean the earlier stages lose their relevance overnight. For many organizations, adopting Copilot Enterprise or Cursor is a big step up from remedial usage. But the endgame is clear: integrated, context-aware AI that accelerates development, enables collaboration, and augments human creativity.
Final Thoughts
Bringing new AI engineering capabilities that integrate deeply into an organization’s workflows represent the new moat. While AI models themselves may be commoditized, the ways we harness them to build software are not. Moving from remedial usage to agentic development is going to be a journey, unlocking deeper capabilities that culminates in a future where AI-driven automation is central to how we craft and maintain software.
The question isn’t whether to use AI, but how and to what extent. Enterprises that ignore the call to enable their teams for advanced, agentic workflows will find themselves lagging behind. Those that commit to an enterprise-wide enablement strategy, complete with security, governance, and best practices, will accelerate beyond their competitors.
If you’re on the fence about going all-in with advanced AI development tools or looking to elevate your team’s current AI practice, think about how each capability level builds upon the last. We need to envision where this is moving and push our teams to adopt more leading edge capabilities so they can start relearning how software is built. We believe success will be found in driving collective commitment to rethinking how we develop software in an AI-driven world.
