Conference talks from someone who's run the systems.

What changes if you design a WordPress site for an AI agent as the primary reader, not a retrofit afterthought? The architectural shifts — content modelling, addressability, provenance — that separate sites cited in the agentic era from those crawled over silently.

Two decades of web dominance gave WordPress a training-data moat; the next two years turn on whether it builds for the AI agents handling content discovery and site management. The trajectory from that moat to the Abilities API, MCP adoption, and AI Building Blocks — and what the industry must work out before 7.0.

AI-generated content is reshaping how sites are built, optimised, and ranked. Four voices from SEO architecture, hosting, agency delivery, and AI tooling debate what WordPress must do to stay the open web's platform of choice in an AI-first world. With Thierry Muller, Vito Peleg, Rahul Bansal, and moderator Robert Jacobi.

Containers and serverless were built for workloads that scale with traffic and idle down. Agentic systems run continuously, hold state across long workflows, and coordinate autonomously — breaking that model. Where today's stack fails for agents, and the new primitives emerging to replace it.

Main-stage results of the CloudFest USA hackathon, where 22 participants built the FAIR Software Security Assistant in a day. As mentor, Alain led FAIR's first labelling implementation: bridging Patchstack's CVE API with the FAIR network to surface vulnerability warnings and block vulnerable installs in wp-admin.

Engineering-minded SEO teams can move past one-off AI prompting to production-grade agentic workflows. How context engineering and a coding agent like Claude Code turn complex SEO objectives into repeatable, multi-step systems that scale an agency's expertise — instead of leaning on clever prompts.

Forty percent of the web runs WordPress, and most of that content was written for a human reader. A forward look at what changes when the reader becomes an AI agent — and how the ecosystem stays relevant through the transition.

Frameworks come and go; the decisions that keep a codebase alive across a decade sit one layer below the framework. A field guide to those decisions — which constraints are structural, which are historical accidents, and how to tell the difference at three in the morning.

Most bugs are born from unchecked assumptions. The psychology behind those assumptions, practical techniques for assumption-proofing code through type-checking and automated tests, and real-world case studies — making the case for proactive, assumption-aware development over reactive debugging.

Server-side performance and scalability, ground up: profiling, deferred processing, and caching to clear the big wins first, then the harder layer of code that simply must run faster. Loop optimization, static data, opcache, and the mechanics behind why PHP slows down.

A hands-on workshop on WP-CLI, the command-line interface for WordPress. Installing the tool, running everyday commands, and building the muscle memory that turns repetitive WordPress administration into fast, repeatable automation.

The Open Web is under constant pressure from walled gardens and app stores monopolising information — yet the WordPress community keeps supporting the very platforms that endanger it. Looking past the bare minimums of accessibility and performance to how UX and monetisation interact, and what a healthy Open Web really needs.

Open-source enthusiasm quietly slides into overcommitment, obligation, and burnout. Every contribution carries a cost that gets paid somehow, even unpaid volunteer time. A frank case for destigmatizing money in "free" software, naming the adverse effects of unsustainable contribution, and building a community that lasts.

PHP's DOM extension manipulates XML and HTML safely, and parts of its object hierarchy are even extensible — until you hit the spots where extension breaks down entirely. Lessons from building the AMP PHP toolbox abstraction layer: clean APIs, cached state, UTF-8 transcoding, and polyfills for libxml bugs.

Core Web Vitals and Page Experience are now search ranking signals: a site that isn't both fast and user-friendly will struggle to rank. What the update means for publishers, then a deep pass on measuring and optimizing those scores for assets served from PHP backends and frameworks.

Open-source packages meant for public distribution live or die on their design decisions. The principles worth holding the line on when you build and maintain them: dependency management, filesystem and namespace structure, and disciplined standards adherence.

Open-source packages meant for public distribution live or die on their design decisions. The principles worth holding the line on when you build and maintain them: dependency management, filesystem and namespace structure, and disciplined standards adherence.

Shift the heavy lifting from runtime to compile time. By generating classes that load straight from opcache, PHP's own parse-and-compile step absorbs the expensive work, leaving runtime extremely fast. Optimization techniques for backends that need real headroom.

Everyone agrees you should use exceptions in PHP, yet almost nobody explains how to structure them across a large codebase. A working approach: the nature of exceptions, how to set up a hierarchy that scales, and the habits that keep them maintainable before refactoring gets expensive.

WordPress owes much of its success to one-click updates that never break sites, but that obsession with backward compatibility quietly compounds technical debt. How the two forces feed each other, and what the tradeoff means for Core's maintainability and future evolution.

WordPress owes much of its success to one-click updates that never break sites, but that obsession with backward compatibility quietly compounds technical debt. How the two forces feed each other, and what the tradeoff means for Core's maintainability and future evolution.

Everyone agrees you should use exceptions in PHP, yet almost nobody explains how to structure them across a large codebase. A working approach: the nature of exceptions, how to set up a hierarchy that scales, and the habits that keep them maintainable before refactoring gets expensive.

A German-language talk. AMP is an open-source HTML framework for building fast, user-friendly pages — an introduction to its goals and the practical techniques for putting AMP to work in WordPress.

Open-source enthusiasm quietly slides into overcommitment, obligation, and burnout. Every contribution carries a cost that gets paid somehow, even unpaid volunteer time. A frank case for destigmatizing money in "free" software, naming the adverse effects of unsustainable contribution, and building a community that lasts.

Serverless and real-time databases open up experiences WordPress alone can't deliver. Builds a status page end to end: a Gutenberg block for updates, a serverless function to post them via a Slack command, and a real-time database pushing changes to every visitor live — with zero load on the WordPress server.

WordPress is raising its PHP floor, but few plugin developers exploit what PHP 7.2+ actually offers. A new boilerplate built on a strictly typed OOP foundation and applied best practices — and how that structure cuts long-term maintenance cost on real plugin code.

WordPress is raising its PHP floor, but few plugin developers exploit what PHP 7.2+ actually offers. A new boilerplate built on a strictly typed OOP foundation and applied best practices — and how that structure cuts long-term maintenance cost on real plugin code.

Gutenberg started as the editor but was designed to swallow the entire admin. Carrying a legacy plugin or theme into that future is an architecture problem first. The concepts governing block-era development, and concrete techniques for migrating existing code cleanly — in stages, not a rewrite.

Gutenberg started as the editor but was designed to swallow the entire admin. Carrying a legacy plugin or theme into that future is an architecture problem first. The concepts governing block-era development, and concrete techniques for migrating existing code cleanly — in stages, not a rewrite.

WordPress owes much of its success to one-click updates that never break sites, but that obsession with backward compatibility quietly compounds technical debt. How the two forces feed each other, and what the tradeoff means for Core's maintainability and future evolution.

Hands-on build of a WordPress backend powering an external app: design the data models and a server-to-client protocol, spec the work for an outsourced app developer, then implement the custom REST API endpoints. Teaches REST design and how to brief non-WordPress teams. Co-led with Sean Blakeley.

A WordCamp Brighton 2018 panel on where WordPress is heading — the editor, the project's direction, and what comes next — with Mika Epstein, David Lockie, and Tammie Lister.

For developers who know the pattern buzzwords and OOP syntax but can't turn them into real benefit. A hands-on build of a WordPress plugin applying dependency injection and practical design patterns to genuine pain points, with strategies for ever-changing requirements. Solid PHP and OOP assumed.

Design patterns give developers a shared vocabulary across languages, but their abstraction makes them hard to apply for real. Building an actual WordPress plugin with several of the more common patterns, showing where each one earns its place and the concrete benefit it delivers.

Composer is far more than a dependency manager. Its plugin system lets external code hook into the execution flow, which opens the door to solving problems it was never designed for. A quick tour of the mechanisms behind that flexibility, then useful and downright exotic ways to bend Composer.

A hands-on 90-minute workshop with John Blackbourn, in two halves: effective day-to-day WP-CLI use and best practices for managing a site, then writing your own PHP commands with tests, documentation, and I/O formatting. For developers comfortable on the command line but new to extending WP-CLI.

WordPress developers reinvent wheels daily, rebuilding problems computer science solved decades ago. A brief tour of the discipline's history and reach, and the case for reaching for known, proven solutions before writing your own from scratch.

As a WordPress plugin grows, structure decides whether it stays maintainable or calcifies. Key techniques for scaling: splitting code into reusable Composer libraries and using dependency injection to decouple from specific implementations. Assumes basic OOP familiarity.

Composer is far more than a dependency manager. Its plugin system lets external code hook into the execution flow, which opens the door to solving problems it was never designed for. A quick tour of the mechanisms behind that flexibility, then useful and downright exotic ways to bend Composer.

Writing object-oriented plugins against WordPress means fighting a procedural API at every hook. Works through a real-world plugin to show how to structure the code and where to hook into the WordPress lifecycle — so you keep the benefits of OOP PHP instead of bolting classes onto procedural patterns.

The WordPress bootstrap is barely documented and understood by only a handful of core developers. Walks the exact execution flow of every page request: file load order, global constants, pluggable functions, the database connection, caching, localization, multisite resolution, and Plugin API init.

Managing more than one WordPress site means repeating the same operation by hand, click by click, across every install. WP-CLI replaces that with a single command run across an arbitrary number of sites. Starts from the command line itself, then works through scenarios where it saves hours of manual work.

Client sites grow organically until business logic outstrips what WordPress can handle reliably. A case study in wrapping a legacy site in a scalable layer: a services architecture with auto-resolved load order, autowiring DI against interfaces, centralized logging, and a non-blocking event/command bus — all invisible to content editors.

Most developers preach reusable code, then quietly copy-paste and tweak instead of reusing what they already wrote. The fix is separating reusable logic from project-specific logic — and how Config files draw that line cleanly so code carries across projects unchanged.

Most developers preach reusable code, then quietly copy-paste and tweak instead of reusing what they already wrote. The fix is separating reusable logic from project-specific logic — and how Config files draw that line cleanly so code carries across projects unchanged.

Developers get lost in the details of a system with this much happening behind the scenes. A step back to map the components and what each is responsible for: client-server architecture in general, then how WordPress's parts fit together. For beginning and intermediate developers.