How to Avoid Slop When Using AI to Write Unit Tests

The Problem Developers Keep Asking About

A question I repeatedly get is how to avoid slop when letting AI write unit tests for your code (in a non-TDD workflow). The concern is simple: tests incorrectly pass, tests do not reflect functional logic, and developers end up unknowingly validating bugs. This fear is closely related to the pitfalls of snapshot testing in Jest.

The Snapshot Testing Parallel

My opinionated view is that AI-generated unit tests face the exact same issue snapshot testing faced. The real problem happens when developers overwrite or regenerate tests after a code change without running the tests first.

New developers often make this mistake when they’re handed a code-coverage target. The implicit assumption becomes: “the code is correct, so let’s just update the tests.” But this is where slop creeps in.

In snapshot testing, every code change results in one of two legitimate outcomes:

• The tests need to be updated.
• The code’s functionality is incorrect.

If the tests need updating, you update them. If the code is wrong, you fix the code. AI or no AI — the corrective path remains identical.

The Same Two Outcomes Exist in AI-Generated Testing

AI-generated tests behave exactly like snapshot tests here. After a code change, a failing test means:

• The test was wrong and must be overwritten (manually or via AI), or
• The code was wrong and must be fixed (manually or via AI).

Slop occurs when you skip the evaluation step — when you overwrite existing tests immediately after changing code. This is equivalent to mindlessly forcing a new snapshot in Jest.

The Recommended Strategy

To avoid slop entirely, follow this workflow:

1. Make the code change.
2. Run the existing tests.
3. If the tests pass — all good. Generate additional tests using AI and verify manually.
4. If the tests fail — inspect both the test and the code.
   • If the code was incorrect, fix the logic (manually or with AI).
   • If the test was incorrect, overwrite or regenerate it (manually or with AI).

Summary

AI-generated unit tests are not inherently sloppy. The slop comes from overwriting tests without validating them against code changes. Follow the same discipline snapshot testing demands: run first, diagnose, then update either the code or the test — never overwrite blindly.