Migration
Upgrading dependencies, languages, frameworks and platforms.
Download all 104
Start here 1
The general, start-from-zero entry for a need in this category: it works from a blank start, asks for what it needs and hands off to the specific entries. Example: Plan a trip.
- Upgrade a major dependency
Upgrades a library or framework across major versions using the official migration notes, fixes what breaks, and proves the result with before-and-after checks. Use for any breaking upgrade.
Specific 79
One situation, audience, tool or format inside the category. Example: Plan a road trip with children.
- Migrate JavaScript to TypeScript
Plans and carries out an incremental JavaScript-to-TypeScript migration with config, file order, typed boundaries and a strictness ratchet. Use to move a JS codebase without a freeze.
- Plan a breaking API version change
Plans a breaking API version change with a deprecation timeline, compatibility shims, a client migration guide and adoption telemetry. Use before changing anything clients rely on.
- Upgrade a project's language runtime
Upgrades a language runtime across code, lockfiles, Docker images, CI and docs, fixing deprecations and running the full suite at each gate. Use before a runtime version reaches end of life.
- Migrate a test suite to another framework
Moves a test suite between frameworks, such as Jest to Vitest or unittest to pytest, in batches with codemods, manual fixes, pass-count parity checks and CI updates. Use for any test framework switch.
- Dependency update sweep track
Brings a project with many outdated dependencies up to date in gated steps, with a risk-ranked inventory, a patch and minor batch, majors one at a time, then lockfile hygiene and update automation.
- Inventory deprecated API usage
Groups deprecation warnings and deprecated API usages by replacement before an upgrade, estimates effort per group and orders the work into small changes that ship on the current version.
- Switch a build tool
Plans moving between build tools such as Webpack to Vite, Maven to Gradle or Make to CMake, with feature mapping, plugin replacements, environment variables, output parity checks and a CI dual run.
- Modernise Python packaging
Moves a Python project from setup.py, requirements files or ad hoc scripts to pyproject.toml with a build backend, locked dependencies, entry points and CI, keeping existing install commands working.
- Replace Moment.js
Replaces Moment.js with date-fns, Day.js, Luxon or Temporal, mapping format tokens, mutability, time zones, parsing and locale loading, with tests around date edge cases.
- Adopt strict type checking module by module
Moves a Python or TypeScript codebase to strict type checking one module at a time, fixing real bugs found and ratcheting config so coverage never slides back. Use to adopt strict mode safely.
- Move cron jobs to an orchestrator
Moves scattered cron jobs to a scheduler or workflow orchestrator with an owned inventory, explicit dependencies, idempotency, retries, time zone and overlap rules, alerts and a parallel-run cutover.
- Replace a state management library
Plans moving a frontend app to a new state approach, such as legacy Redux to server-state caching plus local state, by classifying state, migrating slice by slice and deleting the old store safely.
- Port workloads to Arm64
Plans moving services, containers and CI to Arm64 servers or Apple silicon, finding native dependencies, single-arch images, x86 intrinsics and memory-ordering bugs, with a mixed-arch canary rollout.
- Switch JavaScript package manager
Switches a project or monorepo between npm, Yarn, pnpm and Bun, converting the lockfile without changing resolved versions and fixing workspaces, hoisting, scripts, Docker and CI.
- Adopt Swift 6 strict concurrency checking
Moves a Swift codebase to Swift 6 data-race safety module by module, fixing Sendable, actor isolation and global state errors with minimal escape hatches and runtime checks.
- Convert class components to hooks
Converts React class components to function components with hooks, mapping lifecycles to effects correctly and keeping refs, error boundaries and behaviour, one component at a time with tests.
- Convert infrastructure code between IaC tools
Moves live infrastructure from one IaC tool to another, such as CloudFormation or CDK to Terraform, with retain policies, imports and no-change plans so nothing is recreated.
- Convert Java code to idiomatic Kotlin
Converts Java classes to idiomatic Kotlin file by file in a mixed codebase, fixing nullability, keeping Java callers working with interop annotations and preserving git history.
- Convert Objective-C code to Swift incrementally
Converts Objective-C classes to Swift one at a time in a mixed app, preparing headers with nullability, keeping Objective-C callers working, and preserving runtime features like KVO and selectors.
- Migrate ESLint to flat config
Moves ESLint from .eslintrc to the flat config file used by ESLint 9 and later, mapping extends, plugins, overrides, ignores, globals and TypeScript setup without changing the rule set.
- Migrate javax to the jakarta namespace
Moves a Java codebase from javax.* to jakarta.* enterprise APIs, as needed for Spring Boot 3 or Jakarta EE 9+, including config strings, service files and third-party libraries that still ship javax.
- Migrate pandas code to Polars
Ports pandas data code to Polars expressions and lazy frames, mapping the index, apply, groupby, joins, dtypes and IO, and proves the outputs match before switching over.
- Migrate Pydantic v1 to v2
Moves code from Pydantic v1 to v2, mapping validators, Config, parse and dict methods, settings, custom types and FastAPI integration, and catching changed coercion and Optional behaviour.
- Migrate hand-written Redux to Redux Toolkit
Converts hand-written Redux reducers, action creators and thunks to Redux Toolkit slices, and data-fetching thunks to RTK Query, one slice at a time with tests passing.
- Migrate styles to utility CSS
Migrates component styles from CSS modules, styled-components, Sass or plain CSS to a utility-first framework one component at a time, mapping values to tokens and proving visuals are unchanged.
- Migrate views to declarative UI
Plans an incremental move from UIKit to SwiftUI or Android Views to Jetpack Compose, with two-way interop, screen order, state hoisting, theming, previews and per-screen risks.
- Switch a Python project to uv
Moves a Python project from pip, pip-tools, Poetry or Pipenv to uv with a lockfile, pinned Python, dependency groups, private indexes, Docker and CI caching, keeping resolved versions the same.
- Upgrade Django to a new version
Upgrades a Django project across feature and LTS releases by clearing deprecation warnings step by step, checking third-party packages, Python and database support, settings and migrations.
- Upgrade a game engine version
Plans a game engine major upgrade such as Godot 3 to 4 or a Unity LTS jump, covering backup branch, API and render pipeline changes, shader and asset re-import, plugins and a playtest checklist.
- Upgrade TypeScript to a newer version
Upgrades the TypeScript compiler across versions, including the native compiler, fixing new type errors, changed defaults, deprecated tsconfig options and tool compatibility without weakening types.
- Move an app off Heroku to another platform
Moves an app from Heroku to another platform, mapping dynos, add-ons, config vars, release phase, scheduler and buildpacks, and moving the database with a planned cutover.
- Move existing file uploads to object storage
Moves user uploads from local disk or database blobs to S3-compatible object storage, with a key scheme, private access via signed URLs, verified batch copy and no broken links.
- Upgrade an integration to a vendor's new API version
Moves an integration to a vendor's new API version before the old one is sunset, finding affected call sites and webhooks, adapting to breaking changes and rolling out with sandbox tests.
- Upgrade an Ubuntu server to the next LTS release
Plans and runs an Ubuntu Server LTS upgrade, in place or by rebuilding, with package and service inventory, snapshot, third-party repository checks, post-upgrade service tests and a rollback.
- Convert Vue Options API to Composition API
Converts Vue components from the Options API to the Composition API with script setup, typed props and emits, composables in place of mixins, and the reactivity pitfalls that break behaviour.
- Migrate a Create React App project to Vite
Moves a Create React App project to Vite, covering index.html, REACT_APP_ environment variables, the dev proxy, SVG and asset imports, Jest or Vitest, and build output paths.
- Migrate Enzyme tests to React Testing Library
Rewrites Enzyme tests to React Testing Library, replacing shallow rendering, instance and state checks with user-facing queries and events, keeping what each test proves.
- Upgrade an Express 4 app to Express 5
Upgrades an Express 4 app to Express 5, fixing route path syntax, removed methods, read-only req.query, body and query parser defaults, async error handling and middleware compatibility.
- Migrate Python linting and formatting to Ruff
Replaces Flake8, isort, Black, pyupgrade and parts of pylint with Ruff, mapping rules, plugins and per-file ignores to keep the same checks without a flood of unrelated changes.
- Move a React Native app to the New Architecture
Moves a React Native app and its own native modules to the New Architecture, with library readiness checks, TurboModule and Fabric conversion via codegen specs, and behaviour testing.
- Migrate RxJava code to Kotlin coroutines and Flow
Replaces RxJava streams with Kotlin coroutines and Flow layer by layer, mapping types, operators, schedulers, subjects, errors and lifecycle, with interop adapters during the move.
- Migrate Svelte 4 components to Svelte 5 runes
Moves Svelte 4 components to Svelte 5 runes, snippets and event attributes using the migration script plus manual review of reactive statements, slots, events and component APIs.
- Move a Kotlin project to Kotlin 2 and the K2 compiler
Moves a Kotlin project to Kotlin 2.x and the K2 compiler, fixing new compiler errors, the Compose compiler plugin change, kapt to KSP, compiler plugins and Gradle DSL changes.
- Migrate code and dependencies to NumPy 2
Updates a project for NumPy 2, fixing removed aliases and functions, NEP 50 type promotion changes, scalar repr, copy semantics and dependants compiled against NumPy 1.
- Migrate a Vue CLI project to Vite
Moves a Vue CLI (webpack) project to Vite, covering environment variables, index.html, aliases, require calls, proxy, Sass imports, tests and build output, with the app verified page by page.
- Migrate a WordPress site to a new host
Moves a WordPress site to a new host or domain with a content freeze, files and database transfer, serialization-safe URL replacement, DNS, SSL, email and caching checks, and a rollback path.
- Migrate a Xamarin app to .NET MAUI
Moves a Xamarin.Forms or Xamarin native app to .NET MAUI, covering renderers to handlers, single-project structure, plugin replacements, layout differences and existing user data.
- Move a self-hosted database to a managed service
Moves a self-hosted Postgres or MySQL database to a managed service such as RDS or Cloud SQL, checking extensions and privileges, then cutting over with replication and minimal downtime.
- Move a Gatsby site to another framework
Moves a Gatsby site to Astro or Next.js, replacing the GraphQL data layer, plugins and image handling while keeping every URL, SEO tag and removing the old service worker safely.
- Switch an app to a different LLM API provider
Ports application code from one LLM API to another, mapping messages, system prompts, tool calls, streaming, structured output, token limits and errors, with an eval to prove parity.
Showing 50 of 79. See them all in search
Advanced 24
Expert or deep work that assumes the user can judge expert output. Example: Plan croissant lamination.
- Plan an incremental migration
Plans a framework, platform or system migration as small reversible phases using the strangler fig pattern, with data strategy, verification and rollback per phase. Use instead of a big-bang rewrite.
- Plan a cloud migration
Plans moving workloads from on-premises or another cloud, classifying each with the 6 Rs and ordering waves by dependency and risk, with cutover, rollback and cost checks.
- Plan a monorepo migration
Plans moving several repositories into a monorepo, covering history preservation, build tooling, CI, code ownership and a staged rollout. Use before consolidating repositories.
- Plan a database engine migration
Plans a move between database engines, such as MySQL to Postgres, covering incompatibilities, data copy, cutover, verification and rollback. Use before committing to a migration date.
- Migration engineer
Acts as an engineer who leads upgrades and platform moves through inventories, strangler patterns, dual running, reversible steps and a done definition that includes deleting the old path.
- Switch message brokers
Plans moving producers and consumers to a new message broker, mapping delivery, ordering, retry, dead-letter and retention semantics, with a bridge or dual-publish period and idempotent consumers.
- Switch observability backend
Plans moving logs, metrics and traces to OpenTelemetry and a new backend with a dual-shipping period, name mapping, dashboard and alert parity checks, cost estimates and old agent removal.
- Plan an authentication provider migration
Plans moving users from one authentication provider or in-house auth to another, covering password hashes, sessions, social logins, MFA, a dual-run period, a security review gate and rollback.
- Migrate CI to another provider
Plans and writes the migration of CI pipelines from one provider to another, mapping jobs, caches, secrets, triggers and artifacts, with a parallel-run period and a cutover checklist.
- Migrate to a new payment provider
Plans moving to a new payment provider, covering provider-to-provider card migration, subscriptions, mandates, webhooks, refunds and disputes on old charges, reconciliation and a staged cutover.
- Switch ORM or query layer
Plans replacing an ORM or query builder incrementally, with a query inventory, transaction, lazy loading and null differences, a compatibility layer, per-query tests and performance checks.
- Plan extracting a service from a monolith
Plans extracting one capability from a monolith with the strangler-fig pattern, covering seams, data ownership, traffic shifting and rollback at every step. Use before splitting a service out.
- Migrate a Flask API to FastAPI
Ports a Flask API to FastAPI route by route behind a shared entry point, with Pydantic models, dependencies, sync or async decisions, auth, error format and contract tests against the old responses.
- Migrate SQLAlchemy 1.x code to 2.0
Moves SQLAlchemy code to 2.0 style using the 1.4 transition warnings, covering select() queries, connection and session transactions, typed declarative mappings, Row changes and async loading.
- Port firmware to a new microcontroller
Plans porting firmware to a different MCU or vendor SDK, covering HAL gaps, peripherals, clocks, pin mapping, interrupt priorities, toolchain and bootloader, with a board bring-up test order.
- Upgrade a database major version
Plans a Postgres, MySQL or similar major version upgrade, covering breaking changes, extensions, in-place versus replication method, rehearsal, downtime, rollback and statistics.
- Upgrade Rails to a new version
Upgrades a Rails app one minor version at a time with dual booting, rails app:update, new framework defaults flipped one by one, Zeitwerk, deprecations and gem compatibility.
- Migrate Angular to standalone components and signals
Moves an Angular app from NgModules to standalone components and to signal inputs, outputs, queries and the built-in control flow, using the official schematics in safe, reviewable steps.
- Migrate an AngularJS app to modern Angular
Plans and starts moving an AngularJS 1.x app to modern Angular (or another framework) with preparation work, a hybrid app, downgraded and upgraded pieces, and a screen-by-screen order.
- Migrate a browser extension to Manifest V3
Migrates an existing Manifest V2 browser extension to Manifest V3, moving the background page to a service worker, blocking webRequest to declarativeNetRequest, and fixing remote code and permissions.
- Migrate a Nuxt 2 app to Nuxt 3
Moves a Nuxt 2 app to Nuxt 3 or later, covering asyncData and fetch, plugins and middleware, server middleware to Nitro, runtime config, head management and module replacements.
- Migrate a Vue 2 app to Vue 3
Moves a Vue 2 app to Vue 3 using the migration build, fixing filters, event buses, v-model, global API and transition changes, and swapping Vuex, Vue Router and UI libraries.
- Port a .NET Framework app to modern .NET
Plans porting a .NET Framework 4.x solution to current .NET, sorting projects by blockers like System.Web, WCF and AppDomains, converting to SDK-style first and moving libraries bottom-up.
- Upgrade Apache Airflow to a new major version
Upgrades an Airflow deployment across a major version, covering removed DAG and operator APIs, provider packages, the metadata database migration, scheduler settings and a staged rollout.
Not: database schema design (data); pure restructuring (refactoring).