Location: #core-ai Slack Channel
Theme: Next Steps After WordCamp WordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Europe + Building Blocks for AI in WordPress
Meeting Overview
The AI Team discussed strategic next steps following WordCamp Europe and recent Hallway Hangouts. The focus was on identifying foundational building blocks to support AI development in WordPress, while balancing innovation with long-term maintainability and backward compatibility.
Foundational Strategy & Technical Architecture
Core Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Building Blocks for AI in WordPress
TLDR: Foundational technical architecture to enable flexible AI development.
The AI Team outlined a three-part “Building Blocks” strategy for AI in WordPress:
- Provider-Agnostic LLM Client Abstraction – A shared PHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/preface.php. abstraction layer for interacting with different LLM providers.
- Tool & Resource Definition / Registration – A system to register site features (“abilities”) that LLMs can understand and interact with.
- Integration Bridges (e.g., MCP) – Support for protocols like MCP to connect WordPress to external AI tools and ecosystems.
A showcase plugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party is also planned to demonstrate these concepts working together and help developers build on top of the stack.
Shared LLM Abstraction Layer
TLDR: A PHP package to enable provider-agnostic LLM support across plugins and frameworks.
- PHP lacks a shared LLM abstraction; most WP plugins today hard-code provider-specific integrations.
- @flixos90 shared ai-services, a plugin that abstracts LLM provider access, with plans to extract it into a PHP-agnostic package.
- @isotropic confirmed similar needs exist in Laravel and other PHP projects.
- @swissspidy noted this as a leadership opportunity for WordPress within the PHP ecosystem.
- @schnitzel86 (Drupal) expressed interest in collaborating on shared tooling.
- @johnbillion added that Laravel/Symfony contributors likely face the same challenges.
Tool & Resource Registry + MCP Integration
TLDR: Defining features that AI can understand and interact with, using standards like MCP.
- MCP (Model Context Protocol) allows LLMs to connect with tools across software platforms.
- Tools like data fetching, publishing, and media access can be exposed via MCP or standalone.
- @isotropic noted MCP is maturing rapidly and may signal converging best practices around tools/resources.
- @flixos90 suggested MCP integration could support both external use (e.g. desktop clients) and internal use (e.g. admin-side agents).
- @swissspidy highlighted WordPress media handling as an ideal “resource” use case.
AI Feature Registration and Cross-System Integration
TLDR: Inspired by the Feature API An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.: registering “abilities” LLMs can use via protocols like MCP.
- Inspired by the Feature API, the team envisions a system for registering “abilities” that LLMs can query.
- Enables workflows from simple button-triggered AI actions to multi-tool agents.
- Protocols like MCP act as bridges, exposing these capabilities to other systems or importing tools from platforms like GitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/.
- Early prototypes include AI-Command and WordPress MCP.
Sustainable Development and Tech Debt Strategy
TLDR: Avoiding early lock-in by using canonical plugins and adapter-based architecture.
- AI tech is evolving rapidly; WordPress must guard against locking into unstable patterns.
- The team favors:
- Canonical plugins as the main innovation space.
- WordPress-first adapters to shield internal APIs from volatile protocols.
- Keeping most work Core-adjacent unless clearly stable.
- @isotropic emphasized an “adapter-style” approach.
- @flixos90 added that AI is still early and most tooling doesn’t belong in Core yet.
- @jeffpaul supported this modular approach as a way to iterate quickly and responsibly.
Implementation Focus: Use Cases & Experiments
AI-Powered Triage for Plugins, Themes, and Tickets
TLDR: Exploring how AI can assist with reviews and moderation across WordPress.org The community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/.
- Triage (plugin/theme/ticket review) is a prime use case for AI.
- @karmatosed: wants to apply AI to triage but with “just enough structure.”
- Unattributed: many OSS projects are already experimenting here.
- @isotropic: pointed to dosu.dev as a model.
- @SirLouen: cautioned against skipping over simple automation.
- @flixos90 noted traditional tools may be more effective for well-defined tasks.
- @justlevine: urged reinforcing static analysis and quality tooling first (e.g. PHPStan).
AI for Documentation and Contributor Support
TLDR: Generating user-facing docs with LLMs and streamlining onboarding materials.
- @estelaris is testing LLMs (e.g. ChatGPT) to generate user-facing docs using the WordPress glossary and style guide.
- Current content is inaccurate or off-tone, but long-term goal is full automation from feature videos or releases.
- @jeffpaul confirmed AI Team support for helping Make teams adopt AI — especially #docs.
RAG and Vector Support in WordPress
TLDR: Future consideration for retrieval-augmented generation and vector-based search as MySQL MySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/. evolves.
- @pbiron: asked about support for RAG workflows and vector-based search.
- Noted MySQL 9’s experimental vector data types.
- @isotropic: shared past prototype wpvdb.
- Suggested future support for vector/hybrid search in WP_Query or REST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/..
- @jeffpaul: emphasized exploring early so the community is informed when it’s time to act.
Governance, Culture & Infrastructure
Culture of Collaboration, Governance, and Experimentation
TLDR: Creating a space for decentralized innovation, sharing results, and team autonomy.
- @isotropic: proposed a collaborative “opportunity areas” list for AI across teams.
- @isotropic: proposed publishing it on Make/Core to help teams self-organize vs needing AI team ownership.
- @estelaris: encouraged publishing experiments and results on Make blogs.
- @flixos90: urged matching the right tool to the job — not every problem needs an LLM.
- @justlevine: emphasized we need stronger foundations before layering AI on top.
Technical Planning: GitHub Strategy and Infra
TLDR: Deciding between monorepo vs multi-repo setups to support scalable collaboration.
- Discussed whether to use a monorepo or individual GitHub repos.
- This will impact collaboration, package structure, and release processes.
- Team will aim for clarity by mid-next week via async discussion.
Philosophy: Canonical First, Core When Ready
TLDR: A clear development ethos: iterate fast in plugins, stabilize before touching Core.
WordPress’s long-term success with AI depends on:
- Starting with canonical plugins and packages.
- Building adapter-style architecture to insulate Core from churn.
- Encouraging a culture of open experimentation, documentation, and shared learning.
- Letting the best ideas bubble up through real-world usage and community support.
Open Next Steps & To-Dos
- Decide GitHub Repo Structure
Async discussion this week to determine whether to use a monorepo or split repositories for AI-related work.
Target: Clarity by mid-next week (June 19–20).
- Extract ai-services into Shared PHP Package
@flixos90 shared an early version. Action needed to extract and formalize this for community use.
- Prototype Showcase Plugin
A new plugin is planned to demonstrate how LLM client abstraction, tool registration, and MCP integration work together. Contributors welcome.
- Document AI Opportunity Areas
@isotropic suggested publishing a public list of cross-team AI opportunities (e.g. Docs, Design, Triage).
Goal: Help Make teams self-organize without AI team bottlenecks.
- Encourage Make Team Experiments
Encourage publishing early use cases and learnings (e.g., Docs experiments from @estelaris) on Make/Core or respective team blogs.
- Explore RAG + Vector Support Path
Initial interest flagged around integrating MySQL 9 vector types and reviving the wpvdb prototype. More research needed.
- Continue Triaging AI in Contributor Workflows
Discussion to continue on how to balance static analysis tools (e.g., PHPStan) with LLM-based systems like dosu.dev.
Props to @jeffpaul for review.
#core-ai, #meeting, #summary
Related
