In the first two articles in this series, we saw how to prepare a computer for vibe coding and the system for developing properly with vibe coding, organizing our work with two AIs, Linear, Notion and GitHub.
That was the foundation for any development, for every kind of website, app or software.
Now let's get more specific, because I want to show you how I'm applying all this to this website, which runs on WordPress and has been operating for over fifteen years.
And those are two fundamental differences.
The first is that creating a new application from scratch, where there's nothing to break, is not the same as modifying something that already exists with several thousand URLs, plugins, ten languages, a whole lot of plugins and visitors every day.
Here we can't let Codex change whatever it likes and publish it directly, because we could improve one thing and break three others along the way.
The second is that we're dealing with a database-driven CMS, with several thousand of its own files linked together according to established rules. We're not talking about building static websites with Astro for your business, as I explained in that article.
In this tutorial I'll explain:
- How I've set up the foundations.
- What limits I impose on the AI.
- How I develop.
- How I publish.
- And what problems I've encountered.
So you can reproduce the system on your own website.
It doesn't matter much whether you use Genesis, as I do, or another theme, or where your hosting is.
That said, I'll assume you've already installed the tools from the previous articles and know the general working procedure. Here we're going to focus exclusively on WordPress.
Step 1. Get WordPress running on your computer
The first thing we need is a local copy of the website. In other words, an installation running on our own computer where we can experiment without touching the website everyone else sees.
I use LocalWP, a tool that lets us run WordPress with its web server, PHP and database. Here's a fairly detailed tutorial on how to clone WordPress locally. If you don't have a copy of your website yet, start there and then come back to this article.
What matters now is that LocalWP is running and we can open our local website in a browser, access the admin area and check that plugins and pages behave as expected.
This is where work with Codex begins. As you'll remember from our second article, Codex is the AI analyst and programmer.
The first thing we'll ask it to do is locate our installation files, identify the theme and check where it will be working.
It may sound trivial, but it's important that the code the AI changes is exactly the same code our local WordPress installation is running.
In fact, this happened to me. While manually testing a fix, the change seemed not to work, until we discovered (the agent and I) that LocalWP was using a different Git branch from the one containing the corrected code.
I'll tell you about that case later, because it's quite revealing. For now, there's just one thing to keep in mind: before developing, Codex must check that it's working on the right files.
You only need to make sure your local WordPress works and provide the project location if Codex can't find it.
Step 2. Let Codex get to know our WordPress installation
We now have a working copy. Next we need to explain to Codex what it's dealing with.
And WordPress has a particular characteristic here: it's so flexible and powerful that every installation is different.
One site might use a classic theme, another a block theme, another Elementor, and another a combination of plugins that modify templates, queries or even the editor's behavior.
At Cultura Digital, for example, I use Genesis Sample as a Genesis child theme, Polylang to manage ten languages, ACF for custom fields and Yoast for SEO. I also have several of my own plugins and other extensions that have long been part of the site.
All of this matters.
For example, imagine I want to improve how category pages look. Codex could write a valid PHP template that fails to respect translations, pagination or some feature we already have. The code produces no errors, yet the result is wrong.
That's why, before asking it to develop anything, we have it analyze the installation.
First prompt: analyze our WordPress installation
You can start with something like this:
Let's prepare this WordPress installation for AI-assisted development.
Analyze the project without modifying files.
Identify the local installation, active theme, any child theme, relevant plugins, custom files and dependencies that could affect future development.
Check the relationship between LocalWP, the working folder and Git.
Propose which code should be version-controlled and which elements should stay outside the repository.
Do not modify WordPress core, third-party plugins, credentials or the database.
Explain the results clearly, identify risks and ask for any decisions you need before proceeding.
Codex will start inspecting the project and eventually present its conclusions.
We should check that it has correctly identified the theme, important dependencies and the files we'll be working on.
It must also distinguish code from data.
In WordPress, posts, pages, tags, categories and many plugin settings are stored in a database. Images, meanwhile, are usually stored in wp-content/uploads/.
This means that, at least in my case, my GitHub repository is not a complete copy of WordPress.
I use it to keep track of the code I develop with AI, while the database and media files aren't version-controlled.
This is an important difference from other programming projects, because restoring an earlier version of the code doesn't automatically restore the website to its previous state.
But it's much more manageable and aligned with what I want: I'm not going to touch functionality in the core or the parent theme. I'll only do two things:
- Change specific child-theme files.
- Develop custom plugins for what I need.
And each route is different.
Step 3. Decide which files the AI can modify
Once Codex knows our installation, we need to decide how much we want to let it change.
I'm quite restrictive, for the reasons I mentioned above. I don't see any need to touch 99% of WordPress files to achieve what you want. So rather than let Codex modify any file, I've given it a list of seven child-theme files that can be part of our deployment system.
| File | What we use it for |
| functions.php | Theme functions and hooks |
| style.css | Styles and presentation |
| front-page.php | Home page |
| category.php | Category pages |
| tag.php | Tag pages |
| inc/i18n.php | Internationalization |
| inc/post-i18n.php | Functions relating to multilingual posts |
Why seven? Because those are the ones I touched to turn my lead-generation and training-sales page into a multilingual digital magazine.
On your website there might be three, ten or however many you need. The important thing is that this isn't an improvised decision every time you ask Codex to do something. If a development requires another file, the AI must explain why and ask permission.
For example, Codex might consider it useful to create a new PHP file inside an inc folder. That's fine if it's justified, but first I want to know why it's needed and authorize its inclusion in the project.
Also, even if seven files are authorized, each change should touch only those it needs. If a change affects only style.css, Codex shouldn't take the opportunity to reorganize functions.php, even if it thinks that's a good idea. It can suggest it for consideration, but it doesn't change it without permission.
Do we have to configure all these restrictions ourselves?
No. That's precisely one of the advantages of working with Codex. I explain the rules and it incorporates them into the project documentation.
In my case I use AGENTS.md for operating instructions, and another technical document covering the website's structure, dependencies and decisions we've made.
That way, when we start a new session, Codex can consult those files and recover the context without us having to explain everything again.
Second prompt: establish the project rules
Vamos a establecer las reglas de desarrollo de este WordPress.
Utilizaremos como referencia los archivos del tema hijo que has identificado y que yo autorice expresamente.
Prepara una lista cerrada de archivos que podrán modificarse y publicarse mediante nuestro sistema.
No incluyas el núcleo de WordPress, plugins de terceros, archivos sensibles, base de datos ni contenidos.
Si una futura tarea necesita ampliar esa lista, deberás justificarlo y solicitar autorización antes de hacerlo.
Prepara o actualiza AGENTS.md y la documentación técnica del proyecto.
Establece también que los cambios se desarrollarán en ramas independientes, se probarán localmente y requerirán autorización antes de integrarse y publicarse.
No prepares todavía ningún despliegue a producción.
In the second article I already explained in detail how we organize the work, so I won't repeat the whole procedure here. What matters is that those rules are now adapted to our specific WordPress installation.
Step 4. Ask Codex to configure GitHub and deployment
So far we have:
- Analyzed WordPress.
- Defined which files can be touched.
But we're still missing something fundamental: how are we going to get the changes we develop in LocalWP onto the live website?
Obviously, although we could, we're not going to do it manually by downloading files and uploading them via FTP.
That's one of the reasons we use GitHub.
We'll ask Codex to prepare a GitHub Actions-based system that can publish child-theme files to Webempresa via FTPS.
What I did was explain to Codex how I wanted to work:
- I wanted all modifications to be recorded in GitHub, with their branches, commits and pull requests.
- I didn't want publishing code to the repository to mean automatically updating my website. First we integrate the code; then, when I authorize it, we deploy it.
- I asked for selective deployment. If Codex modifies functions.php, I want to be able to publish only that file, without having to upload all the others again.
- The system must respect our list of seven authorized files.
Codex handled the technical side, asking me to approve the necessary permissions. Antigravity then checked how it worked and whether the restrictions were respected.
Third prompt: configure GitHub and deployment
Once you've decided on the limits for your installation, you can use this prompt:
I want you to prepare the version-control and publishing system for this WordPress project.
Configure the GitHub repository using only authorized code.
Prepare a deployment process compatible with my hosting, proposing the most appropriate technical solution.
Deployment must be triggered manually and allow selecting only files from the authorized list.
Do not let a commit, push or merge automatically trigger a production deployment.
Do not include credentials, databases, backups or sensitive files in GitHub.
Do not automatically expand the list of deployable files.
Prepare the configuration and a testing procedure without publishing anything yet.
Document which access permissions I need to provide and which actions require my authorization.
As I said, you may need to intervene manually to sign in to GitHub, authorize a connection or enter your hosting credentials in the appropriate place.
That's normal. Codex can prepare integrations, but it shouldn't ask you to paste passwords or private keys directly into a conversation.
Once the system is configured, we pass it to Antigravity to check that it respects our limits and can't publish unexpected files.
With the tests passed and connections prepared, we can finally start developing.
Step 5. Let's tackle our first WordPress development
Now we get to the interesting part.
Our local environment is running, Codex knows the project, GitHub is configured, and we've established which files can be modified.
All that's left is deciding what we want to do.
To start, I recommend a relatively simple improvement that you can check visually. At Cultura Digital, for example, I've worked on improving how articles are displayed on tag pages.
I wanted to improve their presentation, highlighting articles I consider relevant, without losing existing features, especially those related to Polylang and SEO.
First we explain to Codex what we want
This is where my part of the work comes in.
I don't need to know which PHP function to change, which Genesis hook to use or whether a template needs an additional query. What I have to do is clearly explain the result I'm looking for and what I want to preserve.
For example:
I want to improve how posts are displayed on the tag pages of my WordPress site.
Featured images, pagination, metadata and the operation of related plugins must be preserved.
Analyze the current code and prepare a mockup and an implementation plan.
Identify the files you would need to modify and check that they're authorized.
Take the available languages and possible SEO effects into account.
Don't write any code yet.
Stop when the plan is ready for an independent audit.
Notice that we're still not asking it to write any code.
First we want to know:
- What design it proposes (if I don't already have a clear idea, in which case I could provide it directly)
- Which files it will need to modify.
- How it plans to verify that the solution works.
This is what we developed in the second article in the series: separating analysis and planning from implementation.
Now Antigravity steps in
When Codex finishes its proposal, I pass it to Antigravity.
Its job is to review it independently, look for potential problems and check that we haven't overlooked an important dependency.
For example, it might spot that an apparently correct solution doesn't account for how Genesis builds certain parts of the page, that a query could be too expensive, or that we haven't checked the result in other languages.
It won't always find major issues. Sometimes it will approve the proposal almost as it is; other times it will force us to revise it.
We can use this prompt:
Independently audit this WordPress development plan.
Check its feasibility, security, compatibility, scope and testing procedure.
Check whether it respects the authorized files and could affect the website's current operation.
Identify risks and errors that must be corrected before implementation.
Do not modify code.
Give a GO, conditional GO or NO-GO verdict, explaining the relevant observations.
If Antigravity finds something worth fixing, we pass its conclusions to Codex.
And that's how, going back and forth between the two, we refine the solution without having to resolve every technical difference ourselves.
When the plan has been sufficiently checked, I authorize implementation.
Codex writes the code and checks the result
Now Codex creates a separate branch, modifies the authorized files and runs the necessary tests.
In our example, it wouldn't be enough to check that categories display correctly in Spanish. Since we have ten languages, it must also check that the change hasn't affected translations, links or how the other versions are displayed.
I can open LocalWP and look at the result to check that it's what I wanted.
I don't need to review every line of code. That's what the technical tests and the next audit are for.
A second review before publishing
When Codex finishes, we return to Antigravity.
But now we ask it to do something different.
Previously it audited a plan. Now it has to review the actual implementation: which files were modified, what code was added, which tests were run, and whether the solution respects the restrictions.
This matters because a technically sound proposal can still be poorly implemented.
If Antigravity finds an issue, we send its observations back to Codex. If it approves the result, we can move on to GitHub.
And we don't need to make this complicated either. Codex can prepare the commits, push the branch and create the corresponding pull request.
We're still the ones who authorize that work to become part of the project's main version.
Step 6. Publish the change without touching the rest of WordPress
With the code finished, tested and audited, there's still one final step.
We need to take it to production.
In our system, merging a pull request doesn't automatically publish anything. And that's deliberate. Remember:
- First we authorize the code to be merged into GitHub.
- Then we authorize its publication on WordPress, on the live hosting.
Suppose the previous improvement required changes to tag.php and style.css.
When Codex prepares the deployment, it will propose uploading those two files, not all seven authorized ones, and certainly not the whole WordPress installation.
The exact procedure will depend on the system you've configured. As you've seen, I use GitHub Actions and FTPS, but you can use another mechanism compatible with your hosting.
What's important is that Codex isn't allowed to publish just any file on its own.
Once deployment is complete, Codex checks that the process finished correctly and carries out whatever technical checks it can.
I can open the affected pages to verify that the improvement is working.
And here's another detail worth remembering: WordPress usually works with different caching systems. In my case it's WP Rocket, so for certain changes we need to check that the website isn't still showing an earlier version.
Only when the result has been verified in production (with any caching effects cleared) do we mark the task as finished.
In any case, GitHub saying that deployment completed successfully doesn't mean the website is working as expected. That's why we keep that final check.
And that completes this development route.
Step 7. What if we want to create a plugin instead of modifying the theme?
So far we've worked exclusively with our child theme, but WordPress lets us develop features that have nothing to do with page design.
And it makes no sense to cram them all into functions.php.
I use several custom plugins, such as YG AI Polylang Bridge, which we use in our translation system, and YG Yoast Primary Category Repair, to reuse Yoast primary categories in certain other places.
They're tools we've developed to address our website's specific needs.
In these cases, the general procedure is practically the same: I explain to Codex what I need, it prepares a plan, Antigravity audits it, Codex develops the feature, and then we carry out another code audit.
We also keep version history in GitHub.
The important difference lies in how we publish those plugins.
Our plugins are not deployed alongside the child theme
Remember that we've established a list of seven files authorized for theme deployment. Custom plugins aren't on that list.
So when I develop one, I version-control and audit it just like any other change, but then I manually install or update its package in LocalWP and production.
That way I keep a change history and can recover earlier versions without letting the workflow touch plugin files.
And that raises another question: how do we know whether a feature belongs in the theme or in a plugin?
In my case, I bounce ideas around with Codex and ask it to analyze the alternatives. I give it my point of view until I get a sense MYSELF of which option is preferable.
As a guide, if we're modifying how a template is presented, working on the child theme is probably better. If we're creating a tool that should keep working even if we change themes, a plugin is usually more suitable.
You can ask Codex to analyze the technical issues with a prompt like this:
I want to develop a new feature for my WordPress site.
Analyze whether it should be implemented in the child theme or as a custom plugin.
Consider its maintenance, updates and dependencies.
Tell me the advantages and disadvantages of each option.
If you propose a plugin, it must be version-controlled independently in GitHub.
Do not include it in the theme's deployment workflow.
Prepare a development, testing, auditing and publishing plan.
Do not implement anything until I've reviewed the proposal.
Once the solution is defined, we start our usual procedure.
As you can see, what changes is how we integrate and publish the feature, not how we plan and review it.
Step 8. Be careful with the database and configuration files
There's one aspect of WordPress that deserves its own section because it's easy to overlook when we start developing with AI.
Not everything we see and configure in the admin area is stored in theme files.
Posts, pages, metadata, taxonomies and many plugin settings are stored in the database.
I've decided not to version-control it in GitHub and not to allow Codex to run indiscriminate SQL changes on production.
That doesn't mean we can't use AI to work with content. In fact, I've performed batch operations through the WordPress API, for example to assign tags to posts in different languages.
The difference is that these operations have a specific objective, use WordPress mechanisms and are carried out under previously defined restrictions.
This isn't about opening up database access and letting the AI change whatever it thinks is appropriate. As I explained at the start, WordPress has certain rules that shouldn't be overlooked. And the AI might break them if you let it.
Actually, it's the same approach I'd take with a human development team. We don't touch the database except in very specific cases.
An example of development outside the limits.
While investigating a slow admin area, Codex found an incorrect setting inside functions.php.
A constant was being used to try to limit the number of revisions WordPress stores for each post.
The problem was that the constant has to be set before WordPress loads the theme. Since I had it in functions.php, it was too late, the expected limit didn't apply and PHP warnings were generated.
Codex prepared a solution that actually required two operations.
The first was to remove the incorrect line from functions.php. That's one of our seven authorized files, so no problem.
The second was to set the revision limit correctly in wp-config.php, the WordPress configuration file. It isn't in our repository, and I don't want to add it because it contains sensitive installation information.
So Codex could prepare the instructions and tests, but the production change had to be made separately. In my case I did it manually from the hosting control panel.
There was also a decision the AI couldn't make for me: how many previous versions I wanted to keep. I barely use revisions, but I don't want to lose the ability to recover a post if I make a mistake. I decide the right number, not Codex or Antigravity.
I think this case is quite revealing because it shows that we can't treat every WordPress change as if it simply involved modifying and publishing PHP files.
Sometimes we need to change configuration, and other times we need to perform operations on data. Those interventions need their own procedure, even if Codex is still responsible for the technical work.
Step 9. Who does what in my system
After going through all this, I think it's pretty clear how I develop with AI in WordPress, but I'll summarize it.
My role is mainly to explain what I want to achieve, make decisions when there are several alternatives and authorize important operations.
Codex does the analysis, proposes the solution, prepares documentation, configures tools, writes code and runs technical tests.
Antigravity independently reviews both plans and implementations.
And that's how we move from one phase to the next.
| Phase | What you do | What Codex does | What Antigravity does |
| Objective | Explain what you need | Analyzes requirements | — |
| Preparation | Approve restrictions | Configures project and GitHub | Reviews configuration |
| Planning | Evaluate the proposal | Designs the solution | Audits the plan |
| Development | Authorize | Writes and tests code | — |
| Testing | Check the result when necessary | Runs and documents tests | Audits implementation |
| GitHub | Authorize integration | Manages branches, commits and PRs | — |
| Deployment | Authorize publication | Executes the permitted procedure | — |
| Verification | Accept the result | Checks production and documents results | Can review incidents |
| Closure | Confirm the objective | Updates the task after verifying production | — |
This may seem like quite an elaborate process for changing a few lines of PHP. And depending on the change, it is.
But you have to understand that I don't personally carry out most of those steps.
I'm not reviewing every SQL query, writing tests or checking all the files one by one. Codex and Antigravity handle much of that work.
My involvement is focused on decisions that really require my judgment.
Also, documenting tasks and decisions lets us end one session and pick up another day without starting from scratch.
Of course, this system doesn't guarantee we won't make mistakes. Both tools can get things wrong, and an independent audit can't replace every test a development project might need.
But for the sort of work I do here at Cultura Digital, it's a fairly sensible way to make progress without relying entirely on my limited programming knowledge.
Conclusion: developing WordPress with AI without becoming programmers
After using vibe coding for both standalone applications and WordPress, I still think WordPress is a somewhat more complicated environment.
With an application built from scratch, we usually have more direct control over every file. In WordPress, by contrast, we depend on the CMS core, theme, plugins, database and settings that may be scattered throughout the installation.
That makes some operations less straightforward and means we need to take more precautions. But it doesn't mean we have to give up using AI to improve our websites.
In the end, it's a matter of having a system. I've explained the one I use and that works for me, and I'm well aware it isn't the only possibility. In fact, I'll probably keep changing things as new tools appear or I discover better ways to work.
But for now it works pretty well for me. And one thing is clear: I can now take on WordPress developments that previously would have required hiring a programmer or spending a lot of time researching on my own.
This article brings the series to a close. We've already prepared the computer for vibe coding, organized our system and seen how to apply the procedure to a real WordPress site.
Now it's your turn to choose a small improvement for your own website and try it. That way you'll discover the system and its peculiarities, and start doing things you wouldn't previously have considered.
At least, that's what happened to me.
Frequently asked questions
Do I need to know PHP to develop WordPress with Codex?
You don't need to master PHP to begin making simple changes, although it helps to understand how WordPress works and be clear about what you want to achieve.
Codex can write the code and Antigravity can review it, but that doesn't remove the need for testing. With complex or sensitive features, a specialist technical review may also be advisable.
Can I use this procedure with any WordPress theme?
Yes, although you'll have to adapt the list of authorized files to your installation's structure.
At Cultura Digital we use Genesis Sample, but you can work with other themes. What I don't recommend is directly modifying files that an update could overwrite. Codex can help you decide whether you need a child theme or a custom plugin.
Do I have to learn how to configure GitHub Actions?
Not necessarily. I've delegated that part to Codex.
The important thing is to tell it what we want: manual deployment, authorized files, protected credentials and a separation between integrating code and deploying it.
Then we have to test and audit the configuration before using it on our real website.
Why do you use Codex and Antigravity instead of a single AI?
Because I'd rather the tool reviewing the work weren't the same one that developed it.
Codex prepares the solutions and Antigravity examines them independently, both before and after implementation.
That doesn't mean they'll catch absolutely every error, but it lets us cross-check technical decisions rather than relying on a single opinion.
Can I create complete plugins with Codex?
Yes. We already use several custom plugins developed with this procedure.
We version-control them in GitHub and follow the same testing and auditing process as with the child theme.
The difference is that we install them manually in LocalWP and production, without including them in the theme deployment workflow.
Why don't you store the WordPress database in GitHub?
Because Git is designed to track changes to code files, while the database contains information that WordPress constantly updates.
Also, Git isn't a substitute for a backup system.
That's why we keep version-controlled code separate from backups of content, settings and media.
Can Codex modify the database?
It can develop controlled operations using WordPress functions or APIs, but we don't allow it to run indiscriminate SQL queries against production.
When we need to modify data, we define exactly what should change, how we'll verify it and what backups we need.
Can I use this system with WooCommerce?
Yes, but an online store requires extra precautions.
Changing a template isn't the same as developing something that could affect orders, payments, inventory or customer data.
The general procedure still applies, although tests and authorizations need to reflect the risk of each change.
It has to explain why and ask permission.
Then we can expand the list, authorize a specific exception or decide to implement the feature as a plugin.
What we want to avoid is Codex automatically expanding deployment permissions every time it needs to solve something.
Are Linear and Notion mandatory?
No. We use them to organize tasks, requirements and decisions, but you can start with GitHub and good instruction files.
The important thing is that Codex can recover the project context and we don't depend exclusively on a conversation's history.
What do I do if Codex and Antigravity disagree?
I ask them to check their arguments against the code and the tests.
It's not about choosing whichever answer sounds more convincing. If there's a significant technical disagreement, we need to identify which check can resolve it.
Usually Codex reviews Antigravity's observations, adjusts the plan or implementation, and we audit whatever changed again.

Leave a Reply