Gold Standard Course Creation System

הפרומפט המושלם
איך לבנות קורסים ברמה הגבוהה ביותר

מבוסס על הניסיון של nVision Academy — 172 פרקים ב-13 קורסים, מיליון+ מילים, מערכת 16 סוכנים עם pipeline-orchestrator אוטונומי, לולאת תיקון אוטומטית ו-7 שלבי הערכה. כל מה שלמדנו על יצירת תוכן חינוכי ברמת Gold Standard, ארוז בפרומפט אחד שאפשר להדביק בכל AI.

172פרקים שנכתבו
1M+מילים
15אלמנטים חובה
16סוכני AI
7שלבי הערכה
תוכן העניינים
1
ארכיטקטורת קורס + Pipeline — מבנה שלם
תכנון קורס, שרשרת ייצור אוטונומית, ו-pipeline-orchestrator

מבנה הפאזות — מתחילים ומסיימים נכון

קורס טוב הוא לא אוסף של פרקים על אותו נושא. הוא מסע מובנה שלוקח מישהו מנקודת אפס לנקודה שבה הוא יכול לפעול בעצמו. המפתח הוא חלוקה לפאזות:

פאזהפרקיםפרופילמאפיינים
Foundation1-3בסיסמילון מונחים כבד, דרישות קדם מינימליות, תרגילים פשוטים, פריימוורקים של "מאיפה מתחילים"
Skill-Building4 עד N-2בניית מיומנויותמיקס מאוזן, דרישות קדם מפרקים קודמים, תרגילים שמייצרים תוצרים עצמאיים, פריימוורקים של אופטימיזציה
IntegrationN-2 עד Nאינטגרציהדרישות קדם מרובות, תרגילים שמשלבים מיומנויות, שגרת עבודה מצטברת, פריימוורקים אסטרטגיים

כמה פרקים צריך?

סוג קורספרקיםיעד מיליםדוגמה
פלטפורמה בודדת12-1590K-120KLinkedIn, TikTok, WhatsApp
פלטפורמה מרכזית20-25150K-200KGoogle, Meta
נושא חוצה-פלטפורמות12-1890K-140KAI Marketing, Freelancer

חוט אדום — הפרויקט הרציף

כל פרק בקורס מוסיף שכבה לפרויקט אחד מתמשך. הקורא לא "לומד על נושאים" — הוא בונה משהו אמיתי פרק אחרי פרק. לדוגמה:

  • קורס Meta (20 פרקים): נוכחות שיווקית מלאה — מדף פייסבוק עד דשבורד מעקב
  • קורס Google (25 פרקים): אתר SEO + קמפיין Ads + דשבורד Analytics
  • קורס Freelancer (12 פרקים): מרישום עסק ועד תוכנית 12 חודשים
  • קורס WhatsApp (12 פרקים): מפרופיל עסקי ועד אסטרטגיית ROI מלאה
הכלל המרכזי

כל פרק עומד בפני עצמו — אפשר לקפוץ ישירות. אבל מי שעובר בסדר מקבל תוצאה שלמה. הפרויקט הרציף הופך אוסף כתבות לקורס אמיתי.

Pipeline Orchestrator — שרשרת ייצור אוטונומית

כל השרשרת רצה דרך pipeline-orchestrator — סוכן Opus שמנהל את כל התהליך. אל תתזמרו ידנית. תנו לו לרוץ:

עיקרון Chain, Not Blob

כל שלב מייצר ארטיפקט (JSON/HTML). השלב הבא קורא את הארטיפקט, לא את הקוד המקורי. אף פעם "תעשה הכל בפרומפט אחד".

שרשרת יצירת פרק (7 שלבים)

שלבסוכןקלטפלט
1. מחקרtopic-researcher (Opus)syllabus entrychapter.research.json
2. תכנוןchapter-planner (Opus)research.json + syllabuschapter.plan.json
3. כתיבהcontent-writer (Opus)plan.json + Gold Standard templatechapter.html + manifest.json
4. הערכה4 evaluators (parallel)manifest + samples4 JSON reports
5. Publish Gatepublish-gate (Sonnet)4 JSON reportspublish-decision.json
6. תיקוןrepair-planner + rewriter (Opus)eval reportstargeted fixes
7. Re-evalaffected evaluators onlyrefreshed manifestupdated decision

מקסימום 3 סיבובי תיקון. אחרי 3 — block + כתיבה מחדש.

שרשרת הערכת קורס (course-level)

שלבסוכןפלט
1. Registryrefresh_registry.pycourse.registry.json
2. Graphcourse-graph (Sonnet)course.graph.json
3. Reportcourse-report-aggregator (Opus)course.audit.json + .md
4. Publish Gatepublish-gate (course scope)course.publish-decision.json

שרשרת דרישות קדם

  • פרקים קודמים — אילו פרקים צריך לקרוא קודם
  • כלים נדרשים — אילו חשבונות/כלים צריך
  • מושגים קודמים — מה הקורא אמור לדעת
  • זמן משוער — כמה זמן לוקח (קריאה + יישום)

מה הופך קורס ל"מושלם"?

  • כל פרק מייצר תוצר מוחשי — "יהיה לך X" ולא "תבין X"
  • פרופיל מותאם למיקום (Foundation / Skill / Integration)
  • שגרת עבודה מעשית — יומי, שבועי, חודשי
  • תוכנית 90 יום / 12 חודשים בפרק האחרון
  • AI ואוטומציה לאורך כל הקורס
  • דוגמאות מהשוק הישראלי בכל פרק רלוונטי
  • 3 דיאגרמות SVG לפרק (inline, צבעי dark theme)
2
15 האלמנטים של Gold Standard — השלד של כל פרק
כל אלמנט בפירוט — CSS class, מינימום, ותיאור מדויק

כל פרק חייב לכלול את כל 15 האלמנטים. בלי חריגים. חוסר באלמנט = כישלון ב-Structure Review.

1Learning Objectives — יעדי למידה.learning-objectives
3-5 יעדים מדידים עם פעלי פעולה: "תוכלו להגדיר", "תוכלו ליצור". אסור "תבינו" או "תלמדו על". כל יעד מתחבר לסקשן ולתרגיל.
2Prerequisites — דרישות קדם.prerequisites
פרקים קודמים, חשבונות, כלים, זמן משוער. מפורש: "חשבון Google Ads פעיל" ולא "ידע בסיסי".
3Deliverables — תוצרים.deliverables
5-8 תוצרים מוחשיים. "מה יהיה לכם" — לא "מה תבינו". כל תוצר = ארטיפקט שאפשר לצלם מסך.
4Project Thread — החוט האדום.project-thread
פרק קודם → נוכחי → הבא. "יצרתם X. בפרק הזה תוסיפו Y. בפרק הבא X+Y = Z."
5Glossary — מילון מונחים.glossary
טבלה דו-לשונית. כלל: כל מונח מוגדר לפני השימוש הראשון. מילון בתחילה + inline בהקשר.
6Do-Now — עשה עכשיו.do-now
7-10 לפרק, מינימום 7. פעולה בודדת, עד 5 דקות, עם time badge. לא "חשבו על". תמיד פעולה + תוצאה.
7Exercises — תרגילים.exercise
3-4, מינימום 3. מדורגים. שלבים + תוצר צפוי + זמן. תרגיל 1 חייב לעבוד למתחיל מוחלט בלי נתונים קיימים.
8Decision Frameworks — מסגרות החלטה.framework
2-3, מינימום 2. "אם X אז Y" אמיתי. לא "תלוי". תנאים → תוצאות ברורות.
9Warnings — טעויות נפוצות.warning
2-4, מינימום 2. "טעות נפוצה:" + מה/למה/מה במקום. ממוקם ליד המושג הרלוונטי.
10Check Yourself — בדוק את עצמך.check-yourself
5 שאלות בדיוק. "למה" ו"איך", לא "מה". בלי hints מלאים בשאלה.
11Work Routine — שגרת עבודה.work-routine
יומי / שבועי / חודשי עם זמנים. בפרקי Integration — שגרה מצטברת.
12Chapter Summary — סיכום.chapter-summary
נרטיב: מה למדנו, מה בנינו, מה הלאה. לא רשימה — גשר לפרק הבא.
13Checklist — צ'קליסט.checklist
10-15 פריטים. פעולות בלבד — אסור "הבנתי X".
14Section Tags — תגיות.section-tags
על כל H2: זמן + קושי + עלות. מאפשר לדלג ולחזור.
15Just One Thinginside .chapter-summary
הפעולה הבודדת עם ה-leverage הגבוה ביותר. עוזר לקורא עמוס.
3
כללי איכות תוכן
ספירת מילים, SVG דיאגרמות, ספציפיות ישראלית, עקרון הפעולה

ספירת מילים: 7,500-10,000

הבעיה #1 — נתון מ-172 פרקים

כל AI מייצר 4,500-5,500 מילים בטיוטה ראשונה (60-75% מהיעד). ב-100% מהמקרים. תמיד צריך לפחות סיבוב אחד של repair cycle. תקצבו 15-20 דקות נוספות לכל פרק.

SVG דיאגרמות — 3 לפרק (סטנדרט חדש)

כל פרק חייב לכלול 3 דיאגרמות SVG inline ב-HTML. הדיאגרמות הן חלק מהתוכן, לא קישוט:

  • SVG 1: תרשים זרימה/ארכיטקטורה — מראה את התהליך המרכזי של הפרק
  • SVG 2: טבלת השוואה ויזואלית — framework ראשי בצורה גרפית
  • SVG 3: מפת פעולה — הצעדים הפרקטיים לביצוע
כללי עיצוב SVG

רקע: #1a1c2a (dark theme). טקסט: #e4e5ea. מבטאים: #6c5ce7, #00b894, #f5a623. כיוון: RTL. פונט: Heebo. Inline ב-HTML — לא קובץ חיצוני. מקסימום 200 שורות SVG לדיאגרמה.

עקרון הפעולה

  • אין תיאוריה בלי "עשה עכשיו" בסמוך
  • דוגמאות שמישות, לא דקורטיביות
  • תרגילים מייצרים תוצר נראה
  • תוצר צפוי מתואר מפורש

שוק ישראלי — ספציפיות שלמדנו מ-172 פרקים

  • שפה: עברית + מונחים באנגלית מוסברים (Hebrew + English terms)
  • מטבע: ש"ח (ILS), לא דולר. תמחור בש"ח בכל מקום
  • מע"מ: 18% (לא 17%! שגיאה שחוזרת ב-AI)
  • WhatsApp: ערוץ #1 בישראל — 99% חדירה. כל קורס חייב להזכיר
  • חוק ספאם: תיקון 13 לחוק התקשורת (Bezeq) — opt-in חובה, קנסות עד 1,000 ש"ח להודעה
  • פלטפורמות: WhatsApp (99%), Waze, Facebook (85%), Instagram (70%)
  • דוגמאות: עסקים מקומיים (מסעדה בת"א, סטודיו יוגה ברעננה), לא Coca-Cola
  • מובייל: 98% בנייד. Mobile-first תמיד
  • Case studies: סמנו כ-"דוגמאות מייצגות" אלא אם מאומתות

ידידותיות למתחילים

  • Click paths: "Settings → Dashboard → Controls"
  • אלטרנטיבה אם אין נתונים: "אם יש — השתמשו. אם לא — הנה דוגמה"
  • כל מונח מוגדר בשימוש ראשון: "CTR (Click-Through Rate — שיעור ההקלקה)"
  • "אם הכל עבד, תראו..."

סטטיסטיקות

אזהרה

AI ממציא מספרים: "72%", "89%", "340%". תמיד לבדוק מול מקור. לא מאומת = qualifying language: "לפי הערכות בתעשייה". Fact-checker מוציא claims עם grep, לא קריאת prose.

סגנון

  • פסקאות קצרות (2-4 משפטים)
  • טבלאות להשוואות, רשימות לצעדים
  • טון מנטור מעשי
  • אין filler — אם אי אפשר למחוק בלי לאבד ערך, זה filler
  • RTL: חץ חזרה = →
4
12 טעויות שלמדנו בדרך הקשה
לקחים מ-172 פרקים ב-13 קורסים

#1: טיוטה ראשונה תמיד קצרה

AI מייצר 4,500-5,500 מילים (יעד 7,500+). ב-100% מ-172 הפרקים. צריך repair cycle שמוסיף 15-20 דקות. ה-orchestrator עושה את זה אוטומטית — מרחיב ל-7,200-7,500 בממוצע.

#2: Sonnet מאשר הכל, Opus תופס בעיות

עם Sonnet בלבד (המערכת הישנה, 44 פרקים ראשונים) — כל פרק עבר. Opus מצא תרגילים לא בני-ביצוע, הנחות סמויות, סקשנים ריקים. לקח: הערכה דורשת מודל חזק יותר מהכותב. Value-audit ו-learner-sim חייבים להיות Opus.

#3: סטטיסטיקות ממוצאות

"72%", "89%", "340%". AI מייצר מספרים לא מבוססים. בקורס Meta: 170 claims נבדקו, 0 בדיוק — אבל רק אחרי grep + web verification. פתרון: fact-checker מוציא claims עם regex, לא קורא prose.

#4: ממשקים משתנים

Meta שינו UI, ביטלו AEM 8-event, שינו שמות של כלים. לקח: סמנו כל UI section כ-freshness-sensitive במניפסט. ב-172 פרקים מצאנו ~340 סקשנים רגישים.

#5: תרגילים שמניחים לקוחות

למתחיל אין לקוחות, אין דאטה, אין חשבון. פתרון: "אם יש — השתמשו. אם לא — הנה דוגמה + נתוני דמו."

#6: מונחים לפני הגדרה

לקח: Glossary בתחילת הפרק + הסבר inline בשימוש ראשון. Learner-sim (Opus) תופס את זה בקטגוריית hidden_term.

#7: "הבנה" לא תוצר

אם אי אפשר לצלם מסך — לא תוצר. "קמפיין פעיל" = כן. "הבנה של קמפיינים" = לא. מדד: ב-172 פרקים — 680+ תוצרים, כולם screenshottable.

#8: פרטים ישראליים שגויים

  • מע"מ 18% (לא 17%! AI חוזר על 17% כמעט תמיד)
  • תיקון 13 לחוק התקשורת — opt-in חובה
  • תמחור בש"ח, לא דולר
  • WhatsApp = ערוץ ראשי (99% חדירה, לא 97%)
  • RTL: חץ חזרה = → (לא ←)

#9: Framework "דמה"

"תלוי" = לא framework. צריך תנאים → תוצאות ברורות. מבחן: אם מישהו קורא את ה-framework ועדיין לא יודע מה לעשות — זה framework דמה.

#10: סיכומים יבשים

רשימה ≠ סיכום. צריך נרטיב שמחבר ובונה ציפייה לפרק הבא. + "Just One Thing" — הפעולה האחת עם ה-leverage הגבוה ביותר.

#11: אל תתזמרו ידנית — pipeline-orchestrator עושה הכל

ב-44 הפרקים הראשונים ניהלנו את השרשרת ידנית. טעות. ה-pipeline-orchestrator מנהל את כל השרשרת אוטונומית: manifest → 4 evaluators → publish gate → repair loop → re-eval → publish. חוסך 50% זמן ומונע שכחת שלבים.

#12: CF Pages — --branch main חובה

עם account token (לא user token) ב-Cloudflare Pages: --branch main חובה ב-deploy. בלי זה — Deploy עולה כ-preview branch ולא כ-production. לקח: תמיד npx wrangler pages deploy dist/ --project-name X --branch main.

5
מערכת ההערכה המלאה — 7 שלבים + Repair Loop
Metadata-first: 500 מילים דגימה, 16 סוכנים, Sonnet vs Opus, שרשרת קורס
עיקרון Metadata-First

אף evaluator לא קורא את ה-HTML המלא. הפרק הוא 7,000-10,000 מילים (~20K tokens). המערכת משתמשת ב-~2,000 tokens בלבד לכל 5 ההערכות — 10% מהעלות, 95% כיסוי.

חלוקת מודלים — Sonnet vs Opus

מודלתפקידלמה
Sonnetstructure-reviewer, fact-checker, manifest-extractor, publish-gate, course-graphעבודת מטאדאטה מכנית — קריאת JSON, ספירות, סף pass/fail
Opusvalue-audit, learner-sim, repair-planner, content-writer, content-rewriter, course-report, topic-researcher, chapter-planner, syllabus-creator, pipeline-orchestratorשיפוט, כתיבה, ניתוח מעמיק — דורש הבנה

שלב 1: Structure Review (/30) — Sonnet, manifest only

קורא רק את chapter.manifest.json (~200 tokens). לא קורא HTML.

אלמנטמינימוםניקוד
מילים7,5005
Do-Now73
Exercises33
Frameworks23
Warnings22
Checklist102
Check Yourself52
Glossary+Thread+Tags+Routine+JOTexists10

סף: 85% (25.5/30)

שלב 2: Fact-Check — Sonnet, grep extraction

לא קורא prose. מוציא claims עם grep patterns: מספרים, אחוזים, שמות כלים, תאריכים. מאמת כל claim עם web search.

חומרהדוגמהפעולה
HIGHמע"מ 17% (נכון: 18%), AEM 8-event (בוטל)תיקון חובה
MEDלא מדויק, לא מטעהqualifying language
LOWהערכה כלליתסימון כהערכה

שלב 3: Value Audit — Opus, דגימה מרובדת של 500 מילים

זה הלב של המערכת. ה-evaluator קורא בדיוק 500 מילים — 10 דגימות של 50 מילים כל אחת, מ-5 שכבות שונות:

שכבהמהדגימותמאיפהלמה
1. Conceptסקשנים תיאורטיים3מ-אמצע הסקשן, לא מהפתיחהפתיחות תמיד טובות — האמצע חושף את האיכות האמיתית
2. Actionתרגילים2תרגיל ראשון + תרגיל אחרוןבודק איכות התחלה + סוף
3. DecisionFramework / decision box1framework אחדבודק branching אמיתי, לא "תלוי"
4. ClosingChecklist + Summary2תמיד — האזור החלשסיכומים וצ'קליסטים הם תמיד הנקודה החלשה
5. Systematicמרווחים שווים2מפוזר על פני שאר הפרקתופס בעיות שהשכבות האחרות פספסו

איך: המניפסט מכיל line numbers לכל סקשן. ה-evaluator קורא עם offset+limit (מקסימום 50 שורות לדגימה). אף פעם לא קורא את הפרק המלא.

כיסוי: ~95% (לעומת ~85% עם דגימה מהפתיחה בלבד), באותה עלות tokens.

5 ממדי הערכה (סף: 7/10 לכל ממד)

Actionability
האם הפעולות מפורשות? הצעדים קונקרטיים?
7/10
Depth (DOK)
לא recall בלבד — צריך application + judgment
2-3
Alignment
יעדים = תוכן = תרגילים = צ'קליסט
7/10
Content Health
צפיפות vs filler, עדכניות, איזון תיאוריה/פרקטיקה
7/10
Beginner Readiness
הנחות סמויות? קפיצות קוגניטיביות? setup gaps?
7/10

שלב 4: Learner Simulation — Opus, תרגיל ראשון + אחרון

לא קורא את הפרק המלא. קורא רק:

  1. תרגיל ראשון — grep ל-class="exercise", קריאת הבלוק
  2. תרגיל אחרון — grep לoccurrence האחרון
  3. מניפסט — למבנה הפרק

מקסימום 2,000 מילים. מדמה מתחיל מוחלט שמנסה לבצע. קטגוריות חיכוך:

  • hidden_term — מונח ללא הגדרה
  • missing_setup_step — שלב התקנה חסר
  • vague_instruction — הוראה מעורפלת
  • exercise_execution_risk — תרגיל שיכשל בפועל
  • prerequisite_leak — הנחת ידע שלא נלמד
  • cognitive_jump — קפיצה גדולה מדי

שלב 5: Publish Gate — Sonnet, JSON reports only

החלטהתנאי
PUBLISHהכל עבר — structure 25.5+/30, כל ממד 7+, 0 HIGH fact errors, exercises executable
REPAIR_FIRSTניתן לתיקון ממוקד (word count, specific sections)
BLOCKכתיבה מחדש — בעיה מבנית/ערכית חמורה

שלב 6: Repair Loop (אם REPAIR_FIRST)

שרשרת אוטומטית שה-pipeline-orchestrator מנהל:

  1. repair-planner (Opus) — קורא את כל ה-eval reports, יוצר chapter.repair-plan.json עם תיקונים ממוקדים
  2. content-rewriter (Opus) — מבצע תיקונים עם grep + Edit (לא כתיבה מחדש)
  3. refresh_manifest.py — מעדכן את המניפסט אחרי כל שינוי
  4. Re-eval — מריץ רק את ה-evaluators המושפעים (לא את כולם)
  5. Publish Gate — בודק שוב

מקסימום 3 סיבובים. אחרי 3 — escalation ל-BLOCK.

שלב 7: Course-Level Audit

אחרי שכל הפרקים עברו — שרשרת הערכה ברמת הקורס:

  1. Registryrefresh_registry.py סורק את כל הפרקים ובונה course.registry.json
  2. Course Graph — course-graph agent (Sonnet) בודק סדר מושגים ודרישות קדם מ-manifests בלבד
  3. Course Report — course-report-aggregator (Opus) מסכם דפוסים על פני הקורס: actionability ממוצע, פערים, חזרות
  4. Course Publish Gate — publish-gate (course scope) מחליט publish/repair/block

דוגמה מ-Meta (20 פרקים): Actionability 8.7/10, Beginner readiness 8.0/10, Coherence 9/10. דוגמה מ-WhatsApp (12 פרקים): 170 claims, 0 inaccurate, Coherence 92/100.

Token Efficiency

Evaluatorמה קוראTokens
structure-reviewermanifest JSON בלבד~200
fact-checkergrep output (מספרים/claims)~100
value-audit500 מילים — 10 דגימות מרובדות~700
learner-simulation2 בלוקי תרגיל~400
publish-gate4 JSON reports~600
סה"כ לפרק~2,000

קריאת הפרק המלא = 15,000-25,000 tokens. המערכת חוסכת 90%.

6
הפרומפטים עצמם — העתיקו והדביקו
שלושה mega-prompts: תכנון קורס, כתיבת פרק, הערכת פרק

Prompt A: תכנון קורס שלם + Pipeline Launch

העתיקו ל-AI כדי ליצור syllabus מלא עם הוראות הפעלת pipeline.

Prompt A — Course Planning + Pipeline
You are an expert curriculum designer creating a full course plan.
This prompt is based on nVision Academy's system — 172 chapters across 13 courses, 1M+ words, 16 AI agents.

## Your Task
Design a complete course syllabus for: [COURSE NAME]
Target audience: [AUDIENCE]
Language: Hebrew with English technical terms (explain every English term on first use)
Market: Israeli (ILS currency, VAT 18%, WhatsApp 99% penetration, Amendment 13 spam law)

## Course Architecture

### Phase Structure
1. **Foundation (ch 1-3)**: Overview, setup, basic tools. Heavy glossary, simple exercises.
2. **Skill-Building (ch 4 to N-2)**: Core skills. Full depth, all elements at maximum.
3. **Integration (last 2-3)**: Strategy, synthesis, action plans. Combined exercises.

### Chapter Count
- Single platform: 12-15 chapters, 90K-120K words
- Major platform: 20-25 chapters, 150K-200K words
- Cross-platform: 12-18 chapters, 90K-140K words

### Project Thread
The entire course builds ONE continuous project. Each chapter adds a layer.
Not a collection of articles — a journey from zero to capable.

## Per-Chapter Requirements
For each chapter provide:
1. **Title** (Hebrew)
2. **Profile**: Foundation / Skill-Building / Integration
3. **Learning Objectives** (3-5, ACTION VERBS only — never "understand" or "learn about")
4. **Prerequisites** (prior chapters, tools, accounts, time estimate)
5. **Deliverables** (5-8 concrete, screenshottable outputs)
6. **Subtopics** (10-15, each 500-700 words worth)
7. **Planned Elements**: 7-10 Do-Now, 3-4 Exercises (scaffolded), 2-3 Frameworks (real if/then), 2-4 Warnings, Glossary terms
8. **3 SVG Diagrams**: Flow/architecture, visual comparison, action map

## Pipeline-Orchestrator Launch Instructions
After the syllabus is ready, the full chain runs autonomously:

### Per Chapter (pipeline-orchestrator manages all):
syllabus entry → topic-researcher → chapter-planner → content-writer + manifest → 4 evaluators (parallel) → publish-gate → repair loop (if needed) → re-eval → publish

### Per Course (after all chapters pass):
registry → course-graph → course-report → course-publish-gate

### Model Assignments:
- **Sonnet** (mechanical): structure-reviewer, fact-checker, manifest-extractor, publish-gate, course-graph
- **Opus** (judgment): value-audit, learner-sim, repair-planner, content-writer, content-rewriter, course-report, topic-researcher, chapter-planner, pipeline-orchestrator

### Key Rules:
- Each stage produces an artifact; next stage reads that artifact, not the source
- No evaluator reads full chapter HTML — manifest + 500-word samples only
- Maximum 3 repair cycles, then block
- After every HTML edit: refresh manifest. After every manifest: refresh registry.
- Deploy to CF Pages with --branch main (required for account tokens)

## Quality Checks
- [ ] Chapters flow logically, each builds on previous
- [ ] AI integrated throughout (not isolated in one chapter)
- [ ] Israeli market in 5+ chapters (Hebrew, ILS, WhatsApp, Amendment 13, VAT 18%)
- [ ] 90-day or 12-month action plan as final chapter
- [ ] No pure-theory chapters — every chapter has 7+ Do-Now, 3+ exercises
- [ ] No duplicate intro chapters
- [ ] Project thread clear end-to-end
- [ ] 3 SVG diagrams planned per chapter

Now create the full syllabus.

Prompt B: כתיבת פרק בודד (Gold Standard)

העתיקו ל-AI כדי לכתוב פרק בודד עם כל 15 האלמנטים + SVG.

Prompt B — Chapter Writing (Gold Standard)
You are an expert educational content writer creating a chapter for a professional course.
Based on nVision Academy's Gold Standard — 172 chapters, 1M+ words, 16 AI agents.

## Chapter Details
- **Course**: [COURSE NAME]
- **Chapter**: [N] of [TOTAL]
- **Title**: [TITLE]
- **Profile**: [Foundation / Skill-Building / Integration]
- **Previous chapter**: [What reader built/learned]
- **Next chapter**: [What comes next]
- **Project thread**: [Continuous project across course]
- **Audience**: [e.g., "Israeli small business owners, absolute beginners"]

## Syllabus Entry
[PASTE SYLLABUS ENTRY WITH SUBTOPICS, OBJECTIVES, PREREQUISITES, DELIVERABLES]

## CRITICAL RULES

### Rule 1: Word Count 7,500-10,000
First drafts ALWAYS come in at 4,500-5,500. You MUST write 7,500+ words of real substance.
This is not padding — it means deeper examples, more steps, richer exercises.

### Rule 2: Every Explanation Leads to Action
No theory without a nearby Do-Now or exercise. Ratio: 60% practical, 40% theory.

### Rule 3: Beginner Safety
- Define every term: "CTR (Click-Through Rate — שיעור ההקלקה)"
- Click-paths: "Settings → Dashboard → Controls"
- Never assume existing data — always provide alternatives + demo data
- Describe success: "אם הכל עבד, תראו..."
- Exercise 1 MUST work for absolute beginner with zero existing data

### Rule 4: Statistics Must Be Sourced
NEVER invent numbers. Source: "(DataReportal, 2026)". Unverifiable = qualifying language: "לפי הערכות בתעשייה".

### Rule 5: Israeli Market
Currency: ILS (ש"ח). Examples: local businesses. VAT: 18% (NOT 17%). WhatsApp: 99% penetration.
Amendment 13 (spam law): opt-in required, fines up to 1,000 ILS per message. Mobile-first (98%).
Case studies: mark as "דוגמאות מייצגות" unless verified real cases.

### Rule 6: Real Frameworks
"It depends" is NOT a framework. Use clear conditions → outcomes. Test: if someone reads it and still doesn't know what to do, it's a fake framework.

### Rule 7: 3 SVG Diagrams (Inline)
Every chapter includes 3 inline SVG diagrams:
1. **Flow/Architecture** — main process of the chapter
2. **Visual Comparison** — primary framework in graphic form
3. **Action Map** — practical steps visualization
Style: bg #1a1c2a, text #e4e5ea, accents #6c5ce7 #00b894 #f5a623, RTL, Heebo font.
Max 200 lines per SVG. Inline in HTML, not external files.

## THE 15 REQUIRED ELEMENTS — Gold Standard Checklist

1. **.learning-objectives** — 3-5 measurable, action verbs (never "understand")
2. **.prerequisites** — prior chapters, tools, accounts, time estimate
3. **.deliverables** — 5-8 concrete, screenshottable outputs
4. **.project-thread** — previous → current → next chapter
5. **.glossary** — bilingual table (Hebrew + English), all new terms, BEFORE first use
6. **.section-tags** — time + difficulty + cost on every H2
7. **.do-now** — MIN 7 (target 10), single action, under 5 min, time badge
8. **.exercise** — MIN 3 (target 4), scaffolded, steps + expected output + time. Exercise 1 = beginner-safe
9. **.framework** — MIN 2 (target 3), real if/then branching with clear conditions → outcomes
10. **.warning** — MIN 2 (target 4), "טעות נפוצה:" + what/why/instead. Placed near relevant concept
11. **.work-routine** — daily/weekly/monthly with time estimates
12. **.chapter-summary** — narrative bridge to next chapter (NOT a list) + Just One Thing
13. **.checklist** — 10-15 action items only (never "understood X")
14. **.check-yourself** — exactly 5 why/how questions (no full-answer hints)
15. **Just One Thing** — highest-leverage single action, inside summary

## HTML Technical
- lang="he" dir="rtl", Heebo font, <link rel="stylesheet" href="../style.css">
- Each callout: <span class="callout-title">[title]</span>
- Time badge: <span class="time-badge">X דקות</span>
- RTL back arrow: &#8594; (NOT &#8592;)
- SVG diagrams inline in <div class="svg-diagram">

## Profile Behavior
- **Foundation (ch 1-3)**: Heavy glossary, simple exercises, "where to start" frameworks
- **Skill-Building (ch 4 to N-2)**: Balanced, standalone deliverables, optimization frameworks
- **Integration (last 2-3)**: Combined skills, cumulative routine, strategy frameworks

## Self-Check Before Submitting
- [ ] 7,500+ words (if under, expand with real substance — not filler)
- [ ] 7+ Do-Now, 3+ Exercises, 2+ Frameworks, 2+ Warnings
- [ ] 5 Check Yourself, 10-15 Checklist items
- [ ] All 15 elements present with correct CSS classes
- [ ] 3 SVG diagrams inline (flow, comparison, action map)
- [ ] Stats sourced or qualified, Exercise 1 beginner-safe
- [ ] All terms defined before first use (glossary + inline)
- [ ] ILS currency, VAT 18%, Israeli examples, WhatsApp referenced
- [ ] Narrative summary (not list) with Just One Thing

Now write the complete chapter.

Prompt C: הערכת פרק (Full Evaluation + Repair Loop)

לביקורת על פרק שנכתב — כולל שיטת הדגימה המלאה ולולאת תיקון.

Prompt C — Full Evaluation + Repair
You are a strict educational content evaluator using the nVision Academy evaluation system.
172 chapters evaluated, 1M+ words, 16 AI agents, 7-stage pipeline.

## Chapter to Evaluate
[PASTE CHAPTER OR PROVIDE FILE PATH]

## CRITICAL: DO NOT Read the Full Chapter
Use the metadata-first method below. Total reading: ~500 words for value audit, ~2,000 words for learner sim.

---

## Stage 1: Structure Review (/30) — Count elements
- Words >= 7,500? (5pts) | Do-Now >= 7? (3pts) | Exercises >= 3? (3pts)
- Frameworks >= 2? (3pts) | Warnings >= 2? (2pts) | Checklist >= 10? (2pts)
- Check Yourself = 5? (2pts) | Glossary? (2pts) | Project Thread? (2pts)
- Section Tags? (2pts) | Work Routine? (2pts) | Just One Thing? (2pts)
- **Pass threshold: 25.5/30 (85%)**

## Stage 2: Fact-Check — Extract claims with grep patterns
Find EVERY number, percentage, tool name, date, legal reference.
Do NOT read prose — extract claims via patterns.
Verify each against web sources.
- **HIGH**: Wrong number affecting decisions (e.g., VAT 17% → must be 18%) — fix required
- **MED**: Inaccurate but not misleading — add qualifying language
- **LOW**: General estimate — mark as estimate

## Stage 3: Value Audit — 500-Word Stratified Sampling
Read EXACTLY 500 words using 10 targeted samples of 50 words each:

| Layer | What | Samples | Where | Why |
|-------|------|---------|-------|-----|
| 1. Concept | Theory sections | 3 | From MIDDLE of section, not opening | Openings always good — middles reveal quality |
| 2. Action | Exercises | 2 | First exercise + last exercise | Start quality + end quality |
| 3. Decision | Framework box | 1 | One framework/decision | Check real branching, not fake |
| 4. Closing | Checklist + summary | 2 | Always sample these | Always weakest area |
| 5. Systematic | Equal intervals | 2 | Spread across remainder | Catch issues in unlayered sections |

Score on 5 dimensions (minimum 7/10 each):
a) **Actionability** — explicit actions, concrete steps, visible outputs
b) **Depth (DOK 2-3)** — application + judgment, not just recall
c) **Alignment** — objectives = content = exercises = checklist
d) **Content Health** — density vs filler, currency, theory/practice balance
e) **Beginner Readiness** — hidden assumptions, setup gaps, term definitions

## Stage 4: Learner Simulation — First + Last Exercise Only
Simulate an absolute beginner attempting:
1. **First exercise** — grep for class="exercise", read that block
2. **Last exercise** — grep for last occurrence, read that block
Max 2,000 words total. Ask:
- Would they complete Exercise 1 without outside help?
- What terms are used before defined?
- What setup is assumed but not taught?
- What would fail in real execution?
Friction categories: hidden_term, missing_setup_step, vague_instruction, exercise_execution_risk, prerequisite_leak, cognitive_jump

## Stage 5: Publish Gate
Based on Stages 1-4:
- **PUBLISH**: Structure 25.5+/30, all value dimensions 7+, 0 HIGH fact errors, exercises executable
- **REPAIR_FIRST**: Fixable issues (word count, specific weak sections, fact corrections)
- **BLOCK**: Severe structural/value problem requiring full rewrite

## Stage 6: Repair Loop (if REPAIR_FIRST)
1. Create repair plan: list each issue + exact location + specific fix needed
2. Apply targeted fixes (grep + edit, not full rewrite)
3. Re-count elements (refresh structure check)
4. Re-evaluate ONLY affected dimensions
5. Re-run publish gate
6. Maximum 3 repair cycles — then BLOCK

## Stage 7: Course-Level (after all chapters pass)
1. Build registry: list all chapters + their publish status
2. Course graph: check concept order + prerequisites from manifests only
3. Course report: aggregate patterns — avg actionability, coherence, gaps
4. Course publish gate: all chapters PUBLISH + no cross-chapter issues

---

## Output Format
For each stage, output structured findings.
Final verdict: PUBLISH / REPAIR_FIRST (with specific fixes) / BLOCK (with reasons)

## Rules
- Be strict. Penalize generic advice and unusable exercises.
- Penalize impressive but unexecutable explanations.
- If Exercise 1 is not beginner-safe, that alone can trigger REPAIR_FIRST.
- Israeli specifics: VAT must be 18%, WhatsApp 99%, currency ILS.
- Check for 3 SVG diagrams (inline, dark theme colors).
- Prefer real learner usefulness over polished formatting.
איך להשתמש ב-3 הפרומפטים ביחד

1. Prompt A — תכננו syllabus (כולל הוראות pipeline). 2. Prompt B — כתבו כל פרק (הדביקו syllabus entry + Gold Standard checklist + SVG). 3. Prompt C — העריכו עם 500-word sampling + first/last exercise sim. REPAIR? תקנו ממוקד (לא כתיבה מחדש) + העריכו שוב (עד 3 סיבובים). Pipeline-orchestrator עושה 2-3 אוטומטית.