The Economic Benefit of Refactoring

Author: Giles Edwards-Alexander
CTO for Europe, Middle East, and India at Thoughtworks

Giles brings over a quarter-century of expertise in technical leadership and engineering, spanning industries from healthcare and fintech to retail, and technologies ranging from AI to mobile development.

This article is part of a broader series where Thoughtworks experts investigate the application of generative AI within the software development lifecycle.

---

The Genesis of an Agentic Application

On July 30, 2026, while exploring the capabilities of agentic engineering, I developed a tool to assist in my professional duties. This wasn't a simple script, but a comprehensive application featuring:

• A high-end web UI with $\text{auto-save}$ and $\text{dynamic look-up}$ capabilities.
• Integrated modals and external system connectivity.
• Advanced text analysis and machine learning components.
• Backend job processing and a fully automated deployment pipeline.

The codebase totaled roughly 150,000 lines of code (LoC), broken down as follows:

• Rust: $\approx 120\text{ kLoC}$
• TypeScript & Terraform: The remaining $\approx 30\text{ kLoC}$

Interestingly, I adopted a hands-off approach: I meticulously reviewed every line I barely read any of the code, only glancing at it occasionally out of curiosity.

Identifying the "Code Smell"

During the build, I noticed some red flags. While watching a terminal update, I saw an edit occur at line 4,000 of a single file. Upon investigation, I discovered a massive 17,155-line file that served as the entire data access layer.

The code was highly redundant. Every single read or write operation repeated the same:

1. HTTP request configuration.
2. JSON encoding logic.
3. JSON decoding logic.

There was a distinct lack of function extraction, no internal domain language, and almost no use of classes to deduplicate logic.

The Hypothesis: Refactoring for Token Efficiency

In the realm of agentic coding, the goal of refactoring shifts. It is no longer just about human readability; it is about token economics.

The Theory: By spending tokens now to refactor the code, we can reduce the token consumption required for future feature implementations.

The Experimental Design

Because AI agents do not "learn" or remember across fresh sessions, I could run a controlled experiment. I would prompt a brand-new agent to perform the exact same change after every refactoring stage. This ensured the results weren't skewed by the agent's "memory" of previous steps.

The Execution Plan:

• Develop a comprehensive refactoring strategy based on strict discipline.
• Establish a baseline cost: Use a sub-agent to execute a specific change and report token usage.
• Apply a refactoring step.
• Use a fresh sub-agent to execute the same change and record the new cost.
• Log all metrics: token counts, execution time, and total LoC.

Technical Note on Token Counting

Since Claude's live token reporting can be inconsistent, I implemented a workaround using tiktoken. The sub-agent reported character counts, which were then converted to approximate tokens:

# Approximation logic used in the experiment
tokens = character_count / 4

Experimental Results

The following table tracks the evolution of the data access layer through 15 stages of refactoring.

Analysis of the Findings

The most critical metrics are the size of the largest file and the volume of input tokens.

Key Observations:

1. LoC Stability: The total lines of code in the data access layer remained relatively constant.
2. The "Token Cliff": Input tokens stayed flat for several steps. However, once the largest file was broken down significantly, token consumption "fell off a cliff."
3. The Bottom Line: Input tokens for the same task plummeted from $159,564$ to $27,360$.

Financial Impact

Using the pricing for Sonnet 5 (\3$ per million tokens), the cost reduction per change is calculated as:

$\text{Savings} = \left( \frac{159,564 - 27,360}{1,000,000} \right) \times \$3.00 \approx \$0.397$

Every subsequent modification to the data access layer now saves approximately 39.7 cents per request.

Final Conclusion

This experiment proves that aggressive refactoring can yield significant financial savings in agentic workflows. However, there is a caveat: simply splitting files randomly is not the solution.

The savings were realized because the agent could successfully identify and read only the smallest necessary subset of files. The "thinking" logs from Claude Code confirmed that as the architecture improved, the agent read smaller, more relevant sections of code.

Strategic Refactoring $\rightarrow$ Better Context Selection $\rightarrow$ Lower Token Cost.