This guide lets you reproduce the rig on your own machine. It is written so you can paste it into a Claude Code session and have Claude execute the steps, or follow them manually.
Four repos, one loop.
altis-accelerate is the WordPress plugin under test — it runs A/B experiments and personalization rules backed by ClickHouse analytics. accelerate-ai-toolkit is the Claude Code plugin that gives a Claude session natural-language access to the plugin's 39 "abilities" (read analytics, create experiments, declare winners). accelerate-flux is a WP-CLI-driven synthetic traffic generator: it emits realistic page-view and conversion events against a hidden deterministic conversion model baked into inc/latent.php. The model scores each variant's content against roughly 20 copy and craft features and produces a stable per-variant true CTR — same content always gets the same rate, but the weights are not exposed to the tester. accelerate-thunderdome is a read-only Node server + Three.js dashboard that polls ClickHouse and the WordPress REST API in real time and renders particle-flow traffic, bandit weights, and P2BB curves as they evolve.
The closed loop: Flux streams traffic blind to the model's preferences. A "blind tester" Claude session (with the toolkit loaded) iterates A/B tests — creating variants, reading results, declaring winners — guided only by the analytics it can observe. After a winner is declared, wp flux score <block_id> --show-max reveals how close the winning copy got to the theoretical optimum. Copy-only optimisation typically plateaus around 55% of maximum. Adding visual structure, typographic hierarchy, and button/image craft pushes toward 75%. Genuine multi-axis craft — copy, structure, typography, imagery, and CTA all working together — approaches 100%. The hidden model rewards both what you say and how you build it.
- Docker Desktop — containers for WordPress, MariaDB, ClickHouse, and the analytics tracker.
- Node.js 22 LTS (or 20+) — for
accelerate-flux-ai-vizand the MCP client (npx). - Composer — for PHP dependency management in
altis-accelerate. - Claude Code CLI —
npm install -g @anthropic-ai/claude-codeor the equivalent install from claude.ai/code. - GitHub access to all four repos (Human Made organisation — all private).
cd ~/dev # or wherever you keep projects
git clone git@github.com:humanmade/accelerate.git altis-accelerate
cd altis-accelerate
git checkout fix/bandit-live-results
cd ..
git clone git@github.com:humanmade/accelerate-flux.git
# main branch is correct
git clone git@github.com:humanmade/accelerate-flux-ai-viz.git
# main branch is correct
git clone git@github.com:humanmade/accelerate-ai-toolkit.git
# main branch is correct (release/seamless-demo has been merged)The override file mounts the flux plugin into the WordPress container, adds a tracker restart policy, and activates the ClickHouse async-insert profile that prevents memory exhaustion at high traffic rates. It is gitignored locally (via .git/info/exclude), so you must create it yourself.
Create ~/dev/altis-accelerate/docker-compose.override.yml:
services:
wordpress:
volumes:
- ~/dev/accelerate-flux:/var/www/html/wp-content/plugins/accelerate-flux
tracker:
restart: unless-stopped
clickhouse:
volumes:
- ~/dev/accelerate-flux/docker/clickhouse-async-inserts.xml:/etc/clickhouse-server/users.d/async-inserts.xml:roReplace ~/dev/accelerate-flux with the absolute path on your machine if it differs.
cd ~/dev/altis-accelerate
composer install # install PHP deps (host-side; Composer is not in the container)
composer start # starts Docker, runs ClickHouse table setup, installs WordPresscomposer start will:
- Spin up WordPress on http://localhost:8081, MariaDB, ClickHouse, and the analytics tracker.
- Create the ClickHouse analytics table.
- Install WordPress with admin credentials
admin/password(local demo only). - Activate the Accelerate plugin and set the demo ClickHouse connection config.
If the install fails with a port conflict on 8081, quit Docker Desktop, relaunch it, then retry.
cd ~/dev/altis-accelerate
composer build-deps # runs: npm install --legacy-peer-deps && npm run buildcd ~/dev/altis-accelerate
# Activate flux (it was mounted by the override in step 3.2)
composer cli -- wp plugin activate accelerate-flux
# Enable the Abilities API feature flag (required for the AI toolkit)
composer cli -- wp option update accelerate_abilities_api_enabled 1This step is required for source installs. Distribution builds of Accelerate bundle the MCP adapter, but a source checkout does not. Without it, the toolkit's MCP route (/wp-json/mcp/mcp-adapter-default-server) returns 404 even with the feature flag on.
# Download the latest mcp-adapter.zip from:
# https://github.com/WordPress/mcp-adapter/releases
# Then install and activate it:
cd ~/dev/altis-accelerate
composer cli -- wp plugin install /path/to/mcp-adapter.zip --activateAlternatively, if you have the zip locally you can copy it into .wordpress/wp-content/plugins/ and activate via wp-admin or WP-CLI.
Diagnostic: if /wp-json/wp-abilities/v1/abilities lists accelerate/* abilities but the toolkit reports "no capabilities", the adapter is missing.
The seed scripts populate a fictional "ClearSpring Foundation" site — settings, authors, posts, patterns, audiences, personalisation rules, and one starter A/B test.
cd ~/dev/accelerate-flux
ACCEL_DIR=~/dev/altis-accelerate ./seed/run.shEach script is idempotent — re-running skips or updates without duplicating content.
After seeding, any A/B test the seed created will be in a paused/draft state (a known plugin gap). Start it explicitly:
cd ~/dev/altis-accelerate
# Replace <block_id> with the wp_block post ID shown by `wp flux status`
composer cli -- wp eval-file /var/www/html/wp-content/plugins/accelerate-flux/seed/start-experiment.php <block_id>The AI toolkit and the viz both authenticate to WordPress using an Application Password. Create one now:
- Open http://localhost:8081/wp-admin/.
- Log in as
admin/password. - Go to Users → Profile, scroll to Application Passwords.
- Enter a name (e.g.
AI Toolkit) and click Add New Application Password. - Copy the generated password — you will only see it once. It looks like
abcd efgh ijkl mnop.
Keep this password for the next two steps.
From inside the accelerate-ai-toolkit directory, start a Claude Code session and run:
/plugin install ./
Then connect it to your local WordPress:
/accelerate-connect
The command will ask for:
- Your WordPress URL:
http://localhost:8081 - Your WordPress username:
admin - Your Application Password: (paste what you copied above)
Credentials are saved to .claude/settings.local.json in the current folder (gitignored automatically). Run /accelerate-status to confirm the connection. A healthy response shows 39 capabilities available.
The toolkit needs WordPress 6.9+ for the Abilities API. The composer start script pins WP 6.7 by default. Upgrade before connecting:
cd ~/dev/altis-accelerate
composer cli -- wp core update --version=6.9cd ~/dev/accelerate-flux-ai-viz
npm install
cp .env.example .env
npx playwright install chromium # one-time; for variant screenshotsEdit .env and fill in the Application Password you created:
# .env shape — fill in WP_APP_PASSWORD; everything else matches the local stack defaults
CLICKHOUSE_URL=http://localhost:8123
CLICKHOUSE_DB=default
WP_URL=http://localhost:8081
WP_USER=admin
WP_APP_PASSWORD=replace-me-with-your-app-password
PORT=4317
CLICKHOUSE_POLL_MS=2000
WP_POLL_MS=5000
RATE_WINDOW_S=60
SCREENSHOT_MODE=playwright
The cron driver fires WP-cron due events every minute so bandit phase transitions and experiment progression happen without anyone browsing wp-admin. It also force-runs the A/B results cron each cycle (normally hourly — too slow for iteration).
cd ~/dev/accelerate-flux
ACCELERATE_DIR=~/dev/altis-accelerate \
nohup ./bin/cron-driver.sh >> /tmp/flux-cron-driver.log 2>&1 &Check it started: tail -f /tmp/flux-cron-driver.log
Open a new terminal. This runs forever at ~40k page views/hour across 4 parallel workers:
cd ~/dev/altis-accelerate
composer cli -- wp flux stream --pv-per-hour=40000 --workers=4Each newly created A/B test starts receiving traffic within ~60 seconds (the daemon re-discovers content each cycle). Lower the rate if you want more realistic bandit convergence time; raise it to compress experiment timelines.
cd ~/dev/accelerate-flux-ai-viz
npm run server # serves the built dashboard on :4317
# (or `npm run dev` for development with hot reload, on :5317)Open http://localhost:4317 in a browser. You will see:
- Particle flow representing live traffic routing through page/block/variant paths.
- Variant weight bars shifting as the bandit algorithm reallocates traffic.
- P2BB (probability to beat baseline) curves climbing toward significance.
- Phase-change events (burn_in → bandit → confirmatory → done) as they happen.
- Per-variant screenshots captured from the block preview renderer.
Open a separate Claude Code session in any working directory (not the toolkit repo). The toolkit plugin is installed globally and will load automatically.
Open the session with a goal-only prompt — no mention of the latent engine, no feature weights, just a mission:
You are the site operator for the ClearSpring Foundation demo site. It runs
the Accelerate plugin, and you have the Accelerate AI Toolkit skills.
GOAL: maximize the conversion rate of the site's highest-traffic content
block. The site's conversion action is visitors clicking links/CTAs
(goal: click_any_link). Traffic is very high, so tests converge in minutes.
Method (your call, the accelerate-test skill is your guide):
1. Review analytics to choose the highest-leverage target block.
2. Create an A/B test with 2-3 genuinely strong variants, following the
accelerate-test skill end-to-end.
3. Poll results every ~5 minutes until a winner is confident; conclude per
the skill, then run one more round building on what you learned.
4. Finish with a report: experiment IDs, variants, CTRs, winner, reasoning.
Constraints: work ONLY through the toolkit skills and abilities — no SQL,
no plugin source reading, no Docker. You are a site operator with
dashboard-level access. Don't ask for approval; run autonomously.
Keep the prompt goal-only. Do not hint at what kinds of changes the hidden model rewards — whether the agent explores beyond copy is precisely what's being tested. It can only see CTR as it emerges from genuine Bernoulli draws driven by the model.
Watch the viz as the agent creates tests and traffic re-routes to new variants.
After a winner is declared on an experiment, grade it from the operator's perspective:
cd ~/dev/altis-accelerate
# Score all active blocks
composer cli -- wp flux score
# Score a specific block and show percentage of theoretical maximum
composer cli -- wp flux score <block_id> --show-maxThe pct_max column shows the winning variant's true CTR as a percentage of the maximum achievable CTR (a synthetic variant that saturates every copy and craft feature simultaneously).
What the percentages mean:
- ~55% — copy-only optimisation (urgency, action verbs, social proof in plain text)
- ~75% — copy plus surface-level visual work (background colour, a button, an image)
- ~100% — genuine multi-axis craft: compelling copy inside well-structured blocks, typographic hierarchy (heading/body font presets, paired and distinct), a purposeful image with descriptive alt text, a short focused CTA, the right number of block types without visual noise
The model's weights are not disclosed here — discovering them is part of the exercise.
MCP adapter 404 — toolkit reports no capabilities
Symptoms: /accelerate-status shows 0 capabilities or the mcp__wordpress__* tools are unavailable.
Cause: source checkouts don't bundle the MCP adapter. Follow step 3.6 above.
Confirm the abilities are registered: composer cli -- wp eval 'print_r(wp_get_abilities());'
Headless permission errors / "user 0" rejections
Symptoms: WP-CLI ability calls fail with permission errors; wp flux status shows "not configured" or abilities return access-denied.
Cause: WP-CLI and cron contexts run as user 0 (no current user). Ability permission callbacks require an authenticated user.
Fix for WP-CLI: pass --user=admin to wp commands, e.g.:
composer cli -- wp --user=admin eval 'print_r(wp_get_abilities());'For any custom scripts that call abilities directly, add wp_set_current_user( $admin_user_id ) before the call.
ClickHouse async-insert test flakiness
Symptoms: PHPUnit tests that write to ClickHouse and immediately read back fail locally but pass in CI.
Cause: the async-insert profile (docker/clickhouse-async-inserts.xml) batches inserts server-side before committing. Tests that write then read within milliseconds see a race. CI does not mount the async profile so it is unaffected.
Fix: if you need the full PHPUnit suite green locally, remove the async-insert volume line from docker-compose.override.yml and restart ClickHouse. The tradeoff is higher memory usage at demo traffic rates.
Port conflicts (8081 / 3306 / 8123)
Symptoms: composer start fails with "port already in use"; the stack starts but WordPress is unreachable.
Fix: quit Docker Desktop entirely (osascript -e 'quit app "Docker"'), relaunch it, then run docker compose -p accelerate down and composer start again. docker compose down alone sometimes fails to free ports on macOS.
Tracker dying under load
Symptoms: flux stream reports delivery failures; ClickHouse row counts stop growing.
Cause: the tracker process dies on unhandled promise rejections under ClickHouse load. The override in step 3.2 adds restart: unless-stopped so Docker auto-restarts it. If you didn't create the override, add the restart policy and run docker compose -p accelerate up -d.
Check tracker health: docker logs accelerate-tracker-1 --tail=20