JCB on the Edge: The Future Is Already Being Built

[Llewellynvdm]

For those who want to be adventurous.
For those who have time to waste, maybe.
For those willing to live on the edge.
And for those who enjoy racing toward the future with perhaps a little too much excitement...

Yes. JCB has a branch for you.

We’ve started pushing JCB forward with extensive AI assistance, and at the moment it is chaotic, fantastic, experimental, and incredibly exciting.

This is very much the edge of development.

Everything being built here will eventually be meticulously reviewed, tested, refined, and carefully moved into the official JCB core releases. But if you want to see what is coming before it gets there—if you want to test it, break it, review it, talk to us about it, and help us shape it—this is where you want to be.

And there is already a lot happening.

We now have an entire extension extruder. You can point JCB at an extension and pull it into JCB in a way that is far more capable than what we had before.

We have also just landed the ability to build the complete API of a component, which is a major step forward.

At the same time, we have been doing some massive refactoring of the compiler itself. My team and I are steadily working through these changes, reviewing them, improving them, and preparing the foundations for the next generation of JCB releases.

So if, from the outside, it sometimes looks as though things are quiet...

It is not because we are not busy.

It is because we are far too busy.

There is a tremendous amount happening behind the scenes, and this branch is where you can begin seeing the future of JCB taking shape.

It is experimental.
It will change.
Things may break.
Things may move.

But that is exactly what makes it exciting.

If you have the time, the curiosity, and the appetite to help us test what comes next, jump in, have a look, and speak to us.

👉 JCB future development branch: LINK

What is happening there right now is phenomenal.

And I genuinely believe the best is yet to come.

[Llewellynvdm]

One interesting detail about all of this is that the very first major feature we built on this branch — the extension extruder — was created for exactly this reason.

As AI helps us move JCB forward, we also need a reliable way to bring those changes back into JCB itself.

A large part of that work happens on the library side, so the extruder was designed not only to pull an extension back into JCB, but also to bring its library classes with it.

In other words, JCB is beginning to digest its own AI-assisted expansion.

That creates a very interesting round trip: we can push JCB forward, experiment outside the core, improve and extend things rapidly, and then increasingly have the tooling to assimilate those improvements back into JCB in a structured way.

The extruder is only one example of what has been happening on this branch, but it gives a good picture of the direction we are moving in.

The more eyes we can get on this work, the better. If people are willing to test it, review it, break it, and give us feedback, that will help tremendously.

Just keep in mind that this is still a very active development branch. It is unstable. Things can change considerably from one day to the next, and nothing there should be treated as settled yet.

But at the same time, it is becoming a fascinating glimpse into where JCB is heading.

We are not just adding features anymore. We are improving the machinery that allows JCB to evolve, absorb those improvements, and then help us build the next round.

That feedback loop is starting to become very powerful.

And we are hoping to bring that future into a stable release before too long.

[Llewellynvdm]

There is another important part of this direction that is worth explaining: JCB can become a powerful multiplier for AI-assisted development.

AI can already generate tens of thousands of lines of documentation, structured configuration, and other boilerplate information. But asking AI to generate and continuously maintain an entire production component directly—potentially more than a million lines of interconnected code—is a very different challenge.

This is where Joomla Component Builder becomes especially valuable.

Instead of asking AI to write every line of the finished component, we can teach it to create the structured blueprint that JCB’s compiler understands. A blueprint containing perhaps 30,000 or even 100,000 lines of structured information could then be compiled by JCB into a complete Joomla component consisting of well over a million lines of deployable code.

The real opportunity is not simply to generate more code. It is to combine the creative and conversational abilities of AI with the deterministic, repeatable structure of a compiler.

AI describes what should be built.
JCB understands how Joomla components must be assembled.
The compiler then turns that blueprint into the complete working system.

That gives us a much more sustainable development model than asking AI to repeatedly rewrite enormous codebases. The blueprint remains the source of intent, while JCB handles the structural multiplication, consistency, and regeneration of the component.

We are therefore exploring two complementary MCP directions.

The first is an MCP builder within JCB. The goal is for JCB to help developers add MCP capabilities directly to the components they generate. A component could then expose selected tools, resources, and operations through a structured MCP interface without every developer having to build that integration manually from the ground up.

The second is an MCP that understands JCB itself. Through that interface, a developer could describe a component conversationally:

Create these fields. Add this admin view. Connect these tables. Include these permissions. Build this API.

The MCP would translate that conversation into the fields, views, relationships, permissions, and other blueprint structures that JCB requires. JCB would then compile those structures into the finished Joomla component.

These are two distinct but closely related opportunities: enabling components built by JCB to communicate through MCP, and enabling developers to build inside JCB through MCP.

There is still considerable work ahead, and these ideas must be developed carefully. But the direction is well within reach. JCB already provides the compiler, the structural knowledge, and the repeatable generation process. What we are now investigating is how AI can interact with that foundation in a disciplined and useful way.

The Joomla community does not merely need AI that can produce large quantities of disposable code. It needs tools that can turn ideas into systems that remain structured, understandable, reproducible, and maintainable.

That may be one of JCB’s most important roles in the emerging AI development landscape: not replacing developers, and not allowing AI to improvise an entire codebase unchecked, but providing the compiler and blueprint system through which human direction and AI assistance can become dependable Joomla software.

In that sense, JCB does not just generate code.

It multiplies carefully structured intent into complete Joomla components.