AI Tools, Agents, and the Future of Software Development

For most of the public conversation, generative AI in software development has been framed as a productivity boost: faster coding, better autocomplete, automated tests. Useful improvements, but ultimately incremental. What is far more interesting, and far more consequential, is happening elsewhere.

Across large enterprises, consultancies and engineering organisations, GenAI is being applied to a much harder problem: understanding and evolving existing software systems. Systems that are large, long-lived, business-critical and poorly documented. Systems where risk does not come from writing new code but from misunderstanding old behaviour. A clear pattern is emerging across the industry: GenAI is becoming a cognitive layer for software systems, not a replacement for developers.

This piece draws together the perspectives of five firms that have published serious work on the subject, Thoughtworks, Boston Consulting Group, Ernst & Young, IBM Consulting and Xebia, to show how AI tools and agents are reshaping what software development actually consists of.

From code generation to system comprehension

The dominant narrative around GenAI has focused on forward engineering: generating code, tests or documentation from prompts. But in real enterprise environments the bottleneck is rarely code creation. It is code comprehension. Thoughtworks makes this explicit in its work on GenAI for modernisation, where the core observation is that developers spend far more time reading and understanding code than writing it. Legacy systems encode business rules, constraints and behaviours that often exist nowhere else: not in documentation, not in specifications, sometimes not even in people’s heads.

Their approach treats code as data. Instead of feeding raw source files to a language model, code is parsed into abstract syntax trees, transformed into a knowledge graph and enriched with explanations generated at multiple levels of abstraction: method, class, module, capability. That representation lets an engineer ask what business capability a part of the system implements, which rules are enforced there and under what conditions, and how control actually flows across components. It is not speculative; it is implemented in Thoughtworks’ internal accelerator, CodeConcise.

The crucial point is that the model is not operating on text alone but on structured representations of the system. That dramatically improves accuracy, reduces hallucination and makes every explanation traceable back to the code it describes.

Agents and multi-step reasoning at enterprise scale

If Thoughtworks focuses on representation, BCG formalises execution through GenAI agents. In BCG’s framework an agent is a language model equipped with a specific role, access to structured information, reasoning capabilities and the ability to iterate. More powerful still is a multi-agent system, where specialised agents collaborate in sequence: analysis, validation, summarisation, refinement.

BCG has applied this in large modernisation programmes, including public-sector and banking systems with millions of lines of COBOL or PL/SQL. In one case, agents processed more than three million lines of code in days, extracting thousands of business rules and producing complexity scores that would traditionally have taken years. The roster is telling: code analysis agents, dependency graph agents, business-rule extraction agents, summarisation and editorial agents. Together they produce what BCG calls hyper-transparent discovery, making the unknowns visible early enough to influence design decisions rather than surprise the team in production.

Across the whole lifecycle, not just the IDE

EY extends the conversation across the full software development lifecycle and insists on GenAI as a force multiplier rather than an autonomous actor. The practical applications are concrete: automated documentation for undocumented COBOL systems, assisted translation from legacy languages to modern stacks (PL/SQL to Spark SQL, SAS to PySpark), test generation and code review, infrastructure-as-code and pipeline generation, security and compliance checks.

The most important insight from EY is organisational. GenAI compresses the experience curve: junior engineers gain context faster, senior engineers reason at higher levels of abstraction, and dependency on a handful of subject-matter experts shrinks without removing human validation. EY’s pilots report efficiency gains of 30 to 60 percent in real modernisation initiatives, with accuracy kept under control and people still in the loop.

Capability-driven modernisation, not just cloud migration

IBM Consulting takes a more architectural stance. A recurring failure pattern in modernisation is the assumption that cloud migration equals transformation. In reality, moving applications without addressing capability duplication, misalignment and organisational structure simply relocates complexity.

IBM positions GenAI as an accelerator for capability-driven modernisation: mapping business capabilities to applications, APIs and data, detecting duplicated functionality across domains, supporting domain-driven decomposition, and generating target architectures, APIs and security patterns aligned with enterprise standards. Its examples include GenAI-assisted API discovery mapped to industry models such as BIAN, which has helped large banks rationalise portfolios running to tens of thousands of APIs.

End to end, from assessment to execution

Xebia completes the picture with an end-to-end, GenAI-enhanced modernisation framework that touches every phase: initial system investigation and dependency detection, automated documentation, technical debt identification, strategy recommendations, code foundation generation, assisted refactoring and migration. Rather than concentrating on one phase, Xebia shows how AI removes friction across the entire journey, with execution gains of 20 to 30 percent in real projects.

Crucially, their work reinforces a conclusion all five firms share: GenAI adds the most value early, during discovery, planning and design, where uncertainty is highest and mistakes are most expensive.

The tools that make the shift real

None of this is theoretical. It rests on a growing ecosystem of production-grade tools, each with a precise architectural role. Graph databases such as Neo4j and Amazon Neptune represent code structure, dependencies, control flow and capability relationships as traversable knowledge graphs. Language model platforms, from OpenAI and Azure OpenAI to Anthropic’s Claude, do the reasoning, summarisation, explanation and translation, always grounded in retrieved context. Retrieval frameworks such as LangChain, LlamaIndex and Haystack orchestrate that retrieval across document stores, vector indexes, graphs and operational databases, while agent frameworks such as AutoGen, CrewAI and Semantic Kernel run the multi-step, role-based workflows.

Deterministic signals matter just as much. Static analysis tools such as SonarQube and IntelliJ inspections provide hard facts about quality, complexity and dead code; observability platforms such as New Relic and Datadog supply runtime evidence about what is actually used; modernisation accelerators such as OpenRewrite and IBM Cloud Accelerators apply large-scale, rule-driven transformation once understanding has been established.

In the middle of all this sits an operational and semantic data platform. MongoDB Atlas is used as the system of record for modernisation intelligence: unified storage for source metadata, AST outputs, documentation and business rules; flexible modelling of schemas that keep evolving during discovery and refactoring; vector search for semantic retrieval over code, documents, APIs and capabilities; change streams and event-driven patterns to support continuous modernisation. It sits exactly where structure, evolution and scale have to coexist, which is the problem space of legacy modernisation.

The winning architectures combine deterministic analysis, structured representations, an operational and semantic data layer, and model reasoning. Prompt-only approaches do not scale. Copilots alone do not modernise systems. Data foundations do.

If GenAI is the reasoning layer, MongoDB is where modernization knowledge lives, evolves, and stays queryable over time.

From software factories to software cognition

Across all five sources a single conclusion emerges. The future of software development is not about producing more code faster. It is about making existing systems intelligible, governable and evolvable. GenAI’s deepest impact is cognitive: code becomes explorable knowledge, architecture becomes visible, legacy systems become understandable again, and modernisation becomes incremental rather than traumatic. That is why the most advanced solutions rely on agents, graphs and orchestration, not just copilots.

MongoDB AMP, an AI-driven approach to modernisation

At this point a reasonable question arises: why should a database company be a modernisation partner? The answer lies in a pattern that has repeated itself across countless programmes over the past decade. When transformation stalls, it is rarely because teams cannot rewrite code. It is because the data layer has become the hardest part to change. Decades of business logic embedded in schemas, stored procedures, triggers and tightly coupled access patterns turn the database into the single largest blocker to evolution. MongoDB’s experience, built on years of real migrations, is that unlocking the data layer often removes the constraints that block the rest of the stack.

The MongoDB Application Modernization Platform (AMP) formalises this learning into a full-stack, AI-driven approach. AMP is not a single tool but a structured methodology that combines experienced modernisation practitioners, proprietary analysis and transformation tooling, and agentic AI workflows, so that legacy applications can be transformed incrementally, safely and at scale.

At its core is a test-first philosophy. Before any transformation occurs, legacy systems are instrumented with comprehensive test coverage that captures real production behaviour. That behavioural baseline acts as a safety net throughout the journey: every transformation step is validated against it, so modernised services behave identically to the systems they replace, and modernisation becomes a controlled, verifiable process rather than a leap of faith.

AMP begins with deep system analysis. Proprietary tooling decomposes complex legacy applications into smaller, testable components, uncovering the hidden dependencies and embedded logic that usually stay invisible until late in a project. That analysis informs sequencing and planning, so teams modernise incrementally instead of attempting a risky big-bang rewrite, and each step reduces overall risk rather than accumulating it.

Agentic AI is a force multiplier on top of that foundation. Analysis outputs feed directly into AI-driven workflows that generate additional test cases, transform code components and help redesign the data layer for MongoDB. Tasks that once took weeks of manual effort complete in hours while keeping rigorous validation standards; customers have reported code transformation speeds improved by an order of magnitude and overall timelines cut by two to three times. Crucially, AMP does not treat AI as an autonomous actor. Guardrails built through years of customer engagements ensure that AI accelerates proven processes rather than bypassing them, and every AI-generated transformation is validated, repaired and verified against legacy behaviour.

The result is a model in which legacy systems are no longer static liabilities. They become systems that can be understood, decomposed and evolved continuously, without disrupting the business functions they support. In that sense AMP fits naturally into the broader shift described here: from modernisation as a one-time, high-risk event to modernisation as an ongoing, governed capability.

Why it matters

AI tools and agents are not replacing developers. They are changing where human intelligence is applied: less effort spent deciphering the past, more effort spent designing the future. For organisations burdened by decades of legacy software this is not a productivity gain but a strategic unlock. Modernisation stops being a once-in-a-generation gamble and becomes a continuous, governed process. And that is how software starts evolving again.