I Build Custom WordPress Plugins With AI Every Day. Hereβs What I Still Donβt Let It Decide.
In September 2026, AI agents opened more than 40% of all pull requests on GitHub. Back in March, it was 17% (GitHub Octoverse 2026).
Honestly? Not surprised. I'm part of that number. I'm a WordPress and frontend developer, and I run Sylvado, a studio that builds websites and custom business systems: custom plugins, CRMs, WooCommerce stores. These days, a lot of my code starts as a conversation with an AI agent.
This isn't a "AI is magic" post. It's not a "AI is ruining everything" post either. After building real client systems this way, I've ended up with a pretty clear line between what I hand over to AI and what I keep for myself. And this year, that line started mattering a lot more.
Everyone's using agents. Almost nobody trusts them with production.
The Stack Overflow 2026 Developer Survey (30,000+ developers) has a few numbers I can't stop thinking about:
- 66% of developers use coding agents, and Claude Code is the most-used one.
- But only 20% use AI to deploy or run production systems.
- And 93% say they need source attribution before they trust AI output.
So we've all kind of quietly agreed on something: AI writes the code, but humans still own what happens when it runs. That's exactly how it feels for me. The question isn't "should I use AI?" anymore. It's "which decisions are still mine?"
Where AI actually earns its keep
Let me give it credit first, because it deserves some.
Scaffolding. Custom post types, taxonomies, settings pages, admin tables, REST routes. I've written this stuff so many times I could do it half asleep. AI just does the first draft faster than I can type, and since I know what "correct" looks like, reviewing it takes minutes.
Boring boilerplate. "Add a meta box with these five fields, sanitize them, save on save_post." Clear task, clear output. AI nails it.
Debugging. This one surprised me the most. A plugin I was working on started throwing a white screen right after activation. I pasted the error log and the function into the agent, and within a minute it pointed out that my code was running on a hook that fired before the class it depended on had even loaded. Moving it to a later hook fixed it. I'd probably have spent half an hour staring at that before spotting it.
That matches the survey too: the top uses are writing code in familiar areas (67%) and debugging (61%). The key word there is familiar. AI is fastest when I already know what the answer should look like.
What I still don't let it decide
1. Who's allowed to do what
Capabilities, nonces, current_user_can() checks, who can see which CRM records. AI will happily write a permission check. It'll also happily write one that's way too loose, because "make it work" and "make it safe" look exactly the same in a demo.
Real example: I asked an agent to build an AJAX handler for updating records in a CRM. It checked the nonce, looked clean, worked perfectly. Then I actually read it. The only access check was is_user_logged_in(). That means any logged-in user, even a basic subscriber, could have edited client records. One line of code, and it would've shipped if I'd trusted the "done" message.
So now I read every capability check myself, line by line. No exceptions.
2. The data model
In a custom CRM, the data model basically is the product. Should this be a custom post type, post meta, or its own table? How do records connect? What happens a year from now when the client has 50x more data?
AI can suggest a schema. But it doesn't know the business, and it won't be around when the client asks for a report the structure can't support. I make that call before a single line of code gets written.
3. WooCommerce edge cases
Order statuses, refunds, stock, payment callbacks, hooks firing in an order you didn't expect. Real stores are full of situations no prompt ever describes. AI writes code for the happy path. My job is every other path.
I once had AI-generated code hooked into both the "processing" and "completed" order statuses, which looked totally fine until I realized a normal order passes through both. Customers would've gotten the same email twice. Not a disaster, but exactly the kind of thing that makes a client lose trust.
4. "Done"
An agent will tell you the task is complete. That's a claim, not a fact. I test on staging, I read the actual diff instead of the agent's summary of it, and I check everything as the lowest-permission user who'll actually use it.
WordPress 7.0 made this line matter way more
Here's the part I don't think many WordPress devs have fully processed yet. WordPress 7.0 (May 2026) shipped an AI Client that works with any provider, an expanded Abilities API, and a Connectors screen in core (overview). On top of that, the official MCP Adapter turns registered Abilities into tools that agents like Claude Code, Cursor and VS Code can find and run (WordPress Developer Blog).
In plain words: the features in your plugin can now become actions an AI agent triggers on a live site.
Honestly, that's exciting for the kind of work I do. A CRM where an agent can look up a record or draft a follow-up through a defined, permissioned action is way more useful than another chatbot slapped onto the dashboard.
But read the security guidance in that announcement. MCP clients act as logged-in users. The recommendations are strict permission_callback checks, low-privilege users, read-only abilities for anything public-facing, and logging. And abilities only get exposed over MCP if you explicitly opt in with meta.mcp.public.
So here's the slightly scary loop: AI can now write the ability, and AI can also call the ability. The only thing standing between an agent and your client's data is the permission_callback, which is exactly the code I said I never hand over.
AI can write the ability. Deciding who gets to run it? That's my job.
My rules now
Not universal truths. Just what works for me on client systems:
- I design, AI drafts. Data model, permissions and architecture are decided before the first prompt.
- Permission and sanitization code gets a human, line-by-line review. Every single time.
- Read the diff, not the summary.
- Staging first, tested as the lowest-privilege user.
- Give the agent project rules. I keep my conventions in a config file the agent reads, things like "always prefix functions with the plugin slug" and "escape everything on output." Before that, I kept getting code with generic function names that clashed with other plugins and had to rename half of it. Octoverse found repos with an agent config file logged eight times as many commits. That's correlation, not proof, but context beats clever prompts every time for me.
- New Abilities start read-only. Write access gets earned, not given by default.
So... is it actually faster?
Yes and no. The first draft? Ridiculously faster. The review? Not at all, and the review is where the real work lives now.
I used to spend most of my day writing code. Now most of it goes into reading, testing and questioning code. I'm not thinking less. I'm just thinking about different things: less syntax, more decisions.
That's why I don't buy either extreme. AI didn't make WordPress development obsolete, and it definitely didn't make it effortless. It just moved the job up a level, toward architecture, permissions and judgment. And now that WordPress sites can be called by agents, that's exactly where the stakes are.
So now I'm curious about your line. If you build WordPress plugins (or anything really) with AI, what's the one decision you never let it make? And has the Abilities API changed how you think about it?
Comments
No comments yet. Start the discussion.