Two websites, one WordPress experiment
Dentista and Maganda started as different design experiments. Building both in WordPress exposed a more interesting question: what changes when AI can work closer to the builder?
I built two concept websites over the same weekend.
They were intentionally different.
Dentista (opens in a new tab) started as an editorial dental concept with oversized type, restrained color, asymmetry, and a patient-first content structure.
Maganda (opens in a new tab) went in another direction. Softer, quieter, more beauty-led. The name means beautiful in Tagalog, and I wanted the project to carry a small piece of my Filipino background without turning that into the whole idea.
At first, I thought the useful experiment was going to be the design work.
It wasn't.
The more interesting part was what happened when I tried to move both concepts into WordPress using Bricks Builder, Codex, and MCP.
Two designs exposed the same production problem
A static concept can look finished long before it is actually buildable.
The moment I moved into WordPress, the questions changed.
Can the type system survive longer headlines?
Can the spacing rules hold up when content changes?
Does the mobile version still feel intentional?
Can a section become reusable without flattening the design into a template?
And if I build another site with a completely different visual language, do I have to start the production process from zero again?
That last question became the real experiment.
I didn't want Dentista and Maganda to look related.
I wanted the production discipline underneath them to be related.
A useful page sequence
Structure carries the decision.
The visual direction could change.
The rules for how I approached structure, responsiveness, tokens, reusable components, and quality control should not have to.
Then AI moved closer to the build
I had already been using AI during planning and development.
What changed was connecting the WordPress environment more directly through MCP while working with Codex.
That reduced some of the distance between the decisions I had already made and the implementation work inside the site.
The loop started to feel less like:
Design something → explain it again → manually reproduce it in the builder
and more like:
Define → build → inspect → correct → reuse
A responsible AI workflow
Direction stays human.
That distinction matters to me.
The useful part wasn't that AI could generate more things.
It was that I could spend less time re-describing work that had already been decided.
The design system became more important, not less
This was probably the clearest lesson from both builds.
AI gets faster when the rules are clear.
It also gets inconsistent faster when they aren't.
If I haven't decided the typography hierarchy, spacing rhythm, container behavior, button treatment, image logic, responsive rules, and section purpose, then giving an AI tool more access does not solve the problem.
It just gives ambiguity a faster implementation path.
With Dentista, the challenge was preserving an editorial composition without letting it break on smaller screens.
With Maganda, the challenge was keeping the quieter visual language from turning into generic luxury styling.
Different design problems.
Same underlying requirement:
The system has to be clear before automation becomes useful.
That made me think differently about the role of a builder like Bricks.
The builder is not the design system.
It is where the design system gets implemented.
And AI is not the design system either.
It is another participant in the implementation process.
MCP did not remove the need to inspect the work
This part is important because the workflow can sound more automatic than it really is.
I still had to look at the pages.
I still had to catch mobile issues.
I still had to decide when the CTA was too weak, when the hierarchy felt wrong, when a composition had lost the original intent, or when a reusable pattern was becoming too generic.
There were also moments when doing something manually was faster than trying to make the AI understand what I wanted.
That is fine.
The goal is not to maximize how much AI touches.
The goal is to reduce unnecessary production friction without giving up judgment.
What the two sites taught me
Dentista and Maganda started as design experiments.
They ended up becoming a small production experiment too.
Not because I found a magic WordPress workflow.
I didn't.
What I found was a better separation of responsibilities.
The design work establishes the direction.
The content and user journey establish what the page needs to do.
The design system turns that direction into rules.
WordPress and Bricks provide the implementation environment.
MCP gives tools like Codex a closer path into that environment.
And I still have to decide whether the result is good enough to ship.
That is the part I want to keep exploring.
Not how much of a website can AI build?
But:
How much repeated implementation work can I remove once the important decisions are already made?
That feels like a more useful question.
The live experiments are here:
WordPress · AI · Process