Boosting Productivity in Migration Projects: Lessons from the Trenches

In this article, I will share a workflow that can help developers boost their productivity when migrating a digital project from a legacy system to Xperience by Kentico.

Preamble

You are an ambitious blacksmith, entrusted with an ancient forge where a master of great renown once crafted his legacy. Now the fire has dimmed, the workshop lies in ruin, and its glory has faded. The duty falls to you:

• Will you tear it down, sacrificing the past to raise a new hall of flame upon its ashes?
• Or will you labor stone by stone, tool by tool, breathing life into the old forge and reshaping it to serve the demands of a new age?

This is the choice faced by development teams inheriting a digital project. A senior developer poured years of effort into the codebase, but after more than a year without active stewardship, a new agency has stepped in with the promise of replatforming and modernization. Now the question is yours:

• Do you treat it as a greenfield project, disregarding the existing site and its history?
• Or do you proceed with a migration—systematically auditing the system, service by service and component by component, refactoring code, upgrading dependencies, and adapting workflows to modern standards?

In practice, this decision depends on many factors: business priorities, technical requirements, and the preferences of the team. But when it comes to replatforming a website to Xperience by Kentico, one message is consistently emphasized: Migrate.

🏚️ What is a migration project?

The analogy between an old building and a website holds up well. Many who buy an old house for renovation later admit: “It would have been easier to tear it down and build anew.” Why? Because at the time of purchase, the true condition is rarely clear. The problems only surface once work begins: rotten beams, unstable walls, a leaking roof.

Websites are no different. At first, migration may seem straightforward. But in reality, it often turns out to be far more complex and demanding than expected.

Still, there’s value in the process. While migration projects inevitably uncover hidden challenges deep in the implementation details, they also provide an opportunity to respect what already exists and carefully evolve it into something sustainable.

So, what does it actually take to migrate a website—specifically into Xperience by Kentico? At the highest level, there are three main areas:

1. Code migration
2. Data migration
3. Infrastructure migration

1️⃣ Code migration

The goal here is well-migrated functionality. Begin by analyzing the current codebase: business logic, frontend, and backend architecture. You’ll likely encounter code that works from a business perspective but carries significant technical debt—outdated dependencies, inefficient patterns, or tightly coupled logic.

Refactor and reimplement where necessary, ensuring the solution fully leverages the APIs of Xperience by Kentico. The end result should be production-ready code: reliable, maintainable, and as robust as if it had been written from scratch.

2️⃣ Data migration

The outcome here is well-migrated content. Start by reviewing the existing information architecture, then remodel it according to Xperience by Kentico best practices. Along the way, you’ll almost certainly discover outdated or irrelevant content—clean it up before moving forward.

For the migration itself, begin with the official migration tool, but be prepared for gaps. Not everything will transfer seamlessly. You’ll likely need to write custom scripts and perform manual adjustments. The scripts can be rough, but the final data in the new system must be accurate, consistent, and complete.

3️⃣ Infrastructure migration

The goal here is a well-organized development workflow and a stable website running across QA, UAT, and Production environments. Replatforming into Xperience by Kentico introduces new services and features, and your team will need to adapt accordingly.

Tip: When replatforming, expect to migrate individual pieces of code and content from the source project, not the entire system wholesale. Read, embrace, and apply the official Xperience by Kentico documentation, guides, and tools. Ideally, complete the Developer and Content Modeling certification exams. A deep understanding of Xperience is crucial: only with the bigger picture in mind can you reshape the project architecture to fit the platform in a way that ensures long-term maintainability.

🔥 Productive developer workflow

Now that we’ve addressed the general challenges of migration projects, let’s take it one step further: how can developers stay productive while navigating them?

Migration projects have a reputation for slowing teams down. Some of the biggest productivity killers include:

• Wrestling with a large, unfamiliar, and often outdated codebase.
• Constantly switching between multiple projects and editors.
• Searching for scattered documentation and best practices.
• Writing boilerplate or repetitive migration code manually.
• Losing context when juggling between source, target, and reference solutions.

These issues often lead to long hours spent on low-value tasks—tasks that feel more like archaeology than software engineering.

With the rise of LLMs and AI coding tools, we are promised higher productivity. But most of those promises are demonstrated on small greenfield projects built with mainstream frameworks. In the context of replatforming to Xperience by Kentico, the situation is different: we face a complex legacy codebase and database that must be migrated into a niche platform.

The challenge, then, is to design a developer workflow that actually delivers productivity under these conditions. The approach described below is especially relevant for code migration and, to a lesser degree, for data migration when creating custom scripts.

🧠 The developer’s role

In this workflow, your role as a developer shifts. Much of the traditional definition—typing out lines of code—is removed. Instead, you rely on agentic coding.

Think of it as having a mid-level developer in the form of an AI agent working alongside you. Your responsibility is not to write everything yourself but to lead and manage the AI effectively. While the AI produces most of the code, your focus shifts to:

• Turning business requirements into solution designs.
• Filling in gaps when information is missing.
• Making architectural decisions and applying best practices.
• Breaking down designs into smaller, actionable tasks.
• Reading and understanding code written by others.
• Reviewing, testing, and refactoring AI-generated code.

In short: less typing, more thinking.

🤖 Who is the AI agent?

The AI agent is essentially the combination of features inside an AI coding tool, powered by an LLM. It can:

• Understand your codebase
• Interpret your prompts and requirements
• Perform actions such as generating, editing, or restructuring code

Breaking it down:

• AI coding tool: Your IDE with integrated AI features (e.g., VS Code with Copilot, Cursor, or JetBrains IDEs with Claude Code).
• Context: The input you provide—requirements, prompts, code references, docs.
• LLM: The large language model (GPT, Gemini, Claude, etc.) interpreting the context.
• Actions: The operations performed, from CRUD over files to running commands or generating docs.

Your task: keep control of the AI and make it work for you.

➡️ The AI coding tool

Choosing the right tool is critical. While many editors now offer AI integration, the depth and usability of these features vary. The workflow described here uses Cursor, as it provides a compact and effective set of features, but the principles apply to any robust AI-powered IDE.

The most important features are:

1. Workspaces
2. File referencing
3. Documentation indexing
4. URL referencing

1️⃣ Workspaces

Workspaces allow you to open multiple codebases in a single environment so the AI can index and reason across all of them. For migration, three types of codebases belong in one workspace:

1. Source codebase – the project you’re migrating from.
2. Target solution – the Xperience by Kentico project you’re migrating into.
3. Reference codebases – inspirational projects, either past client work or public solutions.

Tip: Add a rules to describe the purpose of each codebase, helping the AI understand their roles.

Without workspaces, you’re stuck context-switching between separate editors, and the AI can’t effectively connect the dots.

2️⃣ File referencing

When prompting, you can directly reference files—or even specific code snippets. This ensures the AI operates on exactly what you need, across multiple codebases at once.

Examples:

• Pointing to functionality in the source codebase that must be migrated
• Referencing patterns from reference projects to replicate in the target
• Highlighting existing functionality in the target as a template for new features

Without this, the AI may misinterpret your intent or lose precision.

3️⃣ Documentation indexing

Migration requires respecting Xperience by Kentico’s architecture, APIs, and best practices. The docs are growing but spread out, which makes staying on top of them difficult. With docs indexing, the AI tool can pull directly from the official documentation (and additional sources like Lucene package docs).

This creates synergy with workspaces and file referencing: now your migration can align with both real-world code and official guidance.

4️⃣ URL referencing

Sometimes you need to be laser precise. By including a URL in your prompt, the AI can pull content from a specific page—perfect for referencing API examples or niche blog posts.

Without it, even indexed docs may leave you searching for the right snippet.

👉 A practical example

Let’s see the workflow in action.

You’re migrating a Video widget. Your workspace includes:

• Source solution
• Target Xperience solution
• Three reference projects

The prompt you write:

• Instructs migration of two source widgets, merging them into a single “Video” widget in the target.
• References specific widget files in the source.
• Points to the target folders where code should be placed.
• Explains how to merge the widgets.
• References a sample visibility condition from a reference project.
• Points to a relevant API page in the official docs.
• Instructs alignment with existing patterns in the target.

When you submit the prompt, it takes a minute or two for the AI agent to analyze the context and generate the migrated code files along with the necessary adjustments across the target codebase. The productivity gain comes from the hours saved: instead of manually wiring everything from scratch, you assemble and execute a prompt in minutes, then iterate. The result is not the finished product but a well-structured foundation that reflects the required functionality, follows familiar patterns, and aligns with Xperience best practices.

From here, you can immediately review the code, run it, and begin iterating. This iteration phase combines two strengths: manual adjustments (to fine-tune and correct details) and agentic coding (to speed up repetitive edits and refinements). Step by step, this collaboration pushes the code toward production-ready quality far more efficiently than starting from scratch.

This same approach applies to migrating Page Builder sections, custom modules, services, third-party integrations, or even data migration scripts.

🏁 Final thoughts

Since the start of the AI boom, I’ve been fascinated by agentic coding. Early on, it worked for simple projects, but migrations are where it truly shines. My old workflow—two editors side by side, manually copying files—was slow and exhausting.

The workflow above finally feels like a real productivity breakthrough: less manual labor, more focus on design and architecture, and AI doing the heavy lifting.

It may not eliminate the challenges of migration projects, but it makes them manageable—and, most importantly, it makes developers feel productive again.