Focusing on ActivityPub

The biggest change is a deviation from the original idea: Friendships between WordPresses have been removed. With ActivityPub (when the respective ActivityPub plugin is installed, too) we have a communication protocol that is supported by many more platforms than just other WordPresses that also happen to have installed the Friends plugin.

Removing friendship functionality reduces a lot of complexity in the plugin that changed some fundamentals of WordPress. The friendship functionality had been deactivated for a while behind a checkbox.

This means that the Friends plugin now focusses on functionality of subscribing to feeds (be it RSS, Atom or ActivityPub) and integrating outward communication via ActivityPub (direct messages, replies).

Themes

To make the consuming more attractive, I have worked on providing more integrated themes. I had added the ability to contribute themes already some time ago, thanks for the FediPress theme contribution! Being more a developer than a designer, my default Friends theme has been deemed more functional than pretty (from what I heard).

So, the new themes are:

A Block Theme, which allows you to modify the Friends page using the Site Editor and gives it the design of your own site’s theme.

A Google Reader Theme makes it look like Google Reader. This comes with keyboard shortcuts and the accordion-like behavior of the posts.

I had already done a prototype of a Mastodon Theme and have now added a functional one that is shipped by default.

All the themes now support light and dark mode (which makes the Mastodon theme look a bit unusual in light mode).

I hope that the screenshots above highlight the versatility of the plugin and how much the visual appearance can shape the perception.

Migrations

A big reason for the 4.0 version number was the number of migrations of internal data structures towards more taxonomies (the Friends plugin did not and does not use custom tables). This removes the last bits of supporting WordPress users as friend users and adds proper term relationships between friends and subscriptions. This also allowed to add support for folders.

But it makes a transition from an earlier version potentially a bit tricky. With this amount of changes and migrations, I opted to make it easier to discover what’s new and what is already migrated. I hope that all migrations go smoothly but if they don’t, this gives you insight into where things might be stuck.

The amount of necessary fundamental changes and migrations made this release somewhat risky and was a reason for the long time since the last release. I am hoping that with these changes now shipped, I can provide more frequent updates again!

Oh, I also shipped a new version of the Enable Mastodon Apps plugin (1.5.0) which makes use of some of the taxonomy changes in Friends that now allow to distinguish between mentions and direct messages, and there should be a speed-up in many endpoints, especially the notifications endpoint.

Enjoy this new release, which I hope will make it easier and more feasible to use Your WordPress as Your Personal Mastodon Instance.

But what if you could just fix it right there?

With AI coding assistants that run in the browser—like Claude Code, OpenAI Codex, GitHub Copilot Workspace, or similar tools—combined with WordPress Playground for testing, you can now do WordPress plugin development without a computer.

What It Looks Like

AI: I’ve implemented the fix for you, committed and pushed it to Github. Use this link to Test it in WordPress Playground.

This link above just leads to a generic Playground but to give you an idea of the workflow: The AI helps you fix or implement what you asked for and makes the code available in a branch. You’ll then run/view it via Playground. Here’s how to set this up:

What You Need

• Your plugin or theme in a GitHub repository,
• A web AI coding assistant,
• A way to tell the AI how to generate Playground test links that you can click.

The third part is where the Playground Step Library comes in.

Step 1: Create Your Blueprint

WordPress Playground uses blueprints: JSON configurations that describe what to install and how to set things up. You can install plugins, themes, configure settings, import content, and more. Writing these by hand is a little cumbersome, so I built the Step Library as a visual tool to assemble blueprints step by step.

The Step Library also provides more steps than Playground offers natively: that’s where the name comes from. It compiles these custom steps into the native steps that Playground understands. The native steps are powerful but require you to know how to combine them in clever ways; the Step Library’s custom steps make it easier. Examples include addProduct for WooCommerce, addTemplatePart for block themes, a debug step to enable common debug settings and plugins, or disableWelcomeGuides.

Use this special link to the Step Library to start with an “Install Plugin” step. Paste your HTTPS GitHub repository URL. If you want to test a specific branch, add /tree/branch-name to the URL—but for now, just use your main branch. We’ll make the branch dynamic later.

Add any other steps your testing environment needs: maybe WooCommerce if your plugin integrates with it, or some test content, or specific WordPress settings.

Step 2: Generate AI Instructions

Once your blueprint is ready, open the “Copy/Share” dropdown and select “Generate AI Instructions”. This creates a markdown snippet you can add to your project’s CLAUDE.md, .github/copilot-instructions.md, or similar AI instruction file:

The generated instructions tell the AI to include a Playground testing link at the end of its responses. The branch name in your URL gets replaced with a BRANCH_NAME placeholder, so the AI knows to substitute the actual branch it’s working on.

Step 3: Add to Your Repository

Copy the generated markdown and add it to your AI instruction file. Commit it to your repository. Now any AI assistant that reads these instructions will include Playground links when it makes changes to your code.

Bonus: you can also instruct your coding assistant to add such a file to your repo!

The Workflow

Here’s what this looks like in practice:

1. Open your AI coding assistant on your phone (or desktop),
2. Connect to your GitHub repository,
3. Describe what you want to change or fix,
4. The AI makes the changes and pushes a branch,
5. Tap the Playground link in the response,
6. Test the changes in Playground—if it’s a private repo, you’ll authenticate with GitHub here,
7. If it works, create a PR and merge it—you got to test before even opening the PR.

It’s a complete development loop. The AI handles the code, GitHub handles version control, and Playground handles testing. Your phone is just the interface tying it all together.

Private Repositories

Until recently, this workflow only worked with public GitHub repositories. I submitted a PR to WordPress Playground that adds GitHub OAuth authentication. Now when you load a plugin from a private repository, Playground prompts you to authenticate, and then it works just like public repos.

Beyond Mobile: Preconfigured Test Environments

The mobile workflow is a fun demo, but the same setup is useful on desktop too. The real power is in the preconfigured Playground environments through blueprints (which you can easily create with the Step Library).

Say your plugin integrates with WooCommerce. You can create a blueprint that installs WooCommerce, sets up a test product, and installs your plugin from the current branch. Now every Playground link the AI generates loads an environment where you can actually test the integration—not just whether your plugin activates without errors.

Or you want to test across different configurations: multisite vs single site, classic editor vs block editor, different PHP versions. Create a blueprint for each scenario, generate AI instructions for each, and you have a test matrix that’s one click away.

GitHub Actions

You can take this further with a GitHub Action that posts a Playground link “Try it in Playground” as a comment on every PR. That way anyone reviewing the PR can test the changes without setting up a local environment.

The Step Library is available as an npm package, so you can integrate it into your own tooling and CI pipelines.

Let AI Create Blueprints for You

Something often overlooked: the Step Library is also useful for getting AI to help you create blueprints in the first place. The native Playground steps are low-level—things like writeFile and runPHP—so AI assistants often don’t grasp what’s actually possible with blueprints. The Step Library’s high-level steps are more intuitive, and with a JSON schema that describes them, AI can easily understand what’s available and generate useful blueprints.

Other New Step Library Features

Some notable other things I added recently:

wp-env.json import: Drop your .wp-env.json into the Step Library and it converts your local dev environment config into a Playground blueprint.

GitLab, Bitbucket, and Codeberg support: Not everyone uses GitHub. The Step Library now recognizes repository URLs from these platforms.

Paste detection: Paste a plugin URL, some PHP code, or even an existing Playground URL, and the Step Library figures out what it is and creates the right steps.

Try It

The Playground Step Library is where you can create your blueprint and generate AI instructions.

I’ve found myself using this on the train, in waiting rooms, wherever I have a few minutes and an idea I want to try. It’s not how I imagined WordPress development would work, but it does.

But here, I want to talk about something different: It happens that you search for a tool and then you come across something that almost does what you want, but not quite.

Before AI programming tools, you either had to be lucky to know the software stack, or it must be a really important problem to you that you would try to understand the codebase and make the modification you need.

Today, I can just use Claude Code to modify any tool how I like. So instead of turning away in frustration, I just ask Claude to help me fix what doesn’t work for me. How great is that?

A recent example for me has been transferring files to my Android Phone. OpenMTP exists but to me it has proven to be highly unrealiable, you need to remember to not have Preview open in macOS for it to work, and recently it didn’t complete a copy process but didn’t tell me about it. I only found out on the go that some files had not been copied.

So I realized, that I can use adb to push files to my phone using the debug mode. It’s very niche, I know, but it works. And then I realized a little UI would be nice, and I discovered darkhz’s adbtuifm. A tool written in Go but only tested on Linux, a file manager like Total Commander for the CLI that uses adb in the background.

And indeed, it didn’t really work well on macOS CLI. The left side appeared empty.

But this is what it looks like today:

So I forked it and adapted it to my needs:

• It now uses the current directory instead of the non-existent-on-macOS /home.
• Fixed the colors so that things are also readable in light mode.
• Introduced an ADB log pane to see what’s going on behind the scenes.
• It now shows size and last modification dates.
• Introduced history navigation.
• Even fixed a (tricky?) UI hang when deleting files.

The most important change for me probably was the first one, and, ok, I could have probably just changed the hardcoded string myself.

But it was such a joy to continue and make the tool nicer to use! Also, I don’t think I could have fixed that hanging UI before wasting too much time.

You can try my version, and maybe fork it and add more things you like yourself? I could send back a PR but maybe I won’t do it this time because my changes are opinionated and the repo seems abandoned with the last change in 2022.

Especially when trying to get larger amounts of PHP code to comply with the coding standards, it feels like this tool just scolds you and all you can do is to diligently work away on each and every violation that it discovers.

And you might have gotten yourself into such a situation because you realized well into the project that you forgot an important ruleset, or when you’re merging codebases.

Sniffs are Opinions

One important thing that we tend to forget: often we are in a position where we can actually make the decisions which rules to follow and which not. A ruleset prepared by someone else might contain things we disagree with. Thus phpcs contains the ability to exclude sniffs via its phpcs.xml configuration file, and I think it’s ok to make use of that. But also, I think that phpcs could be more helpful to you in doing so.

When you encounter such an overly eager ruleset, you might complain that the ruleset itself should be updated. But maybe you are not in a position to fight that battle, so you can just find a solution for yourself.

phpcbf can help fix things

The PHP Code Sniffer project comes with two main executables: phpcs, and phpcbf. While phpcs complains, phpcbf tries to help you. Sniffs can provide auto-fixers for violations they encounter and phpcbf applies them for you. But oftentimes it seems like there should be an auto-fixer but in the end, you have to fix it yourself.

A side-note here: maintaining the phpcs project is certainly not a piece of cake since it’s a project heavily exposed to opinion. Many things have to be considered, and it looks like there has been agreement that an auto-fixer can only be added if there is a single and clear solution to the problem.

Thus, there are a number of sniffs where the resolution of a violation needs a user decision. This decision could be complex, like you need to rearrange code, or add something that you forgot (like a type for a parameter). But I believe there are also decisions to make where it’s a matter of choosing between several options.

User Decision Required

One example of this is Squiz.Commenting.InlineComment.InvalidEndChar: “Inline comments must end in full-stops, exclamation marks, or question marks.” Let’s not argue about its validity but about the reason it cannot be auto-fixed: There are multiple valid end chars and an auto-fixer cannot know which one is the right one here.

So, what happens if we make phpcbf interactive, so that it can ask the user to select one of the potential fixes, and then just goes ahead and makes them?

Or, if you realize that you disagree with this sniff: what if phpcbf will just quickly add an <exclude ref="Sniff.Name"/> to your phpcs.xml? Or it could help you just disable the rule for the file? Or just ignore this line?

Many IDEs actually already have some of these ways of dealing with violations, either natively or through an extension. Bringing them to phpcbf itself would make this available to a wider audience and solutions could be baked in to sniffs.

Interactive Mode

All of these thoughts culminate in this idea to make phpcbf interactive. I didn’t know until recently that phpcs has an interactive mode, too. But all it does is to process a file and pauses to allow the user to edit the file, and then to process it again. It assists you in checking, but not in fixing.

So, here is how this could work. Let’s assume this test.php:

<?php

//helo
class test
{
echo 'hello';
}

This file has some problems as phpcs tells you (the selection of Sniffs here is a bit arbitrary but to show the variety of options we’ll face):

As you can see, some violations can be fixed, most cannot. The reason for those is that there is no auto-fixer implemented for them, and often the reason is that there is no one-and-only-way to fix this.

So let’s see how interactive mode would work here. In this first case I’d like to show a situation where there is no auto-fixer available. These would be the options:

Now let’s look at a case where an auto-fixer is available. In non-interactive mode, phpcbf would just fix it, but here you have the option to skip it, too. It would be nice if it even could preview the auto-fix:

Now let’s look come back to our example from above where it seems like an auto-fixer could exist but it does not because there are multiple ways to fix it. For this one, we’d have an interactive fixer that gives the user the choice how to fix it:

One could argue that you can do all of this today but I think with such an interactive mode we can relieve much of the pain it causes to get a code base to comply by streamlining what you need to do already today anyway: go through each violation and try to fix it.

Some of the choices I haven’t described yet:

• i would just append a // phpcs:ignore Sniff.Name to the line.
• d would add a // phpcs:disable Sniff.Name at the beginning of the file.
• p would add an <exclude ref="Sniff.Name"/> to your phpcs.xml.
• e would open an editor at the line of the code

In summary, this is a proposal to improve the user experience. I think this could transform an experience where phpcs is the tool that scolds you, to the tool that assists you in unifying a codebase to certain standards.

You can find the issue I created about this in the PHP CodeSniffer repo, and my implementation on Github. This is not yet a PR because they prefer to have a discussion it first but I worked on an implementation already so that you can experience how it feels to use it and don’t just have to imagine it. Find the instructions to do so on the bottom of the issue.

PS: to make the terminal output look well in this post, I have made this syntaxhighlighter-ansi plugin for the SyntaxHighlighter Evolved plugin for WordPress that will interpret the ANSI escape sequences from the terminal and convert it to colorful output like you can see above.

Behind the scenes this actually dominoed into migrating it to TypeScript and restructuring the code so that it now both powers the Web UI and the npm package.

Having those custom steps available now makes even more sense that the Playground CLI is production ready and you can use it for things like testing your WordPress plugin with Playwright, see this presentation Building Automated Tests with WordPress Playground from WordCamp Europe 2025 by my colleague Berislav “Bero” Grigicak.

In this example you can see a blueprint JSON that contains steps setSiteName and addPage that don’t exist in the library of steps of Playground. At the time of writing there are 36 custom steps with the goal of making it easier to do things that can be done with a blueprint already but need some complexity. See in the example below how creating a page can be done with runPHP and wp_insert_post but it’s visually easier with a step addPage.

import PlaygroundStepLibrary from 'playground-step-library';
const compiler = new PlaygroundStepLibrary();

const blueprint = {
    steps: [
        {
            step: 'setSiteName',
            sitename: 'My Site',
            tagline: 'A WordPress Playground demo'
        },
        {
            step: 'addPage',
            title: 'Welcome',
            content: '<p>Welcome to my site!</p>'
        }
    ]
};

const compiledBlueprint = compiler.compile(blueprint);
console.log(compiledBlueprint);

Which turns this into a valid blueprint:

{
  "steps": [
    {
      "step": "setSiteOptions",
      "options": {
        "blogname": "My Site",
        "blogdescription": "A WordPress Playground demo"
      }
    },
    {
      "step": "runPHP",
      "code": "\n<?php require_once '/wordpress/wp-load.php';\n$page_args = array(\n\t'post_type'    => 'page',\n\t'post_status'  => 'publish',\n\t'post_title'   => 'Welcome',\n\t'post_content' => '<p>Welcome to my site!</p>',\n);\n$page_id = wp_insert_post( $page_args );"
    }
  ]
}

You can then pass this blueprint to playground CLI to run it (see other demos by my colleague Fellyph):

import { runCLI, RunCLIServer } from '@wp-playground/cli';
await runCLI({
  command: 'server',
  login: true,
  blueprint: compiledBlueprint
});

You can also conveniently try it out in WordPress Playground with this link (and also view in the Step Library UI).

Finally, in the repo there are a number of examples that you can browse and I created a little screen recording of a few of them:

Happy coding!

I attended (German-spoken) FediCamp Graz 2025 last Saturday (see Heinz Wittenbrink’s summary in German) where we discussed a plethora of topics around the Fediverse, barcamp-style.

One question that we discussed and that has been bugging me for a long time, is why people are quite unwilling to switch to federated, open networks.

One reason is certainly is inertia. I guess it’s a human property to stick with what you know. Also change means work.

Another reason is ignorance. You know, like “bliss.” It can be comforting to focus on the good sides of your social consumption and not deal too much with the negative sides.

Following a train of thought, I realized that maybe many people don’t realize that they can’t be followed by people who are not on their network. And don’t realize that this is a lock-in by the platform that is not necessary.

To combat this, I created a little one-page website (source on Github, open to PRs!) that is meant as something that you can take and send this URL to a person you’d like to follow who is on a closed social network.

It contains a table of ActivityPub equivalents of social networks (see also my WordCamp Europe 2025 presentation What you’re missing if you don’t have your own WordPress; slides, video):

At the bottom of the page you can customize it:

Probably this is not going to change the needle significantly, but I see this as a little contribution to enable raising awareness about the problem. The decentralized fediverse surely has a steeper learning curve because you need to make a choice before you start. But I think it’s worth it.

The Friends plugin also provides an RSS/Atom feed parser (and can be extended with more of them) so you that you can automatically receive content from many sources. You can also save posts from around the web using the Post Collection plugin, which also provides a “retrieve full content” for excerpt-only RSS feeds. To read what you’ve saved without distractions, you can then send this to your e-reader.

Because this runs on your WordPress, it means that you don’t have to play by the rules set by others (= the social media platform that hosts you). I am not talking about illegal content or anything similar, but rather avoiding exposure to unsolicited content that is intended solely to keep you addicted to the platform.

Another aspect for which I believe WordPress is excellent is maintaining private blogs for content that you don’t want to put on the public web, such as photos of your children. Or a family wiki, a Wikipedia for your family members. All these are things that I prefer not to expose to algorithms like those used by social media platforms.

Digital Consumption Pyramid, modeled after the Food Pyramid

For our digital consumption, I propose we model this after the food pyramid. Sweets (= the addictive stuff) is on the top, it is ok to consume some, but it should not dominate. Below that, we’d have video games, then time on productive systems without algorithms like your own WordPress, or messaging with your friends. I believe the base should consist of research and reading for gaining knowledge.

This is just my own suggestion that I may need to adjust over time. However, I think it illustrates the point that you should be conscious of your own digital and screen time: Your WordPress can be a place for your own consumption needs, away from algorithms that try to manipulate you.

Yes, it’s harder to set up a WordPress than just creating a social media account. I believe that with Playground and blueprints this will become easier soon. But this little bit of extra work gives you the freedom to not be constantly monitored in order to manipulate you with new content to stay on the platform. Or have your data be used for training AI.

I’ll be talking about the above in more detail this weekend in German at WordCamp Vienna (April 25, 2025 at 10am), and in English at WordCamp Europe (June 7, 2025 at 2pm) in Basel, Switzerland. See you there!