---
title: "Too Many WordPress Plugins Is Never the Problem. Your Code Placement Is."
date: 2026-11-19
modified: 2026-11-19
author: "Russell Aaron"
url: "https://russellenvy.com/too-many-wordpress-plugins-is-never-the-problem-your-code-placement-is/"
markdown_url: "https://russellenvy.com/too-many-wordpress-plugins-is-never-the-problem-your-code-placement-is.md"
type: post
excerpt: "A developer audited a WordPress site with 96 plugins and asked where to even start. Here's where: Must Use, Network Activated, Standard Activate and then the theme files. This is the Loading Sequence of WordPress and always where my audits start."
description: "Too many WordPress plugins was never the problem. Code quality is. Here's why I'd take 400 well-built plugins over one Frankenstein child theme."
categories:
  - "WordPress"
tags:
  - "PLugins"
  - "WordPress"
---
# Too Many WordPress Plugins Is Never the Problem. Your Code Placement Is.

It’s almost 2027, and we’re still arguing about too many WordPress plugins. A developer on LinkedIn got hired to audit a site recently. The site had 96 plugins, and their big takeaway for everyone was a shrug dressed up as an insight: where do you even start?

I’ll tell you where you start. You start at the Plugins screen, because that’s the one page on the entire site that tells you what every piece of code does, who wrote it, and how to turn it off. It’s the closest thing to documentation most sites will ever have, and WordPress made somebody fill it out.

That post bugged me, and not because the developer is a bad person. It bugged me because the same take shows up every few months from someone trying to grow an audience, and it gets the problem exactly backwards. It usually comes from people who never had to clean up the way sites used to be built.

## Too Many WordPress Plugins Is the Wrong Question

The number was never the metric. Code quality is. Four hundred well-built plugins won’t hurt your site, and one badly written plugin can take it down in an afternoon. So can one badly written function in a child theme. The code doesn’t care what folder it lives in, and neither does your server.

So when someone panics about too many WordPress plugins, ask them a better question. Which of these is poorly built? Which one runs a heavy query on every page load? Which one hasn’t seen an update since 2019, and which one does a job that core handles now? Those questions are an audit, and they take actual work to answer.

Quality is also what separates the products that last from the ones that were always thin. I wrote about that in [what AI exposed about the plugin business](https://russellenvy.com/what-the-wordpress-plugin-business-forgot/), and the same rule applies to the code on any single site. You judge what’s there, not how much of it there is.

Counting is not an audit. It’s arithmetic.

## Where Does the Code Go If It Isn’t in a Plugin?

Every site needs functionality the theme and core don’t provide. Maybe it’s a custom post type for a client’s team members, a delivery date field at checkout, or a redirect for an old URL that still gets traffic. Something has to do that work. So where do you put it?

If you’ve been doing this long enough, you know where it usually lands. It goes in the child theme’s functions.php, and after five years and three developers, you know what that file looks like. Code gets dropped on the next available line with no comments, no headers, and nothing that tells you what a block does, why it’s there, or who added it. A snippet copied from an old Stack Exchange answer sits right under a WooCommerce hook somebody forgot about.

Now something breaks. Checkout throws a fatal error on a Friday afternoon, the client is emailing, and orders aren’t going through. Where do you look? Everywhere. You read the whole theme line by line, comment out chunks to see what changes, and hope the culprit announces itself before the weekend does.

That’s the Frankenstein child theme. I’ve opened more of them than I can count.

## A Plugin Tells You What It Is and Who to Call

Now take that same code and put it in a plugin. You get a name. You get a description of what it does, a version number, an author, and a link to whoever is responsible for it. If it breaks, you know exactly who to contact, and that sounds pretty good to me.

Debugging changes completely, too. You spin up staging, deactivate the plugin, and see if the problem goes away. If it does, you found it. If it doesn’t, you turn it back on and move to the next one, whether you’re clicking through the dashboard or running WP-CLI. That’s isolation, and you can’t do it with line 412 of functions.php.

This is the part the 96-plugin crowd misses, and it’s why I’ll never lose sleep over too many WordPress plugins. Every plugin on that screen is documentation WordPress requires somebody to write before the code ever runs. A child theme full of snippets requires nothing, so most of the time that’s exactly what you get.

A plugin is a labeled box. A Frankenstein child theme is a junk drawer.

## Your Theme Should Handle the Look. That’s It.

Here’s the line I draw. Your theme is the layout, the structure, and the overall look of the site, and everything else belongs in a plugin. I don’t care what the functionality is. If it changes how the site works instead of how it looks, it gets its own plugin with its own header.

There are exceptions, and WooCommerce is the obvious one. Copying WooCommerce templates into your child theme to override them is the right call, because that’s presentation and WooCommerce built the override system for exactly that purpose. But business logic, custom post types, and integrations with a CRM aren’t the look of your site. They’re how it works, and they shouldn’t vanish when the look changes.

Block themes make this even clearer. When theme.json and templates handle nearly all of the presentation, business logic has no reason to live in the theme at all. And if you ever switch themes, everything in that functions.php leaves with the old one. Your custom post types disappear the day you activate something new, and the client calls asking where their content went.

Need code that always runs and can’t get switched off by accident? Use a must-use plugin. I’ll take mu-plugins over the theme every time, because the code still lives in its own file, with its own header, in a folder WordPress built for that job. You lose the deactivate button, but you never lose track of what the code is.

That isn’t a theme problem. It’s a placement problem.

## WordPress Loads Your Theme Last

There’s a technical reason behind all of this, and it comes down to the order WordPress loads things. Core loads first. Then must-use plugins, then network-activated plugins on multisite, then your regular active plugins. The theme comes last, and if you’re running a child theme, its functions.php loads right before the parent’s.

That sequence is the order of operations for your entire site, and it shows you the dependencies. By the time your theme loads, hooks like muplugins\_loaded and plugins\_loaded have already fired. Pluggable functions are already defined, so a plugin can replace wp\_mail() and a theme can’t. Any code that needs to run early, or that other code depends on, has already missed its window if it lives in the theme.

Now think about what that means for a Frankenstein child theme. You’ve got business logic sitting in the very last file WordPress reads, and every plugin on the site loaded before it with no idea it exists. When something breaks, you’re debugging the end of the chain and working backwards. Knowing the load order tells you where code belongs before you ever write a line of it.

Your theme is the last thing WordPress loads. It shouldn’t be the first place you put your code.

## But Every Plugin Is a Security Risk

I hear this one a lot. Every plugin adds attack surface, so too many WordPress plugins must mean a less secure site. It sounds reasonable until you remember that the same thing is true of every single line of code on your site, no matter where it lives.

A theme isn’t safer because it’s a theme. A good one blocks direct file access and dies if someone calls the file directly, and a bad plugin might not. But child themes vary just as much as plugins do, and I’ve seen plenty of them that wouldn’t survive a code review. The folder doesn’t make the code secure. The developer does.

The risk is always there, and you don’t escape it by moving code somewhere else. So it doesn’t weigh much in this argument for me. How I debug the site when something breaks is what actually costs a client time and money.

Security is a wash. Debugging isn’t.

## I’ve Been Saying This for 15 Years

This isn’t a new opinion for me. I’ve pushed it for more than 15 years, from taking on client sites at Maintainn, to working in managed hosting at Nexcess, to the eight years I helped run the Las Vegas WordPress Meetup. The question of where the code goes came up in every one of those places, and my answer never changed.

I’ve talked about it with Pippin Williamson, the founder of Easy Digital Downloads and the person behind [Pippin’s Plugins](https://pippinsplugins.com/). Pippin also reviewed plugin code for the WordPress.org repository, which means he spent real time reading other people’s code and deciding whether it was fit to ship. He felt the very same way.

When someone who reviewed plugins tells you code belongs in plugins, that carries weight. Not because plugins are magic, but because he saw firsthand what unlabeled code costs the next person who has to touch it.

## How to Write a Plugin Header That Actually Helps

If you write plugins for clients, or even just for yourself, fill in the header like someone else is going to read it. Because someone will, and it might be you in three years with no memory of why this code exists. Here’s what a useful one looks like.

```
<?php
/**
 * Plugin Name:       Acme Delivery Dates
 * Plugin URI:        https://example.com/plugins/acme-delivery-dates/
 * Description:       Adds a delivery date field to WooCommerce checkout and saves it to the order. Built for Acme Bakery.
 * Version:           1.2.0
 * Requires at least: 6.5
 * Requires PHP:      8.1
 * Requires Plugins:  woocommerce
 * Author:            Russell Aaron
 * Author URI:        https://russellenvy.com/
 * License:           GPL-2.0-or-later
 * License URI:       https://www.gnu.org/licenses/gpl-2.0.html
 * Text Domain:       acme-delivery-dates
 */

// Stop here if the file is called directly.
defined( 'ABSPATH' ) || exit;

/**
 * Add a Get Support link to this plugin's row on the Plugins screen.
 *
 * @param string[] $links Plugin row meta links.
 * @param string   $file  Plugin basename of the current row.
 * @return string[]
 */
function acme_delivery_dates_row_meta( $links, $file ) {
	if ( plugin_basename( __FILE__ ) === $file ) {
		$links[] = sprintf(
			'<a href="%s" target="_blank" rel="noopener noreferrer">%s</a>',
			esc_url( 'https://example.com/support/' ),
			esc_html__( 'Get Support', 'acme-delivery-dates' )
		);
	}

	return $links;
}
add_filter( 'plugin_row_meta', 'acme_delivery_dates_row_meta', 10, 2 );
```

A few lines here do real work. The Description is your documentation, so write it for the person who opens the Plugins screen at 2 a.m. trying to figure out what broke checkout. Author URI turns your name in the Plugins list into a link to your site, and Plugin URI adds a Visit plugin site link right beside it. Requires Plugins tells WordPress this code depends on WooCommerce, so nobody can activate it on a site where it won’t work.

Then the plugin\_row\_meta filter adds a Get Support link to the same row, so the next developer doesn’t have to guess who to call. The ABSPATH check stops the file from running if someone hits it directly. The full list of fields lives in the [plugin header requirements](https://developer.wordpress.org/plugins/plugin-basics/header-requirements/) in the developer handbook, and filling it out properly takes about five minutes.

## The Real Fix for Too Many WordPress Plugins Is Better Labels

So the next time you open a site with 96 plugins, don’t ask where to start. Start at the top of the list and read. Every one of those plugins is telling you its name, its job, and who to call when it breaks. Try getting that out of a Frankenstein child theme.

I’d rather have 400 plugins and a theme that handles the layout than one monster child theme with zero documentation. That number isn’t a goal, and it isn’t the point. It’s how I feel about code I can find, read, and switch off. If a site really does have too many WordPress plugins, the fix is quality and labels, not a lower count.

Plugin count is not the problem. Unlabeled code is.
