The 5 Levels of Agentic WordPress  🔗 **Source:** [The 5 Levels of Agentic WordPress](https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/#article) > [!note]+ Document Notes > tags: [agentic-wordpress, ai-agents, abilities-api, loop-engineering, mcp, wordpress-automation] > author: Noel Tock > source: Accelerate (accelerateplugin.com) > reference: https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/ > date created: 2026-07-06 10:32 > > # 🏷️ Title: The 5 Levels of Agentic WordPress > <!-- deep-read:sections start --> ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - [The 5 Levels of Agentic WordPress — Noel Tock, Accelerate](https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/) - [Introducing the WordPress Abilities API](https://make.wordpress.org/core/) — the L3 primitive the framework leans on - [Model Context Protocol](https://modelcontextprotocol.io/) — the MCP standard referenced throughout L2–L3 - [karpathy/autoresearch](https://github.com/karpathy) — cited as the L5 self-optimization reference - [humanmade/block-runner](https://github.com/humanmade/block-runner) — Human Made's HTML-to-blocks CLI plugged at the end ## 📝 Summary - **What happened.** Noel Tock (CGO, Human Made) publishes a five-level maturity model for "agentic WordPress," from AI autocomplete up to self-evolving sites, explicitly aimed at demystifying terms like "agentic," "loop engineering," and "context management" for WordPress builders who currently stop at copy-pasting ChatGPT snippets. - **Why it matters.** It gives the WordPress community a shared vocabulary and a concrete learning ladder for AI capability, anchored on WordPress-native primitives (the Abilities API, the MCP adapter, WP-CLI) rather than generic AI hype. It also names the exact tooling (SKILL.md, MCP, Claude Code/Codex routines, OpenClaw) that practitioners can adopt at each rung. - **Key stakeholders.** Independent WordPress builders and agencies (the primary audience), the WordPress core/Abilities API effort (whose adoption this accelerates), agent-tooling vendors (Claude Code, Codex, OpenClaw, Paperclip, Hermes), and Accelerate/Human Made (whose A/B-testing plugin and block-runner CLI are the commercial subtext). - **Risks and tradeoffs.** The model treats capability as a smooth ladder and understates the governance, safety, and error-management burden that grows sharply at Levels 4–5 (agents acting on production, self-modifying sites). The author acknowledges the real difficulty shifts to "tokens, context, error reduction, output quality" — i.e., the hard part is operating the higher levels reliably, not reaching them. - **Bottom line.** Getting to functional agentic WordPress is easier than past web/programming learning curves because much of it runs on natural language; the differentiator is no longer writing code but managing context, reliability, and — at the top — building self-optimizing feedback loops. "Assess where you are, and level up today." ## 📖 Main Content - **Framing.** WordPress + AI feels daunting from both sides — the "legacy blogging software" stereotype and AI's daily-shifting meta. Tock's thesis: the scary-sounding walls (agentic, loop engineering, context management) are far more approachable than they seem, and everyone can level up from wherever they are. - **Level 01 — Autocomplete.** Ghost-text prediction (IDE autocomplete since 2018, popularized by GitHub Copilot in 2021). It predicts the next token from what you've written but has no project/codebase context — it works within a fragment. Now so ubiquitous (e.g., Gmail) it's "somewhat insignificant" post-agentic; the author wouldn't even call it a true Level 1 except for its origin-story fame. - **Level 02 — Creation.** ChatGPT and later frontier models writing whole functions/plugins/apps. The real shift was **coding harnesses (Claude Code, Codex)** — terminal interfaces sitting on the filesystem that supply context and edit files directly, ending the copy-paste era. "Where most people stagnate": amazed by the tools but not pushing further. Graduation requires understanding **SKILL.md** files and giving your harness access to **MCPs**. WordPress tasks: edit your theme, create plugins, audit performance. - **Level 03 — Delegation.** Same mechanics as L2 but a mentality shift: point the agent at *dynamic* targets — staging/production sites, not just static files. "Where agentic WordPress truly begins." The enabling stack: the **Abilities API** (an "agentic version of the REST API" — agents read and effectuate changes), the **MCP adapter** ("the highway the Abilities API runs on"), and **WP-CLI over SSH** as the workaround for anything the (still-new) Abilities API doesn't yet expose. WordPress tasks: interact with a live site, extract intelligence, create live content, mass-work (de-duping, migrations, regeneration). - **Level 04 — Automation.** The L3 components put **on a schedule** (as simple as a cron job): a SKILL.md doing data hygiene via the Abilities API, wrapped in a prompt inside an agent scheduler. The illustrative overnight run: 12 broken links fixed, 47 alt texts backfilled, 23 spam comments cleared, 1 vulnerable plugin patched, sitemap/search index rebuilt. The sweet spot is work "too wishy-washy for Zapier or IFTTT" but not so novel an agent can't produce consistent outcomes from differing inputs. "Your website essentially comes to life." Tooling: Claude Code routines, Codex automations (basic); Paperclip, Hermes Agent, OpenClaw (advanced). - **Level 05 — Evolution.** L4 is "the Truman Show" — alive but sealed, no external data informing its decisions. L5 drops that setup into the real world where **outcomes push back**: behavioural and technical signals feed the agent, which adapts. The example is an agent running multiple rounds of A/B testing to raise conversion itself. This is the only level that departs from built-in harness commands — you (well, frontier models) build **self-learning optimization mechanisms**. Tasks: make the site adapt to user behaviour (engagement) and to technical signals (performance/stability). References: Accelerate Analytics, karpathy/autoresearch. - **The way forward.** The levels are "a lot easier than other things we've had to learn," largely natural-language driven — you could paste the whole page into Claude Code/Codex and have it design a curriculum. Code is not the blocker; the complexity arrives later in managing tokens, context, error reduction, and output quality, or in genuinely large/complex projects. - **Commercial subtext (worth flagging).** The piece closes on Accelerate (A/B testing + personalization in the block editor, free on wordpress.org) and humanmade/block-runner (HTML-to-valid-blocks CLI). The Level-5 example (self-optimizing A/B testing) is exactly Accelerate's product surface — the framework subtly routes toward the author's tooling. - **Uncertain/contested.** The ladder implies clean progression, but Levels 4–5 introduce qualitatively different problems (safety, rollback, oversight of autonomous production changes) that the piece treats as "just scheduling" plus "self-learning mechanisms." The maturity of the Abilities API is explicitly still partial ("not everything… is available to agents today"). ### 🗒️ Notes - The spine is a Karpathy-style "levels of autonomy" analogy applied to WordPress — a deliberate echo of self-driving-car levels (and it name-checks Karpathy's autoresearch at L5). - WordPress-native anchoring is the key contribution: **Abilities API = agentic REST API**, **MCP adapter = the highway**, **WP-CLI/SSH = the backup path**. That triad is the practical L3 stack. - The L2→L3 jump is framed as *mentality*, not tooling — static files vs. live sites. That's the real inflection point where "agentic WordPress truly begins." - L4 is explicitly loop engineering: SKILL.md + Abilities API + a scheduler. The overnight-hygiene example (links/alt-text/spam/patching) is the canonical maker-loop use case. - L5's "Truman Show → real world" metaphor is the sharpest idea: the difference between a sealed automation and a system with an external feedback signal that can change its decisions. - Honest caveat buried at the end: "Code is not the blocker. The complexity comes later" — tokens, context, error reduction. This is the true operating difficulty of the higher levels. - Tooling name-drops worth noting for the ecosystem: Claude Code/Codex routines (basic automation), Paperclip / Hermes Agent / OpenClaw (advanced), Context7 / Brave (MCP starters). ## 📚 References - [The 5 Levels of Agentic WordPress — Noel Tock, Accelerate (2026-07-06)](https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/) — primary source - [WordPress Abilities API (make.wordpress.org / WordPress 6.9)](https://make.wordpress.org/core/) — the L3 primitive - [WordPress/abilities-api (GitHub)](https://github.com/WordPress/abilities-api) — reference implementation - [Model Context Protocol](https://modelcontextprotocol.io/) — MCP spec underpinning L2–L4 - [WP-CLI](https://wp-cli.org/) — the L3 backup path - [Agent Skills / SKILL.md docs](https://docs.anthropic.com/) — the L2 graduation requirement - [humanmade/block-runner](https://github.com/humanmade/block-runner) — HTML→blocks CLI (commercial subtext) ## 🗣️ Paraphrase - **Framing.** WordPress + AI feels intimidating, but the scary-sounding concepts are approachable; here's a ladder so anyone can level up from where they are. - **L1 Autocomplete.** Next-token ghost text (Copilot-era); fragment-scoped, no project context, now table stakes and nearly insignificant. - **L2 Creation.** Models write whole functions/plugins; coding harnesses (Claude Code/Codex) with filesystem context ended copy-paste. Most people stall here; graduate via SKILL.md + MCP. - **L3 Delegation.** Point agents at live staging/production, not just static files. The Abilities API (agentic REST), MCP adapter (the highway), and WP-CLI/SSH (backup) make it work. This is where agentic WordPress really starts. - **L4 Automation.** Same components on a schedule (cron): scheduled SKILL.md hygiene via the Abilities API. Perfect for repeatable-but-not-creative work; the site "comes to life." - **L5 Evolution.** Feed the automation external behavioural/technical signals so outcomes push back; the site self-optimizes (e.g., autonomous A/B testing). Requires custom self-learning mechanisms. - **Way forward.** It's easier than past web learning because it's natural-language driven; code isn't the blocker — managing context, reliability, and scale is. Assess your level and advance. ## 📰 Newsletter **A cheat-code map for "agentic WordPress" — and it's WordPress-native, not generic AI hype.** Noel Tock (Human Made) just dropped a five-level ladder that finally puts vocabulary to what a lot of us are already doing: L1 autocomplete → L2 coding harnesses writing whole plugins → L3 pointing agents at your *live* site via the **Abilities API** and **MCP adapter** → L4 putting those on a **cron schedule** (overnight: dead links fixed, alt-text backfilled, spam cleared, a vulnerable plugin patched) → L5 **self-optimizing** sites that read real-world signals and A/B-test themselves toward better conversion. The best line is the Level-4-vs-5 framing: L4 is "the Truman Show," alive but sealed; L5 is that same setup dropped into the real world where outcomes push back. If you've been meaning to graduate past copy-pasting ChatGPT snippets, the piece even lists the required reading per level (SKILL.md, MCP, Abilities API, agent routines). Fair warning: it's also a soft on-ramp to the author's Accelerate plugin — but the framework stands on its own, and "code is not the blocker" is exactly the right mental model for 2026. 🤖🧱 ## ✅ Action Items #### DevRel - Developer advocacy: adopt this 5-level model as a teaching scaffold for agentic-WordPress talks/workshops; it's a clean progression to demo. - Education: build a "which level are you?" self-assessment + a per-level required-reading path (SKILL.md → MCP → Abilities API → routines). - Developer experience: publish SKILL.md and MCP-connection quickstarts as the L2→L3 on-ramp. - Developer marketing: contrast agentic-WordPress-native (Abilities API) with generic AI to differentiate WordPress's story. - Community management: gather practitioner examples at each level to make the ladder concrete. - Internal/external/cross-project: align this vocabulary with the Abilities API team's messaging. #### OSPO - Policy & Governance: L3–L5 need an agent-action governance policy (what agents may touch on production, approval gates) — the article omits this. - License Compliance: n/a to this source. - Security Management: agents patching plugins / editing production (L4 example) demand a security review model — vuln-patch automation must be gated and logged. - Software Inventory: track which sites run agent automations and at what level. - Developer Support: consultation on safely delegating to agents against live sites. - Community Engagement: fund Abilities API adoption and safe-automation patterns. - Strategic Alignment: treat "agentic maturity level" as an org capability KPI. #### Community - Maintainers: expose plugin/theme capabilities via the Abilities API so agents can operate them (L3 enabler). - Contributors: write SKILL.md recipes for common WordPress maintenance tasks. - Sponsors: back safe-automation and rollback tooling for L4–L5. - Ecosystem: shared library of vetted agent skills for WordPress hygiene. #### WordPress - Core: prioritize Abilities API coverage — the article flags "not everything… is available to agents today" as the main L3 gap. - Core Performance: L5 "technical-signal" optimization aligns with perf goals — agents tuning for Core Web Vitals. - Core AI: this framework is directly on-charter; consider adopting/endorsing a maturity model + safety guidance. - **Core Program Team:** coordinate Abilities API + MCP adapter roadmap across Core, Docs, and the AI team. - Mobile: agent access from any device (L3 claim) — validate mobile agent workflows. - Playground: build a Playground demo of each level (esp. L3 Abilities API interaction). - Community: WordCamp talk track on the 5 levels; hands-on labs. - Training: Learn WordPress path per level; this maps cleanly to lesson plans. - Marketing: WordPress-native agentic story vs generic AI. - Support: prepare support for agent-driven site changes (audit trails, rollback). - Design: design approval/oversight UIs for agent actions on production. - Documentation: expand Abilities API + MCP adapter docs (the required-reading links the article leans on). - Photos / TV / Polyglots: n/a to this source. - Accessibility: the L4 alt-text-backfill example is an a11y automation — ensure agent-generated alt text meets quality standards, not just presence. - Meta: expose .org data/actions via Abilities API where safe. - CLI: WP-CLI is the L3 backup path — keep it agent-friendly (recipe-able, SSH-accessible). - Hosting: hosts can offer per-site agent automation with guardrails as a product. - Tide / Openverse: n/a directly. - Themes / Plugins: register Abilities so agents can drive your plugin/theme; document agent-facing capabilities. #### The WPCC - Programs: education on safe agentic automation for maintainers. - Projects: a governance clinic for agent-on-production practices. - Funding experiments: grants for open safe-automation/rollback tooling. ### FAIR - Technical independence: the Abilities API + MCP adapter are federation-friendly agent rails — align with FAIR's local-control ethos. - Policies and covenants: covenants for autonomous agent behaviour on independent sites (L4–L5 safety). - Productized governance artifacts: an "agentic maturity + safety scorecard" per site. ## 🧪 Hypotheses - **H1.** Most WordPress practitioners self-locate at Levels 1–2; a maturity self-assessment would show a long tail below Level 3 (delegation to live sites). - **H2.** The L2→L3 transition is gated more by mentality/trust (letting agents touch production) than by tooling availability. - **H3.** Abilities API coverage is the binding constraint on Level-3 adoption; WP-CLI/SSH is used as the workaround most often where the Abilities API lacks a capability. - **H4.** Level-4 automations produce reliable outcomes for "predictable but wishy-washy" tasks (link fixing, alt-text, spam) but error rates rise sharply for creative/novel tasks. - **H5.** Level-5 self-optimizing loops without human oversight gates have a higher incidence of harmful autonomous changes (bad A/B variants shipped, over-optimization) than gated loops. - **H6.** Content sites operated at Levels 4–5 shift practitioner effort from writing code to managing context/tokens/error-handling (the author's own claim), measurable as a time-allocation change. ### 📊 Methodology - **The article's method:** a conceptual/experiential taxonomy (a maturity model), drawn from Human Made's agency practice and the current WordPress+AI tool landscape — not empirical. It asserts levels and illustrates each with a concrete WordPress scenario and required-reading list. - **To test H1/H2:** survey WordPress developers with a level self-assessment + reasons for not advancing; segment by agency vs solo. - **To test H3:** instrument agent sessions to log Abilities-API-vs-WP-CLI usage and capability gaps. - **To test H4/H5:** controlled runs of Level-4 and Level-5 automations across task types, measuring outcome quality, error rate, and harmful-action incidence with/without oversight gates. - **To test H6:** time-tracking study of practitioners before/after adopting L4–L5 workflows. - **Confounders:** rapidly changing tooling (levels blur as harnesses add features), self-selection of AI-forward practitioners, and the author's commercial incentive shaping the L5 example toward A/B testing. ### ❓ Questions - Where do safety, rollback, and human-in-the-loop gates fit in this model? (They're conspicuously absent from a ladder that ends in autonomous production changes.) - Is Level 5 realistically achievable/safe for most sites, or is it a frontier reserved for high-traffic optimization contexts? - How mature is the Abilities API really — which common tasks still require the WP-CLI fallback? - Does the linear ladder hide the fact that L4–L5 are a different discipline (ops/governance) rather than a further step of the same skill? - How much of "level up today" is gated by trust and organizational risk tolerance vs. individual skill? ### 🔮 Future Research - A safety/governance layer mapped onto each level (approval gates, audit trails, blast-radius limits). - Empirical adoption survey establishing the real distribution across the five levels. - Case studies of Level-5 self-optimizing WordPress sites: what actually works, failure modes, guardrails. - Abilities-API capability-coverage tracker (what agents can/can't do natively over time). - Reliability engineering for agentic loops: measuring and reducing error rates at L4–L5. ### 💡 Implications - **Practice.** A shared vocabulary and learning path lowers the barrier to agentic WordPress; the highest-leverage move for most is L2→L3 (delegating to live sites via the Abilities API). - **Policy.** Autonomous agents acting on production (L4–L5) require governance the article omits — approval gates, logging, rollback, blast-radius limits. - **Security.** Agent plugin-patching and live edits are powerful but risky; treat agent actions as privileged operations with audit trails. - **Education.** The per-level required-reading structure is a ready-made curriculum for community training. - **Funding/economics.** Value shifts from writing code to operating reliable loops; tooling that manages context, cost, and safety at L4–L5 is where the durable investment is. ### 🧠 Learning Styles Assessment - Reading level estimate: approximately Flesch–Kincaid Grade 10–12 (clear but concept-dense; some jargon defined inline). Flesch Reading Ease roughly 45–55. #### 👀 Visual learners - Present: strong — numbered level badges, inline UI/terminal mockups (Claude Code prompts, a Slack-style overnight report, an A/B-testing lineage view). - Improve: a single overview diagram of all five levels side-by-side; a capability matrix (level × WordPress task × required tool). #### 🔊 Aural learners - Present: none — text and images only. - Improve: a short audio walkthrough of the five levels; a podcast-style explainer. #### 🗣️ Verbal learners - Present: strong — vivid analogies ("the Truman Show," "the highway the Abilities API runs on," "your website comes to life") and clear per-level definitions. - Improve: a glossary (agentic, loop engineering, context management, Abilities API, MCP adapter, SKILL.md). #### 🧩 Kinesthetic learners - Present: strong — explicit per-level required-reading checklists and "WordPress things you can do at this level" task lists. - Improve: a hands-on lab per level (e.g., wire one MCP; register one Ability; schedule one hygiene skill). #### 🧠 Logical learners - Present: strong — a clean ordered maturity model with consistent structure (concept → WP tasks → required learning). - Improve: a decision tree ("can your agent touch production? scheduled? fed external signals?") to self-locate; explicit prerequisites/dependencies between levels. #### 🧑‍🤝‍🧑 Social learners - Present: partial — invites LinkedIn questions. - Improve: a community cohort/challenge to advance a level together; shared skill library. #### 🧘‍♀️ Solitary learners - Present: good — self-paced ladder with a "paste this page into your harness for a curriculum" suggestion. - Improve: reflection prompts per level ("what's blocking me from the next rung?"). #### 🌿 Naturalistic learners - Present: strong — the L5 "mimicking nature: evolving itself" framing is an explicit ecosystem/evolution metaphor. - Improve: extend the lifecycle framing (the site as an organism that senses and adapts). ### 📊 Accessibility Assessment #### Screen reader semantics - Present: standard blog headings and level structure; badge numbers. - Improve: the many UI-mockup images (terminal prompts, Slack report, ASCII "BLOCK RUNNER" art) need descriptive alt text conveying their content, not decorative alt; the ASCII art in particular is meaningless to a screen reader. #### Keyboard navigation - Present: standard article; some interactive elements (the "drag to pan / scroll-lock, pinch to zoom" lineage view). - Improve: ensure the zoom/pan A/B-lineage widget is keyboard-operable and has a text-equivalent, or it excludes keyboard/AT users. #### Contrast and readability - Present: modern marketing-site styling. - Improve: verify code-snippet and badge-number contrast meets 4.5:1; muted metadata ("CGO, Human Made · July 6, 2026") should be checked. #### Text resizing and reflow - Present: responsive. - Improve: the terminal/code mockups and the ASCII art must not force horizontal scroll at 200% zoom. #### Media and captions - Present: interactive A/B-lineage visualization. - Improve: provide a static, described alternative for the interactive/animated element; respect prefers-reduced-motion. #### Forms and interactions - Present: download / "play in sandbox" CTAs. - Improve: ensure link/button labels are descriptive out of context. #### Standards reference - Gaps map to WCAG 2.2 AA: 1.1.1 Non-text Content (image/ASCII alt text), 2.1.1 Keyboard (interactive widget), 1.4.10 Reflow (code mockups), 1.4.3 Contrast, 2.3.3/2.2.2 (motion in the interactive view). ### 🌍 DEIB Assessment #### Cultural breadth - Present: limited — English-only, enterprise/agency-WordPress vantage (Human Made). - Improve: acknowledge cost/access barriers (frontier-model subscriptions, SSH/hosting access) that gate the higher levels for lower-resourced builders globally. #### Inclusive language - Present: good — deliberately welcoming ("everyone has a chance to level up from wherever they are"); jargon mostly defined. - Improve: a few terms (harness, MCP, Abilities API) still assume context; a glossary would widen access. #### Neurodiversity support - Present: strong — consistent, chunked, numbered structure with checklists; predictable per-level pattern. - Improve: a TL;DR/overview up front for readers who need the whole map before the parts. #### Representation - Present: single-author, single-agency perspective; tooling list skews to a specific stack. - Improve: include voices from solo builders and non-agency contexts who reached higher levels differently. #### Psychological safety - Present: strong — explicitly anti-gatekeeping and encouraging ("not that scary at all," "level up today"), non-judgmental about beginners copy-pasting snippets. - Improve: pair the encouragement with honest risk framing for L4–L5 so newcomers don't automate on production unsafely. ### ✅ Logical Validity #### Strong reasoning - **Analogical, strong.** The "levels of autonomy" analogy (self-driving-style, Karpathy-flavored) is apt and well-executed — each level adds one clear capability (context → live targets → schedule → external feedback). - **Constructive/definitional, strong.** Grounding abstract "agentic" talk in concrete WordPress primitives (Abilities API, MCP adapter, WP-CLI) turns hype into an actionable path — the piece's core strength. - **Honest limitation, notable.** "Code is not the blocker. The complexity comes later" correctly relocates difficulty to operations (context, tokens, error reduction), pre-empting an over-optimistic reading. #### Fallacies - **Oversimplification / suppressed complexity.** Location: Level 4 framed as "basically just the components you've learned so far… on a schedule," and Level 5 as adding "self-learning mechanisms." Weakness: this elides the qualitatively harder problems of safety, oversight, rollback, and harmful autonomous actions on production. Fix: add a governance/safety dimension to each level. - **Conflict of interest / subtle special pleading.** Location: the L5 exemplar (autonomous A/B testing to lift conversion) and the closing CTAs are Accelerate/Human Made products. Weakness: the "pinnacle" of the model happens to be the author's product surface. To his credit the framing is educational and the tools listed are broad, but the terminus is product-shaped. Fix: give a vendor-neutral L5 example. - **False-ladder implication (mild).** Location: presenting 1→5 as a single continuous skill progression. Weakness: L4–L5 are arguably a different discipline (ops/reliability/governance), not just "more of L3." Fix: distinguish "capability levels" from "operating disciplines." - **Appeal to ease (mild).** Location: "The levels are not hard… a lot of it simply works on natural language." Weakness: true for reaching a level, less true for running it reliably — the author partly self-corrects in the same paragraph. #### Tone of voice - Encouraging, accessible, and evangelistic-but-grounded — a practitioner lowering the barrier for peers. Confident and enthusiastic ("now it's getting fun," "your website comes to life"), with a genuine pedagogical intent and light, honest hedging about where the real difficulty lives. ### 🛡️ DARVO Analysis - **Deny:** Not applicable — no accusation is being answered; this is an explainer, not a defense. - **Attack:** Not applicable — no attack on critics or opponents; the "legacy blogging software" stereotype is named neutrally, not weaponized. - **Reverse victim/offender:** Not applicable — no victim/offender dynamic present. - Overall: no DARVO pattern. The only rhetorical caution is the commercial gravity of the piece (the model culminates in the author's product category), which is a conflict-of-interest note rather than DARVO. ## 🎯 Conclusion - **Bottom line.** Tock's five levels — Autocomplete → Creation → Delegation → Automation → Evolution — give WordPress builders a clear, native vocabulary and learning path for AI, anchored on the Abilities API, MCP adapter, and WP-CLI. The real inflection is L2→L3 (letting agents act on live sites); the real difficulty is operating L4–L5 reliably (context, cost, error-handling), not reaching them. Code is no longer the blocker. - **Practical next steps for readers.** (1) Self-locate honestly on the ladder. (2) If below L3, learn SKILL.md + one MCP, then point an agent at a *staging* site via the Abilities API (WP-CLI as backup). (3) For L4, wrap a hygiene SKILL.md in a scheduler — but add approval gates, logging, and rollback the article omits. (4) Treat L5 as feedback-loop engineering with external signals, and keep human oversight on autonomous production changes. (5) Read the per-level links as a ready-made curriculum, and mind the Accelerate/Human Made commercial framing when weighing the L5 example. ## 🔄 Refactor Appendix — The 5 Levels of Agentic WordPress > Density: 2–5 Literature atoms (H3), 0–3 Permanent candidates (H4). > Defaults: 3 Literature, 1 Permanent. Resonance filter: if you can't > articulate in one line why a claim matters, drop it. ### 📚 Literature Atoms (H3) #### [H1] Agentic WordPress begins when agents touch live sites > [!quote] ID:rw_accel_deleg1 > "Many people limit themselves to working on a codebase, on so-called static files, but never point their coding agent at more dynamic tasks, such as interacting with your staging or production sites. This is largely where agentic WordPress truly begins its journey." **Context & use**: - Section: Level 03 — Delegation. - Why this matters: names the real inflection point (L2→L3) as a mentality shift from static files to live sites — the highest-leverage move for most practitioners. **Tags**: #xref #addendum **Highlight**: [view highlight](https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/) <!-- atomicity: 1 idea ✓ --> #### [H2] The Abilities API is the agentic REST API; MCP adapter is its highway > [!quote] ID:rw_accel_api2 > "The Abilities API is almost an agentic version of the REST API… The MCP adapter is the highway the Abilities API runs on." **Context & use**: - Section: Level 03 — Delegation. - Why this matters: the clearest one-line mental model of the WordPress-native agent stack; WP-CLI/SSH is the backup where the Abilities API lacks coverage. **Tags**: #xref **Highlight**: [view highlight](https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/) <!-- atomicity: 1 idea ✓ --> #### [H3] Level 4 is a sealed world; Level 5 lets outcomes push back > [!quote] ID:rw_accel_truman3 > "The previous level, level four, is essentially the Truman Show: everything is alive, but it's a sealed world… Level five is that same setup dropped into the real world, where outcomes push back and inform your website how to react accordingly." **Context & use**: - Section: Level 05 — Evolution. - Why this matters: the sharpest distinction in the piece — automation vs. a self-optimizing system with an external feedback signal. Maps to maker/checker loops gaining a real-world measurement. **Tags**: #xref #aphorisms **Highlight**: [view highlight](https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/) <!-- atomicity: 1 idea ✓ --> #### [H4] Code is no longer the blocker; context and reliability are > [!quote] ID:rw_accel_blocker4 > "Code is not the blocker. The complexity comes later when you're trying to manage tokens, context, reduce errors, increase output quality." **Context & use**: - Section: Summary — The way forward. - Why this matters: relocates the real difficulty of agentic work from writing code to operating reliable loops — directly validates a loop-engineering discipline. **Tags**: #xref #aphorisms **Highlight**: [view highlight](https://www.accelerateplugin.com/blog/the-5-levels-of-agentic-wordpress/) <!-- atomicity: 1 idea ✓ --> ### 🧠 Permanent Candidates (H4) #### [P1] A feedback signal, not more automation, is what makes a system self-improving **Claim** (one sentence, Courtney's voice): An automated system only becomes self-improving when it is given an external outcome signal that can change its future decisions; without that loop it is merely scheduled, however lifelike it appears. **Evidence pointer**: [[#H3]] **Scope & conditions**: Holds for agentic automations and optimization loops. Breaks when the "signal" is noisy/gameable (over-optimization risk) or when autonomous changes lack human oversight gates. **Links**: - [[Loop engineering OS]] — because applies-in Courtney's maker/checker loops - [[Maker-checker discipline]] — because extends - [[Goodhart's Law]] — because contrasts on optimizing a proxy signal - [[Karpathy autoresearch]] — because evidence-for <!-- atomicity: 1 idea ✓ --> ### ✏️ Fleeting Queue - [F1] Map Courtney's existing loops (devrel-daily, cos-nightly, wiki-nightly-promote) onto these 5 levels — most are L4, are any truly L5 with external feedback? — loop-engineering OS #fleeting #inbox - [F2] Article omits governance/safety gates at L4–L5 — cross-link to cross_surface_governance (freeze/careful hooks, OpenClaw exec-approvals) as the missing layer #fleeting #inbox - [F3] OpenClaw is name-checked as advanced automation tooling — note the ecosystem validation #fleeting #inbox ### → Things 3 (max 2 actions) - [ ] Draft a note mapping my loop registry to the 5 levels + the safety layer the article omits — loop-engineering OS #things - [ ] Consider a courtneyr.dev post: "the 5 levels, plus the governance layer nobody mentions" — content strategy #things <!-- deep-read:sections end --> 📄 **Full text:** [[Full Document Contents/Articles/The 5 Levels of Agentic WordPress.md|The 5 Levels of Agentic WordPress by Noel Tock]] ## Highlights - The underlying mechanics of level three are the same as level two, but it’s a step change in mentality and approach. Many people limit themselves to working on a codebase, on so-called static files, but never point their coding agent at more dynamic tasks, such as interacting with your staging or production sites. This is largely where agentic WordPress truly begins its journey. ([View Highlight](https://read.readwise.io/read/01kwvxw0r64wcmrajdx4mpf61q)) - Note: The real inflection point (L2→L3): a mentality shift from static files to live staging/production sites. The highest-leverage move for most practitioners. - Tags: atom/literature/h1 - The Abilities API is almost an agentic version of the REST API, allowing agents to easily communicate with your website. Not only to read and understand parts of your website, but to effectuate changes too. ([View Highlight](https://read.readwise.io/read/01kwvxw2rgyj7xngj7abwxf5wq)) - Note: The clearest one-line model of the WordPress-native agent stack: Abilities API = agentic REST API; MCP adapter is its highway; WP-CLI/SSH the backup. - Tags: atom/literature/h2 - The previous level, level four, is essentially the Truman Show: everything is alive, but it’s a sealed world. It doesn’t have the benefit of external data, be it behavioural signals, technical signals or otherwise, so nothing from the outside ever changes the decisions it makes. ([View Highlight](https://read.readwise.io/read/01kwvxw57c1x6bv4gwq33aj5gx)) - Note: The sharpest distinction in the piece: L4 automation is sealed; L5 adds an external feedback signal that can change decisions. Maps to maker/checker loops gaining a real-world measurement. - Tags: atom/literature/h3 - We want to think it’s hard, because these things used to be hard. However, the playing field has changed, and here you’re rewarded with functional apps and tools very quickly. Code is not the blocker. ([View Highlight](https://read.readwise.io/read/01kwvxw770q930qr4xvhz9efjb)) - Note: Relocates the real difficulty of agentic work from writing code to operating reliable loops (context, tokens, error reduction) — validates a loop-engineering discipline. - Tags: aphorisms, atom/literature/h3