Let an Agent Write Your Characterization Tests Before You Refactor Legacy Code

Consider a legacy checkout service that applies a loyalty discount only when the server timezone is UTC+1. No test covers it, the original developer left, and the comment says "magic numbers are fine." You need to refactor it because a new tax rule depends on the same logic. The only safe way forward is to capture current behavior before changing a single line.

Characterization tests are the difference between a refactor that ships quietly and one that pages you at 2 AM. They don't assert what the code should do; they assert what the code actually does today. Once you know the baseline, you can make small, mechanical changes and let the test suite tell you if you broke something.

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

Why Characterization Tests Matter for Agent-Driven Refactors

AI coding tools have transformed every developer into a reviewer, but nobody tested the reviewer. When you ask a model to rewrite a messy function, it can introduce subtle behavior changes because it doesn't know which quirks are intentional. A characterization suite becomes the feedback loop that catches those changes.

MonkeyCode's free model access lets you generate test suggestions without spending your own tokens, and its free server option gives you a disposable runner for the suite. The workflow below works with or without those tools, but they make it fast enough to do on a Friday afternoon.

The Four-Step Refactor Workflow

Step 1: Map the Public Interface

Before generating a single test, list every public function, its inputs, its outputs, and any side effects it touches. For the checkout service, you might identify applyDiscount(price, user), which reads the current time and returns a modified price. Write down all known edge cases: empty carts, negative prices, VIP tiers, and times near midnight.

Step 2: Generate Characterization Tests

Send that interface list and the original source to a model and ask for a test skeleton. MonkeyCode's free model access means you can iterate on prompts freely. The goal isn't perfect tests; it's enough tests to lock down every branch and boundary you can find.

Here's a minimal example using Node's built-in test runner:

// cart.js
export function applyDiscount(price, user) {
  if (user.tier === 'gold' && new Date().getHours() < 12) {
    return price * 0.8;
  }
  return price;
}

// cart.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { applyDiscount } from './cart.js';

test('characterization: gold user before noon pays 80%', () => {
  assert.equal(applyDiscount(100, { tier: 'gold' }), 80);
});

test('characterization: standard user pays full price', () => {
  assert.equal(applyDiscount(100, { tier: 'standard' }), 100);
});

test('characterization: gold user after noon pays full price', () => {
  const now = new Date();
  if (now.getHours() < 12) {
    // Time-dependent; refine later by injecting a clock.
  }
});

Seasoned testers will notice the flaky time dependency. That's intentional: characterization tests often reveal hidden dependencies, and that discovery is the first refactor win.

Step 3: Run the Suite on a Disposable Server

You need fast, repeatable feedback after every micro-change. MonkeyCode's free server option provides a clean environment for running your test command without consuming your laptop's battery or your CI budget. Run the suite, capture the output, and treat any failure as a behavior-change alarm.

# safety-net.sh -- run from repo root
node --test test/characterization/

You can execute this script locally, in a container, or on a free server like the one MonkeyCode offers. The point is to make the command so cheap that you run it after every ten-line diff.

Step 4: Apply the Smallest Safe Change

Now refactor. Change one function, rename one variable, extract one helper, and run the suite. If the tests pass, commit. If they fail, you know exactly which behavior slipped, and you can decide whether the new behavior is an improvement or a regression. Do not "fix" the test to make it pass unless you have a documented reason.

A Reproducible Test-Generation Checklist

Use this checklist when asking any model or agent to write characterization tests:

• List every function signature and return type.
• Include all branches, loops, and early returns.
• Add boundary values: zero, empty, null, negative, maximum.
• Mention any external state: time, network, filesystem, environment variables.
• Ask for three tests per branch: one happy path, one alternative path, one adversarial.
• Run the suite once before refactoring to establish the baseline.

Limitations and When Not to Use This Approach

Characterization tests preserve current behavior, not desired behavior. If the code contains a known security vulnerability or a business-logic bug, don't enshrine it with a test. Fix the bug first, then characterize the corrected behavior.

The suite can be brittle when tests depend on time, randomness, or external services. You should inject dependencies before writing the tests, or at least mark the flaky cases to revisit later.

This approach is overkill for a greenfield project with full test coverage. It's also the wrong tool for a codebase where the original behavior is so broken that nearly every output is wrong. In that case, invest in product requirements first.

The Boring Refactor Is the Safe Refactor

Characterization tests turn a scary legacy rewrite into a series of boring, reviewable commits. You don't need a smarter model or unlimited infrastructure; you need a safety net and the discipline to move in small steps. With MonkeyCode's free model access and free server, you have no excuse to skip that net.

Try the workflow on your worst file, and you might find that the most dangerous code in your system becomes the most boring to change.