The DRY Principle: Stop Writing the Same Code Twice

I once took over a WooCommerce project for a client selling complex configurable products. The previous developer had copied and pasted the same pricing logic across half a dozen different template files. The single product page, the cart, the mini-cart, checkout… everywhere. When the client asked for a simple tweak to their discount structure, what should have been a 30-minute job became a day-long, high-risk surgery. That’s the cost of ignoring the DRY principle.

DRY stands for “Don’t Repeat Yourself.” It’s a fundamental rule in software development. Taken literally, it means you shouldn’t have duplicate code. But it’s more than that; it’s a philosophy. It’s about making your code maintainable and sane. When you have the same logic in multiple places, you have multiple points of failure. Fix a bug in one spot? You better hope you remember to fix it in all the others. You probably won’t.

Why “WET” Code Will Drown Your Project

The opposite of DRY is WET—”Write Everything Twice” (or three times, or ten). A WET codebase is a nightmare. In my client’s case, the pricing logic was slightly different on the product page versus the checkout page. Not on purpose. No, a bug was fixed in one place and not the other, leading to confused customers and lost sales. That’s the kicker. This stuff has real financial consequences.

My first thought, and the trap many junior devs fall into, was to just do a project-wide find-and-replace for the logic. Quick and dirty, right? Wrong. That’s how you create even more problems. You might accidentally replace something you shouldn’t or miss a variation. Trust me on this, a band-aid on a broken leg doesn’t work. The only real fix was to refactor.

// The only way to fix the mess was to centralize the logic.
// Now, any change to pricing happens in ONE place.

function get_my_complex_product_price( $product_id ) {
    $product = wc_get_product( $product_id );
    if ( ! $product ) {
        return 0;
    }

    $price = $product->get_price();

    // ...
    // All the custom logic, special conditions, and discount rules live here.
    // And only here.
    // ...

    return apply_filters( 'my_custom_price', $price, $product );
}

I created one function that became the single source of truth for that pricing logic. Every template file that needed the price now calls that one function. The code is cleaner, the risk of regressions is almost zero, and the next time the client wants a pricing change, it’ll actually be a 30-minute job. This isn’t some new-fangled idea; it’s a core concept that developers have been talking about for years, and Carl Alexander even wrote a great piece on it over at his blog, which you can find at https://carlalexander.ca/harnessing-superpower-dry/.

So, What’s the Point?

The point is that writing code is only the first step. Writing maintainable code is the job. The DRY principle isn’t just about showing off how clever you are. It’s about respecting the next person who has to touch your code—which is often your future self. More importantly, it’s about building a stable, reliable foundation for your client’s business so that a small change doesn’t turn into a five-alarm fire.

Look, this stuff gets complicated fast. If you’re tired of debugging someone else’s mess and just want your site to work, drop my team a line. We’ve probably seen it before.