app-entwickeln-lassen.de LogoApp entwickeln lassen

Workshops & Training

Legacy Modernisation with Agentic Coding: The Hands-on Workshop

app-entwickeln-lassen.de editorial team 6 min read
Contents
  1. Why Legacy Projects Benefit Particularly from Coding Agents
  2. Where the Risks Are
  3. The Approach: Legacy Modernisation with Agents in 6 Steps
  4. Typical Modernisation Tasks and How Well Agents Handle Them
  5. Possible Content of a Legacy Modernisation Workshop
  6. Common Mistakes When Modernising with Agents
  7. Setup and Enquiries
  8. Conclusion
  9. Frequently Asked Questions

Legacy modernisation with agentic coding means coding agents help your team understand grown legacy code, secure it with tests and move it step by step to modern technology. Used correctly, they shorten the most tedious phases – code analysis, building tests, repetitive refactorings. A specialised workshop shows your team how to do this safely and in a controlled way.

Why Legacy Projects Benefit Particularly from Coding Agents

Modernisation projects rarely fail for lack of technical skill. They fail because of time and risk: nobody knows every corner of the system any more, documentation is missing or outdated, tests are patchy, and any change can break something in an unexpected place. This is exactly where coding agents are strong:

  • Reading and explaining code: agents search large codebases, follow call chains and summarise what a module actually does.
  • Retrofitting tests: they generate characterisation tests that capture current behaviour – the foundation of every safe change.
  • Repetitive changes: API migrations, framework upgrades or renamings across hundreds of files are exhausting for humans and quite feasible for agents.
  • Generating documentation: architecture overviews and module descriptions are derived from the code, then checked and extended by the team.

Our article on modernising legacy apps: costs and AI savings describes the effect on cost and effort.

Where the Risks Are

The limits are just as clear. Agents do not understand unwritten business rules that only exist in the heads of long-serving staff. They can be wrong about outdated libraries, and they tend to "tidy up" where nothing should change on purpose. With legacy systems, the rule applies more than anywhere else: lock down behaviour before you change it, and work in small, verifiable steps.

The Approach: Legacy Modernisation with Agents in 6 Steps

  1. Map: the agent creates an overview of modules, dependencies, entry points and external interfaces. The team reviews and corrects the map.
  2. Identify critical paths: which functions are business-critical, which are barely used? Domain knowledge from the business side comes in here.
  3. Pin down behaviour: characterisation tests for the critical paths, ideally with realistic but anonymised data. No migration without this foundation.
  4. Choose a migration strategy: gradual replacement of individual parts (strangler pattern), module-by-module upgrade or reimplementation of individual components – depending on architecture and risk.
  5. Change in small steps: the agent implements clearly scoped changes, each with a green test suite and its own review.
  6. Remove the old and document: only when the new path runs stably is the old code removed; architecture decisions are recorded.

Read more about planning larger migrations in agentic coding for legacy systems.

Typical Modernisation Tasks and How Well Agents Handle Them

TaskSuitabilityWhat matters
Analyse and document the codebaseHighHave the team cross-check results
Write characterisation testsHighTests must capture actual, not desired, behaviour
Update dependencies and language versionsHigh to mediumProceed incrementally, check changelogs
Framework migrationMediumProvide clear patterns, migrate module by module
Split a monolith into servicesMedium to lowArchitecture decisions stay with the team
Reinterpret business logicLowRequires domain knowledge and human decisions

Possible Content of a Legacy Modernisation Workshop

A workshop on this topic should take place on your own system, because legacy code is always unique. Possible building blocks:

  • Exploring the codebase with the agent: asking the system questions, making dependencies visible, documenting knowledge gaps.
  • Building a safety net: creating characterisation tests for a selected module and assessing how meaningful they are.
  • Refactoring under control: implementing a real change in small steps with the agent, including review. Background: refactoring with AI.
  • Project rules for legacy code: what may the agent change and what not? Which areas are off-limits, which patterns should be introduced?
  • Sketching a migration plan: developing a realistic, prioritised roadmap for the next steps together.

The format – for example a half-day introduction or a multi-day team training, in-house or remote – is agreed individually. If needed, a support phase in the ongoing modernisation project can follow.

Common Mistakes When Modernising with Agents

  • Refactoring without tests: the fastest way to damage a working legacy system.
  • Steps that are too big: "migrate the whole project to framework X" produces huge changes that are nearly impossible to review.
  • Accepting agent documentation unchecked: summaries can sound plausible and still be wrong.
  • Leaving out the business side: business rules that are documented nowhere get lost during the rebuild.
  • Merely moving technical debt: rebuilding old code one-to-one in new syntax only modernises the surface. More in technical debt and AI.

Setup and Enquiries

We place AI developers from real-world practice as trainers who carry out modernisation projects with coding agents themselves. Workshops start from €799 net; content, format and scope are agreed individually after a briefing call. Write to us at team@app-entwickeln-lassen.de. If you would rather outsource the modernisation entirely, we also develop apps ourselves – request an offer via our offer wizard.

Planning an app? Request a free fixed-price quote in 2 minutes

Conclusion

Coding agents do not make legacy modernisation trivial, but they make it much more manageable. They help you understand old code, retrofit tests and implement repetitive changes quickly. A disciplined approach remains essential: secure first, then change in small steps, and leave architecture and domain decisions with the team. A workshop on your own system makes this way of working tangible for your team.

Frequently Asked Questions

Can coding agents handle very old programming languages?

Many agents can read and explain older languages and frameworks too. Quality varies more than with widespread modern stacks, so tests and reviews are especially important here.

What are characterisation tests?

Characterisation tests capture the current behaviour of a system, regardless of whether it is functionally correct. They form the safety net used to verify changes during modernisation.

Should an agent rewrite a legacy application from scratch?

We generally advise against it. Incremental change with secured behaviour is usually less risky than a full rewrite that can miss unknown business rules.

Does the workshop take place on our own code?

For legacy modernisation we strongly recommend it, because legacy systems are highly individual. We clarify access and data protection during the briefing call.

This article was written by the editorial team of app-entwickeln-lassen.de – the app and AI development service of jocapps GmbH, based in Freiburg, Germany, and building apps since 2014. The content is for general information and does not replace individual (legal) advice.

You might also like

Workshops & TrainingAI Coaching for Developer Teams: Practice Instead of Lectures

AI coaching for developer teams: why guided real-world projects have a more lasting effect than lectures and how coaching with experienced AI developers works.

5 min read
Workshops & TrainingPrompt and Context Engineering Training for Developers

Context engineering training for developers: how teams shape tasks, project rules and context so that coding agents reliably deliver high-quality code.

5 min read
Workshops & TrainingSecurity Workshop: Working Safely with Coding Agents

Working safely with coding agents: the key risks from prompt injection to leaked secrets, concrete safeguards and how a workshop helps your team apply them.

6 min read
Workshops & TrainingAgentic Coding for Data Scientists and ML Engineers: The Workshop

Agentic coding for data scientists: how coding agents help with pipelines, experiments and model code – with a focus on data protection and reproducibility.

6 min read
Workshops & TrainingAI Literacy Under the EU AI Act: Must Companies Train Their Teams?

AI literacy under the EU AI Act: what Article 4 requires, who is affected and how to upskill developer teams in a practical and well-documented way.

6 min read
Workshops & TrainingFinancing AI Training: Funding and Budgets for Developer Courses

Financing AI training in Germany: which funding routes exist, when they fit short workshops and how to combine internal budgets to pay for team upskilling.

6 min read