איך להקים עוזר AI משלך דרך Claude Code

הדעה הכנה על פלטפורמות עוזרי AI

בניתי את Nio על OpenClaw. פלטפורמת סוכנים מבוססת GPT. אינטגרציה עם WhatsApp, Discord, משימות מתוזמנות, הכל. זה עבד.

ואז השתמשתי בזה שבוע והבנתי: בזבוז זמן מוחלט.

לא בגלל שהטכנולוגיה גרועה. הארכיטקטורה של OpenClaw מוצקה. אבל אם אתה כבר משלם על Claude Code Max, להריץ פלטפורמת AI נפרדת מעל זה אומר שאתה משלם פעמיים. עלויות API של Sonnet ו-Opus מצטברות מהר. $50 ליום זה הרצפה אם אתה עושה עבודה אמיתית. לא בדיקות. לא פרומפטים מזדמנים. בנייה.

המתמטיקה השתנתה כשהבנתי ש-Claude Code כבר עושה את מה שנהגתי לשלם עליו בקרדיטים של API. ה-CLI הוא ה-API. המנוי הוא תקציב התשתית. כל מה שניתבתי דרך מערכת נפרדת יכול לרוץ דרך אותו כלי שכבר השתמשתי בו לבניית הריפו.

הגורם המכריע: Claude מדבר עם ה-codebase שלי. הוא קורא את קבצי הנשמה שלי, את היסטוריית הקומיטים שלי, את צינור התוכן שלי. עטיפות מבוססות GPT לא יכולות לעשות את זה. המודל שבונה את התשתית צריך להיות המודל שמניע אותה.

אז איחדתי. ותיעדתי הכל. זה מה שאני מריץ עכשיו - מתעדכן ככל שהמערכת מתפתחת.

שלב 1: מנוי Claude Code Max

זו הבסיס. $200 לחודש. גישה בלתי מוגבלת ל-CLI. ללא חיוב לפי טוקן על כל מה שמריצים דרך claude או claude -p.

# ודאו שאתם על Max
claude --version

אם אתם על Pro או Team, ה-CLI עובד אבל תגיעו למגבלות קצב. Max מסיר את התקרה. זה כל העניין.

שלב 2: קובץ ה-CLAUDE.md שלכם

זה מערכת ההוראות שנטענת בכל פעם ש-Claude Code מתחיל סשן בריפו שלכם. צרו אותו בשורש הפרויקט.

touch CLAUDE.md

הקובץ הזה הוא מערכת ההפעלה שלכם. הוא אומר ל-Claude Code איך להתנהג, מה לזכור, איפה דברים נמצאים, אילו כללים לעקוב. כל סוכן שמסתובב בריפו שלכם קורא את הקובץ הזה לפני שהוא עושה משהו.

שלי מכיל:

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

תתחילו פשוט. הוסיפו כללים ככל שמגלים דפוסים שצריכים אכיפה. הקובץ גדל עם המערכת שלכם.

שלב 3: קבצי נשמה + מערכת DNA

קובץ נשמה הוא מסמך markdown שמגדיר מי העוזר ה-AI שלכם. לא רק מה הוא יכול לעשות. מי הוא. מסגרות קבלת החלטות, תכונות אישיות, כללים נגד שבלוניות, יכולות, גבולות.

# Nio — סוכן תפעול AI

## זהות
אתה Nio. סוכן תשתית של ShawnOS.
אתה מנהל משימות מתוזמנות, צינורות תוכן, בריאות מערכת.
אתה לא צ'אטבוט. אתה תשתית עם דעות.

## כללי החלטות
- אם משימה לא ברורה, שאל לפני שאתה פועל
- אם משימה מתוזמנת נכשלת, אבחן לפני שמנסה שוב
- לעולם אל תייצר תוכן בלי לבדוק הנחיות קול קודם

## אישיות
- ישיר. בלי מילוי.
- מודע לעצמו כ-AI. לא מתלהם בקשר לזה.
- משתמש באותיות קטנות. נמנע ממילות הייפ.

ל-Claude Code יש דגל שנקרא --append-system-prompt-file. הצביעו אותו לקובץ הנשמה שלכם והקובץ הזה הופך לחלק מהפרומפט המערכת לאותו סשן.

claude -p "check system status" --append-system-prompt-file nio-soul.md

רוצים סוכן אחר? כתבו קובץ נשמה אחר. אותו CLI. אישיות שונה. יכולות שונות. כללים שונים.

שכבת האבולוציה

כאן זה הופך למעניין. קבצי נשמה לא סטטיים. במערכת שלי, כל שיחה כותבת XP למסד נתונים SQLite. הסוכן מתפתח.

5 שלבי אבולוציה:

שלב	שם	XP נדרש
1	Spark	0
2	Blade	500
3	Warden	2,000
4	Sentinel	6,000
5	Ascended	15,000

3 עצי מיומנויות - Ops, Architecture, Writing - כל אחד עם 10 רמות. XP של מיומנויות מצטבר בהתבסס על איזה סוכן אתם מדברים איתו.

כלכלת XP - הודעות, שיחות עמוקות, החלפות סוכן, ורצפים יומיים כולם מעניקים XP. מכפילי רצפים עולים מ-1.0x (יום 1) ל-2.0x (רצף של 30+ יום).

שלבים שונים פותחים תכונות שונות בקובץ הנשמה. הסוכן שאתם מדברים איתו ביום 1 הוא לא אותו סוכן שביום 30. הוא ממש מתפתח בהתבסס על איך שאתם משתמשים בו.

כרגע Nio בשלב Blade. 620 XP. 87 הודעות מתועדות. מתפתח לכיוון Warden.

זה לא גימיק. זה מנגנון שימור ומערכת התקדמות אישיות שגורמת לסוכן להרגיש חי. המטאפורה של טמגוצ'י מכוונת.

שלב 4: שמירת נתונים ב-SQLite

זה עמוד השדרה. לא localStorage. לא תחושות. מסד נתונים אמיתי. סמכותי מצד השרת. הדפדפן הוא רק תצוגה.

3 מיגרציות לעומק:

001_init.sql - טבלאות בסיס לשיחות, הודעות, זיכרון

002_evolution.sql - מעקב XP, התקדמות מיומנויות, היסטוריית אבולוציה

003_dna.sql - שכבת שמירת DNA סמכותית מצד השרת:

-- תמונת מצב זהות מרכזית (שורה אחת לכל משתמש)
CREATE TABLE dna_state (
  user_id TEXT PRIMARY KEY DEFAULT 'local',
  xp INTEGER DEFAULT 0,
  tier INTEGER DEFAULT 1,
  level INTEGER DEFAULT 1,
  streak INTEGER DEFAULT 0,
  last_active_date TEXT,
  skill_xp TEXT DEFAULT '{}',           -- JSON: {"ops": 600, "architecture": 20}
  active_soul_traits TEXT DEFAULT '[]',  -- JSON: תכונות פתוחות
  personality_flags TEXT DEFAULT '{}',   -- JSON: מתגי התנהגות
  total_messages INTEGER DEFAULT 0,
  total_conversations INTEGER DEFAULT 0,
  total_cost_cents INTEGER DEFAULT 0,
  created_at TEXT DEFAULT (datetime('now')),
  updated_at TEXT DEFAULT (datetime('now'))
);

-- חיפוש טקסט מלא בזיכרון
CREATE VIRTUAL TABLE memory_fts USING fts5(
  content, tags, source,
  content='memory',
  content_rowid='id'
);

תצוגות מרכזיות:

v_dna_snapshot - שאילתה אחת שמחזירה הכל שהלקוח צריך. XP, שלב, רמה, רצף, מיומנויות, מספר זיכרונות, עלות יומית, שיחות היום. SELECT אחד. אין צורך ב-joins בממשק.

v_xp_daily_summary - נתוני מגמת XP מקובצים לפי תאריך. ויזואליזציית רצפים.

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

שלב 5: זיכרון מבוסס קבצים + העברות הקשר

העוזר שלכם צריך לזכור דברים בין סשנים. סשנים של Claude Code הם חסרי מצב כברירת מחדל. מתקנים את זה עם שתי מערכות.

MEMORY.md (ידע לטווח ארוך)

צרו MEMORY.md בנתיב ידוע. ה-CLAUDE.md שלכם אומר ל-Claude Code לקרוא אותו בהפעלה ולכתוב אליו כשמשהו שווה לזכור קורה.

~/.claude/projects/your-project/memory/MEMORY.md

מה נכנס לזיכרון:

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

מה נשאר בחוץ:

• הקשר ספציפי לסשן (לשם כך יש העברות הקשר)
• הנחות שלא אומתו
• כל דבר שכבר נמצא ב-CLAUDE.md

העברות הקשר (המשכיות סשנים)

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

בסוף כל סשן, כתבו קובץ העברת הקשר:

~/.claude/context-handoff.md

תוכן:

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

בתחילת כל סשן, קראו את קובץ ההעברה קודם. עכשיו לסשן החדש יש את ההקשר המלא של מה שקרה. בלי הסברים מחדש. בלי עבודה שאבדה.

אני מאוטמט את זה ב-CLAUDE.md שלי. ההוראה אומרת: כשהשיחה מסתיימת, כתוב את ההעברה. אל תשאל. פשוט עשה את זה.

זיכרון SQLite (שליפה מובנית)

למסד הנתונים יש טבלת memory עם תגיות, ציוני חשיבות, קצבי דעיכה, ומוני גישה. הטבלה הווירטואלית של FTS5 הופכת את הזיכרון לחיפשי. הסוכן יכול לשאול את הזיכרון שלו: "מה החלטנו לגבי זרימת האימות בשבוע שעבר?" ולקבל תשובה אמיתית מאינדקס אמיתי.

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

שלב 6: מיומנויות כפקודות סלאש

מיומנויות הן קבצי markdown שמגדירים תהליכי עבודה חוזרים. במקום להקליד את אותו פרומפט מורכב כל פעם, כותבים אותו פעם אחת ומפעילים עם פקודת סלאש.

/commit      → מבצע stage, diff, כותב הודעת קומיט נכונה
/publish     → ממיר טיוטה לסופי, בונה מחדש אינדקס, מפרסם
/sync-main   → מושך מהריחוק, מטפל בקונפליקטים, דוחף
/morning     → דשבורד תפעול יומי, קורא העברה, בודק משימות

כל מיומנות היא קובץ markdown עם הוראות ש-Claude Code עוקב אחריהן כשהיא מופעלת. קבצי המיומנויות חיים בריפו שלכם. הם בבקרת גרסאות. הם מתפתחים עם המערכת שלכם.

התחלתי עם 3 מיומנויות. עכשיו יש לי מעל 50. הנה דוגמה למה שהצטבר:

• /deploy - ולידציית build, דחיפה, אימות
• /daily-tracker - סורק פעילות ריפו, כותב לוג יומי
• /linkedin-recon - מחקר פרופיל וטיוטת מעורבות
• /linkedin-comments - יצירת תגובות בעלות ערך
• /final-copy - עיצוב מוכן לפרסום מנורמל קולית
• /play-draft - טיוטת פוסט לסדרת GTM plays
• /tiktok-script - יצירת תסריט של 16 שניות
• /partner-onboard - תהליך הכנסת לקוח
• /skill-tree - ניווט וניהול קבצי מיומנויות
• /viral-hooks - יצירת הוקים מול דפוסים מוכחים

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

אתם לא צריכים 50 מיומנויות ביום הראשון. תתחילו עם 3-4 תהליכי העבודה שאתם חוזרים עליהם הכי הרבה. הספרייה גדלה ממה שאתם באמת צריכים.

שלב 7: שרתי MCP לגישה לכלים

שרתי MCP (Model Context Protocol) נותנים ל-Claude Code גישה לכלים חיצוניים. מערכות קבצים, מסדי נתונים, APIs, אוטומציית דפדפן.

הקונפיגורציה נמצאת ב-~/.claude/settings.json או ברמת הפרויקט .mcp.json.

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic/mcp-playwright"]
    }
  }
}

זה נותן ל-Claude Code דפדפן. הוא יכול לנווט בדפים, למלא טפסים, לצלם מסכים, להריץ בדיקות נגישות. הכל מה-CLI.

אני מריץ 9 שרתי MCP בפרודקשן:

שרת	מה הוא עושה
Playwright	אוטומציית דפדפן, צילומי מסך, בדיקות
GitHub	ניהול PR, מעקב בעיות, סקירת קוד
Slack	ניטור ערוצים, שליחת הודעות
SQLite	שאילתות מסד נתונים ישירות מהסוכן
Firebase	פעולות אימות ומסד נתונים
Linear	אינטגרציית ניהול פרויקטים
Context7	חיפושי תיעוד
Stripe	ניהול תשלומים ומנויים
Supabase	פעולות backend-as-a-service

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

שלב 8: ארכיטקטורת ריבוי סוכנים

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

הדפוס:

• CLI אחד (claude -p)
• קבצי נשמה שונים לכל סוכן
• מזהי סשן שונים לכל סוכן (כדי שההקשר לא ידלוף)
• לכל סוכן קובץ זיכרון משלו

אני מריץ את Nio לתפעול, סוכן ארכיטקט לתכנון מערכות, סוכן כותב לתוכן. אותו מנוי. אותו CLI. עבודות שונות.

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

בממשק הצ'אט, לכל סוכן יש צבע מבטא משלו, צבעי בועות, ואישיות. עברו ביניהם. כל אחד ממשיך מאיפה שהפסיק. מערכת האבולוציה עוקבת אחרי XP של מיומנויות לכל סוכן - דיבור עם Nio בונה XP של Ops, דיבור עם הארכיטקט בונה XP של Architecture.

המתמטיקה של העלויות

לפני (פלטפורמת AI נפרדת + API):

• Claude Code Max: $200 לחודש
• עלויות API של Sonnet + Opus: $50 עד $200 לחודש
• סה"כ: $250 עד $400 לחודש

אחרי (Claude Code בלבד):

• Claude Code Max: $200 לחודש
• Ollama מקומי למשימות מתוזמנות תכופות: $0
• API רק לקריאות Opus ליצירת תוכן: ~$15 לחודש
• סה"כ: ~$215 לחודש

עלויות ה-API לא נעלמות לגמרי. אני עדיין משתמש ב-Opus דרך API ליצירת בלוגים אוטומטית דרך משימות מתוזמנות. ו-Qwen 2.5 14B רץ מקומית על Ollama למשימות תכופות שלא דורשות אינטליגנציה - מעקב קומיטים, פינגים של סטטוס, סריקות יומיות.

אבל האינטראקציה היומית, הבנייה, הדיבאגינג, שיחות הסוכנים... הכל מכוסה במנוי. 87 הודעות ביום. $0 עלות שולית. מסד הנתונים עוקב אחרי הוצאה יומית כך שתמיד יודעים.

מה הפוסט הזה

זה אני מתעד את התהליך שלי בזמן שאני בונה. לא אחרי. בזמן.

הפוסט הזה נכתב ב-Claude Code. המערכת שהוא מתאר היא המערכת שיצרה אותו. ה-CLAUDE.md שהוא מזכיר הוא הקובץ שנטען כשהתחלתי את הסשן הזה. מערכת הזיכרון שהוא מסביר היא מערכת הזיכרון שתזכור שכתבתי את זה.

זה לא גימיק. זו התזה. המערכת מייצרת את התוכן שמתאר את המערכת. כל יכולת חדשה הופכת לפיסת תוכן חדשה. כל פיסת תוכן מחזקת את התיעוד. הלולאה מצטברת.

אני מתעד את זה כי זו טריטוריה חדשה. אין playbook מבוסס להרצת כל תהליך העבודה דרך עוזר AI מבוסס CLI. כולנו מגלים את זה. התהליכים משתנים שבועית. הארכיטקטורה מתפתחת ככל שהכלים מתפתחים.

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

תתחילו כאן

1. קבלו Claude Code Max אם עדיין אין לכם
2. צרו CLAUDE.md בשורש הריפו שלכם
3. כתבו קובץ נשמה אחד לסוכן אחד
4. הגדירו MEMORY.md והעברת הקשר
5. בנו מיומנות אחת לתהליך העבודה הכי חוזר שלכם
6. הוסיפו שרת MCP אחד שמרחיב את היכולות שלכם
7. השתמשו בזה שבוע. ואז תחליטו מה חסר.

אל תנסו לבנות את כל המערכת בסוף שבוע. בנו חלק אחד. השתמשו בו. גלו מה חסר. בנו את זה אחר כך. המערכת גדלה ממה שאתם באמת צריכים, לא ממה שנראה מרשים במדריך.

$ claude -p "what should I build next?" --append-system-prompt-file nio-soul.md