Objective

Build a self-contained interactive course that takes someone with no marketing background to writing ads that actually sell, and get its first module into her hands tonight because a real apartment has to be listed by tomorrow morning.

The course is built from primary source, not summaries. Desktop\Mozi edu\hormozi-playbooks\ already holds ~2.3 MB of Hormozi material — $100M Offers, $100M Money Models, and eleven playbooks including Goated Ads, Hooks, Marketing Machine, Branding, Pricing and Lead Nurture. Frameworks get taught in his exact terminology with a line-range citation recorded for each one.

Done means

• The apartment is live on Dubizzle, Facebook Marketplace and a Facebook group, in both languages, before the deadline.
• She can open mozi-edu.pages.dev on her phone, and her work and progress survive closing the tab.
• Every module ends in a graded application, and a written rubric exists for each one so grading stays identical across sessions.
• The full round trip completes at least once: she writes → exports → he forwards → graded feedback lands back on that exact rep.
• node verify_course.mjs prints ALL CHECKS PASSED before every deploy, with no browser opened.

The feedback loop

A single loop is the wrong shape here. Three different jobs need three different latencies, and each one has a different grader — so they nest rather than compete. The fast loop builds accuracy, the slow loop builds transfer, and the outer loop is the only one that pays.

Every module also opens with copywork — hand-copying a proven piece, from the 121-hook swipe file in the Hooks playbook or a top-performing real listing. It is the drill the profession has actually used for a century, and it is the one place she types someone else's words rather than her own.

Course map

Minutes are computed from screen contents, never declared in a header. A previous course in this house drifted 90 minutes low on declared numbers, so the verifier now owns the arithmetic.

What the source covers, and what it doesn't

An extraction pass across the playbooks established exactly where the material runs out. This is the part most likely to go wrong quietly, so it is settled before authoring starts.

Module 01 in detail — the part that has to ship

Twelve screens, roughly four hours, split across tonight and tomorrow morning. It is ordered so that the ad exists before the polish does.

1. Deal sheet — the form above, filled once and reused by every later rep.
2. Who actually buys this flat, and what they are really buying.
3. Marketplace awareness reality: buyers there are solution-, product- and most-aware, so hooks must be promise-, proof- and offer-driven. Pain and curiosity hooks are wasted on a search results page.
4. Title = a hook with no room. 20 titles in both languages using the 7 formats, then pick 5.
5. Photos as demonstration ads — order, first frame, and what each shot has to prove.
6. Body copy driven through the value equation, with the honest negatives stated.
7. Price framing against real comparables.
8. The CTA line, all five parts.
9. Repackaging for Dubizzle vs Marketplace vs Groups — different lengths, different rules.
10. Buyer-reply scripts — first response, qualification, booking a viewing, the negotiation opener. Speed is a conversion factor; the scripts exist so she can be fast without thinking.
11. Ship checkpoint — post, then log the three URLs.
12. Metrics log at 24h / 48h / 7d. This is what module 03 rewrites against.

Module 07 — the media-buying module

The one he wants for himself as much as for her, and the one with no source material on disk. The money math comes first and is drilled on generated dashboards: CPM, CTR, CPC, CVR, CPA, AOV, ROAS, breakeven, LTV:CAC. Then Ads Manager structure, objectives, CBO vs ABO, audiences, placements, pixel and CAPI, attribution windows; creative testing at Hormozi volume using his CTA A/B/C protocol; kill criteria and minimum spend per creative; frequency and fatigue; scaling rules. Worked examples run in two tracks — the apartment for her, StudyFix for him.

The app

One self-contained page, no dependencies, no build step. Content is split one file per module — which is what makes the modules authorable in parallel without merge conflicts, and what keeps the engine stable while content churns.

app/
  index.html         engine only — CSS, hash router, widget engine, export + print views
  data/
    course.js        module manifest; minutes computed from contents, never declared
    m0.js … m7.js    one file per module — the split that allows parallel authoring
  fonts/             self-hosted variable fonts, including an Arabic face
  manifest.webmanifest, icons
GRADING.md           the loop protocol + a rubric per rep — the grading contract
SOURCES.md           playbook + line range for every framework, and every web citation
verify_course.mjs    the gate — must print ALL CHECKS PASSED before any deploy
STATUS.md            live state, one screen
plans/ads-course/    this plan

Reused from the existing courses

Two courses in this house already run this engine — workspace\victor\course\index.html and Desktop\Sites\sf-design\. The second generation is the better one and is what gets carried over:

• Pure string renderers (renderX() → HTML string, no DOM access) plus the mount guard that leaves document and window undefined — together these are what make headless node verification possible at all.
• The esc() + mini-markdown pair from sf-design, not the first generation's const esc = s => s no-op.
• Event delegation over inline onclick, so widget state survives a re-render.
• Computed module minutes, and per-lesson step position persisted so she resumes mid-module.

New widgets this course needs

Cheat sheets are a #/print route with print CSS, one A4 page per module with wide margins for annotation. Living inside the app means they cannot drift out of sync with the content the way separate PDFs would.

Stored state

Key mozi.v1 — deliberately not sfc2 or sfdesign.v1, which belong to the two existing courses and would collide.

{
  deal:    { district, price, size, floor, papers, negatives, buyer },
  answers: { "m1.r4.ar": "…", "m1.r4.en": "…" },
  grades:  { "m1.r4": { self: 3, predicted: 3, coach: 4 } },
  checks:  { "m1.r4": [1,1,0,0,1] },
  metrics: { "dubizzle": { h24: {views,saves,msgs}, h48: {…} } },
  notes:   { "m1.r4": "coach feedback text" },
  done:    { "m1.r4": 1755400000000 },
  step:    { "m1": 4 }
}

Nothing leaves her browser. The deal sheet is never uploaded anywhere, and the published page makes no network requests.

Build order

The constraint that shapes everything: a listing has to be live tomorrow morning. So the engine and day one ship before a single line of the rest of the week is written, and the deadline stops being at risk while there is still most of a session left to spend on the other six days.

Timeline

Aug 22 (tonight)         Aug 23        24      25      26      27      28
|------------------------|-------------|-------|-------|-------|-------|-------|
BUILD  schema → engine    fan-out lands  (all seven days of content already built)
       → m0 + m1 → DEPLOY  → audit
       → fan out m2–m7     → redeploy

SHE    m0 + m1 block A    m1 block B     M02     M03     M04     M05     M06/07
       ~3h tonight        ►► AD LIVE     ~8h/day — she is free all week
                          by midday

CONSTRAINT  listing live tomorrow AM — Phase B ships before anything else is written
ADJACENT    his own tracks (StudyFix, the 120h course) are untouched; separate folder

Verification

node verify_course.mjs from Mozi edu\ must print ALL CHECKS PASSED before every deploy. It evaluates the engine headlessly with a shimmed localStorage and document/window left undefined; renderers return strings, so every assertion is a string check. No browser is ever opened on his screen.

• Schema — every module and every screen validates; no unknown widget types.
• Every screen renders ≥ 200 chars; no unrendered ${ template leaks anywhere.
• Minutes computed from contents match the module header; the total is within 1% of ~54h.
• Every module has at least one graded application, and every graded rep has a matching rubric entry in GRADING.md. A rep with no rubric fails the build.
• Every pair rep has both AR and EN slots, and Arabic strings render RTL-safe.
• Every selfgrade gates its reveal — the prediction cannot be skipped.
• Module 01 contains the deal sheet, the ship checkpoint and the metrics logger.
• Module 07 contains the false-green dashboard drill.
• Longest paragraph ≤ 180 characters; one idea per screen.
• localStorage round-trip: write the full shape, reload, read it back identical. The key is mozi.v1 and appears nowhere else.
• The print route emits one page per module and the print stylesheet exists.
• Every external link resolves; every framework in SOURCES.md names a real file and line range.

Then deploy and confirm it is actually live:

node verify_course.mjs
npx wrangler pages deploy app --project-name mozi-edu --branch main --commit-dirty=true
# then fetch the deployed URL and assert HTTP 200 + the expected <title>

Non-goals

• Nothing inside workspace\ is touched. This lives entirely in Desktop\Mozi edu\.
• No git. That folder is not a repository and this plan does not make it one.
• Leila_Hormozi_Unfiltered_Advice.md is 62 pages on company culture and scaling, not advertising. It is not a source for this course.
• hormozi files to learn from\ is a byte-identical duplicate of hormozi-playbooks\. Only the latter is read; the duplicate is left alone, not deleted.
• No real ad spend happens without a confirmed budget first.

Open Questions

Four decisions that would change the build. Everything else is settled above.