מבנה הפאזות — מתחילים ומסיימים נכון
קורס טוב הוא לא אוסף של פרקים על אותו נושא. הוא מסע מובנה שלוקח מישהו מנקודת אפס לנקודה שבה הוא יכול לפעול בעצמו. המפתח הוא חלוקה לפאזות:
| פאזה | פרקים | פרופיל | מאפיינים |
|---|---|---|---|
| Foundation | 1-3 | בסיס | מילון מונחים כבד, דרישות קדם מינימליות, תרגילים פשוטים, פריימוורקים של "מאיפה מתחילים" |
| Skill-Building | 4 עד N-2 | בניית מיומנויות | מיקס מאוזן, דרישות קדם מפרקים קודמים, תרגילים שמייצרים תוצרים עצמאיים, פריימוורקים של אופטימיזציה |
| Integration | N-2 עד N | אינטגרציה | דרישות קדם מרובות, תרגילים שמשלבים מיומנויות, שגרת עבודה מצטברת, פריימוורקים אסטרטגיים |
כמה פרקים צריך?
| סוג קורס | פרקים | יעד מילים | דוגמה |
|---|---|---|---|
| פלטפורמה בודדת | 12-15 | 90K-120K | LinkedIn, TikTok, WhatsApp |
| פלטפורמה מרכזית | 20-25 | 150K-200K | Google, Meta |
| נושא חוצה-פלטפורמות | 12-18 | 90K-140K | AI Marketing, Freelancer |
חוט אדום — הפרויקט הרציף
כל פרק בקורס מוסיף שכבה לפרויקט אחד מתמשך. הקורא לא "לומד על נושאים" — הוא בונה משהו אמיתי פרק אחרי פרק. לדוגמה:
- קורס Meta (20 פרקים): נוכחות שיווקית מלאה — מדף פייסבוק עד דשבורד מעקב
- קורס Google (25 פרקים): אתר SEO + קמפיין Ads + דשבורד Analytics
- קורס Freelancer (12 פרקים): מרישום עסק ועד תוכנית 12 חודשים
- קורס WhatsApp (12 פרקים): מפרופיל עסקי ועד אסטרטגיית ROI מלאה
כל פרק עומד בפני עצמו — אפשר לקפוץ ישירות. אבל מי שעובר בסדר מקבל תוצאה שלמה. הפרויקט הרציף הופך אוסף כתבות לקורס אמיתי.
Pipeline Orchestrator — שרשרת ייצור אוטונומית
כל השרשרת רצה דרך pipeline-orchestrator — סוכן Opus שמנהל את כל התהליך. אל תתזמרו ידנית. תנו לו לרוץ:
כל שלב מייצר ארטיפקט (JSON/HTML). השלב הבא קורא את הארטיפקט, לא את הקוד המקורי. אף פעם "תעשה הכל בפרומפט אחד".
שרשרת יצירת פרק (7 שלבים)
| שלב | סוכן | קלט | פלט |
|---|---|---|---|
| 1. מחקר | topic-researcher (Opus) | syllabus entry | chapter.research.json |
| 2. תכנון | chapter-planner (Opus) | research.json + syllabus | chapter.plan.json |
| 3. כתיבה | content-writer (Opus) | plan.json + Gold Standard template | chapter.html + manifest.json |
| 4. הערכה | 4 evaluators (parallel) | manifest + samples | 4 JSON reports |
| 5. Publish Gate | publish-gate (Sonnet) | 4 JSON reports | publish-decision.json |
| 6. תיקון | repair-planner + rewriter (Opus) | eval reports | targeted fixes |
| 7. Re-eval | affected evaluators only | refreshed manifest | updated decision |
מקסימום 3 סיבובי תיקון. אחרי 3 — block + כתיבה מחדש.
שרשרת הערכת קורס (course-level)
| שלב | סוכן | פלט |
|---|---|---|
| 1. Registry | refresh_registry.py | course.registry.json |
| 2. Graph | course-graph (Sonnet) | course.graph.json |
| 3. Report | course-report-aggregator (Opus) | course.audit.json + .md |
| 4. Publish Gate | publish-gate (course scope) | course.publish-decision.json |
שרשרת דרישות קדם
- פרקים קודמים — אילו פרקים צריך לקרוא קודם
- כלים נדרשים — אילו חשבונות/כלים צריך
- מושגים קודמים — מה הקורא אמור לדעת
- זמן משוער — כמה זמן לוקח (קריאה + יישום)
מה הופך קורס ל"מושלם"?
- כל פרק מייצר תוצר מוחשי — "יהיה לך X" ולא "תבין X"
- פרופיל מותאם למיקום (Foundation / Skill / Integration)
- שגרת עבודה מעשית — יומי, שבועי, חודשי
- תוכנית 90 יום / 12 חודשים בפרק האחרון
- AI ואוטומציה לאורך כל הקורס
- דוגמאות מהשוק הישראלי בכל פרק רלוונטי
- 3 דיאגרמות SVG לפרק (inline, צבעי dark theme)
כל פרק חייב לכלול את כל 15 האלמנטים. בלי חריגים. חוסר באלמנט = כישלון ב-Structure Review.
ספירת מילים: 7,500-10,000
כל 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: מפת פעולה — הצעדים הפרקטיים לביצוע
רקע: #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: חץ חזרה =
→
#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.
אף evaluator לא קורא את ה-HTML המלא. הפרק הוא 7,000-10,000 מילים (~20K tokens). המערכת משתמשת ב-~2,000 tokens בלבד לכל 5 ההערכות — 10% מהעלות, 95% כיסוי.
חלוקת מודלים — Sonnet vs Opus
| מודל | תפקיד | למה |
|---|---|---|
| Sonnet | structure-reviewer, fact-checker, manifest-extractor, publish-gate, course-graph | עבודת מטאדאטה מכנית — קריאת JSON, ספירות, סף pass/fail |
| Opus | value-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,500 | 5 |
| Do-Now | 7 | 3 |
| Exercises | 3 | 3 |
| Frameworks | 2 | 3 |
| Warnings | 2 | 2 |
| Checklist | 10 | 2 |
| Check Yourself | 5 | 2 |
| Glossary+Thread+Tags+Routine+JOT | exists | 10 |
סף: 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. Decision | Framework / decision box | 1 | framework אחד | בודק branching אמיתי, לא "תלוי" |
| 4. Closing | Checklist + Summary | 2 | תמיד — האזור החלש | סיכומים וצ'קליסטים הם תמיד הנקודה החלשה |
| 5. Systematic | מרווחים שווים | 2 | מפוזר על פני שאר הפרק | תופס בעיות שהשכבות האחרות פספסו |
איך: המניפסט מכיל line numbers לכל סקשן. ה-evaluator קורא עם offset+limit (מקסימום 50 שורות לדגימה). אף פעם לא קורא את הפרק המלא.
כיסוי: ~95% (לעומת ~85% עם דגימה מהפתיחה בלבד), באותה עלות tokens.
5 ממדי הערכה (סף: 7/10 לכל ממד)
שלב 4: Learner Simulation — Opus, תרגיל ראשון + אחרון
לא קורא את הפרק המלא. קורא רק:
- תרגיל ראשון — grep ל-
class="exercise", קריאת הבלוק - תרגיל אחרון — grep לoccurrence האחרון
- מניפסט — למבנה הפרק
מקסימום 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 מנהל:
- repair-planner (Opus) — קורא את כל ה-eval reports, יוצר
chapter.repair-plan.jsonעם תיקונים ממוקדים - content-rewriter (Opus) — מבצע תיקונים עם grep + Edit (לא כתיבה מחדש)
- refresh_manifest.py — מעדכן את המניפסט אחרי כל שינוי
- Re-eval — מריץ רק את ה-evaluators המושפעים (לא את כולם)
- Publish Gate — בודק שוב
מקסימום 3 סיבובים. אחרי 3 — escalation ל-BLOCK.
שלב 7: Course-Level Audit
אחרי שכל הפרקים עברו — שרשרת הערכה ברמת הקורס:
- Registry —
refresh_registry.pyסורק את כל הפרקים ובונהcourse.registry.json - Course Graph — course-graph agent (Sonnet) בודק סדר מושגים ודרישות קדם מ-manifests בלבד
- Course Report — course-report-aggregator (Opus) מסכם דפוסים על פני הקורס: actionability ממוצע, פערים, חזרות
- 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-reviewer | manifest JSON בלבד | ~200 |
| fact-checker | grep output (מספרים/claims) | ~100 |
| value-audit | 500 מילים — 10 דגימות מרובדות | ~700 |
| learner-simulation | 2 בלוקי תרגיל | ~400 |
| publish-gate | 4 JSON reports | ~600 |
| סה"כ לפרק | ~2,000 | |
קריאת הפרק המלא = 15,000-25,000 tokens. המערכת חוסכת 90%.
Prompt A: תכנון קורס שלם + Pipeline Launch
העתיקו ל-AI כדי ליצור syllabus מלא עם הוראות הפעלת 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.
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: → (NOT ←) - 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)
לביקורת על פרק שנכתב — כולל שיטת הדגימה המלאה ולולאת תיקון.
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.
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 אוטומטית.