איך מתחילים להשתמש במיומנויות ב-Google Antigravity

1. מבוא

‫Google Antigravity (שנקרא בהמשך המסמך Antigravity) הוא סביבת פיתוח משולבת (IDE) מבוססת-סוכן מבית Google. ב-Getting started with Antigravity codelab (תחילת העבודה עם Antigravity codelab) אפשר ללמוד את היסודות של Antigravity. ב-codelab הזה נשתמש ב-Antigravity כדי ליצור Agent Skills – פורמט קל משקל ופתוח להרחבת היכולות של סוכני AI באמצעות ידע ותהליכי עבודה מיוחדים. תוכלו לקרוא על כישורי סוכנים, על היתרונות שלהם ועל אופן הבנייה שלהם. לאחר מכן תבנו כמה מיומנויות של סוכנים, החל מעיצוב Git, יצירת תבניות, פיגומים של קוד כלים ועוד, שניתן להשתמש בהם ב-Antigravity.

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

‫Google Antigravity מותקן ומוגדר.
הבנה בסיסית של Google Antigravity. מומלץ להשלים את ה-Codelab: Getting Started with Google Antigravity.

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

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

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

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

איך זה עובד

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

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

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

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

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

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

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

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

פרוטוקול הקשר של המודל (MCP) פועל בתור ה"ידיים" של הסוכן – הוא מספק חיבורים חזקים וקבועים למערכות חיצוניות כמו GitHub או PostgreSQL – והמיומנויות פועלות בתור ה"מוח" שמכוון אותן.

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

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

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

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

מבנה הספרייה

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

היקף Workspace: נמצא ב-<workspace-root>/.agent/skills/. הכישורים האלה זמינים רק בפרויקט הספציפי. האפשרות הזו אידיאלית לסקריפטים ספציפיים לפרויקט, כמו פריסה בסביבה מסוימת, ניהול מסד נתונים של האפליקציה או יצירת קוד boilerplate למסגרת קניינית.
היקף גלובלי: נמצא ב~/.gemini/antigravity/skills/. הכישורים האלה זמינים בכל הפרויקטים במחשב של המשתמש. האפשרות הזו מתאימה לשימוש בכלים כלליים כמו 'Format JSON',‏ 'Generate UUIDs',‏ 'Review Code Style' או לשילוב עם כלים לשיפור הפרודוקטיביות האישית.

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

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

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

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

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

דוגמה לתוכן של קובץ 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 ומציגות בהדרגה תכונות שונות כמו משאבים, סקריפטים וכו'.

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

אפשר להציב כל אחת מהמיומנויות האלה בתיקייה ~/.gemini/antigravity/skills או בתיקייה /.agent/skills.

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

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

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

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`

איך מריצים את הדוגמה הזו:

מבצעים שינוי קטן בקובץ כלשהו בסביבת העבודה.
פותחים את הצ'אט ומקלידים: Commit these changes.
הסוכן לא יריץ רק git commit. קודם תופעל היכולת git-commit-formatter.
תוצאה: תוצע הודעת קומיט רגילה של Git.

לדוגמה, ביקשתי מ-Antigravity להוסיף כמה הערות לקובץ Python לדוגמה, והוא יצר הודעת קומיט ב-Git כמו docs: add detailed comments to demo_primes.py.

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

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

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

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

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

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

לעתים קרובות, יעיל יותר להציג דוגמה מצוינת (קלט -> פלט) מאשר לתת הוראות מפורטות.

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 `<!-- ... -->`.

איך מריצים את הדוגמה הזו:

יוצרים קובץ Python פיקטיבי חדש: touch my_script.py
סוג: Add the license header to my_script.py.
הנציג יקרא license-header-adder/resources/HEADER_TEMPLATE.txt.
התוכן יודבק בקובץ בדיוק כמו שהוא, מילה במילה.

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

התבנית Few-Shot.

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

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

איך מריצים את הדוגמה הזו:

מספקים לסוכן קטע JSON (מדביקים אותו בצ'אט או מציינים קובץ).

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

סוג: Convert this JSON to a Pydantic model.
הנציג בודק את צמד המילים examples בתיקיית המיומנות.
הוא יוצר מחלקה ב-Python שמחקה באופן מושלם את סגנון הקידוד, הייבוא והמבנה של output_model.py, כולל טיפול במלאי null כ-Optional.

למטה מוצג פלט לדוגמה (product_model.py):

from pydantic import BaseModel
from typing import Optional

class Product(BaseModel):
   product: str
   cost: float
   stock: Optional[int] = None

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

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

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

נאציל את הבדיקה הזו לסקריפט דטרמיניסטי. אנחנו משתמשים במיומנות כדי להפנות את הנציג להפעלת סקריפט 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])

איך מריצים את הדוגמה הזו:

יוצרים קובץ SQL לא תקין bad_schema.sql: CREATE TABLE users (name TEXT);
סוג: Validate bad_schema.sql.
הסוכן לא מנחש. הפקודה תפעיל את הסקריפט, שייכשל (קוד יציאה 1), ותדווח לנו ש'האימות נכשל כי בטבלה 'users' חסר מפתח ראשי'.

רמה 5: האדריכל (adk-tool-scaffold)

הדפוס הזה כולל את רוב התכונות שזמינות ב-Skills.

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

אנחנו משלבים:

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

adk-tool-scaffold/
├── SKILL.md
├── resources/
│   └── ToolTemplate.py.hbs (Jinja2 Template)
├── scripts/
│   └── scaffold_tool.py    (Generator Script)
└── examples/
    └── WeatherTool.py      (Reference Implementation)

קובץ SKILL.md מוצג בהמשך. אפשר לעיין ב מאגר המיומנויות כדי לבדוק את הקבצים בתיקייה scripts, resources ו-examples. כדי ללמוד על המיומנות הספציפית הזו, עוברים אל adk-tool-scaffold המיומנות.

---
name: adk-tool-scaffold
description: Scaffolds a new custom Tool class for the Agent Development Kit (ADK).
---

# ADK Tool Scaffold Skill

This skill automates the creation of standard `BaseTool` implementations for the Agent Development Kit.

Instructions

1. **Identify the Tool Name**:
  Extract the name of the tool the user wants to build (e.g., "StockPrice", "EmailSender").
 
2. **Review the Example**:
  Check `examples/WeatherTool.py` to understand the expected structure of an ADK tool (imports, inheritance, schema).

3. **Run the Scaffolder**:
  Execute the python script to generate the initial file.
 
  `python scripts/scaffold_tool.py <ToolName>`

4. **Refine**:
  After generation, you must edit the file to:
  - Update the `execute` method with real logic.
  - Define the JSON schema in `get_schema`.
 
Example Usage
User: "Create a tool to search Wikipedia."
Agent:
1. Runs `python scripts/scaffold_tool.py WikipediaSearch`
2. Editing `WikipediaSearchTool.py` to add the `requests` logic and `query` argument schema.

איך מריצים את הדוגמה הזו:

סוג: Create a new ADK tool called StockPrice to fetch data from an API.
שלב 1 (הכנה): הסוכן מריץ את סקריפט ה-Python. הפעולה הזו יוצרת באופן מיידי את StockPriceTool.py עם מבנה הכיתה הנכון, מייבאת את הנתונים ונותנת לכיתה את השם StockPriceTool.
שלב 2 (הטמעה): הסוכן 'קורא' את הקובץ שהוא יצר. הוא רואה # TODO: Implement logic.
שלב 3 (הנחיות): לא ברור איך להגדיר את סכימת ה-JSON לארגומנטים של הכלי. הכלי בודק את examples/WeatherTool.py.
השלמה: הוא עורך את הקובץ כדי להוסיף את requests.get(...) ומגדיר את ארגומנט הטיקר בסכימה, בהתאם לסגנון ADK.

6. מזל טוב

השלמתם בהצלחה את שיעור ה-Lab בנושא Antigravity Skills ויצרתם את ה-Skills הבאים:

מעצב של Git commit.
כלי להוספת כותרת רישיון.
מ-JSON ל-Pydantic.
כלי לאימות סכימות של מסדי נתונים.
פיגום של כלי ADK.

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

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

‫Codelab : תחילת העבודה עם Google Antigravity
האתר הרשמי : https://antigravity.google/
תיעוד: https://antigravity.google/docs
הורדה : https://antigravity.google/download
מסמכי Antigravity Skills: https://antigravity.google/docs/skills

איך מתחילים להשתמש במיומנויות ב-Google Antigravity

1. מבוא

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

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

איך זה עובד

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

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

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

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

מבנה הספרייה

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

שילוב סקריפטים

5. מיומנויות כתיבה

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

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

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

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

רמה 5: האדריכל (adk-tool-scaffold)

6. מזל טוב

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

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