"Analyst research shows that about 65% of enterprise applications are now considered legacy," Phil de Valence opened, setting the stage for one of the most practical sessions in the DEV track. Legacy applications---those relying on outdated technology that are hard to maintain and extend---typically consume the majority of IT budgets. But with the advent of generative AI, the modernization game is changing dramatically.
Phil de Valence, Principal Product Manager at AWS, and Matt Lewis, Chief AWS Architect at IBM Consulting and AWS Data Hero, delivered DEV333 with a clear mission: show real AI agents already working for customers. No theory, no slides full of promises---just seven demonstrations of AI-based reusable patterns for application modernization.
"AI agents can do reasoning. They can use tools. They can do multi-step workflows, and all of this can dramatically increase the speed and the quality for executing modernization tasks," Phil explained. The session proved this wasn't aspirational---it was happening now.
The Modernization Approach: Reverse and Forward Engineering
Matt outlined the two complementary approaches to modernization that organizations need to master.
Reverse engineering breaks down existing systems to understand how they work:
- Analyzing systems to understand features and components
- Updating and creating new technical documentation
- Extracting business rules and business logic
- Decomposing systems into discrete modular components
- Planning migration strategies
Forward engineering starts with requirements to build new systems:
- Transforming applications in cloud-native ways
- Building deployment pipelines
- Creating APIs for system integration
- Implementing comprehensive testing phases
- Planning cutover to drive cost savings
"Organizations today tend not to have just a single monolithic application, but quite a disparate IT estate," Matt noted. This reality drives the need for flexible, pattern-based approaches rather than one-size-fits-all solutions.
Modernization Patterns: From Rehost to Microservices
The session covered the spectrum of application stack modernization patterns:
Rehost (Lift and Shift): Moving the application stack from operating system up onto modernized compute without changes, gaining agility through cloud-based practices.
Re-platforming: Changing the runtime and database type to leverage managed services and operational efficiencies.
Refactor: Transforming the complete application stack including language and framework while maintaining business functions---enabling automation and speed at scale.
Beyond application stack modernization, decomposition moves from tight coupling to loose coupling:
- Technical decomposition: Separating applications into layers (presentation, business logic, data) to optimize each independently
- Business decomposition: Aligning applications with business needs, enabling granular teams without tight dependencies
The strangler pattern emerged as a popular mechanism for incremental modernization---introducing a gateway and integrations between old and new environments, gradually rerouting queries to modernized services while maintaining the ability to revert if needed.
How Agentic AI Accelerates Modernization
Phil demonstrated why AI agents are uniquely suited for modernization tasks. AI agents have key characteristics that traditional tools lack:
- Understanding and reasoning: Decomposing goals into executable tasks
- Observation: Understanding application languages, frameworks, and dependencies
- Tool access: Performing specific operations like code conversion
- Knowledge bases: Accessing best practices for modernization
- Feedback loops: Improving transformation quality iteratively
The architecture is elegant: users interact with an orchestration agent that decomposes goals and calls specialized agents (analysis, transformation, testing) that observe inputs, execute modernization activities, and provide outcomes. For large-scale modernization, all application artifacts reside in a repository that agents access to modernize each artifact systematically.
AWS Agentic AI Capabilities for Modernization
Phil showcased three key AWS capabilities:
AWS Transform: An agentic AI service for large-scale modernization supporting mainframe to cloud, .NET modernization, VMware modernization, and custom transformations.
Amazon Q Developer: A coding assistant residing in your IDE (VS Code, JetBrains) that helps throughout the software development lifecycle.
Kiro: The latest agentic IDE from AWS, optimized for agentic collaboration with a strong focus on specification-driven development for production-ready applications.
Seven Live Demonstrations
The session's strength was its demonstrations---seven real examples showing AI agents in action.
Demo 1: Generating Specifications from Legacy Code
Matt demonstrated using AWS Step Functions to automatically generate design specifications from legacy source code. The serverless architecture used Amazon S3, Amazon EventBridge, AWS Step Functions, and Amazon Bedrock to transform a REXX mainframe scripting file into a readable specification document.
"If you try and translate directly from one programming language to another, you often end up with semantic drift caused by differences in the various different idioms within programming languages," Matt explained. The solution: ground modernization in design specifications rather than direct code translation.
The workflow automatically triggers when legacy code is uploaded to S3, calls an LLM on Bedrock with a prompt template defining the desired specification structure, and sends a pre-signed URL via Amazon SNS for business analyst review---enabling human-in-the-loop validation without requiring AWS console access.
Demo 2: Understanding Code and Extracting Business Logic
Phil demonstrated AWS Transform's ability to analyze legacy applications and extract comprehensive business logic. The demonstration showed a mainframe application being analyzed at multiple levels:
- Application level: Overall summary and functional groups
- Functional group level: Detailed business descriptions
- Component level: Business summaries with workflows
- Program level: Every single action, business function, decision point, and branch with complete input/output data sources
"When you start extracting information, that information can be overwhelming. You could have hundreds of pages of documentation," Phil noted. The solution: a chat agent that allows natural language queries against the generated documentation, eliminating the need to manually search through extensive technical materials.
The system generates both business logic extraction and technical documentation in PDF and JSON formats---making the information reusable for creating specifications, test cases, and other modernization workflow purposes.
Demo 3: Re-platforming for Cross-Platform Portability
Phil demonstrated modernizing a .NET Framework 3 application (Windows-only) to .NET 8 (cross-platform, including Linux). AWS Transform analyzed the application, proposed a transformation plan that users could adjust, then executed the plan---upgrading packages, ensuring .NET 8 compatibility, and performing builds to validate changes.
The transformation report provided comprehensive details: statistics on what was completely upgraded versus partially transformed, file-by-file change comparisons, build errors, and Linux readiness assessments. Most importantly, it generated a markdown document with suggested next steps that developers could execute manually or with LLM assistance.
"We want to make sure this information is reusable," Phil emphasized, explaining why outputs are provided in JSON format for integration into broader modernization workflows.
Demo 4: Upgrading Runtime Dependencies
Matt demonstrated AWS Transform Custom, released earlier in the week, using the AWS Transform CLI to upgrade a five-year-old bicycle license application from Java 11 and outdated Spring Boot to current long-term supported versions.
The CLI experience was conversational: entering a natural language prompt like "upgrade my Java application," the system identified relevant pre-built transformations, asked for additional requirements (AWS SDK V1 to V2, Spring Boot upgrade), created a detailed plan in JSON format, and executed it using specialized sub-agents.
"As it goes through it detects compilation errors and fixes them," Matt explained, showing how the execution agent detected a breaking change in Spring Boot's interface and automatically added the required method. The system created a new Git branch with commits for each transformation step---enabling full traceability and easy pull request creation.
Demo 5: Generating Code Conforming to Corporate Standards
Matt demonstrated Kiro's specification-driven development approach, showing how to generate code that conforms to corporate standards using steering files, Model Context Protocol (MCP), and Retrieval Augmented Generation (RAG).
The first attempt generated a simple API using API Gateway and Lambda with Node.js, but used an outdated Node runtime and lacked tracing, structured logging, and AWS Lambda Powertools.
The solution: steering files (markdown files providing persistent knowledge to Kiro), MCP configuration connecting to a knowledge base on Amazon Bedrock, and best practice code snippets stored in Amazon S3 with S3 vectors (a new GA feature providing low-cost scalable vector storage).
With these configurations, the same prompt produced dramatically different results: Node 22 runtime, tracing enabled, structured logging with AWS Lambda Powertools, custom CloudWatch metrics---all conforming to corporate standards without explicit instruction in the prompt.
"This is where within Kiro there are capabilities that you can provide that can help it conform to your corporate standards," Matt explained.
Demo 6: Multi-Agent Orchestration with Strands Agents SDK
Matt demonstrated building a multi-agent system using Strands Agents SDK, an open-source SDK providing a code-first framework for building agents with just a few lines of code.
The architecture used an "agent as tools" pattern: an orchestrator agent managing three sub-agents (design specification agent, implement from design agent, Python code improvement agent) plus a Python compilation tool using Code Interpreter on Amazon Bedrock Agents.
The key insight: rather than hardwiring a workflow like AWS Step Functions, the orchestrator received instructions through a prompt template and used its own reasoning to determine which tools to call and when. When given a Java calculator class, the orchestrator automatically decided to create a design specification first, then generate Python code, then compile and test it---all without explicit workflow definition.
The result: a Java class automatically converted to a fully commented, fully documented Python class following PEP 8 guidelines.
Demo 7: Mainframe to Java Refactoring and Reforging
Phil demonstrated the complete mainframe modernization workflow using AWS Transform, starting with a COBOL application with BMS maps (screens), copybooks (data structures), and JCL scripts (batch jobs).
AWS Transform's analysis phase identified missing dependencies, then the refactoring phase transformed:
- COBOL code to Java
- BMS maps to Angular screens
- JCL scripts to modern scripts
- VSAM data stores to relational databases
The new reforge capability provided LLM-based improvements to enhance refactored Java code: adding descriptive comments, optimizing variable usage, improving code flow, and factorizing repetitive code. Phil showed verbose error handling code being automatically refactored into a clean, reusable method---dramatically improving readability and maintainability.
"The reforge process is really designed to enhance the refactored Java code," Phil explained, noting it performs incremental improvements while ensuring code remains buildable after each step.
Operational Excellence: Troubleshooting with Kiro CLI
Matt closed with a powerful demonstration of using Kiro CLI for operational troubleshooting in production environments. By providing Kiro CLI with access to code repositories, config files, and an assumed role for AWS resources, the agent could:
- Invoke API endpoints and analyze CloudWatch logs when timeouts occurred
- Read code to identify the specific line causing issues
- Debug AWS service denied exceptions by reading Service Control Policies from the file system
- Investigate Amazon EKS cluster node restart issues, identifying availability zone balancing problems combined with spot capacity constraints
"These are screenshots from a live production issue," Matt emphasized. "That could have taken an hour, a couple of hours to try and track down going through every single SCP to understand why that wasn't working."
The Kiro CLI's ability to combine AWS CLI commands, kubectl commands, code analysis, and configuration file reading---all with appropriate permission controls---demonstrated how AI agents are already solving real operational challenges.
Key Takeaways
AI agents dramatically accelerate modernization: Reasoning, tool usage, and multi-step workflows reduce timelines from months to weeks or days.
Pattern-based approaches work at scale: Rehost, re-platform, refactor, and decomposition patterns provide flexibility for diverse application portfolios.
Specification-driven development reduces ambiguity: Grounding transformations in design specifications prevents semantic drift and technical debt migration.
Corporate standards can be enforced automatically: Steering files, MCP, and RAG enable code generation that conforms to organizational requirements without manual intervention.
Multi-agent orchestration enables complex workflows: Specialized sub-agents coordinated by orchestrator agents handle sophisticated modernization tasks autonomously.
Operational troubleshooting benefits from agentic AI: Production issue diagnosis that previously took hours can be completed in minutes with appropriate agent access.
Human-in-the-loop validation remains critical: While agents automate transformation tasks, business analysts and developers validate specifications, review changes, and make strategic decisions.
Phil's closing advice: "We look forward to seeing how you're going to be able to leverage those capabilities in your own modernization journeys. Feel free to reach out to us if you need any guidance."
The session proved that agentic AI for application modernization isn't future technology---it's production-ready today, with real customers achieving real outcomes. The seven demonstrations provided concrete patterns and tools that organizations can immediately apply to their legacy modernization challenges.
About This Series
This post is part of DEV Track Spotlight, a series highlighting the incredible sessions from the AWS re:Invent 2025 Developer Community (DEV) track.
The DEV track featured 60 unique sessions delivered by 93 speakers from the AWS Community - including AWS Heroes, AWS Community Builders, and AWS User Group Leaders - alongside speakers from AWS and Amazon. These sessions covered cutting-edge topics including:
- 🤖 GenAI & Agentic AI - Multi-agent systems, Strands Agents SDK, Amazon Bedrock
- 🛠️ Developer Tools - Kiro, Kiro CLI, Amazon Q Developer, AI-driven development
- 🔒 Security - AI agent security, container security, automated remediation
- 🏗️ Infrastructure - Serverless, containers, edge computing, observability
- ⚡ Modernization - Legacy app transformation, CI/CD, feature flags
- 📊 Data - Amazon Aurora DSQL, real-time processing, vector databases
Each post in this series dives deep into one session, sharing key insights, practical takeaways, and links to the full recordings. Whether you attended re:Invent or are catching up remotely, these sessions represent the best of our developer community sharing real code, real demos, and real learnings.
Follow along as we spotlight these amazing sessions and celebrate the speakers who made the DEV track what it was!
Top comments (0)