יצירת מיומנויות ב-Google Antigravity

1. מבוא

‫Google Antigravity היא פלטפורמת פיתוח אג'נטית שנועדה לעזור לכם לפתח בעידן הזה של הסוכנים. ‫Antigravity משמשת כמרכז הבקרה המרכזי של סוכני ה-AI, ומספקת פלטפורמה מאוחדת להפעלת הפעילויות שלהם, למעקב אחריהן ולתזמור שלהן.

בשיעור Codelab הזה נסביר קודם על Agent Skills – פורמט קל משקל ופתוח להרחבת היכולות של סוכני AI באמצעות ידע ותהליכי עבודה מיוחדים. תוכלו ללמוד מהם כישורי סוכן, מה היתרונות שלהם ואיך הם בנויים. לאחר מכן תיצרו כמה מיומנויות של סוכנים, החל מכלי לעיצוב Git, מחולל תבניות, יצירת scaffolding של קוד כלי ועוד, וכולן ניתנות לשימוש ב-Antigravity.

דרישות מוקדמות:

2. למה כדאי להשתמש במיומנויות

סוכני AI מודרניים התפתחו ממנגנוני האזנה פשוטים למנגנוני ניתוח מורכבים שמשולבים עם מערכות קבצים מקומיות וכלים חיצוניים (באמצעות שרתי MCP). עם זאת, טעינה לא סלקטיבית של סוכן עם בסיסי קוד שלמים ומאות כלים מובילה לרוויית הקשר ול'ריבוי כלים'. גם עם חלונות הקשר גדולים, העברת 40,000 עד 50,000 טוקנים של כלים לא בשימוש לזיכרון הפעיל גורמת לזמן אחזור ארוך, לבזבוז כספי ול'ריקבון הקשר', שבו המודל מתבלבל מנתונים לא רלוונטיים.

הפתרון: מיומנויות של סוכנים

כדי לפתור את הבעיה הזו, Anthropic הציגה את Agent Skills, ובכך שינתה את הארכיטקטורה מטעינת הקשר מונוליטית לProgressive Disclosure. במקום לאלץ את המודל "לזכור" כל תהליך עבודה ספציפי (כמו העברות של מסדי נתונים או ביקורות אבטחה) בתחילת סשן, היכולות האלה ארוזות ביחידות מודולריות שאפשר לגלות.

כיצד זה עובד

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

d3f4bcb065a19fea.png

3. מיומנויות של סוכנים ו-Antigravity

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

מהי מיומנות ב-Antigravity?

במסגרת Google Antigravity, מיומנות היא חבילה מבוססת-ספרייה שמכילה קובץ הגדרה (SKILL.md) ונכסי תמיכה אופציונליים (סקריפטים, הפניות, תבניות).

זהו מנגנון להרחבת היכולות על פי דרישה.

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

מיומנויות לעומת המערכת האקולוגית (כלים, כללים ותהליכי עבודה)

בעוד ש-Model Context Protocol‏ (MCP) פועל כ'ידיים' של הסוכן – הוא מספק חיבורים חזקים וקבועים למערכות חיצוניות כמו GitHub או PostgreSQL – המיומנויות פועלות כ'מוח' שמכוון אותן.

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

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

4. יצירת מיומנויות

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

מבנה הספרייה

ספריית מיומנויות טיפוסית נראית כך:

my-skill/
├── SKILL.md # The definition file
├── scripts/ # [Optional] Python, Bash, or Node scripts
     ├── run.py
     └── util.sh
├── references/ # [Optional] Documentation or templates
     └── api-docs.md
└── assets/ # [Optional] Static assets (images, logos)

המבנה הזה מפריד בין הנושאים בצורה יעילה. הלוגיקה (scripts) מופרדת מההוראה (SKILL.md) ומהידע (references), ומשקפת שיטות עבודה מקובלות בהנדסת תוכנה.

קובץ ההגדרה SKILL.md

קובץ SKILL.md הוא המוח של המיומנות. ההוראות האלה אומרות לסוכן מהי המיומנות, מתי להשתמש בה ואיך לבצע אותה.

הוא מורכב משני חלקים:

  • YAML Frontmatter
  • גוף ההודעה ב-Markdown.

YAML Frontmatter

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

---
name: database-inspector
description: Use this skill when the user asks to query the database, check table schemas, or inspect user data in the local PostgreSQL instance.
---

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

  • ‫name: לא חובה. המזהה חייב להיות ייחודי בהיקף. אפשר להשתמש באותיות קטנות ובמקפים (למשל, postgres-query, pr-reviewer). אם לא מציינים שם, ברירת המחדל היא שם הספרייה.
  • תיאור: זהו שדה חובה והוא הכי חשוב. הוא פועל כ "ביטוי ההפעלה". התיאור צריך להיות מפורט מספיק כדי שה-LLM יזהה את הרלוונטיות הסמנטית. תיאור לא ברור כמו 'כלים למסדי נתונים' לא מספיק. תיאור מדויק כמו "מריץ שאילתות SQL לקריאה בלבד במסד הנתונים המקומי של PostgreSQL כדי לאחזר נתוני משתמשים או נתוני טרנזקציות. השימוש בביטוי הזה 'Use this for debugging data states' מוודא שהמיומנות תזוהה בצורה נכונה.

הגוף של הודעת ה-Markdown

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

גוף ההודעה צריך לכלול:

  1. המטרה: הצהרה ברורה של מה שהמיומנות משיגה.
  2. הוראות: לוגיקה מפורטת.
  3. דוגמאות: דוגמאות של קלט ופלט שנועדו להנחות את ביצועי המודל.
  4. מגבלות: כללים שמתחילים במילים Do not (למשל, Do not run DELETE queries).

דוגמה לתוכן של SKILL.md:

Database Inspector

Goal
To safely query the local database and provide insights on the current data state.

Instructions
- Analyze the user's natural language request to understand the data need.
- Formulate a valid SQL query.
 - CRITICAL: Only SELECT statements are allowed.
- Use the script scripts/query_runner.py to execute the SQL.
 - Command: python scripts/query_runner.py "SELECT * FROM..."
- Present the results in a Markdown table.

Constraints
- Never output raw user passwords or API keys.
- If the query returns > 50 rows, summarize the data instead of listing it all.

שילוב סקריפט

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

סקריפטים צריכים להיות בספריית המשנה scripts/. התג SKILL.md מפנה אליהם באמצעות נתיב יחסי.

5. יצירת מיומנויות

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

אפשר להוריד את המיומנויות ממאגר Github כאן: https://github.com/rominirani/antigravity-skills.

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

שימוש ב-Antigravity או ב-Antigravity CLI

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

  • היקף גלובלי (~/.gemini/config/skills/): זמין בכל מוצרי Antigravity (‏Antigravity, ‏ Antigravity IDE, ‏ Antigravity CLI) ובכל הפרויקטים. הכישורים האלה זמינים בכל הפרויקטים במחשב של המשתמש. האפשרות הזו מתאימה לשימושים כלליים כמו 'עיצוב JSON', 'יצירת מזהי UUID', 'בדיקת סגנון קוד' או שילוב עם כלי פרודוקטיביות אישיים.
  • היקף הפרויקט או Workspace (<project-root>/.agents/skills/): הגדרת ההיקף הזה תאפשר להשתמש במיומנות רק בפרויקט ספציפי. האפשרות הזו אידיאלית לסקריפטים שספציפיים לפרויקט, כמו פריסה בסביבה מסוימת, ניהול מסד נתונים של האפליקציה או יצירת קוד שחוזר על עצמו (boilerplate) למסגרת קניינית.

התקנת המיומנויות ב-Antigravity או ב-Antigravity CLI

במדריך הזה, כל מה שצריך לעשות הוא לבצע את השלבים הבאים (אפשר גם לעשות את זה בדרך שלכם):

שלב 1: מבצעים git clone של https://github.com/rominirani/antigravity-skills

שלב 2: עכשיו, בהתאם לכלי שבו אתם משתמשים – Antigravity או Antigravity CLI – אתם יכולים לנווט אל התיקייה antigravity-skills/skills_tutorial.

שלב 3: תופיע קבוצה של מיומנויות, שמאורגנות בתיקיות שלהן. מעתיקים את 4 התיקיות הבאות:

  • git-commit-formatter
  • license-header-adder
  • database-schema-validator
  • json-to-pydantic

לתיקיית הכישורים המטורגטים של המוצר (היקף הפרויקט או היקף גלובלי).

שלב 4: אם אתם משתמשים ב-Antigravity או ב-Antigravity CLI , מעתיקים אותו אל <project-root>/.agents/skills/ (היקף הפרויקט).

אם הפעלתם את Antigravity, תוכלו לשאול שאלה פשוטה כמו What skills are available?‎ (אילו מיומנויות זמינות?) והוא יענה לכם. תוכלו לראות את 4 המיומנויות שמופיעות שם. יכול להיות שיש לכם גם מיומנויות נוספות, אם התקנתם אותן בסביבה שלכם.

191842a2a0d69597.png

באופן דומה, אם אתם משתמשים ב-Antigravity CLI, אתם יכולים להריץ את הפקודה /skills והיא אמורה להציג את 4 הכישורים. דוגמה:

46be7782d027aa41.png

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

רמה 1 : הנתב הבסיסי ( git-commit-formatter )

אפשר להתייחס לזה כאל 'Hello World' של מיומנויות.

מפתחים כותבים לעיתים קרובות הודעות קומיט עצלניות, למשל: 'wip',‏ 'fix bug',‏ 'updates'. האכיפה הידנית של 'הודעות קומיט קונבנציונליות' היא מייגעת ולעתים קרובות נשכחת. בואו ניישם מיומנות שמחילה את המפרט של Conventional Commits. פשוט נותנים לסוכן הוראות לגבי הכללים, והוא פועל כאוכף.

git-commit-formatter/
└── SKILL.md  (Instructions only)

קובץ SKILL.md לדוגמה:

---
name: git-commit-formatter
description: Formats git commit messages according to Conventional Commits specification. Use this when the user asks to commit changes or write a commit message.
---

Git Commit Formatter Skill

When writing a git commit message, you MUST follow the Conventional Commits specification.

Format
`<type>[optional scope]: <description>`

Allowed Types
- **feat**: A new feature
- **fix**: A bug fix
- **docs**: Documentation only changes
- **style**: Changes that do not affect the meaning of the code (white-space, formatting, etc)
- **refactor**: A code change that neither fixes a bug nor adds a feature
- **perf**: A code change that improves performance
- **test**: Adding missing tests or correcting existing tests
- **chore**: Changes to the build process or auxiliary tools and libraries such as documentation generation

Instructions
1. Analyze the changes to determine the primary `type`.
2. Identify the `scope` if applicable (e.g., specific component or file).
3. Write a concise `description` in an imperative mood (e.g., "add feature" not "added feature").
4. If there are breaking changes, add a footer starting with `BREAKING CHANGE:`.

Example
`feat(auth): implement login with google`

איך מריצים את הדוגמה הזו ב-Antigravity

השלבים הבאים מניחים ש-Git זמין במחשב המקומי שלכם ושההגדרה שלו תקינה.

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: הגדרת מאגר Git לבדיקה

מבקשים מהסוכן להגדיר ספרייה נקייה ומבודדת לבדיקת פעולות Git.

ההנחיה שלך:

Create a folder named git_test in the workspace, initialize a git repository inside it, and create an initial file auth.py with def login(): pass. Stage this file and make an initial commit.

הסוכן ייצור את הספרייה, יאתחל את המאגר, יכין את הקובץ להעלאה ויבצע commit עם הודעה כמו initial commit.

שלב 2: ביצוע שינוי בקוד

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

ההנחיה שלך:

In the git_test folder, modify auth.py to add Google Login functionality.

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

שלב 3: העברת השינויים לאזור ההכנה והוספתם למאגר

מפעילים את המיומנות git-commit-formatter על ידי בקשה מהסוכן להכין את השינויים וליצור קומיט.

ההנחיה שלך:

Stage the changes in the git_test folder and commit them. Make sure to format the commit message using the Conventional Commits skill.

הסוכן יריץ את הפקודה git add auth.py, ינתח את ההבדלים כדי לקבוע שתכונה חדשה נוספה למודול auth, וינסח הודעת התחייבות רגילה כמו feat(auth): implement google login לפני שיריץ את הפקודה git commit.

שלב 4: אימות יומן ה-Git

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

ההנחיה שלך:

Show me the git log in the git_test folder.

הסוכן יריץ את הפקודה git log -n 5 ויחזיר את הפלט עם הודעת המסירה המעוצבת.

רמה 2: ניצול נכסים (license-header-adder)

זו תבנית ה'הפניה'.

יכול להיות שכל קובץ מקור בפרויקט ארגוני יצטרך כותרת רישיון ספציפית של Apache 2.0 בת 20 שורות. הוספה של הטקסט הסטטי הזה ישירות להנחיה (או SKILL.md) היא בזבוז. הוא צורך טוקנים בכל פעם שהמיומנות עוברת אינדוקס, ויכול להיות שהמודל ימציא שגיאות הקלדה בטקסט משפטי. מומלץ להעביר את הטקסט הסטטי לקובץ טקסט פשוט בתיקייה resources/. התכונה הזו מאפשרת לסוכן לקרוא את הקובץ רק כשצריך.

הקבצים יופיעו בתיקייה license-header-adder בספרייה skills.

license-header-adder/
├── SKILL.md
└── resources/
   └── HEADER_TEMPLATE.txt  (The heavy text)

קובץ SKILL.md לדוגמה:

---
name: license-header-adder
description: Adds the standard open-source license header to new source files. Use involves creating new code files that require copyright attribution.
---

# License Header Adder Skill

This skill ensures that all new source files have the correct copyright header.

## Instructions

1. **Read the Template**:
  First, read the content of the header template file located at `resources/HEADER_TEMPLATE.txt`.

2. **Prepend to File**:
  When creating a new file (e.g., `.py`, `.java`, `.js`, `.ts`, `.go`), prepend the `target_file` content with the template content.

3. **Modify Comment Syntax**:
  - For C-style languages (Java, JS, TS, C++), keep the `/* ... */` block as is.
  - For Python, Shell, or YAML, convert the block to use `#` comments.
  - For HTML/XML, use `<!-- ... -->`.

איך מריצים את הדוגמה הזו ב-Antigravity

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: יצירת קובץ Python עם קוד לדוגמה

ההנחיה שלך:

Create a new file my_script.py with the following python code:

def hello():
   print("Hello, World!")

מה קרה (הסבר): הסוכן הפעיל כלי לכתיבת קבצים (write_to_file) כדי ליצור קובץ חדש בשם my_script.py ישירות בספרייה הפעילה של סביבת העבודה, וכתב בו את פונקציית Python הבסיסית. בנוסף, ההנחיה הפעילה את המיומנות license-header-adder. הסוכן איתר וקרא את קובץ תבנית הרישיון (HEADER_TEMPLATE.txt), שינה את סגנון התגובה מתגובות של בלוק בסגנון C ‏(‎/* ... */‎) לתגובות בסגנון Python ‏ (#), והוסיף אותו בתחילת הקובץ באמצעות הכלי replace_file_content.

שלב 2: אימות התוכן של הקובץ

מעיינים בקובץ my_script.py. הוא יכיל את כותרת הרישיון בחלק העליון.

רמה 3: למידה באמצעות דוגמאות (json-to-pydantic)

התבנית Few-Shot.

המרת נתונים לא מאורגנים (כמו תגובה מה-API בפורמט JSON) לקוד מאורגן (כמו מודלים של Pydantic) כוללת עשרות החלטות. איך כדאי לקרוא לכיתות? כדאי להשתמש ב-Optional? snake_case או camelCase? כתיבה של 50 הכללים האלה באנגלית היא מייגעת ומועדת לטעויות.

מודלים גדולים של שפה הם מנועים להתאמת תבניות.

לרוב, עדיף לכתוב את המיומנות באמצעות דוגמה מוצלחת (Input -> Output) מאשר באמצעות הוראות מפורטות.

עוברים לתיקייה json-to-pydantic/ שמכילה את קובצי המיומנות, כמו שמוצג בהמשך:

json-to-pydantic/
├── SKILL.md
└── examples/
   ├── input_data.json   (The Before State)
   └── output_model.py   (The After State)

קובץ SKILL.md לדוגמה:

---
name: json-to-pydantic
description: Converts JSON data snippets into Python Pydantic data models.
---

# JSON to Pydantic Skill

This skill helps convert raw JSON data or API responses into structured, strongly-typed Python classes using Pydantic.

Instructions

1. **Analyze the Input**: Look at the JSON object provided by the user.
2. **Infer Types**:
  - `string` -> `str`
  - `number` -> `int` or `float`
  - `boolean` -> `bool`
  - `array` -> `List[Type]`
  - `null` -> `Optional[Type]`
  - Nested Objects -> Create a separate sub-class.
 
3. **Follow the Example**:
  Review `examples/` to see how to structure the output code. notice how nested dictionaries like `preferences` are extracted into their own class.
 
  - Input: `examples/input_data.json`
  - Output: `examples/output_model.py`

Style Guidelines
- Use `PascalCase` for class names.
- Use type hints (`List`, `Optional`) from `typing` module.
- If a field can be missing or null, default it to `None`.

בתיקייה /examples יש קובץ JSON וקובץ פלט , כלומר קובץ Python. שני התגים מוצגים בהמשך:

input_data.json

{
   "user_id": 12345,
   "username": "jdoe_88",
   "is_active": true,
   "preferences": {
       "theme": "dark",
       "notifications": [
           "email",
           "push"
       ]
   },
   "last_login": "2024-03-15T10:30:00Z",
   "meta_tags": null
}

output_model.py

from pydantic import BaseModel, Field
from typing import List, Optional

class Preferences(BaseModel):
   theme: str
   notifications: List[str]

class User(BaseModel):
   user_id: int
   username: str
   is_active: bool
   preferences: Preferences
   last_login: Optional[str] = None
   meta_tags: Optional[List[str]] = None

איך מריצים את הדוגמה הזו ב-Antigravity

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: יוצרים את קובץ ה-JSON עם נתונים לדוגמה

מבקשים מהסוכן ליצור קובץ חדש product.json שמכיל את מטען ה-JSON הייעודי הגולמי.

ההנחיה שלך:

Create a new file product.json with the following JSON:

{
 "product": "Widget",
 "cost": 10.99,
 "stock": null
}

שלב 2: המרת ה-JSON למודל Pydantic

מפעילים את json-to-pydanticהתכונה כדי להמיר את נתוני ה-JSON למחלקה מובנית של Pydantic.

ההנחיה שלך:

Convert the JSON in product.json to a Pydantic model and save it to product_model.py.

שלב 3: בדיקת הפלט

מעיינים בקובץ product_model.py. הוא יכיל את מודל Pydantic שהושלם.

רמה 4: לוגיקה פרוצדורלית (database-schema-validator)

זהו דפוס השימוש בכלי.

אם תשאלו מודל LLM 'האם הסכימה הזו בטוחה?', יכול להיות שהוא ישיב שהכול בסדר, גם אם חסר מפתח ראשי קריטי, פשוט כי ה-SQL נראה תקין.

נפנה את הבדיקה הזו לסקריפט דטרמיניסטי. ה-database-schema-validator skill שלנו ינתב את הסוכן להרצת סקריפט Python שכתבנו. הסקריפט מספק אמת בינארית (True/False).

database-schema-validator/
├── SKILL.md
└── scripts/
   └── validate_schema.py  (The Validator)

קובץ SKILL.md לדוגמה:

---
name: database-schema-validator
description: Validates SQL schema files for compliance with internal safety and naming policies.
---

# Database Schema Validator Skill

This skill ensures that all SQL files provided by the user comply with our strict database standards.

Policies Enforced
1. **Safety**: No `DROP TABLE` statements.
2. **Naming**: All tables must use `snake_case`.
3. **Structure**: Every table must have an `id` column as PRIMARY KEY.

Instructions

1. **Do not read the file manually** to check for errors. The rules are complex and easily missed by eye.
2. **Run the Validation Script**:
  Use the `run_command` tool to execute the python script provided in the `scripts/` folder against the user's file.
 
  `python scripts/validate_schema.py <path_to_user_file>`

3. **Interpret Output**:
  - If the script returns **exit code 0**: Tell the user the schema looks good.
  - If the script returns **exit code 1**: Report the specific error messages printed by the script to the user and suggest fixes.

קובץ validate_schema.py לדוגמה:

import sys
import re

def validate_schema(filename):
   """
   Validates a SQL schema file against internal policy:
   1. Table names must be snake_case.
   2. Every table must have a primary key named 'id'.
   3. No 'DROP TABLE' statements allowed (safety).
   """
   try:
       with open(filename, 'r') as f:
           content = f.read()
          
       lines = content.split('\n')
       errors = []
      
       # Check 1: No DROP TABLE
       if re.search(r'DROP TABLE', content, re.IGNORECASE):
           errors.append("ERROR: 'DROP TABLE' statements are forbidden.")
          
       # Check 2 & 3: CREATE TABLE checks
       table_defs = re.finditer(r'CREATE TABLE\s+(?P<name>\w+)\s*\((?P<body>.*?)\);', content, re.DOTALL | re.IGNORECASE)
      
       for match in table_defs:
           table_name = match.group('name')
           body = match.group('body')
          
           # Snake case check
           if not re.match(r'^[a-z][a-z0-9_]*$', table_name):
               errors.append(f"ERROR: Table '{table_name}' must be snake_case.")
              
           # Primary key check
           if not re.search(r'\bid\b.*PRIMARY KEY', body, re.IGNORECASE):
               errors.append(f"ERROR: Table '{table_name}' is missing a primary key named 'id'.")

       if errors:
           for err in errors:
               print(err)
           sys.exit(1)
       else:
           print("Schema validation passed.")
           sys.exit(0)
          
   except FileNotFoundError:
       print(f"Error: File '{filename}' not found.")
       sys.exit(1)

if __name__ == "__main__":
   if len(sys.argv) != 2:
       print("Usage: python validate_schema.py <schema_file>")
       sys.exit(1)
      
   validate_schema(sys.argv[1])

איך מריצים את הדוגמה הזו ב-Antigravity

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: יוצרים את קובץ ה-JSON עם נתונים לדוגמה

מבקשים מהסוכן ליצור קובץ חדש bad_schema.sql שמכיל כמה הפרות מדיניות.

ההנחיה שלך:

Create a new file bad_schema.sql with the following SQL:

DROP TABLE IF EXISTS legacy_users;

CREATE TABLE userProfile (
    id INT PRIMARY KEY,
    bio TEXT
);

CREATE TABLE posts (
    title TEXT,
    content TEXT,
    created_at TIMESTAMP
);

CREATE TABLE comments (
    id INT PRIMARY KEY,
    post_id INT,
    body TEXT
);

קובץ הסכימה שלמעלה מפר את כל שלוש המדיניות: הוא משתמש בהצהרת DROP TABLE אסורה, משתמש ב-camelCase לשם הטבלה userProfile ושוכח את המפתח הראשי id בטבלה posts.

שלב 2: אימות סכימת ה-SQL

מפעילים את database-schema-validator skill כדי להריץ את סקריפט האימות של Python על הקובץ.

ההנחיה שלך:

Validate bad_schema.sql using the database-schema-validator skill.

שלב 3: בדיקת הפלט

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

Suggested Fixes:

Remove the line DROP TABLE IF EXISTS legacy_users; as dropping tables is forbidden by safety policy.

Rename the table userProfile to use snake_case (e.g., user_profile).

Add a primary key column named id to the posts table definition.

6. ערכת הכלים למפתחים (מיומנויות של Agents CLI)

התבנית 'פעולה ומחזור חיים'.

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

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

היכולות של Agent CLI (ממשק שורת הפקודה) מספקות אוטומציה יעילה וממוקדת למפתחים ישירות בטרמינל, ומגשרות על הפער בין קוד גולמי לבין ביצוע אוטונומי. הערכה לפיתוח סוכנים (ADK) מתמקדת במסגרת הפרוגרמטית, ומספקת לכם את ערכות ה-SDK, ממשקי ה-API והתוכניות המבניות ליצירה ולניהול של סוכני AI. לעומת זאת, הכישורים של Agent CLI מספקים את היכולות התפעוליות. הוא מאפשר למפתחים ליצור סביבת פיתוח, לבדוק ולפרוס סוכנים באופן מקומי עם לולאות משוב מהירות, בלי להסתמך על ממשק משתמש כבד.

אופציונלית, כשממפים את הכישורים של Agent CLI ל-Google Cloud, הם פועלים כצינור ישיר לתשתית ברמה ארגונית. במקום ללחוץ על המסופים, אפשר להשתמש בפקודות CLI כדי לארוז באופן מיידי תהליכי עבודה של סוכנים, לנהל הרשאות גישה ולפרוס אותם במערכות אקולוגיות של Google Cloud (כמו Vertex AI או Cloud Run). השימוש ב-ADK הופך משימות מורכבות של ארכיטקטורת ענן לפקודות פשוטות בטרמינל שאפשר לשחזר, וכך קל יותר לשלב סוכנים אוטונומיים בפייפליינים קיימים של פריסת CI/CD.

איך מתקינים

מוודאים שכלי ניהול החבילות Python 3.11+, Node.js ו-uv מותקנים. לאחר מכן, מריצים את פקודת ההגדרה בטרמינל:

uvx google-agents-cli setup

הפקודה הזו מתקינה את הקובץ הבינארי agents-cli ורושמת את הכישורים המיוחדים שלו ליצירת תשתית (scaffolding) ולהערכה בסביבה של עוזר התכנות.

הערה: הכישורים יותקנו בתיקייה ~/.agents/skills, שגלויות ל-Antigravity. כדי לראות את הכישורים האלה ב-Antigravity CLI, צריך להעביר אותם לתיקייה ~/.gemini/antigravity-cli/skills (היקף גלובלי).

כדי לבדוק שהמיומנויות נטענו ב-Antigravity, פשוט שואלים אילו מיומנויות זמינות. למטה מוצגת דוגמה לתגובה של Agent CLI Skills שהתקנו זה עתה.

aade8c84acacf956.png

הדרכה מפורטת

אחרי ש-uvx google-agents-cli setup יסתיים, תוכלו להתחיל הרצה של סוכן AI, ליצור איתו אינטראקציה ולבדוק אותו במחשב המקומי שלכם.

שלב 1: יצירת תבנית והפעלה של פרויקט חדש של סוכן

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

# 1. Create a lightweight prototype project structure
agents-cli create weather-assistant --prototype --yes

# 2. Move into the directory and install required ADK dependencies
cd weather-assistant
agents-cli install

מה קורה מאחורי הקלעים: נוצר סביבת עבודה נקייה עם app/agent.py (קוד הליבה), pyproject.toml (מטא-נתונים של החבילה) ו-agents-cli-manifest.yaml (כלי למעקב אחרי פרויקטים).

שלב 2: מריצים שאילתת בדיקה מקומית

מריצים בדיקה מהירה וישירה בשורת הפקודה מול הסוכן. אם אתם לא משתמשים ב-Application Default Credentials (פרטי כניסה שמוגדרים כברירת מחדל לאפליקציה) של Google Cloud, ודאו שייצאתם את GEMINI_API_KEY במסוף. אפשר לקבל מפתח Gemini API כאן. אחרי שמקבלים את המפתח, מייצאים אותו בטרמינל באמצעות הפקודה הבאה:

export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"

מזינים את הפקודה הבאה בטרמינל:

agents-cli run "How are you?"

מה קורה מאחורי הקלעים: ממשק שורת הפקודה (CLI) מאתחל את מחזור החיים של ערכת פיתוח הסוכן (ADK) באופן מלא בזיכרון במסוף. הוא מעביר את ההנחיה באופן מאובטח דרך פרטי הכניסה המקומיים שלכם ומתעד את התגובה של השידור החי ישירות בשורת הפקודה.

שלב 3: הפעלת סביבת המשחקים האינטראקטיבית באינטרנט

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

agents-cli playground

מה קורה מאחורי הקלעים: ה-CLI מפעיל שרת של ממשק משתמש אינטרנטי של ADK, שבדרך כלל אפשר לגשת אליו בכתובת http://localhost:8080 או בכתובת חלופית http://127.0.0.1:8000, עם טעינה מחדש של קוד בזמן ריצה. בממשק האינטרנטי, בוחרים באפשרות אפליקציה בתפריט הנפתח בחירת אפליקציה בחלק העליון, ומנהלים אינטראקציה עם הסוכן בממשק השיחה בצד שמאל של אפליקציית האינטרנט.

7. התקנת מיומנויות של סוכנים באמצעות npx skills

‫npx skills הוא כלי לשורת הפקודה שפותח על ידי Vercel Labs ומשמש כמנהל חבילות לסוכני AI (כמו Antigravity,‏ Claude Code,‏ GitHub Copilot,‏ Cursor ו-Cline). זהו ממשק שורת הפקודה (CLI) של הסביבה העסקית הפתוחה של מיומנויות סוכנים.

אם אתם רוצים להוריד ולהתקין את Agent Skills באמצעות חבילת npx skills, חשוב לדעת שהמיומנויות ממוקמות בתיקייה ~/.agents/skills. במאמר מצוין שכלים כמו Antigravity יזהו את המיומנויות בתיקייה הזו, אבל חשוב לדעת שבזמן כתיבת המאמר, Antigravity מזהה את המיומנויות בתיקייה הזו, אבל Antigravity CLI לא מזהה אותן. כמו שציינו קודם, תצטרכו להעתיק את המיומנויות האלה שמותקנות בתיקייה ~/.agents/skills, או לפרויקט או להיקף הגלובלי של תיקיות המיומנויות ב-Antigravity CLI, כלומר:

  1. היקף הפרויקט: נמצא ב<project-root>/.agent/skills/.
  2. היקף גלובלי: ממוקם ב~/.gemini/antigravity-cli/skills/.

8. מזל טוב

מעולה! השתמשתם בהצלחה ב-Google Antigravity כדי ליצור את מיומנות הסוכן הראשונה שלכם, הגדרתם אותה והוספתם לה יכולות מותאמות אישית.

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

עכשיו אתם יכולים להשתמש ב-Antigravity כדי לכתוב קוד בפרויקטים שלכם.

איך מקבלים את התג Kaggle 5-Day AI Agents

השלמתם את שיעור ה-Lab הזה כחלק מקורס אינטנסיבי בן 5 ימים בנושא סוכני AI: כתיבת קוד עם Google ב-Kaggle? קבלת תג על השלמת הקורס: קבלת תג על השלמת הקורס בנושא סוכני AI בחמישה ימים.

9. מסמכים לדוגמה