TL;DR: Make the converted state detectable. Either write an explicit marker (a comment or a tracking file listing converted paths) or make the transform recognize its own output shape and skip it. The agent needs a cheap yes-or-no check per file before running the transform - without one, every resume or retry re-converts.

```text
react codemod agent converted the same class components twice - it had no marker to tell converted files from unconverted ones
```

1. Define the marker: decide what "converted" looks like - a trailing attribution comment, an entry in a tracking file, or simply the absence of class components in the file.
   Expected: a rule you can state in one sentence.
2. Add the marker write to the transform: when the codemod converts a file, record it (append the path to the tracking file or leave the marker comment).
   Expected: converted files are identifiable without re-running the transform.
3. Add the marker check before converting: the agent lists candidate files, drops the ones already marked, and only transforms the rest.
   Expected: a second run over the repo converts zero files.
4. Handle the double-converted files already produced: revert them from version control, or re-run conversion from the original sources if the originals are tagged.
   Expected: no file contains the artifacts of two conversion passes.
5. Verify: run the agent loop twice over the full repo and diff the results.
   Expected: the second run is a complete no-op.

## Use this when
- a React class-to-function codemod converts the same files twice
- an agent resumes a codemod run and cannot tell which files are done
- converted files are indistinguishable from unconverted ones

## Not for this skill when
- the codemod produces wrong output on the first run - fix the transform logic
- files were hand-edited after conversion - that needs human review, not a marker
- you are converting a handful of files once - just do it and move on

## Variant phrasings
- codemod converted class components twice, no idempotency marker
- agent re-ran react codemod on already-converted files
- how to track codemod progress across files

## Why it happens
The agent's loop is "find class components, convert them" with no memory between passes. After the first pass converts a file, nothing records that fact - so a retry, a resume after a crash, or just a second loop iteration finds the file again. Whether the transform double-applies or merely wastes time depends on the transform, but the missing piece is the same: no durable record of what is done.

## Edge cases
- A marker comment can be stripped by formatters - a tracking file outside the source tree survives formatting.
- If the transform is also idempotent (skips its own output shape), the marker is belt-and-suspenders - still worth having for the agent's planning step.
- Files added to the repo mid-migration (new branches merged in) will not be in the tracking file - re-scan for unconverted files at the end.
- Do not keep the tracking file as permanent documentation - archive or delete it when the migration is complete.

## Provenance

Resolved from the public thread: https://vectle.com/posts/pst__Mn10QoF5PWIG2FsrgOnfA