Claude Code Mods: בונים מסנן סודות, חוסם rm -rf ושורת CI, ושולחים ל-Code Review

המודים של Claude Code (בשמם הרשמי Claude Code Mods) הם פונקציות קטנות ב-TypeScript או ב-JavaScript שרצות בתוך Claude Code עצמו, ויכולות לראות, לשנות או לעצור כל פרומפט, כל קריאה לכלי וכל פיקסל בממשק. חברת Anthropic השיקה אותם ב-1 באוקטובר 2026, ושבועיים אחר כך, ב-15 באוקטובר, הוציאה לזמינות מלאה גם את Code Review, השירות שבו כמה סוכנים סוקרים כל Pull Request ב-GitHub. ביחד, שני הפיצ'רים האלה סוגרים את הלולאה: המוד שומר עלינו בזמן שהסוכן עובד על המחשב שלנו, ו-Code Review שומר עלינו כשהקוד מגיע ל-PR.

במדריך הזה נבנה דבר אחד, מההתחלה ועד הסוף: פלאגין בשם team-guard לריפו של הצוות, עם שלושה מודים. מסנן סודות שמוחק מפתחות API לפני שהם מגיעים למודל, חוסם שעוצר rm -rf ושואל אותנו קודם, ושורת סטטוס שמראה מה מצב ה-CI של ה-PR שלנו. ובסוף, נשלח את ה-PR לסקירה של Claude.

מה זה בכלל מוד, ולמה זה שונה מכל מה שהיה

בואו נפרק את זה. עד היום היו לנו ב-Claude Code ארבע דרכים להתאים אותו לעצמנו: Skills (קבצי הוראות שהמודל קורא), שרתי MCP (תהליכים חיצוניים שנותנים לו כלים), Settings Hooks (סקריפט שרץ באירוע מסוים, כמו לפני הרצת כלי) ושורת סטטוס. כולם עובדים "מבחוץ": מריצים סקריפט, מוסיפים טקסט או מוסיפים כלי.

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

מבחינה טכנית, מוד הוא אוסף של event handlers (פונקציות שמופעלות כשקורה אירוע). Claude Code מפעיל אירוע בכל נקודה שבה הוא עומד לפעול: tool.call כשהסוכן עומד להריץ כלי, prompt.submit כששלחנו פרומפט, ui.render כשהוא עומד לצייר חלק מהממשק. כל handler מקבל שלושה דברים: את $, ה-API של המודים, את e, האירוע עצמו, ואת next, הפונקציה שמעבירה את האירוע הלאה. מה שהפונקציה שלנו עושה עם next קובע הכל: לקרוא לו כמו שהוא זה להסתכל, לקרוא לו עם עותק משונה זה לשכתב, ולא לקרוא לו בכלל זה לענות במקום Claude Code.

הנה ההשוואה, לפי טבלת ההשוואה בתיעוד הרשמי:

בקצרה: אם Settings Hook או Skill כבר עושים את העבודה, אין סיבה לכתוב מוד. מוד שווה את זה כשרוצים לצייר משהו בממשק, להוסיף פקודה שרצה מיד בלי תור של Claude, או לשכתב אירוע תוך כדי תנועה.

המכשול: קוד שרץ בתוכנו, בלי ארגז חול

לפני שנכתוב שורה אחת, צריך להגיד את הדבר הכי חשוב במדריך הזה. מודים לא רצים ב-sandbox (ארגז חול, סביבה מבודדת). מוד רץ עם ההרשאות שלנו: הוא יכול לקרוא ולכתוב כל קובץ, להריץ תוכניות, לשלוח בקשות לרשת ולקרוא משתני סביבה, כולל מפתחות API. התיעוד אומר את זה במפורש, ומוסיף שגם אם הפעלנו sandboxing, הוא מבודד את פקודות ה-Bash של Claude, לא תהליך שמוד מפעיל.

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

אז מה עושים? ארבעה הרגלים פשוטים:

• בודקים לפני שמתקינים. הפקודה claude plugin validate ./some-mod מדפיסה, בלי להריץ כלום, את שורת hooks: (לאילו אירועים המוד מאזין) ואת שורת calls: (באילו יכולות הוא משתמש). אם מוד של "ערכת צבעים" קורא ל-$.http.fetch ול-$.env.get, משהו לא בסדר.
• מתקינים רק ממקורות שאנחנו סומכים עליהם, בדיוק כמו כל קוד אחר.
• בודקים בעיות עם claude --safe-mode, שמכבה את כל המודים המותקנים לסשן אחד.
• בארגון, נותנים למנהלים לשלוט. במחשב עם managed settings, או אצל משתמש שמחובר עם מנוי Team או Enterprise, נטען לפני כל מוד של משתמש מוד מובנה בשם sec-default. הוא מונע ממוד של משתמש לאשר קריאה שחוק deny חוסם, ומגן על ה-hooks המנוהלים, על ה-system prompt ועל ההגדרות שהארגון קבע. מנהל יכול גם להפעיל את האופציה allowManagedModsOnly, ואז רק מודים של הארגון רצים.

חשוב להבין גם את הגבול של ההגנה הזאת: חוק deny על Read(.env) חוסם את הכלי Read של Claude, אבל לא קריאה של המוד עצמו ל-$.fs.read. ההגנה האמיתית היא לא לטעון מוד שאנחנו לא סומכים עליו.

בונים: שלושה מודים בפלאגין אחד

מסתבר שלא צריך Node.js, bundler או שלב build. ‏Claude Code טוען קבצי .js ו-.ts ישירות. כל מוד צריך שלושה קבצים: plugin.json (תעודת הזהות של הפלאגין), hooks/hooks.json (שמצביע על הקוד) וקובץ הקוד עצמו. גרסה מינימלית: Claude Code v2.1.287.

mkdir -p team-guard/.claude-plugin team-guard/hooks

# team-guard/.claude-plugin/plugin.json
cat > team-guard/.claude-plugin/plugin.json <<'EOF'
{
  "name": "team-guard",
  "version": "0.1.0",
  "description": "Redacts secrets, holds risky shell commands, shows CI status",
  "author": { "name": "Your Name" }
}
EOF

# team-guard/hooks/hooks.json - the "modules" key is what makes it a mod
cat > team-guard/hooks/hooks.json <<'EOF'
{
  "description": "The team-guard hooks module",
  "modules": ["./register.ts"]
}
EOF

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

// team-guard/hooks/register.ts
// Three mods in one hooks module. Patterns follow the official mods docs.

// Our own patterns: AWS access key id, GitHub classic token, Anthropic API key
const SECRET = /AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{36}|sk-ant-[A-Za-z0-9_-]{20,}/g
// From the docs: rm -r / rm -rf, git reset --hard, git push --force
const RISKY = /\brm\s+-rf?\b|\bgit\s+reset\s+--hard\b|\bgit\s+push\b.*--force/

// Our own helper (no $ inside): count checks by bucket
function summarize(stdout: string): string {
  try {
    const counts: Record<string, number> = {}
    for (const c of JSON.parse(stdout)) counts[c.bucket] = (counts[c.bucket] || 0) + 1
    return Object.entries(counts).map(([b, n]) => n + ' ' + b).join(' · ') || 'no checks'
  } catch {
    return 'no PR for this branch'
  }
}

// Mod 2: hold risky Bash commands until the user decides (docs pattern)
async function guard($, e, next) {
  if (!RISKY.test(e.command)) return next(e)
  let answer = 'Refuse'
  try {
    answer = await $.ui.ask('Run this command? ' + e.command, ['Run it', 'Refuse'])
  } catch {
    // Dismissed, or a claude -p run with nobody to ask
  }
  if (answer !== 'Run it') {
    return { deny: 'The user declined this command. Ask before trying a different approach.' }
  }
  return next(e)
}

export function register(on) {
  // Mod 1a: redact secrets from what we type, before Claude reads it
  on('prompt.submit', async ($, e, next) => {
    const clean = e.text.replace(SECRET, '[REDACTED]')
    if (clean === e.text) return next(e)
    $.ui.toast('team-guard removed a secret from your prompt')
    return next({ ...e, text: clean })
  })

  // Mod 2: the guard, failing closed if it throws or times out
  on('tool.call', { tool: 'Bash' }, guard).catch(async ($, e, next) => {
    if (next.called) return next(e)
    return { deny: 'The command guard failed, so this command was not run: ' + next.error.kind }
  })

  // Mod 1b: withhold tool output that contains a secret
  on('tool.call', { tool: ['Bash', 'Read'] }, async ($, e, next) => {
    const result = await next(e)
    if (!JSON.stringify(result).match(SECRET)) return result
    return { deny: 'Output withheld: it contained what looks like a secret. Refer to the env var name instead of printing its value.' }
  })

  // Mod 3: CI status line under the prompt, refreshed every minute
  on('session.start', async ($, e, next) => {
    $.clock.every(60_000, async () => {
      try {
        const r = await $.process.run(['gh', 'pr', 'checks', '--json', 'name,bucket'])
        $.ui.status('CI: ' + summarize(r.stdout))
      } catch {
        $.ui.status('CI: gh is not available')
      }
    })
    return next(e)
  })
}

בואו נעבור על שלושת החלקים.

1. מסנן הסודות. ה-hook על prompt.submit מקבל את הטקסט שהקלדנו ב-e.text. אם מצאנו בו משהו שנראה כמו מפתח של AWS, טוקן של GitHub או מפתח API של Anthropic, אנחנו מעבירים הלאה עותק עם [REDACTED] במקומו. המודל פשוט לא רואה את המקור. ה-hook השני מטפל בפלט של כלים: הוא מחכה לתוצאה עם await next(e), ואם יש בה משהו שנראה כמו סוד, מחזיר { deny }. לפי התיעוד, זה מסתיר את התוצאה מ-Claude, והוא קורא את ההסבר שלנו במקומה. שימו לב שזה מסתיר את כל הפלט ולא רק את הסוד. כדי למחוק רק את הסוד, צריך לבנות תוצאה בצורה המדויקת של כל כלי, וזו מופיעה בקבצי הטיפוסים ש-Claude Code כותב לתיקייה .claude-plugin/types/.

2. חוסם rm -rf. זה כמעט אחד לאחד הדוגמה מהתיעוד. ה-hook על tool.call מסונן ל-Bash בלבד. אם הפקודה מתאימה לתבנית מסוכנת, הוא עוצר את הקריאה ופותח שאלה עם $.ui.ask. הקטע המדליק הוא שהקריאה לכלי פשוט מחכה עד שנענה. בחרנו "Run it"? הקריאה ממשיכה, ובדיקת ההרשאות הרגילה עדיין רצה אחר כך. כל תשובה אחרת, או סשן claude -p שאין בו את מי לשאול, מחזירה deny. הוספנו גם .catch, כדי שאם הבדיקה עצמה קורסת, הפקודה לא תרוץ. זה נקרא fail closed: כשמשהו נשבר, ברירת המחדל היא לחסום. וחשוב להגיד בהגינות: ביטוי רגולרי לא יתפוס כל כתיב (למשל git push -f). זו רשת ביטחון ולא חומה.

3. שורת ה-CI. ב-session.start אנחנו מפעילים טיימר עם $.clock.every, שכל 60 שניות מריץ gh pr checks --json name,bucket דרך $.process.run, ומציג סיכום מתחת לשורת הפרומפט עם $.ui.status. השדה bucket של GitHub CLI כבר ממיין כל בדיקה ל-pass, fail, pending, skipping או cancel. רוצים פאנל אמיתי בצד המסך עם טאבים וכפתורים? זה $.ui.open ועוד hook על ui.render עם { component: 'Pane' }, בדיוק כמו בדוגמת hello-tabs בתיעוד.

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

מהמחשב שלנו ל-PR: Code Review יוצא לאוויר

המוד שומר על הסשן המקומי. אבל מה קורה כשהקוד כבר ב-PR? כאן נכנס Code Review, שיצא לזמינות מלאה ב-15 באוקטובר עבור ארגונים במנוי Team ו-Enterprise.

הוא עובד בארבעה שלבים, על התשתית של Anthropic: כמה סוכנים קוראים במקביל את ה-diff ואת הקוד שמסביב, שלב אימות מסנן התראות שווא, הממצאים מקבלים דירוג חומרה, ואז הכל עולה ל-PR כהערות על השורות הרלוונטיות, עם סיכום ו-check run בשם Claude Code Review. הוא לעולם לא מאשר ולא חוסם מרג'. ההחלטה נשארת אצלנו.

החידוש הגדול ב-GA הוא שלוש רמות עומק לכל ריפו: Quick (מעבר קל, הכי מהיר והכי זול), Standard (ברירת המחדל) ו-Deep (הכי יסודי, הכי איטי והכי יקר). לפי Anthropic, רוב הסקירות מסתיימות עכשיו תוך 6 עד 10 דקות, לעומת כ-20 דקות בתקופת התצוגה המקדימה. כל מי שיש לו הרשאת כתיבה יכול לבקש סקירה עם תגובה @claude review על ה-PR, ואת סגנון הסקירה מכוונים עם קובץ REVIEW.md, שנקרא תמיד מה-base branch ולעולם לא מהשינויים של ה-PR עצמו. ככה אף PR לא יכול "לשכנע" את הסוקר להקל עליו. ובלי מנוי ארגוני? הפקודה /code-review בתוך Claude Code עובדת בכל מנוי.

כדי להבין למה זה חשוב, שווה להציץ איך Anthropic עובדת מבפנים. בפוסט הנדסי מ-13 באוקטובר הם מספרים שבמאי 2026 מרג'גו אצלם בממוצע כ-2,500 שינויי קוד ביום, ובספטמבר כבר יותר מ-30,000 ביום. מערכת Git פשוט לא החזיקה את הקצב, אז צוות של שבעה אנשים בנה תוך חמישה חודשים מערכת ניהול גרסאות חדשה בשם Scion, ולצידה ממשק סקירת קוד בשם Antique.

ובפוסט שפורסם ב-15 באוקטובר ("How the Claude Code team does code review", שצבר 478 נקודות ב-Hacker News) צוות Claude Code מתאר תהליך של שבע שכבות, בקוד שכ-90% ממנו Claude כותב: אימות עצמי וסוכן שני לפני PR, סקירת AI על כל PR, סקירת אבטחה שיכולה לחסום, CI חובה, אישור אנושי לפי רמת סיכון (אפס אנשים לשינוי בסיכון נמוך, אחד לבינוני ושניים לגבוה), תור מרג' ו-rollback מהיר.

מספר ה-PRs שעברו בסבב סקירה אחד עלה מ-65% ל-78%, וה-PRs שנזקקו לחמישה סבבים או יותר ירדו מ-8.9% ל-1.5%. וגם: מספר ה-PRs שמורג'גו יותר מהוכפל בין יוני לספטמבר, בזמן ששיעור ה-reverts ירד ביותר מ-40%.

בעיניי: מה זה כן, ומה זה לא

בעיניי, מודים הם הצעד שהופך את Claude Code מכלי לפלטפורמה. עד עכשיו התאמנו את עצמנו לכלי. עכשיו הכלי מתאים את עצמו לצוות: לחוקים שלנו, ל-CI שלנו, לפחדים הספציפיים שלנו. והחיבור עם Code Review הוא בדיוק המודל של Anthropic בקטן: שכבות. שום שכבה לא מושלמת לבד, אבל ביחד הן תופסות את רוב מה שחשוב.

עכשיו המגבלות, בלי הנחות. מודים לא מבודדים, ומוד זדוני הוא קוד זדוני עם גישה לכל מה שלנו. ה-API חדש ומשתנה בין גרסאות, והתיעוד עצמו אומר לסמוך על קבצי הטיפוסים שנוצרים לגרסה שלנו יותר מאשר על כל עמוד תיעוד. חוסם מבוסס regex הוא תזכורת ולא אכיפה, ולהגנה אמיתית על main צריך branch protection ב-GitHub. ו-Code Review בתשלום, זמין רק ל-Team ו-Enterprise, ולא זמין לארגונים עם Zero Data Retention. גם Anthropic כותבת במפורש שסקירה בלי ממצאים לא אומרת שהקוד נקי מבאגים.

אז איזה מוד ראשון אתם הולכים לכתוב לצוות שלכם?

רוצים ללכת עם זה רחוק יותר?

את כל העולם של Claude Code, מ-hooks ופלאגינים ועד סוכנים שעובדים במקביל, אני מפרק לעומק בקורס Claude Code Mastery (באנגלית, ב-yuv.ai).

מי שרוצה להתחיל מהבסיס בעברית, עם Claude Desktop, ‏MCP, ‏Skills, סוכנים ואוטומציות, ימצא את זה ב-Practical AI with Claude.

את הדמואים, כולל המודים מהמדריך הזה בפעולה, אני מעלה ל-YouTube ול-LinkedIn. אפשר לעקוב גם ב-X, ב-Instagram וב-TikTok, ואת הקוד שלי תמצאו ב-GitHub.