How to Refactor Code with AI

In short: lock behaviour with tests first, ask for a small named improvement, compare the diff, re-run tests. Ban “while you’re at it” feature changes.

Why refactor with AI

Messy helpers slow every future change. AI is fast at renaming, extracting functions and simplifying nested loops. It is also eager to change behaviour. Tests are the seatbelt.

What a safe refactor request includes

• Goal: “extract slugify”, “rename for clarity”, “remove duplication” — one goal.
• Freeze behaviour: “do not change outputs; keep public names unless I say so.”
• Scope: one file or one function first.
• Proof: existing tests, or ask the AI to add characterisation tests before editing.

How a safe refactor flows

Example: messy process() → slugify_many()

def process(d):
    o = []
    for x in d:
        if x is not None and str(x).strip() != "":
            s = str(x).strip().lower().replace(" ", "-")
            while "--" in s:
                s = s.replace("--", "-")
            o.append(s)
    return o

import re

_SLUG = re.compile(r"[^a-z0-9]+")


def slugify_many(values: list[object]) -> list[str]:
    """Turn each non-empty value into a simple URL slug."""
    out: list[str] = []
    for raw in values:
        if raw is None:
            continue
        text = str(raw).strip().lower()
        if not text:
            continue
        slug = _SLUG.sub("-", text).strip("-")
        if slug:
            out.append(slug)
    return out

from after import slugify_many

def test_basic():
    assert slugify_many(["Pune City", "  ", None, "Nashik--Road"]) == [
        "pune-city",
        "nashik-road",
    ]

cd code/refactor
python3 -m pytest -q
# -> 1 passed

How to refactor step by step

1. Get a green baseline (or write tests that pin today’s behaviour).
2. Ask for one improvement: rename, extract, simplify — not all three plus features.
3. Read every changed line. Reject new dependencies you did not request.
4. Re-run tests. If behaviour shifted, either fix the prompt or discard the diff.
5. Commit the refactor alone so reviews stay easy.

Settings tip

1. Project rules: “Refactors must not change public behaviour without a new test.”
2. In Cursor / Copilot Agent: point at files with @ and say “only these files”.
3. Prefer a strong model for big design refactors; use inline/fast for rename-only work.

Quick quiz

Save tokens and money

Small scope = fewer tokens and safer diffs. Do not ask five models to rewrite the same module. One good pass + tests is enough.

Save these cards