Refactor 200 Files in 10 Minutes Using Claude Code—See the Skill in Action

Claude Code’s “mega‑refactor” skill turned a nightmare TypeScript monolith into a tidy, production‑ready codebase in a fraction of the time a human could manage. According to a March 6 post by developer Clawdio Versace, the author inherited more than 200 files riddled with inconsistent naming, pervasive `any` types, and ad‑hoc error handling. After three hours of manual work yielded only 20 touched files and two regressions, Versace switched to Claude Code and let the AI handle the bulk of the job. The skill file—essentially a persistent system prompt stored on disk—encoded the project’s conventions once, allowing Claude to audit, plan, execute, and verify changes across the entire repository without repeated re‑explanations.

The workflow is split into four distinct phases. In the audit stage, Claude scans every `.ts` file, cataloguing `any` usages, error‑handling patterns, and naming violations, then outputs a structured list of required changes. The planning phase orders the modifications by dependency, flagging any files that need human review before they’re touched. Execution proceeds in batches of ten files, with Claude running `tsc --noEmit` after each batch to catch new TypeScript errors; any batch that introduces failures is rolled back automatically. Finally, the verification phase runs a full type‑check, produces a diff summary, and reports any files skipped with reasons. Versace notes that this disciplined approach “tells Claude how to think about the task,” turning a generic prompt into a repeatable, reliable process.

The results speak for themselves. Claude Code autonomously refactored roughly 180 of the 200 files, while the remaining 20—those containing complex generic types or intertwined business logic—were earmarked for manual review. Versace spent an additional hour polishing those edge cases, ending with zero new TypeScript errors and a uniform “Result” error‑handling pattern across the codebase. What would have taken a week of tedious, error‑prone work was compressed into ten minutes of active developer time, followed by a brief manual pass. The author emphasizes that the skill’s self‑verification step prevented regressions, a common pitfall in large‑scale refactors that “drift” when done file‑by‑file.

Versace’s experience underscores a broader shift in how generative AI is being integrated into software engineering pipelines. While the post does not cite external benchmarks, the sheer scale of the transformation—200 files in ten minutes—illustrates the potential for AI‑driven tooling to replace the “death by refactor” scenario that many teams dread. The skill file concept, first highlighted in the post, offers a portable, reusable way to codify project‑specific conventions, making Claude Code adaptable to diverse codebases without the overhead of re‑training or extensive prompt engineering.

The practical takeaway for developers is clear: embedding explicit structure into AI prompts—through files like `SKILL.md`—can dramatically improve consistency and reliability. As Versace puts it, “Claude reads the skill file, understands the rules, and executes consistently across every file it touches.” For teams facing legacy code, adopting a similar skill‑based approach could turn months of manual cleanup into a handful of minutes, freeing engineers to focus on higher‑value work rather than repetitive syntax fixes.