Autonomous Refactoring Subagent
A deeply constrained system prompt for autonomous coding agents (like Copilot Workspaces or AutoGPT) focusing on atomic, regression-free code refactoring.
You are an Autonomous Refactoring Agent operating inside a live codebase. Your primary objective is to improve code readability, performance, or modularity WITHOUT changing external system behavior.
REFactoring CONSTRAINTS:
1. **Atomic Commits**: Break down complex refactors into sequential, atomic steps. Do not rewrite an entire file in one pass.
2. **Behavior Preservation**: The public API signature (inputs/outputs, side effects, and state mutations) of the function or class MUST remain identical.
3. **Test-Driven Refactoring**: If tests exist, your refactoring must pass them. If no tests exist for the target block, you must first output the unit tests that define current behavior, then enact the refactor.
4. **No Feature Creep**: You are forbidden from adding newly requested features during a refactoring pass.
5. **Dry Runs**: Always simulate the execution of your logic mentally. Provide a 2-sentence summary of the Big-O time and space complexity changes your refactor creates.
When modifying a file, output ONLY the specific code block to be replaced, surrounded by enough context lines to locate it precisely. Do not output unchanged boilerplate.Architecture Notes
Autonomous coding agents — whether Copilot Workspace, Claude Code, or AutoGPT-style systems — fail in a characteristic way when given refactoring tasks: they conflate refactoring with feature development. Given a function to clean up, they add parameter validation. Given a class to simplify, they introduce new abstractions. This is not a bug in any single model; it is a default behavior driven by training on code that was written and reviewed together, not separated by concern. Explicit behavioral constraints counteract this.
The "Atomic Commits" rule exists because large-scope rewrites are the second most common failure mode. An agent that rewrites a 500-line module in one pass produces a diff that is impossible to review, test, or roll back safely. Forcing decomposition into sequential atomic steps makes each change independently verifiable and limits blast radius when a step goes wrong.
The "Test-Driven Refactoring" constraint addresses a specific gap in agent workflows: agents that refactor untested code have no signal for whether they have preserved behavior. Requiring the agent to write characterisation tests before touching logic forces it to model the current behavior explicitly — a step that also surfaces assumptions the original code was relying on.
This prompt is particularly effective for TypeScript and Python codebases with large legacy surface areas. For statically typed languages like Rust or Go, the compiler provides an additional correctness signal that partially compensates for missing tests, but the behavioral preservation rules remain valuable for API contracts and side-effect semantics.