Mastering GUM-PROMPT-01: Prompt Engineering for Automated Code Refactoring

Building on our previous guide to advanced prompt engineering, this article focuses on a powerful use case: automated code refactoring using the GUM-PROMPT-01 toolkit. Refactoring is essential but often manual and error‑prone. With structured prompts, we can steer LLMs to produce safe, behavior‑preserving changes that follow project conventions.

Why Generic Prompts Fail for Refactoring

A prompt like “Refactor this code” is too vague. The model might:

• Change logic unintentionally
• Ignore style guides
• Produce output that’s hard to apply programmatically

Effective refactoring prompts must specify:

1. The exact transformation (e.g., “Add type hints”)
2. Behavior preservation (must pass existing tests)
3. Adherence to project‑specific conventions
4. A clear, machine‑readable output format

GUM-PROMPT-01’s templating system lets us embed these constraints and inject variables (target code, language, goal) for repeatable results.

Three Proven Prompt Patterns

1. Chain‑of‑Thought (CoT) for Complex Refactorings

Force the model to reason step‑by‑step before emitting code. This reduces hallucinations and creates an auditable trail.

Template (refactor.cot):

Let's refactor the following {{language}} code to {{goal}}.
We will proceed step by step.

**Step 1: Analyze the code**
- Identify areas needing {{goal}}.
- Note edge cases or dependencies.

**Step 2: Plan the transformation**
- List exact changes (function signatures, types, etc.).
- Explain how each change preserves behavior.

**Step 3: Apply the transformation**
- Show the refactored code, clearly marked.

**Step 4: Verify safety**
- Mention tests/checks that confirm correctness.
- Suggest a diff‑style review if helpful.

Now, perform these steps on the code below:

{{code_block}}

Example: Adding type hints to a Python function
Input:

def process_user_data(users):
    results = []
    for user in users:
        if user["age"] >= 18:
            results.append({
                "name": user["name"],
                "email": user["email"].lower()
            })
    return results

The CoT prompt guides the model to:

1. Analyze: function filters adults, returns processed dicts.
2. Plan: Add UserDict TypedDict and type annotations.
3. Apply: Show typed version.
4. Verify: Run tests, use mypy, check diff.

2. Few‑Shot Learning for Syntactic Patterns

When refactoring follows a common pattern (callbacks → async/await, loops → map/filter), few‑shot examples lock in the exact transformation.

Template (refactor.fewshot):

Here are examples of {{language}} code refactored to {{goal}}:

Example 1:
Input: {{example1_input}}
Output: {{example1_output}}

Example 2:
Input: {{example2_input}}
Output: {{example2_output}}

Now refactor the following code to {{goal}}:

{{code_block}}

Example: Converting Node.js callbacks to async/await
Examples show wrapping fs.readFile and db.query in await. The prompt then asks to refactor an http.get callback. The model learns to return a Promise and use await.

3. Role Prompting for Expert‑Level Advice

Assigning a role (“Senior database engineer with 15 years of experience”) elicits suggestions that incorporate best practices beyond syntax.

Template (refactor.role):

You are a {{role}} with {{years}} years of experience refactoring {{language}} codebases. Your goal is to {{goal}} while preserving behavior and improving maintainability.

Given the following {{language}} code:

{{code_block}}

Please:
1. Explain the refactoring strategy you would use.
2. Show the refactored code.
3. Note any assumptions or prerequisites.

Example: Optimizing a legacy SQL query
The role‑prompted model suggests adding indexes, moving date filters into a derived table, and keeping the HAVING clause for clarity — advice that blends syntactic refactoring with performance tuning.

A Practical Workflow with GUM-PROMPT-01

1. Define the goal – e.g., “Add type hints to all public functions in src/api.”
2. Pick a template – refactor.cot for logic changes, refactor.fewshot for syntactic patterns, refactor.role for expert advice.
3. Inject variables – use GUM-PROMPT-01 to substitute {{code_block}}, {{language}}, {{goal}}, and any examples or role details.
4. Generate the prompt – let the toolkit render the final prompt.
5. Run the prompt – send it to your LLM (GPT‑4, Claude, etc.).
6. Review and apply – check the model’s reasoning, apply changes, run your test suite.
7. Iterate – adjust variables (add more examples, tweak role) if needed.
8. Save successes – add effective prompts to your GUM-PROMPT-01 library for reuse.

Bonus: Chaining Prompts for Enterprise‑Scale Refactorings

For large‑scale efforts (e.g., migrating a whole codebase to a new framework), combine multiple specialized prompts into a chain. Start with a role‑based prompt to get a high‑level strategy, then use a JSON‑plan template to break the work into file‑by‑file tasks, and finally apply CoT or few‑shot prompts to each file. This mirrors how senior engineers decompose complex refactorings while keeping each LLM call focused and manageable.

Call to Action

Ready to automate your refactoring workflow? The GUM-PROMPT-01 prompt engineering toolkit includes all templates above, plus a library of pre‑built examples for common tasks (type‑hint addition, async conversion, SQL optimization, and more). Use discount code LAUNCH50 for 50% off your first purchase.

👉 Get GUM-PROMPT-01 on Gumroad

---

*Published on dev.to to share knowledge and drive traffic to our Gumroad product. Follow for more AI‑assisted development insights.