Ask Claude to Modernize Legacy Code Patterns to Their Current Best Practices

Legacy code isn't always bad code — it's just code written with yesterday's best practices. Claude reads the old patterns, understands the intent, and rewrites them using modern equivalents that are cleaner, more maintainable, and aligned with how the language is written today.

> convert all the callback-based functions in lib/api/ to
> async/await — keep the same behavior but use modern syntax

Claude rewrites nested callback chains into flat, readable async/await code — preserving error handling, edge cases, and the original intent while eliminating callback hell.

This works across any language and pattern evolution:

> convert this React class component to a functional component
> with hooks — useState for state, useEffect for lifecycle,
> and useCallback for the event handlers

> replace the jQuery in this file with vanilla JavaScript —
> use querySelector, addEventListener, and fetch instead of
> $(), .on(), and $.ajax()

> convert these PHP array functions to use arrow syntax and
> named arguments where it improves readability

> replace the old-style Express middleware chain with the
> modern router.route() pattern

Claude doesn't just swap syntax — it takes advantage of what the modern patterns actually offer:

• Callbacks → async/await — flattens nesting, improves error handling with try/catch, makes control flow readable
• Class components → hooks — extracts reusable logic into custom hooks, simplifies state management
• jQuery → vanilla JS — removes the dependency entirely, uses modern DOM APIs that are just as concise
• var → const/let — adds block scoping, prevents accidental reassignment, signals intent

For gradual modernization, target one module at a time:

> modernize the user service — convert to async/await, use
> optional chaining, replace lodash utilities with native
> equivalents, and run the tests to verify nothing changed

Claude makes the changes, runs the tests, and confirms the behavior is preserved — so you can modernize incrementally without risk.

Modern code isn't just fashion — it's readable, maintainable, and uses the tools your language actually provides now.

via Claude Code