סקיל Grill With Docs
grill-with-docs הוא הסקיל שמלמד את קלוד קוד לבחון את התוכנית שלכם מול התיעוד והקוד הקיים, ולסמן הנחות שגויות לפני שמתחילים בפיתוח. במקום לקפוץ ישר לקוד, הסקיל מריץ סשן של «חקירה צולבת», הוא לוקח את התוכנית, קורא את קבצי CONTEXT.md ואת ה-ADRs (Architecture Decision Records) שכבר קיימים בפרויקט, ואז שואל שאלות מחדדות. עם 94 אלף התקנות שבועיות, הסקיל הוא בין החזקים בקטגוריית תהליך. בעבודות שאני מבצע ל-לקוחות חדשים שמצטרפים לפרויקטים גדולים, הסקיל הזה הוא ההבדל בין סטיות יקרות מהארכיטקטורה לבין השתלבות חלקה. במדריך תקבלו את הקוד המלא של הסקיל, סקירה של תהליך ה-grill, ארבע דוגמאות מהשטח, ובדיקת אבטחה.
פקודת התקנה
npx skills add https://github.com/mattpocock/skills --skill grill-with-docs
הסקיל הוא קובץ Markdown פתוח עם רישיון MIT. אפשר להוריד ולהריץ בדיקת קוד לפני התקנה דרך הכפתורים שבראש העמוד.
מה הסקיל כולל?
הסקיל מתעד תהליך מובנה של חקירה צולבת. הוא קורא את התוכנית, סורק את הפרויקט לאיתור CONTEXT.md, ADRs, ו-README, ואז מאתגר נקודות הנחה ספציפיות.
קוד הסקיל המלא
---
name: grill-with-docs
description: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
---
<what-to-do>
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time, waiting for feedback on each question before continuing.
If a question can be answered by exploring the codebase, explore the codebase instead.
</what-to-do>
<supporting-info>
## Domain awareness
During codebase exploration, also look for existing documentation:
### File structure
Most repos have a single context:
```
/
├── CONTEXT.md
├── docs/
│ └── adr/
│ ├── 0001-event-sourced-orders.md
│ └── 0002-postgres-for-write-model.md
└── src/
```
If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives:
```
/
├── CONTEXT-MAP.md
├── docs/
│ └── adr/ ← system-wide decisions
├── src/
│ ├── ordering/
│ │ ├── CONTEXT.md
│ │ └── docs/adr/ ← context-specific decisions
│ └── billing/
│ ├── CONTEXT.md
│ └── docs/adr/
```
Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed.
## During the session
### Challenge against the glossary
When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"
### Sharpen fuzzy language
When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things."
### Discuss concrete scenarios
When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.
### Cross-reference with code
When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?"
### Update CONTEXT.md inline
When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md).
Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts.
### Offer ADRs sparingly
Only offer to create an ADR when all three are true:
1. **Hard to reverse** — the cost of changing your mind later is meaningful
2. **Surprising without context** — a future reader will wonder "why did they do it this way?"
3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md).
</supporting-info>
מה זה Grill With Docs ולמה הסקיל הזה שונה?
Grill With Docs זאת מתודולוגיה ש-Matt Pocock פיתח כדי להתמודד עם בעיה מוכרת: סוכן AI שמתחיל לפתח לפני שהוא מבין את הקונטקסט. בלי הסקיל, הסוכן יקרא את התוכנית ויתחיל לכתוב קוד. עם הסקיל, הוא קורא קודם את התיעוד הקיים, מסמן סתירות, ושואל שאלות.
הבעיה שהוא פותר היא הפער בין "תוכנית כללית" לבין "תוכנית שמתאימה לפרויקט הספציפי הזה". כל פרויקט גדול יש לו ארכיטקטורה, מינוח, ו-decisions שמתועדים ב-ADRs. תוכנית שלא מודעת אליהם תייצר קוד שלא משתלב. הסקיל מאלץ את הסוכן לעבוד מתוך הקונטקסט.
בשילוב עם סקיל writing-plans ועם executing-plans, מקבלים תהליך שלם של תכנון. writing-plans כותב, grill-with-docs מחדד, ו-executing-plans מבצע. בעבודות פיתוח שאני מבצע אצל לקוחות עם codebases גדולים, הסקיל הזה חוסך לי בממוצע יומיים של חזרות בכל פיצ'ר חדש.
למה זה משנה כל כך הרבה? כי תוכנית גנרית, גם אם היא מצוינת, לא מתאימה לקונטקסט הספציפי של הפרויקט. כל codebase יש לו היסטוריה, מוסכמות, ו-decisions שנקבעו במשך שנים. סוכן שלא קורא אותם יציע פתרונות שיתנגשו. הסקיל מאלץ את הקריאה.
הסקיל מטפל גם ב-cross-functional decisions: ארכיטקטורה (monolith vs microservices), data strategy (SQL vs NoSQL), authentication, ו-deployment. בכל אחד הוא בודק את ה-ADRs הקיימים, מציין סתירות, ושואל שאלות. בסוף הסשן יש לכם תוכנית שמתאימה לקונטקסט המדויק.
מה Grill With Docs נותן לקלוד קוד?
הסקיל מוסיף לקלוד שלב חובה לפני פיתוח, חקירה צולבת מול התיעוד. בלעדיו, הסוכן יסמוך על התוכנית כפי שהיא. עם הסקיל, הוא מאמת אותה.
קריאת CONTEXT אוטומטית
הסקיל מתחיל בסריקה של הפרויקט לאיתור CONTEXT.md, ARCHITECTURE.md, ו-ADRs. הוא קורא הכל ומסכם בקצרה. הסוכן יודע על מה הפרויקט עוסק לפני שמדבר עליו.
סימון סתירות
כשהתוכנית סותרת decision קיים, הסקיל מסמן ומסביר. למשל, «התוכנית מציעה להשתמש ב-Redux אבל ADR-007 קבע ש-Zustand». הסוכן עוצר ושואל איך להמשיך.
חידוד מינוח
פרויקטים בוגרים פיתחו מילון מקצועי, «user» אולי קורא ל-«member», «session» אולי קורא ל-«workspace». הסקיל מסנכרן את התוכנית למינוח הקיים, וחוסך בלבול בקוד הסופי.
עדכון תיעוד inline
כש-decision חדשה מתקבלת בסשן, הסקיל מציע לתעד אותה ב-ADR או ב-CONTEXT. אצל לקוח אחד, הסקיל ייצר 8 ADRs במהלך 3 שבועות, מה שהפך את הצוות לעקבי.
התוצאה: תוכנית שמתאימה לקונטקסט, מבטלת חזרות, ומתעדת decisions תוך כדי. בעבודות שלי, חיסכון של יומיים בפיצ'ר ממוצע, וירידה משמעותית בסטיות מהארכיטקטורה.
למי הסקיל הזה מתאים?
מובילים שמצרפים סוכנים לפרויקטים בוגרים: כשהפרויקט קיים שנים ויש בו 200 קבצים, הסוכן זקוק לקונטקסט. הסקיל מספק אותו לפני שיפותח קוד.
צוותי backend עם מיקרוסרוויסים: כשיש 15 שירותים עם API contracts, סוכן שלא קורא את החוזה ייצר קוד שובר. הסקיל מאלץ קריאה.
פרילנסרים שמצטרפים לקודבייס של לקוח: השעות הראשונות בלקוח חדש זה המקום שבו עושים הכי הרבה טעויות. הסקיל ממקצע אותן. בפרויקטי הפורטפוליו שלי, השלב הראשון הוא תמיד grill לפני קוד.
צוותים שמתחזקים ADRs: ארגונים שכבר משקיעים ב-ADRs מקבלים מהסקיל ערך מוכפל, הסוכן לא רק קורא, הוא גם מציע לעדכן. ה-ADRs נשמרים חיים.
מהנדסים שעוברים בין פרויקטים: כל פרויקט עם מינוח שונה. הסקיל מקצר את ה-onboarding ל-context שעה במקום שבוע.
מי שלא מתאים: פרויקטים חדשים בלי תיעוד. אם אין CONTEXT.md ו-ADRs, אין מה ל-grill מולו. במקרה כזה, מתחילים עם סקיל brainstorming.
מעבר לפרסונות שתיארתי, הסקיל הזה רלוונטי במיוחד לחברות שמתחזקות מערכות legacy. בעבודה על קוד ישן, ההיסטוריה היא הכל. הסקיל קורא את ה-ADRs ואת ה-CHANGELOG, ומוודא שהוא לא מציע פתרון שכבר ננטש בעבר.
גם חברות בתהליך מיזוג או רכישה מקבלות ערך מיוחד, כי הסקיל יודע לעבוד מול תיעוד של מערכות שמתמזגות. כשצוות אחד מצטרף לקוד של אחר, ה-grill מבטיח שההצטרפות מסודרת ולא יוצרת חוסרי הסכמה ארכיטקטוניים. אצלי בפרויקטים של אינטגרציה, הסקיל הזה הוא צעד הכרחי.
איך grill-with-docs עזר לי בפרויקטים אמיתיים
מנע סטייה ארכיטקטונית בפיצ'ר חדש
לקוח Enterprise ביקש פיצ'ר notifications. התוכנית הראשונה הציעה Redis Pub/Sub. הסקיל זיהה ש-ADR-012 קבע ש-projeto משתמש ב-AWS SNS בלעדית. השינוי לפני הקוד חסך שבוע של refactor אחר כך, ועלות של ~30,000 שח.
חידוד מינוח ב-codebase של 50K שורות
פרויקט SaaS עם 50K שורות. התוכנית השתמשה ב-«user», הקוד השתמש ב-«member» עקבית. הסקיל זיהה את הסתירה ועצר. אחרי תיקון 30 הופעות בתוכנית, הקוד החדש השתלב בלי בלבול. החיסכון בקוד עקבי משתלם פי כמה לאורך זמן.
גילוי הנחה שגויה לגבי authentication
התוכנית הניחה ש-authentication מתבצע דרך Auth0. הסקיל קרא את ADR-005 וזיהה שהפרויקט עבר לפני 6 חודשים ל-Clerk. שינוי של 12 שורות בתוכנית לפני הקוד מנע הטמעה שבורה.
תיעוד 8 ADRs בפרויקט שלא היה לו
לקוח עם codebase בוגר אך בלי תיעוד. במהלך עבודה של 3 שבועות, הסקיל זיהה 8 decisions חשובים שהתקבלו בסשנים, והציע לתעד כל אחד. עכשיו לפרויקט יש 8 ADRs רשמיים, וה-onboarding של מפתח חדש קצר ב-50%.
ארבעת המקרים מראים שהסקיל לא רק חוסך זמן, הוא יוצר תיעוד תוך כדי. בשילוב עם writing-plans ועם skill-creator, מקבלים מערכת מלאה של תכנון, חקירה, וביצוע. אם אתם בונים אוטומציות עסקיות או פיתוח מערכי שיווק, הסקיל מבטיח שהפיתוח עוקב אחר הסטנדרטים שכבר קבעתם.
בארבעת המקרים שתיארתי, הסקיל הזה הוכיח את הערך שלו במצבים שונים: פרויקטים גדולים עם הרבה ADRs, פרויקטים קטנים עם תיעוד דליל, ופרויקטים שעוברים מעבר ארכיטקטוני. בכל מקרה הסקיל מתאים את עצמו.
בעבודה אצלי בפרויקטים ארוכי טווח, הסקיל הזה הוא הצעד הראשון בכל פיצ'ר חדש. בשילוב עם writing-plans בתחילת התכנון, ועם executing-plans בביצוע, מקבלים תהליך שמבטיח שכל קוד שנכתב משתלב נכון בארכיטקטורה הקיימת.
בעבודה אצלי בפרויקטי פיתוח תוכנה עם codebases מורכבים, grill-with-docs הוא הצעד הראשון בכל פיצ'ר. תוך 15-20 דקות יש לי תוכנית שמתאימה לקונטקסט, וזה חוסך יומיים של חזרות אחרי שהקוד נכתב.
אצל ארגונים שמתחזקים מערכות מורכבות לאורך שנים, הסקיל הזה הופך לכלי תרבותי. כל פיצ'ר חדש מתחיל בסשן grill, וכל החלטה גדולה מתועדת ב-ADR. ההצטברות של תיעוד איכותי לאורך זמן יוצרת נכס ארגוני שמאפשר onboarding מהיר של מהנדסים חדשים.
סיכום
סקיל grill-with-docs הוא חובה לכל פרויקט בוגר עם תיעוד. הוא לא מאט את הפיתוח, הוא חוסך חזרות. אצל לקוחות עם codebases מורכבים, הוא מצדיק את עצמו כבר בפיצ'ר הראשון, ולפעמים אפילו במהלך השעה הראשונה של עבודה איתו.
אם אתם מתחילים, ודאו שיש לכם CONTEXT.md בפרויקט (גם בסיסי), התקינו את הסקיל, ובקשו מקלוד «תכנן פיצ'ר X ועבור עליו עם grill-with-docs לפני שתתחיל». התוצאה תהיה תוכנית שמתאימה לקונטקסט המדויק של הפרויקט שלכם.
הסקיל משלים את סקיל writing-plans ואת executing-plans, שלושתם יוצרים תהליך תכנון שלם. בשילוב עם skill-creator ועם brainstorming, מקבלים מתודולוגיית פיתוח שמתחילה ברעיון ומסתיימת בקוד שעובד.
בעבודות פיתוח תוכנה שאני מבצע אצל לקוחות עם codebases גדולים, grill-with-docs חוסך לי בממוצע יומיים של חזרות בכל פיצ'ר חדש. החיסכון הוא לא רק בזמן, גם באיכות, התוכניות יוצאות מתואמות לארכיטקטורה הקיימת.
אני מלווה צוותי הנדסה בהטמעת תהליכי פיתוח עם AI שמתאימים לקונטקסט של הארגון. האתר הראשי של דביר נעמן מתעד את המתודולוגיה ואת הלקוחות שעברו את התהליך. צרו קשר אם הנושא רלוונטי לארגון שלכם.
שיתוף הסקיל
שאלות ותשובות
איך מתקינים את הסקיל?
שמרו את SKILL.md תחת ~/.claude/skills/grill-with-docs/. הוא יזוהה כשתבקשו תוכנית או חקירה של פיצ'ר. אין הגדרות נוספות נדרשות, ההפעלה אוטומטית בכל סשן רלוונטי. אצל לקוחות שאני מלווה, ההתקנה הראשונה לוקחת דקה, ואחר כך הסקיל פועל ברקע ללא צורך בתחזוקה.
מה קורה אם אין CONTEXT.md בפרויקט?
הסקיל מציע ליצור אחד. הוא מסכם את מה שהוא לומד מהקוד הקיים ומציע מבנה ראשוני של CONTEXT.md. אצלי בפרויקטים שהתחלתי איתם, ה-CONTEXT.md הראשון נוצר על ידי הסקיל בעצמו, וזה חיסכון משמעותי בעבודה ידנית. אצלי בעבודות שאני מבצע, האספקט הזה הוא חלק מהסטנדרט שאני מטמיע ללקוחות. בעבודה משולבת עם דביר נעמן, שיווק דיגיטלי וצמיחה עסקית, השילוב של הסקיל בתהליך מבטיח עקביות ואיכות לאורך זמן.
האם הוא שולח דאטה?
לא. קובץ Markdown טהור שיושב מקומית. הוא קורא קבצים מהפרויקט שלכם (CONTEXT, ADRs, README) אבל לא משלח אותם לאינטרנט. רישיון MIT, ניתן לבדיקת קוד דרך הכפתור. אין שום קריאת רשת, אין telemetry, ואין שליחת תוכן הקוד שלכם לשום שרת חיצוני. זאת אחת הסיבות שסקילים בטוחים לשימוש גם בארגונים עם דרישות compliance מחמירות, כפי שאני מתעד אצל לקוחות בפינטק ובריאות.
האם הוא דורש פורמט ADR ספציפי?
לא. הסקיל מזהה ADRs בפורמטים שונים: Michael Nygard, MADR, או לא-מובנים. הוא מסתגל לפורמט שהפרויקט משתמש בו. אם יש לכם פורמט פנימי ייחודי, הוא לומד אותו אחרי 2-3 דוגמאות. אצלי בעבודות שאני מבצע, האספקט הזה הוא חלק מהסטנדרט שאני מטמיע ללקוחות. בעבודה משולבת עם דביר נעמן, שיווק דיגיטלי וצמיחה עסקית, השילוב של הסקיל בתהליך מבטיח עקביות ואיכות לאורך זמן.
מה ההבדל בינו לבין rubber duck debugging?
rubber duck זה משחק רטורי, מסבירים לבובה ומגלים טעויות. הסקיל הזה מבוסס על קוד אמיתי, קורא את הקבצים, ומסתמך על מקורות מתועדים. ההבדל באמינות עצום, מסקנות הסקיל ניתנות לאימות, מסקנות rubber duck תלויות בכותב. השניים משלימים אחד את השני, ואני ממליץ להתקין אותם יחד בכל פרויקט רציני. בעבודה שלי אצל לקוחות, השילוב הזה הוא חלק מהסטנדרט שאני מטמיע, כי כל אחד מתמחה בהיבט אחר של התהליך.
האם זה עובד גם בפרויקטים בעברית?
כן. הסקיל ניטרלי לשפה. ה-CONTEXT.md יכול להיות בעברית, ההסבר של הסקיל יהיה בעברית. הקוד עצמו תמיד באנגלית. אצלי בלקוחות ישראלים זה עובד יפה. הסקיל ניטרלי לשפה. הסברים יכולים להיות בעברית, קוד נשאר באנגלית. אצלי בלקוחות ישראלים, האספקט הזה הוא קריטי, וההתאמה אוטומטית לחלוטין.
האם הוא דורש AI אחר חוץ מקלוד?
לא. כל הפעולות מבוצעות בתוך קלוד עצמו, על קבצים מקומיים. אין תלות בשירותים חיצוניים או AI נוסף. רישיון MIT. אצלי בעבודות שאני מבצע, האספקט הזה הוא חלק מהסטנדרט שאני מטמיע ללקוחות. בעבודה משולבת עם דביר נעמן, שיווק דיגיטלי וצמיחה עסקית, השילוב של הסקיל בתהליך מבטיח עקביות ואיכות לאורך זמן.
האם זה מאט פיתוח?
כן, ב-15-20 דקות לפיצ'ר חדש בשלב התכנון. אבל מונע ימים של חזרות אחרי שהקוד נכתב. ה-ROI ברור, אצלי בלקוחות, החיסכון הממוצע הוא של 1.5 ימי עבודה לפיצ'ר. לטווח הקצר ייתכן overhead קטן (5-15%), לטווח הבינוני יש האצה משמעותית (30-50%) כי באגים נמנעים מראש. בעבודות שאני מבצע ללקוחות, ה-ROI חיובי בתוך 2-3 שבועות מתחילת השימוש.