Features

Everything it does

Every claim below is true of the shipped build. Every paid tier gets all of it — tiers differ only by how many sites you can activate on.

What it is, in one line

A WordPress plugin that lets an AI assistant design real pages on your site in pure HTML and CSS — no page builder, no block format — and leaves every one of them editable by a non-technical human afterwards.

The core model

Every page is a list of sections. Every section is four things:

Part	What it holds	Who edits it
`template_html`	The markup, with `{{placeholder}}` markers	AI, or a developer in Advanced Mode
`content_fields`	The actual text, images, links, icons	Anyone, in a friendly admin form
`scoped_css`	CSS scoped to that section	AI, or a developer
`section_js`	Optional JS, in an IIFE with the section pre-bound	AI, or a developer

This split is the whole product. Design changes need the AI; content changes never do.

Placeholder prefixes decide how a field is treated and rendered:

html_* — allows safe HTML (bold, links)
image_* — media picker, with a companion *_alt field
icon_* — Phosphor icon picker, resolved to inline SVG that inherits currentColor
shortcode_* — run through do_shortcode() on render
plain — escaped text

Plus site-level placeholders that resolve at render time: NoLeemits, https://noleemits.com/, 2026, , {{business:*}}, and the full {{post_*}}, {{archive_*}}, {{term_*}}, {{loop_wc_*}} families for templates.

Editing

Content Mode — for the person who inherits the site

A generated form, one labelled input per content field, with the type the field deserves: text, textarea, WYSIWYG, URL, image picker, icon picker, colour picker, number, select. Descriptions and placeholders come from an optional content_fields_schema the AI can attach while it builds. No HTML is ever required, and no AI tokens are spent.

Advanced Mode — for the developer

Raw template_html, scoped_css, section_js and dependency lists, per section, in the same screen.

The editability guarantee

When the AI saves a section that's mostly hardcoded text with few or no editable fields, the plugin warns it during the write that Content Mode users won't be able to edit it — nudging the copy into fields instead of into the markup. Sections that slipped through show a notice in the editor pointing at the code editor. This is the mechanism that stops AI-built pages from becoming black boxes.

Section-level concurrency

Optimistic locking via an if_version parameter, plus WordPress post locks honoured on every MCP write (409 post_locked, with an explicit force override). A human and an agent can work the same page without silently clobbering each other.

Content Mode — a labelled form generated from the section’s schema.

Output & performance

Pure HTML/CSS. No block format, no shortcode serialization, no builder runtime.
Zero frontend JavaScript by default. Twelve libraries are available — GSAP, ScrollTrigger, AOS, Alpine.js, Swiper, Splide, Plyr, CountUp, Typed.js, Lottie, HTMX — and each loads only on pages whose sections declared it.
No jQuery, in the admin or on the front end. The admin UI is vanilla JS with no build chain.
Images optimized at render time — srcset, sizes, width, height, loading and fetchpriority are injected automatically. Nobody has to remember to do it, and the AI is told not to hand-roll them.
CSS isolation — a scoped reset shields sections from theme CSS without out-specifying your own rules.
CSS minification that correctly preserves calc(), clamp(), min(), max() and var().
Caching-plugin safe — WP Rocket, W3 Total Cache, LiteSpeed and similar treat the output as ordinary HTML.

No lock-in

Export as JSON — move a page between sites.
Export as standalone HTML — take the design somewhere else entirely.
Import JSON across sites, with an optional publish status.
Convert to Page — bake a design into a regular WordPress page, CSS preserved.
Restore to Design Page — go back the other way.
Uninstalling leaves your sections in post meta as plain JSON-serializable data.

Design system

Design tokens — site-wide CSS custom properties (--ppd-*) for colours, fonts, spacing and shape. Change once, every page follows. Token declarations are stripped from page CSS on save so a stale hex can never shadow a live token.
Style guide — the AI reads the site's design language (palette, type scale, CSS patterns, layout principles) before it designs anything.
Component templates — thirteen proven skeletons the AI starts from instead of improvising: timeline, vertical tabs, bento grid, accordion, pricing table, comparison table, testimonial carousel, logo marquee, split hero, stats counter, step process, nav dropdown, nav mega.
Global sections — header and footer defined once and injected on every page, with per-page overrides and a per-page on/off switch.
Shared section library — save any section to the library and reuse it across pages; edit the library item and every page using it updates. Library previews snapshot the source page's CSS so they render faithfully.
Business info globals — phone, email, address, social profiles set once and referenced anywhere as {{business:*}}, with auto-generated LocalBusiness JSON-LD (opt-in, and it warns when another SEO plugin is already emitting schema).
Icons — 104 Phosphor icons shipped, 1,500+ more fetched on demand from CDN, in outline and fill styles, searchable by name and category, sized via CSS and inheriting text colour.

The shared section library — edit once, update everywhere.

Templates, not just pages

Assign a Design Page as the template for:

Single posts and any custom post type
Category, tag and custom taxonomy archives
Post type archives
Search results, date archives, and 404
The homepage

Fourteen template placeholder families resolve at render time ({{archive_*}}, {{term_*}}, {{post_type_archive_*}}, {{search_query}}, {{paged_*}}), and assignments can be tested before they go live.

WooCommerce

Design the shop archive with a real {{main_query}} loop and seven {{loop_wc_*}} placeholders.
Working price slider, category dropdown and sort filters, driven by URL parameters.
Proper template_include integration, so WooCommerce's pre_get_posts, Yoast/Rank Math head output and pagination all stay intact.
Single products in either render mode — full (plugin owns the page, globals included) or content (theme header/footer, PPD sections as the body), working even on themes that build product pages their own way.

Working with clients

Front-end review mode

A Comments menu in the admin bar for anyone who can edit. Turn review mode on, click any section on the live page, and leave feedback pinned to it — a question, an assumption, a note, or a warning. Sections with feedback show a numbered marker; open it to read the thread and resolve or delete in place. Invisible to public visitors: the overlay only loads for logged-in editors with review mode on.

Comments dashboard

Every thread on the site in one screen, with an open-count indicator in the admin bar. Comments whose section was later deleted collect in an orphaned tray instead of vanishing. The AI can read and write these threads too — it can flag an assumption for a human to confirm rather than guessing.

Revisions with real attribution

Every revision records the actor (human or AI), the route (admin / REST / MCP), the client name and version, the user agent and the IP. The history screen has a "Who" column. Restore any version. Retention is configurable — max versions per page, retention in days, WP-Cron cleanup.

Role access

A Settings → Access tab lets administrators grant Design Page management to any role, independent of normal post editing. Granted roles get their own self-service MCP Connection screen and can generate and revoke their own tokens; they see only their own. Settings and the library registry stay administrator-only. The rule is enforced identically in the admin, the REST API and over MCP.

Review mode: feedback pinned to the section it is about.

Fitting an existing site

Two render modes, set per post type and overridable per post: full (the plugin owns the whole document; header and footer come from global sections) and content (your theme provides header and footer; sections render into the content area).
Any theme, block themes included — including for archive templates.
Builder conflict detection — Elementor, Divi, Beaver Builder, Bricks, Brizy, Oxygen, Thrive and WPBakery are detected per post, and the plugin disables itself there. The other builder's data is untouched and switching is reversible.
Per-post opt-in for non-default post types; enable or disable a whole post type in Settings.
Shortcode embeds — and drop a design into a normal post or another builder's page, carrying its CSS and external stylesheet links with it.
Third-party widgets — documented patterns for all three shapes: shortcode-based (CF7, WPForms, Gravity, Fluent, Trustindex), script-plus-container (Trustpilot, Elfsight, SociableKit) and iframe (Calendly, TypeForm, Maps). Form plugins are auto-discovered so the AI can list real forms instead of guessing.

The MCP server

One Streamable-HTTP endpoint, one bearer token, 85 tools. Protocol revisions 2025-06-18, 2025-03-26 and 2024-11-05 are all supported, negotiated down to whatever the client understands.

Connecting: a single claude mcp add command for Claude Code and VS Code, or a copy-paste JSON block for Claude Desktop (launched via npx -y mcp-remote, with the token passed through an env block so it works on Windows). The endpoint address is read from WordPress itself, so it's correct on plain-permalink sites and subdirectory installs. The screen warns about the specific mistakes that produce a silent failure.

Group	Tools
Pages	`create_page` `create_page_from_template` `auto_build_page` `clone_page` `get_page` `list_pages` `update_post` `update_page_title` `publish_page` `delete_page` `render_page` `get_preview_url` `validate_page` `set_homepage` `get_homepage` `convert_to_page` `restore_to_design_page`
Sections	`append_section` `bulk_append_sections` `insert_section` `replace_section` `update_sections` `patch_section` `move_section` `delete_section`
Library	`create_shared_section` `get_shared_section` `list_shared_sections` `update_shared_section` `insert_shared_section` `delete_shared_section`
Globals	`get_global_sections` `set_global_sections` `get_page_global_overrides` `set_page_global_overrides` `get_business_info` `set_business_info`
Design	`get_style_guide` `get_design_tokens` `set_design_tokens` `get_component_templates` `get_section_examples` `get_best_practices` `start_project` `list_icons`
Templates	`create_template_assignment` `list_template_assignments` `update_template_assignment` `delete_template_assignment` `test_template_assignment`
Media	`find_images` `generate_image` `insert_image` `insert_images` `get_batch_status`
Variants & i18n	`create_variant` `get_variant` `list_variants` `delete_variant` `translate_page`
Feedback	`add_comment` `list_comments` `resolve_comment` `delete_comment`
Versions	`list_versions` `get_version` `restore_version` `get_edit_lock`
Transfer	`export_page_json` `export_page_html` `import_page` `scrape_page_html` `fetch_external_html`
Site	`check_health` `get_plugin_settings` `update_plugin_settings` `get_allowed_post_types` `enable_ppd` `disable_ppd` `list_forms` `list_taxonomies` `list_libraries` `register_library` `remove_library` `bust_cache`

The AI doesn't design blind: start_project, get_style_guide, get_best_practices, get_section_examples and get_component_templates give it your site's design language, your tokens and proven skeletons before it writes a line.

Also included

A/B variants — create and manage alternate versions of a page.
Translation — translate_page with WPML and Polylang awareness; the page list shows language.
Auto-build — hand auto_build_page a brief and get a whole page back.
Site migration input — scrape_page_html and fetch_external_html pull an existing page's markup in so the AI can rebuild it as sections.
WP-CLI — wp ppd page create --file=page.json.
Onboarding wizard on first run.
JS/CSS library registry — register additional CDN libraries for sections to depend on.
WPML config shipped for translatable strings.

Reference: what ships this at the plugin level

includes/class-renderer.php (rendering + placeholders), class-mcp-server.php (the 85 tools), class-content-schema.php (Content Mode field types), class-design-tokens.php, class-shared-sections.php, class-template-assignments.php, class-variants.php, class-comments.php + class-comments-frontend.php, class-versions.php, class-roles.php, class-builder-compat.php, class-business-info.php, class-icons.php, class-export.php / class-import.php, class-shortcodes.php, class-auto-builder.php, class-pixelvault.php, class-cli.php.

Want to see it on your own site?

Talk to us — we’ll build a real page live, not a canned demo.