I got a call last week about a WooCommerce site where the custom shipping calculator had gone sideways. The client explained that a previous developer built it, but after they left, any attempt to add a new shipping class would either fail silently or, worse, bring down the checkout page.
When I finally got into the plugin’s code, the problem was obvious. It was a single 2,000-line PHP file full of functions like calculate_shipping_method_one(), calculate_shipping_method_two_new(), and so on. This was a developer who had learned PHP only through WordPress hooks and procedural code. It is a good reason to talk about a path to better PHP coding for WordPress developers.
From plugin tinkerer to real developer
A lot of us got our start with WordPress, and it is an incredible gateway. You solve a small problem for a client with a few hooks in functions.php, then you learn to wrap it in a plugin. It feels great to solve a real problem. The danger is staying in that “high school” phase of coding, where everything is a global function and you are not thinking about structure.
My first instinct with that shipping plugin was to just patch it. Find the right conditional, add another elseif statement for the new shipping class, and bill for an hour. And yeah, that would have worked for now. But I would just be kicking the can down the road and setting a trap for the next developer, or for myself in six months when another class gets added. The real fix had to be architectural.
How WordPress core can teach better PHP coding
So where do you learn these “college-level” concepts? As a community, we often point to frameworks like Symfony or Laravel, but that is a huge leap. WordPress itself should be the next step. This builds on an idea I saw over at Carl Alexander’s blog about using the WordPress core as a learning gateway. Core has a chance to teach by example, but it often falls short and sticks to legacy patterns.
Instead of just patching that broken plugin, I started refactoring it into a class. I did not need a massive framework, just a simple, clean class structure. The first step was defining an interface for what a “shipping method” should be.
<?php
interface ShippingMethodInterface {
public function get_name();
public function calculate_cost($weight, $dimensions);
}
// Now, each shipping method is a self-contained class.
class FlatRateShipping implements ShippingMethodInterface {
public function get_name() {
return 'Flat Rate';
}
public function calculate_cost($weight, $dimensions) {
// Simple logic for flat rate
return 15.00;
}
}This creates a contract. Any new shipping method must have a calculate_cost method, so there is no more guesswork or similarly named functions. It makes the code predictable and stable. This is the kind of basic object-oriented principle, using an interface, that I would like to see more of in WordPress core components like WP_Post or WP_Widget.
The point isn’t perfection, it’s maintainability
This isn’t about being a code purist. It’s about being a professional. Code like this means the next developer, or an AI assistant helping with a refactor, can understand the structure right away and extend it without breaking everything. We can do better than decade-old PHP patterns. It starts with demanding more from ourselves and showing junior devs that there is a step between hacking functions.php and learning a whole new framework.
- Use interfaces to define contracts for your objects.
- Keep your classes small and focused on a single responsibility.
- Use dependency injection instead of relying on global state.
This stuff gets complicated fast. If you are tired of debugging someone else’s mess and just want your site to work, drop my team a line. We have probably seen it before.
