Leveraging AI and the ReAct Framework for Efficient Code Refactoring

In a previous blog post the author enthusiastically demonstrated how the Cursor AI tool could generate a complete AI‑assisted feature in half a day. The initial excitement quickly gave way to the realization that simple code‑generation prompts are insufficient for real‑world, complex projects.

The author then investigated deeper, focusing on code refactoring with Cursor. While the tool could understand high‑level refactoring instructions and apply changes rapidly, applying the same approach to a large, intricate codebase resulted in numerous problems.

Key Problems Encountered

Uncontrolled change scope: Refactoring attempts felt like navigating without a map, leading to random, unpredictable modifications.

Chaotic refactoring strategy: Relying entirely on the model to choose a strategy was akin to handing the steering wheel to a blind driver.

Context comprehension gaps: Even with the @Codebase tag, Cursor appeared unaware of the overall project context.

Heavy code‑review burden: Every change required meticulous manual review, creating a high‑risk, "walking on a knife edge" situation.

Negative feedback loop: Repeated failures forced the author to discard and restart, creating a vicious cycle.

Root‑Cause Analysis

Excessive logical complexity in business rules.

Lack of proper framework onboarding for the AI.

Diverse coding styles across developers.

Heavy inter‑module dependencies creating a tangled context.

Unpredictable model behavior.

Human vs. AI Refactoring Approaches

Human developers typically follow a systematic process: identify code smells, apply object‑oriented best practices, restructure architecture, and verify through tests. In contrast, the AI behaved like a mechanical worker that merely repeats "modify code" without strategic planning or contextual awareness.

Introducing the ReAct Framework

The ReAct framework (Yao et al., 2022) combines reasoning and action for large language models (LLMs). It enables LLMs to generate alternating reasoning traces and task‑specific actions, interact with external tools, and improve both performance and interpretability.

Interaction with external tools: Allows the model to fetch additional information.

Performance boost: Outperforms many baselines on language and decision tasks.

Combination with Chain‑of‑Thought (CoT): Merges internal reasoning with external data for optimal results.

Prompt Design for DDD Refactoring

Guided by ReAct and CoT, the author crafted a multi‑step prompt for a Domain‑Driven Design (DDD) refactoring task. The prompt includes context about Application Service, Domain Service, and Port responsibilities, then asks the model to analyze, observe, and act on a specific Java file.

Context: 在六边形架构的DDD实现模式中，Application Service、Domain Service、Query 以及 Port 的设计和实现有一些最佳实践和经验。以下是总结的经验和适合的重构提示：
1. Application Service - 负责用例编排和事务管理，不包含业务逻辑。
2. Domain Service - 包含核心业务逻辑，处理复杂业务规则。
3. Port - 定义应用程序与外部系统之间的接口。

基于上述上下文。请参照 @AcademyCourseDomainService.java 对当前文件进行重构，如果涉及 @EnrollmentApplicationService.java 的修改，也可以进行修改。使用 ReAct 框架按照下面的思考步骤来指导此过程，以分析、观察、执行并最终完成代码重构。

Thought-1：是否有明显的codesmell？
Observation-1：有codesmell：Longmethod
Action-1：使用这个codesmell对应的最佳实践进行重构

Thought-2：是否有特别需要注意的codesmell，比如说面向对象的5大基本原则？
Observation-2：有几个地方，不符合单一职责原则
Action-2：了解单一职责原则的最佳实践，并进行代码重构

Thought-3：当前文件是什么Layer，需要遵循哪些职责？
Observation-3：当前的文件是DomainServiceLayer，里面有些实现做的事情不属于domainservice的职责
Action-3：根据Domainservice职责，对这几个实现进行重构，分析这些做的事情属于哪些layer的职责，将实现挪到对应的Layer中去

Experimental Results

Multiple rounds of experiments showed that the ReAct‑driven prompt achieved:

Higher correctness: Desired outcomes were reached within two to three interaction rounds.

Goal‑oriented reasoning: The model stayed on task, reducing hallucinations by incorporating observations.

Transparent thought‑action trace: Users could see each reasoning step and corresponding code changes.

Key Success Factors

Clear context boundaries limit the model's scope.

Explicit step‑by‑step guidance aligns the AI with human expectations.

Feedback loops ensure each action is validated before proceeding.

Conclusion

The author concludes that AI is not a magic solution, but with proper prompt engineering and frameworks like ReAct, it becomes a powerful assistant that amplifies human creativity and execution. The shift from "question‑oriented" to "coach‑oriented" interaction enables higher code quality and development efficiency while avoiding the pitfalls of unchecked productivity.