# The Agentic WordPress Prompt Book
*The field guide to agentic WordPress, by Mihai Dragomirescu. Living version: https://www.respira.press/prompt-book*

## Agentic WordPress

For twenty years, working on a WordPress site meant operating it: logging in, finding the right screen, learning the builder, clicking through settings. Agentic WordPress is what happens when your site stops being something you operate and starts being something you talk to. You describe the outcome. An AI agent, connected to your live site, does the work in your page builder's own format, with an undo button under everything.

That category did not exist, so Respira became the first tool built for it. Not a chatbot bolted onto a dashboard, and not a code generator that hands you HTML to paste. An infrastructure layer that gives Claude, ChatGPT, and any MCP-capable agent real, structured, reversible access to live WordPress sites.

The numbers behind the claim, all shipping today:

**Over 200 tools.** Reads, writes, audits, SEO, accessibility, media, menus, custom post types, WooCommerce, snapshots, migrations. The count grows with every release; over 200 stays true.

**16 page builders, written natively.** Gutenberg, Elementor, Divi 4 and 5, Bricks, Oxygen, Beaver Builder, Breakdance and more. Fifteen take full writes; SeedProd is read-only today. Each edit lands in the builder's own format and stays editable in its visual editor. No other WordPress AI tool comes close on builder depth.

**37 ready-made skills.** Whole jobs, packaged: migrations between builders, conversion audits, SEO amplification, design-system extraction. The full catalog is a chapter of this book.

**A safety net designed for agents.** Edits stage on duplicates you approve. Full-page writes snapshot first, with 90 days of rollback by default. Destructive operations require an explicit yes. Recovery is a feature, not an apology.

**Business tooling inside the plugin.** Client-ready activity reports generated from your site's own audit log, and Earn, a dashboard that shows what your AI work actually cost so agencies know what to charge. The closing chapter covers both.

One honest note on scope: most of this book is the discipline of agentic WordPress, and the discipline is true with any MCP-capable tool. The primer, the four workflows, the anti-patterns and the storage tables work everywhere. Where something is Respira-specific (the skills catalog, staged approvals, snapshots, Earn), it is named as such, so you always know which is which.

> This book is the field guide to that way of working. Every example in it ran against a real site before it was written down.

## You don't learn tools. You talk to your site

Respira gives your AI assistant more than 200 tools across 16 page builders. You will never need to memorize any of them. The whole point is that you say what you want in plain English and the agent picks the right tool, in the right order, with the safety rails on.

This book is the companion for that: how to phrase things, what happens under the hood when you do, and the small set of habits that separate a great session from a frustrating one.

### Start every session with the primer

Paste this first, once per session, before any real work:

```
You're connected to my WordPress site through Respira. Before doing anything, detect my page builder and read my site's structure, then follow Respira's safe workflow: edit through the builder's native modules (never raw HTML), and duplicate or snapshot a page before changing it live. Confirm what builder i'm on and what you can do.
```

Why this matters: every builder stores content differently: shortcodes, block comments, JSON in hidden fields. When the agent detects your builder first, everything it writes lands in your builder's native format, stays editable in your visual builder, and survives the round trip. Skip the primer and the agent may guess, and a wrong guess is how pages end up as one opaque HTML blob.

### Priming variants by intent

**Editing an existing page:** add "Today we're editing the [page name] page. Read its full structure first and tell me what sections it has before changing anything."

**Building something new:** add "Today i want to build a new page from scratch. Use my builder's native modules and keep it as a draft until i say publish."

**Auditing, not touching:** add "Today is read-only: audit, analyze, report. Don't write anything to the site unless i explicitly ask."

> The primer also lives in your WordPress admin under Respira → Prompts, next to twenty ready-made workflow prompts in five categories. They're kept current with the plugin.

## The first ten minutes on a new site

The primer covers the session. This is the checklist for a site you have never touched before: agency-suggested, run once per site rather than once per session.

**Which site am i actually connected to?** if you manage more than one, confirm before you start: "what site am i connected to right now, and what's its URL?"

**Builder and plugin inventory.** "what page builder is this site using, and what plugins are active?"

**Cache stack.** Respira purges every major caching plugin automatically after a live write; this is about knowing whether a CDN edge cache or host-level cache sits outside that reach.

**Staging availability.** if the site has one, connect Respira there too and rehearse a risky change first.

**Backup status.** snapshots cover page content; they are not a substitute for a full-site backup.

> Five questions, one time per site. After that, the primer takes over for every session.

## The four write workflows

Everything you ask for routes through one of four patterns. You don't have to name them, but knowing them helps you phrase asks that land on the right one.

### 1 · Small edit: find it, change it

Text, dates, colors, a single image, one button. The agent locates the element by its current text, its label, or its type, and updates only that element. Two tool calls, one element touched, nothing else moves.

```
change the button on the contact page to say "Get a quote"
```

### 2 · Redesign existing: read, modify, write back

The agent extracts the full builder structure, modifies the tree, and injects it back in one atomic write. A snapshot is taken first, so it's reversible.

```
restructure my services page so each service is its own section with a heading, a paragraph, and a button
```

### 3 · Build from scratch: describe the page

New pages are built from a nested structure in your builder's vocabulary. For Divi you can describe structure the natural way, rows containing cols containing modules, and it lands correctly. If a build can't write every element you asked for, it fails with a clear error instead of pretending it succeeded.

```
build a landing page: hero with headline and CTA, three feature columns, a testimonial, a closing CTA section
```

### 4 · The two-pass build: skeleton first, then fill

For pages where copy matters more than speed. Pass one creates the skeleton with placeholder labels; pass two updates each module by its label. The most controllable way to build, and each request stays small.

```
build the hero skeleton: two columns, left has Hero Headline, Hero Subhead and Hero CTA placeholders, right has Hero Image. then read it back and confirm the structure.
```

> Very large pages: build them a section at a time ("add the pricing section to the draft"), not as one giant request. AI clients cap how much a single request can carry. A dedicated streaming build mode is on the roadmap; i haven't shipped that yet.

## Anti-patterns, and the safety net

### The four ways sessions go wrong

### The three layers that protect you

**Duplicate-before-edit.** By default, write tools stage changes on a duplicate of the page. You review in Respira → Changes and approve before anything replaces the original. This covers every structural tool, not just text updates.

**Snapshots.** Full-page writes snapshot the page first. "Undo that" restores the snapshot; "what changed?" diffs before and after.

**Approval for destructive operations.** Deletions and other destructive calls require an explicit approval step; the agent can't rush past it.

The phrases that drive it: *"undo that last change"* · *"show me what changed"* · *"restore the version from before we started"*.

If you manage more than one site, add a fourth phrase to the rotation: *"confirm which site you're connected to before you do anything"*. asking costs one message and is the whole guard against writing to the wrong client's site.

> When Respira's workflow makes the agent ask "which of these three sections did you mean?" or "this will affect 40 pages, proceed?", that's the system working. Answer specifically; never say "just do whatever's best" to a question about scope.

## Eight worked recipes

> Anything in [brackets] is yours: replace it with your own words before pasting. The first recipe is shown twice, once as the template and once filled in with real words, so you can see the shape.

#### 1 · Hero redesign
*Same design, new message, staged for your approval.*

```
read my homepage structure, then rewrite the hero section to target [audience]: new headline, one-line subhead, and a CTA that says [text]. keep the layout and images, stage it for my approval.
```

#### 1b · The same recipe, filled in
*What it looks like with real words instead of brackets.*

```
read my homepage structure, then rewrite the hero section to target busy parents comparing local dentists: new headline, one-line subhead, and a CTA that says "Book a checkup". keep the layout and images, stage it for my approval.
```

#### 2 · Site-wide find and replace
*A reviewed list first, then one bulk pass across up to 100 pages.*

```
find every page that mentions [old thing] and show me the list. then replace it with [new thing] everywhere except [page you want untouched].
```

#### 3 · SEO refresh on a key page
*Mechanical wins applied, strategic calls surfaced for you.*

```
run an SEO analysis on [page]. then fix the mechanical findings: title tag, meta description, heading hierarchy, image alt text, and internal links to related pages. show me anything that needs a judgment call instead of fixing it.
```

#### 4 · Accessibility pass
*Alt text, labels and heading order fixed; judgment calls reported.*

```
scan [page] for accessibility issues. fix missing alt text, unlabeled buttons and broken heading order. give me a short report of what you fixed and what needs a human decision (contrast, link text wording).
```

#### 5 · New page from scratch (two-pass)
*A labeled skeleton you fill section by section.*

```
build a draft [type] page: [list the sections in order, one line each]. use placeholder labels for every text module. then read it back and confirm the structure before we fill in copy.
```
*Follow with one message per section: "update [label] to say ...". This is the workflow that makes long pages controllable.*

#### 6 · Case study machine
*A custom post type, its fields, a template, and post one, in one conversation.*

```
create a "case study" custom post type with fields for client, industry, result and quote. then build a template page for it and create the first case study from these notes: [paste notes].
```

#### 7 · Divi 4 to Divi 5 migration check
*A readiness report before anything changes.*

```
run a Divi 5 migration readiness audit on my site. tell me which pages and modules would convert cleanly, which won't, and what to fix first. don't change anything yet.
```

#### 8 · The Monday morning audit
*One prioritized list of what to fix this week. Read-only.*

```
give me a site health snapshot: pages changed in the last week, anything that looks broken, SEO issues on the top 5 pages, and one prioritized list of what to fix this week.
```

### The anatomy of a good recipe

Every recipe above has the same four parts, and once you see them you can write your own for any job. **The read step**: have the agent look before it touches ("read my homepage structure"). **The change**: what you want, described by outcome, not by mechanism. **The boundary**: what must not move ("keep the layout and images", "everywhere except the legal page"). **The staging clause**: "stage it for my approval", "as a draft", "show me the list first". Read, change, boundary, staging. That is the whole craft, and it is true with any agentic WordPress tool.

A fifth habit belongs right after the write lands: **read it back and diff it.** staging catches intent before a change goes live; it does not catch a write that landed wrong or silently dropped an element. one extra message, and it catches what staging cannot.

## Builder cheat sheets

You never write these payloads by hand; your agent does. These sheets exist so that when you look over its shoulder, you know what "correct" looks like. The storage formats belong to the builders, not to Respira, so this chapter is true whatever tool you use. One universal rule: the canonical nesting key is `children`, and for Divi the natural vocabulary (`rows`, `cols`, `modules`) works too, at any depth, on both Divi 4 and Divi 5.

Multilingual sites (WPML, Polylang): Respira has a dedicated tool for duplicating a page across your configured language variants and keeping the translation relationships intact. Ask directly: "duplicate this page across all our configured languages".

### Divi 4

Stores shortcodes directly in the page content: what you see in the database is the page. Settings live in `attrs` (or `settings`); body text goes in `content`. Buttons use `url`, not Divi 5's `linkUrl`. Divi 4 has a per-attribute writer: give your modules admin labels when building, and later edits become one-liners ("update the module labeled Hero Headline").

```
{ "type": "et_pb_section", "children": [ { "type": "et_pb_row", "children": [
  { "type": "et_pb_text", "content": "Hello", "settings": { "admin_label": "Intro" } } ] } ] }
```

### Divi 5

Stores WordPress block comments, one `divi/*` block per module. Simplified setting names (like `font_color`) route to Divi 5's nested attributes automatically. Column widths use `flexColumnStructure` in 24ths (8_24,8_24,8_24 is three equal columns); a blurb's title is an object, not a string. A single module can be patched without rewriting the page.

> A site can run the Divi 5 theme with old shortcode pages still on the Divi 4 pipeline. Respira routes by the site's actual runtime, never by what the payload looks like: a legacy shortcode page on a Divi 5 site reads as one opaque block until it's migrated.

### Elementor

Stores JSON in a hidden field (`_elementor_data`), so hand-editing the visible page content does nothing. Nesting key is `elements`, settings key is `settings`, responsive overrides use suffixes (`title_color_tablet`). Elementor 4's atomic elements mix with classic widgets on the same page; both are read and written.

### Bricks

Stores a flat JSON list in a hidden field where every element names its parent and children by id; Respira unfolds it into a tree and rebuilds both directions on write, which the Bricks editor requires. Bricks has the deepest tool set of any builder: global classes, theme styles, color palettes, typography, components, cross-site class search. Say "apply my global class 'card' to this section" and the class registry resolves for you.

### Gutenberg

Native WordPress block comments in the page content, no hidden fields. Nesting key is `innerBlocks`, settings key is `attrs`. Because this is the native format, Gutenberg round-trips are the most forgiving of any builder.

### Every other builder, in one line each
| Builder | Where content lives | Nesting | Settings |
|---|---|---|---|
| Beaver Builder | flat node map in _fl_builder_data (draft: _fl_builder_draft) | children | attributes |
| Breakdance | JSON tree in _breakdance_data; EssentialElements\ namespace | children | properties |
| Oxygen 6 | node tree in _oxygen_data; headers/footers are separate post types | children | options |
| WPBakery | shortcode-derived flat map; some attrs pipe-encoded (a:1|b:2) | children | attributes |
| Brizy | envelope in the brizy meta field; the editor tree inside is the content | children | attributes |
| Flatsome (UX) | shortcodes in the page content, Divi-4-style | elements | attributes |
| Thrive Architect | serialized content in tve_updated_post | children | attributes |
| Visual Composer | URL-encoded JSON in vcv-pageContent | children | attributes |

> You don't need to remember any of this: the primer's "detect my builder first" step is what turns all of it into someone else's problem. It's here for the day you want to check the agent's work.

## Your builder, specifically

Every prompt in this book works on all sixteen builders; Respira translates to whatever your site runs. But each builder has one or two things worth knowing when you phrase an ask. Not sure what you're on? Start with:

How you would know a write did not fully land: a Divi build that drops elements returns a hard error instead of a false success, an Elementor write to an unsupported widget type is refused up front rather than silently dropped, and every builder-content write echoes back exactly how many elements it received and persisted. The read-back-and-diff habit is still worth doing regardless, since these guards catch dropped structure, not a wrong color or a mistyped word.

```
what page builder is this site using, and what can you do with it?
```

**Gutenberg:** the most direct pipeline of all sixteen; what the agent writes is exactly what the block editor opens. Name blocks by what they say, not by position: "the paragraph under the pricing heading" beats "the third block".

**Elementor:** the agent can read and update your global colors and typography site-wide. Say "use my existing global colors and fonts" and new sections come out on-brand instead of hardcoded.

**Divi 4:** ask for admin labels on every module while building. Later edits become one-liners: "update the module labeled Hero Headline". The two-pass recipe from chapter four was made for Divi.

**Divi 5:** same prompts as Divi 4; Respira detects which Divi runtime your site is on and writes the right format. Planning the upgrade? Ask for a "Divi 5 migration readiness audit" first: read-only, and it tells you what converts cleanly.

**Bricks:** the deepest design-system support in the lineup. Say "reuse my global classes" or "follow my theme styles" so new sections extend your design system instead of piling up inline styles.

**Oxygen Classic:** structural edits, element updates and rebuilds all work on the ct_ element tree. Be explicit about which page you mean; Oxygen templates and pages can share names.

**Oxygen 6:** a new engine under the hood (shared with Breakdance) with a rich element set, including the full Section, Heading and Button elements. Prompts that name elements plainly map cleanly onto its element names.

**Beaver Builder:** full read-modify-write on the flat node map. Rows and modules have internal node ids; let the agent read the page first and reference elements by their text.

**Breakdance:** writes go against the builder's own element schema so the visual builder opens everything cleanly. Works the same as Oxygen 6 in practice; the two share an engine.

**Flatsome (UX Builder):** common on WooCommerce shops. For shop pages, mention the WooCommerce context: "the product grid section on the shop landing page".

**Brizy:** full writes supported. Standard prompts work; read the page first, then edit by description.

**WPBakery:** great for audits, text refreshes and structure updates on long-lived sites. Many WPBakery sites are migration candidates; there are ready-made skills for WPBakery to Gutenberg or Bricks (next chapter).

**Visual Composer:** full writes supported. Not the same product as WPBakery despite the shared history; Respira detects which one you actually run.

**Thrive Architect:** conversion-focused landing pages. Reference elements by their copy ("the CTA that says Book a call"), which stays stable across Thrive's markup.

**Kadence · Spectra · GenerateBlocks:** block suites riding the Gutenberg pipeline with their own block families. You can name the family ("use Kadence blocks for the accordion") or just describe the outcome and let detection handle it.

**SeedProd:** read and audit only today. Ask for audits and content inventories; for edits, do them in SeedProd itself for now.

## The skills catalog: 37 jobs, already packaged

A skill is a ready-made, tested playbook for a whole job: you install or paste it into your AI client once and trigger it with a sentence. All 37 ship in every Respira plan, browsable under Skills in your dashboard. This is the full catalog, so you know what you never have to prompt from scratch.

### Getting started

**respira-setup-assistant:** Diagnose your Respira MCP connection, walk through first-time setup, and fix common connection problems...

**site-onboarding:** First-run primer for AI coding tools. Verifies MCP connectivity, discovers site architecture (theme...

### Workflow

**prime-the-agent:** Fast 30-second session-starter. Loads the active site, identifies the page builder, loads inline...

**page-template-library:** Capture canonical page patterns (case study, service page, landing page hero + 3-up + CTA) as re-usable...

**build-oxygen6-page:** Build or rebuild pages on Oxygen 6 (Jenga) as native, editable elements instead of a single HTML block...

### Audits

**wordpress-site-dna:** Archaeological analysis of WordPress sites. Detects all page builders, audits plugins (active vs dead...

**technical-debt-audit:** Identifies technical debt in WordPress sites: orphaned shortcodes from deleted plugins, unused plugins...

**woocommerce-health-check:** WooCommerce configuration diagnostics: identifies checkout problems, cart errors, AJAX mismatches...

**mobile-experience-report:** Mobile layout diagnostics: identifies responsive breakpoint problems, text sizing issues, column...

**stale-content-detector:** Find pages and posts that haven't been updated in a long time. Categorize as fresh / aging / stale /...

**conversion-audit:** Audit a WordPress site for conversion-rate friction across six dimensions: above-the-fold clarity, CTA...

### Performance and SEO

**seo-aeo-amplifier:** Comprehensive on-page SEO and Answer Engine Optimization audit with automated duplicate creation and...

**wordpress-ai-image-optimizer:** AI-powered image optimization that downloads images from WordPress, processes locally (compress, WebP...

**internal-link-builder:** Strategic internal link building for WordPress sites. Analyzes all published content, maps topic...

### Site intelligence

**design-system-synthesizer:** Read your site's representative pages, theme files, and media library to extract a complete reusable...

**brand-voice-synthesizer:** Read 5-10 published posts and extract the brand voice: tone, lexicon, sentence patterns, person used...

### Content architecture

**custom-post-type-architect:** Design and create WordPress custom post types end to end: CPT + supporting taxonomies + ACF field group...

### Reporting

**activity-report-composer:** Turn the audit log of work done on a WordPress site into a polished written report. Wraps the v7.1...

### Migrations and conversions (19 skills)

**content-portability:** Export WordPress pages, posts, and custom posts to portable local packages...

**migrate-elementor-to-bricks:** Converts Elementor pages to Bricks Builder by reading Elementor JSON widget...

**migrate-elementor-to-gutenberg:** Converts Elementor pages to native WordPress Gutenberg blocks by mapping...

**migrate-elementor-to-breakdance:** Converts Elementor pages to Breakdance Builder by mapping widgets to...

**migrate-elementor-to-oxygen:** Converts Elementor pages to Oxygen Builder by mapping widgets to Oxygen...

**migrate-divi-to-bricks:** Converts Divi pages to Bricks Builder by parsing shortcode content, mapping...

**migrate-divi-to-gutenberg:** Converts Divi pages to native Gutenberg blocks by parsing shortcodes, mapping...

**migrate-divi-to-breakdance:** Converts Divi pages to Breakdance Builder by parsing shortcodes, mapping...

**migrate-wpbakery-to-gutenberg:** Converts WPBakery pages to native Gutenberg blocks by parsing shortcodes...

**migrate-wpbakery-to-bricks:** Converts WPBakery pages to Bricks Builder by parsing shortcodes, mapping...

**migrate-beaver-builder-to-gutenberg:** Converts Beaver Builder pages to native Gutenberg blocks by reading the flat...

**migrate-beaver-builder-to-bricks:** Converts Beaver Builder pages to Bricks Builder by reading the flat node map...

**migrate-oxygen-to-bricks:** Converts Oxygen Builder pages to Bricks by mapping component trees to Bricks...

**migrate-oxygen-to-breakdance:** Converts Oxygen Builder pages to Breakdance by mapping component trees to...

**migrate-brizy-to-gutenberg:** Converts Brizy pages to native Gutenberg blocks by parsing Brizy JSON data...

**migrate-thrive-architect-to-gutenberg:** Converts Thrive Architect pages to native Gutenberg blocks by parsing Thrive...

**migrate-visual-composer-to-gutenberg:** Converts Visual Composer pages to native Gutenberg blocks by parsing VC data...

**html-to-bricks:** Convert raw HTML/CSS into native Bricks Builder elements. Maps colors...

**figma-to-elementor:** Rebuilds a Figma frame as an editable Elementor page. Reads the Figma node...

The pattern for all of them: install or paste the skill, then ask in plain English.

```
run the conversion audit on my homepage
```

> The skill carries the expertise so your prompt doesn't have to. Migrations create draft duplicates for review; nothing replaces a live page without your approval.

## Playbooks: teach your site a repeatable job

When you and your agent work out a workflow you'll want again, you don't have to re-explain it next month. Ask the agent to save it as a **playbook**: a named, typed sequence of steps stored on your site itself. Once saved, it shows up as a tool the agent can run on demand.

```
save what we just did as a playbook called page-outline-report, so next time i can just say "run the page outline report".
```

Playbooks are validated when they're saved, not when they run: a step that references a missing tool or a missing argument is rejected on the spot with a message telling the agent exactly what to fix, so a broken playbook can't sit there looking healthy. "List my playbooks" and "delete the playbook called X" work the way you'd expect.

> This is a newer feature; skills are the curated library, playbooks are the ones you grow yourself.

## Run a business on it

Agencies were the first to figure out what agentic WordPress changes: the same job, done well, in a fraction of the hours you used to bill. Two features inside Respira exist for exactly that shift.

### Client reports from the audit log

Every tool call Respira makes on your site lands in an audit log. The activity report tool reads that log plus the snapshot history and returns structured data: what was changed, on which pages, when, and a time-saved estimate baselined per tool. Your agent turns it into a polished client-ready report in your voice. There is a ready-made skill for it (activity-report-composer, previous chapter).

```
generate an activity report for the last 30 days on this site and write it up as a client update: what was done, what it would have cost in senior hours, what's recommended next month.
```

Your site's audit log is a client report waiting to be written. You did the work; the log already remembers it.

### Earn: know what to charge

The other half of the agency question is pricing. If the job took a fraction of the hours you used to bill, what goes on the invoice? Earn is a dashboard inside Respira that cross-joins your AI usage telemetry with your Respira tool calls, per client site: what the AI work actually cost, what it replaced, and what that means for your invoice. No extra AI bill, no setup beyond pasting a snippet, free with every plan.

> The full story is at respira.press/earn. Between the reports and the numbers, the invoice writes itself, honestly.

### Staging vs production

Duplicate-before-edit and snapshots reduce how often a separate staging environment is needed for a single small change, but they are not a replacement for staging on anything structural or client-sensitive. Connect Respira to staging too when it exists, rehearse the risky change there, then repeat it on production once read back and confirmed.

## What agentic WordPress can't do yet

An honest guide names its edges. These are the real limits today, stated plainly so you can plan around them instead of discovering them mid-project.

**Undo is per page, not per element.** A snapshot captures and restores a whole page. "Undo that" rolls the page back; it cannot surgically revert one module while keeping the three edits after it. If you need fine-grained history, work in smaller sessions: more snapshots, smaller blast radius.

**Media files are not versioned.** Snapshots cover page structure and content, not the image binaries themselves. If the agent replaces an image, the old file still exists in your media library, but there is no automatic "restore the previous image here". Deleting media requires an explicit yes for exactly this reason.

**Very large single builds hit the AI client's own ceiling, not Respira's.** A 300-element page described in one tool call can exceed what the model is willing to write in one response; some clients then quietly trim the call. Respira now reports exactly how many elements arrived, and the reliable pattern is chunking: build the skeleton, then append a few sections per request. A dedicated streaming build mode is on the roadmap; i haven't shipped that yet.

**One builder is read-only, and a few have caveats.** SeedProd is audit-only today. The per-builder chapter names each caveat where it lives, so there are no surprises.

**The agent can still misunderstand you.** No tool fixes an ambiguous ask. The primer, the read-first habit, and staged approvals exist because language is lossy. The safety net is what makes that survivable.

> If a limit here disappears in a future release, the living version of this book at respira.press/prompt-book is where that gets recorded first.

## One worked example, *end to end.*

Ran on a live Divi 4 test site before this book shipped. The ask: "build a draft page: a dark section with two rows. first row, two columns: left has Hero Headline, Hero Subhead and Hero CTA; right has a Hero Image and a Hero Badge. second row, five short trust modules. label everything."

What got written: one section, two rows with correct column structures, three columns, ten labeled modules. sixteen of sixteen. Then: "update the module labeled Hero Headline to say Smiles that last a lifetime." One module changed, nothing else touched.

That's the whole book in one story: say it plainly, let the workflow protect you, and label what you build.

respira.press · the living version of this book is at respira.press/prompt-book questions? word@respira.press