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

1. מבוא

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

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

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

2. למה כדאי להשתמש ב-Skills

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

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

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

מבנה הספרייה

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

היקף Workspace: נמצא ב-<workspace-root>/.agent/skills/. הכישורים האלה זמינים רק בפרויקט הספציפי. האפשרות הזו אידיאלית לסקריפטים ספציפיים לפרויקט, כמו פריסה בסביבה מסוימת, ניהול מסד נתונים של האפליקציה או יצירת קוד תבנית למסגרת קניינית.
היקף גלובלי: נמצא ב~/.gemini/antigravity/skills/. הכישורים האלה זמינים בכל הפרויקטים במחשב של המשתמש. האפשרות הזו מתאימה לשימוש בכלים כלליים כמו 'עיצוב JSON', 'יצירת מזהים ייחודיים אוניברסליים (UUID)', 'בדיקת סגנון קוד' או לשילוב עם כלים אישיים לפרודוקטיביות.

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

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

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

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

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

המטרה: תיאור ברור של מה שהמיומנות מאפשרת.
הוראות: לוגיקה מפורטת.
דוגמאות: דוגמאות של קלט ופלט שנועדו להנחות את ביצועי המודל.
אילוצים: כללי "אל תעשה" (לדוגמה, אל תריצו שאילתות 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. האכיפה הידנית של 'הודעות קומיט קונבנציונליות' היא מייגעת ולעתים קרובות נשכחת. בואו ניישם Skill שמחיל את המפרט של 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`

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

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

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

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

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

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

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

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

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

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

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, כולל טיפול במלאי אפס כערך אופציונלי.

דוגמה לפלט (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.
כלי לאימות סכימות של מסדי נתונים.
‫scaffolding של כלי 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. למה כדאי להשתמש ב-Skills

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

איך זה עובד

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` )