Taming the Gilded Rose: A 5-Step Framework for Refactoring Legacy Code

Prerequisites

To follow this guide, you should be comfortable with basic Python syntax, including loops and conditional statements. Familiarity with Object-Oriented Programming (OOP) concepts like classes and inheritance is helpful, along with a basic understanding of how to run tests using pytest.

Key Libraries & Tools

• Python: The primary programming language used for the implementation.
• pytest: A robust testing framework used to build our safety net.
• GitHub Copilot: An AI pair programmer used to accelerate boilerplate generation and test writing.
• Hypothesis: A library for property-based testing (recommended for advanced edge-case detection).

Step 1 & 2: Analysis and Goal Setting

Before touching the keyboard, you must understand the business logic. In the Gilded Rose, items have a sell_in value (days remaining) and a quality value. Most items degrade over time, but "Aged Brie" improves, and "Sulfuras" is a legendary item that never changes.

Our specific goal is to add a new "Conjured" item type. The measure of success is simple: after refactoring, adding this new type should require minimal changes to the core engine.

Step 3: Creating the Safety Net

You cannot safely refactor without tests. If you don't have a safety net, you're just guessing. Start by writing pytest functions for every requirement.

import pytest
from gilded_rose import Item, GildedRose

def test_item_quality_decreases_over_time():
    items = [Item("Standard Item", 10, 20)]
    gilded_rose = GildedRose(items)
    gilded_rose.update_quality()
    assert items[0].quality == 19
    assert items[0].sell_in == 9

def test_quality_never_negative():
    items = [Item("Standard Item", 10, 0)]
    gilded_rose = GildedRose(items)
    gilded_rose.update_quality()
    assert items[0].quality == 0

Step 4: Step-by-Step Refactoring

Refactor in small, verifiable increments. I start by extracting the logic into a separate function to reduce indentation and then move hard-coded strings into constants.

Inverting Logic to Untangle Nesting

One of the most powerful moves is inverting if not statements. By focusing on what an item is rather than what it isn't, we can flatten the logic into a clean if/elif chain.

Implementing the Strategy Pattern

Once the logic is flat, we replace the conditionals with an inheritance hierarchy. Each item type gets its own updater class.

from typing import Protocol

class ItemUpdater(Protocol):
    def update_quality(self, item: Item) -> None: ...
    def update_sellin(self, item: Item) -> None: ...

class DefaultUpdater:
    def update_sellin(self, item: Item):
        item.sell_in -= 1

    def update_quality(self, item: Item):
        item.quality -= 1
        if item.sell_in < 0:
            item.quality -= 1

We then map these to a dictionary for easy lookup:

UPDATER_MAP = {
    "Aged Brie": AgedBrieUpdater(),
    "Backstage passes": BackstagePassUpdater(),
    "Sulfuras": SulfurasUpdater(),
}

Step 5: Measuring Success

With our new structure, adding the "Conjured" item—our original goal—becomes trivial. We simply create a new class and add it to the map.

class ConjuredUpdater(DefaultUpdater):
    def update_quality(self, item: Item):
        item.quality -= 2
        if item.sell_in < 0:
            item.quality -= 2

Syntax Notes

• Protocols: We use typing.Protocol for structural subtyping, which defines an interface without requiring explicit inheritance in the base implementation.
• Type Annotations: Adding types to the legacy Item class immediately improves IDE support and helps catch bugs during the refactor.
• Max/Min Functions: Use max(0, quality) and min(50, quality) to keep values within bounds instead of writing multiple if checks.

Tips & Gotchas

• Commit Often: Commit every time your tests pass. If you break something three steps later, you can revert easily.
• Avoid AI Blindness: GitHub Copilot is great at generating tests, but it often gets the Gilded Rose's weird logic wrong. Always verify the expected values manually.
• Don't Change the Item Class: In the original Kata, you aren't allowed to touch the Item class. Use a wrapper or an updater class to work around this constraint.