การเขียนทักษะของ Google Antigravity

1. บทนำ

Google Antigravity เป็น IDE แบบเป็น Agent จาก Google ใน Codelab นี้ เราจะใช้ Antigravity เพื่อสร้างทักษะของ Agent ซึ่งเป็นรูปแบบโอเพนซอร์สแบบน้ำหนักเบาสำหรับการขยายความสามารถของ AI Agent ด้วยความรู้และเวิร์กโฟลว์เฉพาะทาง คุณจะได้เรียนรู้ว่าทักษะของ Agent คืออะไร มีประโยชน์อย่างไร และสร้างขึ้นอย่างไร จากนั้นคุณจะสร้างทักษะของ Agent หลายอย่าง ตั้งแต่ตัวจัดรูปแบบ Git, ตัวสร้างเทมเพลต, การจัดโครงสร้างโค้ดเครื่องมือ และอื่นๆ อีกมากมาย ซึ่งทั้งหมดนี้สามารถใช้ได้ภายใน Antigravity

ข้อกำหนดเบื้องต้น:

ติดตั้งและกำหนดค่า Google Antigravity แล้ว
มีความเข้าใจพื้นฐานเกี่ยวกับ Google Antigravity เราขอแนะนำให้ทำ Codelab เริ่มต้นใช้งาน Google Antigravity ให้เสร็จสมบูรณ์

2. เหตุผลที่ต้องมีทักษะ

AI Agent สมัยใหม่พัฒนาจากผู้ฟังธรรมดาๆ ไปเป็นผู้ให้เหตุผลที่ซับซ้อนซึ่งผสานรวมกับระบบไฟล์ในเครื่องและเครื่องมือภายนอก (ผ่าน เซิร์ฟเวอร์ MCP) อย่างไรก็ตาม การโหลด Agent ด้วยฐานโค้ดทั้งหมดและเครื่องมือหลายร้อยรายการโดยไม่เลือกสรรจะทำให้เกิดContext Saturation และ "เครื่องมือบวม" แม้จะมีหน้าต่างบริบทขนาดใหญ่ การทิ้งโทเค็นเครื่องมือที่ไม่ได้ใช้ 40,000-50,000 รายการลงในหน่วยความจำที่ใช้งานอยู่จะทำให้เกิดเวลาในการตอบสนองสูง การสูญเสียทางการเงิน และ "บริบทเสื่อม" ซึ่งโมเดลจะสับสนกับข้อมูลที่ไม่เกี่ยวข้อง

วิธีแก้ปัญหา: ทักษะของ Agent

Anthropic ได้เปิดตัวทักษะของ Agent เพื่อแก้ปัญหานี้ โดยเปลี่ยนสถาปัตยกรรมจากการโหลดบริบทแบบโมโนลิธไปเป็นการเปิดเผยแบบค่อยเป็นค่อยไป แทนที่จะบังคับให้โมเดล "จดจำ" ทุกเวิร์กโฟลว์ที่เฉพาะเจาะจง (เช่น การย้ายข้อมูลฐานข้อมูลหรือการตรวจสอบความปลอดภัย) เมื่อเริ่มต้นเซสชัน ความสามารถเหล่านี้จะรวมอยู่ในหน่วยแบบแยกส่วนที่ค้นพบได้

วิธีการทำงาน

ในตอนแรก โมเดลจะแสดงเฉพาะ "เมนู" ข้อมูลเมตาแบบน้ำหนักเบา โดยจะโหลดความรู้เชิงกระบวนการที่ซับซ้อน (วิธีการและสคริปต์) ก็ต่อเมื่อความตั้งใจของผู้ใช้ตรงกับทักษะที่เฉพาะเจาะจงเท่านั้น ซึ่งจะช่วยให้มั่นใจได้ว่านักพัฒนาแอปที่ขอให้ปรับโครงสร้างมิดเดิลแวร์การตรวจสอบสิทธิ์จะได้รับบริบทด้านความปลอดภัยโดยไม่ต้องโหลดไปป์ไลน์ CSS ที่ไม่เกี่ยวข้อง ทำให้บริบทมีขนาดเล็ก รวดเร็ว และคุ้มค่า

3. ทักษะของ Agent และ Antigravity

ในระบบนิเวศ Antigravity หาก Agent Manager เป็นสมองและเครื่องมือแก้ไขเป็นผืนผ้าใบ ทักษะ จะทำหน้าที่เป็นโมดูลการฝึกอบรมเฉพาะทางที่เชื่อมช่องว่างระหว่างโมเดล Gemini 3 แบบทั่วไปกับบริบทที่เฉพาะเจาะจงของคุณ โดยจะช่วยให้ Agent "ติดตั้ง" ชุดวิธีการและโปรโตคอลที่กำหนดไว้ เช่น มาตรฐานการย้ายข้อมูลฐานข้อมูลหรือการตรวจสอบความปลอดภัย ก็ต่อเมื่อมีการขอให้ทำงานที่เกี่ยวข้องเท่านั้น การโหลดโปรโตคอลการดำเนินการเหล่านี้แบบไดนามิกจะเปลี่ยน AI จากโปรแกรมเมอร์ทั่วไปให้เป็นผู้เชี่ยวชาญที่ปฏิบัติตามแนวทางปฏิบัติแนะนำและมาตรฐานความปลอดภัยที่กำหนดไว้อย่างเคร่งครัด

ทักษะใน Antigravity คืออะไร

ในบริบทของ Google Antigravity ทักษะคือแพ็กเกจที่อิงตามไดเรกทอรีซึ่งมีไฟล์คำจำกัดความ (SKILL.md) และอาร์ติแฟกต์สนับสนุนที่ไม่บังคับ (สคริปต์ การอ้างอิง เทมเพลต)

ซึ่งเป็นกลไกสำหรับการขยายความสามารถตามความต้องการ

ตามความต้องการ: ทักษะจะโหลดลงในบริบทของ Agent ก็ต่อเมื่อ Agent กำหนดว่าเกี่ยวข้องกับคำขอปัจจุบันของผู้ใช้เท่านั้น ซึ่งแตกต่างจากพรอมต์ระบบ (ซึ่งจะโหลดเสมอ) วิธีนี้จะเพิ่มประสิทธิภาพหน้าต่างบริบทและป้องกันไม่ให้ Agent ฟุ้งซ่านกับวิธีการที่ไม่เกี่ยวข้อง ในโปรเจ็กต์ขนาดใหญ่ที่มีเครื่องมือหลายสิบรายการ การโหลดแบบเลือกนี้มีความสำคัญอย่างยิ่งต่อประสิทธิภาพและความแม่นยำในการให้เหตุผล
การขยายความสามารถ: ทักษะทำได้มากกว่าแค่การสั่งการ แต่ยังดำเนินการได้ด้วย การรวมสคริปต์ Python หรือ Bash เข้าด้วยกันจะช่วยให้ทักษะสามารถให้ความสามารถแก่ Agent ในการดำเนินการหลายขั้นตอนที่ซับซ้อนในเครื่องในเครื่องหรือเครือข่ายภายนอกได้โดยไม่ต้องให้ผู้ใช้เรียกใช้คำสั่งด้วยตนเอง ซึ่งจะเปลี่ยน Agent จากเครื่องมือสร้างข้อความให้เป็นผู้ใช้เครื่องมือ

ทักษะเทียบกับระบบนิเวศ (เครื่องมือ กฎ และเวิร์กโฟลว์)

ในขณะที่ Model Context Protocol (MCP) ทำหน้าที่เป็น "มือ" ของ Agent ซึ่งให้การเชื่อมต่อที่ใช้งานหนักและต่อเนื่องกับระบบภายนอก เช่น GitHub หรือ PostgreSQL ทักษะจะทำหน้าที่เป็น "สมอง" ที่สั่งการ

MCP จัดการโครงสร้างพื้นฐานแบบเก็บสถานะ ในขณะที่ทักษะเป็นคำจำกัดความของงานแบบชั่วคราวและน้ำหนักเบาซึ่งรวมวิธีการใช้เครื่องมือเหล่านั้น แนวทางแบบ Serverless นี้ช่วยให้ Agent ดำเนินการตามงานเฉพาะกิจ (เช่น การสร้างบันทึกการเปลี่ยนแปลงหรือการย้ายข้อมูล) ได้โดยไม่ต้องมีค่าใช้จ่ายด้านการดำเนินงานในการเรียกใช้กระบวนการต่อเนื่อง โดยจะโหลดบริบทก็ต่อเมื่อมีการใช้งานเท่านั้น และจะปล่อยบริบททันทีหลังจากนั้น

ในแง่การทำงาน ทักษะจะอยู่ตรงกลางระหว่าง "กฎ" (การป้องกันแบบพาสซีฟที่เปิดอยู่เสมอ) กับ "เวิร์กโฟลว์" (แมโครแบบแอ็กทีฟที่ผู้ใช้ทริกเกอร์) ทักษะจะทริกเกอร์โดย Agent ซึ่งแตกต่างจากเวิร์กโฟลว์ที่ต้องใช้คำสั่งที่เฉพาะเจาะจง (เช่น /test) โดยโมเดลจะตรวจหาความตั้งใจของผู้ใช้โดยอัตโนมัติและติดตั้งความเชี่ยวชาญที่เฉพาะเจาะจงที่จำเป็นแบบไดนามิก สถาปัตยกรรมนี้ช่วยให้สามารถประกอบกันได้อย่างมีประสิทธิภาพ ตัวอย่างเช่น กฎส่วนกลางสามารถบังคับใช้ทักษะ "การย้ายข้อมูลที่ปลอดภัย" ระหว่างการเปลี่ยนแปลงฐานข้อมูล หรือเวิร์กโฟลว์เดียวสามารถจัดระเบียบทักษะหลายอย่างเพื่อสร้างไปป์ไลน์การติดตั้งใช้งานที่แข็งแกร่ง

4. การสร้างทักษะ

การสร้างทักษะใน Antigravity ต้องเป็นไปตามโครงสร้างไดเรกทอรีและรูปแบบไฟล์ที่เฉพาะเจาะจง การกำหนดมาตรฐานนี้ช่วยให้มั่นใจได้ว่าทักษะจะพกพาได้และ Agent สามารถแยกวิเคราะห์และดำเนินการได้อย่างน่าเชื่อถือ การออกแบบนั้นจงใจให้เรียบง่าย โดยอาศัยรูปแบบที่เข้าใจกันอย่างกว้างขวาง เช่น Markdown และ YAML ซึ่งช่วยลดอุปสรรคในการเริ่มต้นสำหรับนักพัฒนาแอปที่ต้องการขยายความสามารถของ IDE

โครงสร้างไดเรกทอรี

คุณกำหนดทักษะได้ 2 ขอบเขต ซึ่งช่วยให้ปรับแต่งได้ทั้งแบบเฉพาะเจาะจงสำหรับโปรเจ็กต์และแบบเฉพาะเจาะจงสำหรับผู้ใช้

ขอบเขตพื้นที่ทำงาน: อยู่ใน <workspace-root>/.agent/skills/ ทักษะเหล่านี้ใช้ได้เฉพาะภายในโปรเจ็กต์ที่เฉพาะเจาะจงเท่านั้น เหมาะสำหรับสคริปต์ที่เฉพาะเจาะจงสำหรับโปรเจ็กต์ เช่น การทำให้ใช้งานได้ในสภาพแวดล้อมที่เฉพาะเจาะจง การจัดการฐานข้อมูลสำหรับแอปนั้น หรือการสร้างโค้ด Boilerplate สำหรับเฟรมเวิร์กที่เป็นกรรมสิทธิ์
ขอบเขตส่วนกลาง: อยู่ใน ~/.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 คือสมองของทักษะ โดยจะบอก Agent ว่าทักษะคืออะไร ควรใช้เมื่อใด และจะดำเนินการอย่างไร

ไฟล์นี้ประกอบด้วย 2 ส่วน ได้แก่

ส่วนหัว YAML
เนื้อหา Markdown

ส่วนหัว YAML

นี่คือเลเยอร์ข้อมูลเมตา ซึ่งเป็นส่วนเดียวของทักษะที่ตัวจัดเส้นทางระดับสูงของ Agent ทำดัชนี เมื่อผู้ใช้ส่งพรอมต์ Agent จะจับคู่พรอมต์กับช่องคำอธิบายของทักษะทั้งหมดที่มีอยู่ตามความหมาย

---
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) หากไม่ระบุ ระบบจะใช้ชื่อไดเรกทอรีเป็นค่าเริ่มต้น
description: บังคับและเป็นช่องที่สำคัญที่สุด โดยจะทำหน้าที่เป็น "วลีทริกเกอร์" ต้องอธิบายได้เพียงพอเพื่อให้ LLM จดจำความเกี่ยวข้องตามความหมายได้ คำอธิบายที่คลุมเครือ เช่น "เครื่องมือฐานข้อมูล" ไม่เพียงพอ คำอธิบายที่แม่นยำ เช่น "เรียกใช้การค้นหา SQL แบบอ่านอย่างเดียวกับฐานข้อมูล PostgreSQL ในเครื่องเพื่อดึงข้อมูลผู้ใช้หรือข้อมูลธุรกรรม ใช้คำอธิบายนี้เพื่อแก้ไขข้อบกพร่องของสถานะข้อมูล" จะช่วยให้ระบบเลือกทักษะได้อย่างถูกต้อง

เนื้อหา Markdown

เนื้อหาประกอบด้วยวิธีการ ซึ่งเป็นการ "วิศวกรรมพรอมต์ (Prompt Engineering)" ที่บันทึกลงในไฟล์ เมื่อเปิดใช้งานทักษะ ระบบจะแทรกเนื้อหานี้ลงในหน้าต่างบริบทของ Agent

เนื้อหาควรมีข้อมูลต่อไปนี้

เป้าหมาย: คำกล่าวที่ชัดเจนเกี่ยวกับสิ่งที่ทักษะทำได้
วิธีการ: ตรรกะแบบทีละขั้นตอน
ตัวอย่าง: ตัวอย่างอินพุตและเอาต์พุตแบบไม่กี่ช็อตเพื่อแนะนำประสิทธิภาพของโมเดล
ข้อจำกัด: กฎ "ห้าม" (เช่น "ห้ามเรียกใช้การค้นหา 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.

การผสานรวมสคริปต์

หนึ่งในฟีเจอร์ที่มีประสิทธิภาพมากที่สุดของทักษะคือความสามารถในการมอบหมายการดำเนินการให้กับสคริปต์ ซึ่งช่วยให้ Agent ดำเนินการที่ LLM ทำได้ยากหรือทำไม่ได้โดยตรง (เช่น การดำเนินการไบนารี การคำนวณทางคณิตศาสตร์ที่ซับซ้อน หรือการโต้ตอบกับระบบเดิม)

วางสคริปต์ไว้ในไดเรกทอรีย่อย scripts/ โดย SKILL.md จะอ้างอิงสคริปต์ตาม Relative Path

5. การเขียนทักษะ

เป้าหมายของส่วนนี้คือการสร้างทักษะที่ผสานรวมเข้ากับ Antigravity และแสดงฟีเจอร์ต่างๆ เช่น ทรัพยากร / สคริปต์ / ฯลฯ แบบค่อยเป็นค่อยไป

คุณสามารถดาวน์โหลดทักษะจากที่เก็บ Github ได้ที่ https://github.com/rominirani/antigravity-skills

เราสามารถพิจารณาวางทักษะแต่ละอย่างเหล่านี้ไว้ในโฟลเดอร์ ~/.gemini/antigravity/skills หรือโฟลเดอร์ /.agent/skills

ระดับที่ 1 : ตัวจัดเส้นทางพื้นฐาน ( `git-commit-formatter` )

ลองพิจารณาว่านี่คือ "Hello World" ของทักษะ

นักพัฒนาแอปมักจะเขียนข้อความคอมมิตแบบคร่าวๆ เช่น "wip", "fix bug", "updates" การบังคับใช้ "คอมมิตแบบเดิม" ด้วยตนเองนั้นน่าเบื่อและมักจะลืม มาใช้ทักษะที่บังคับใช้ข้อกำหนดคอมมิตแบบเดิมกัน เพียงแค่สั่งให้ Agent ทำตามกฎ เราก็อนุญาตให้ Agent ทำหน้าที่เป็นผู้บังคับใช้ได้

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`

วิธีเรียกใช้ตัวอย่างนี้:

ทำการเปลี่ยนแปลงเล็กน้อยกับไฟล์ใดก็ได้ในพื้นที่ทำงาน
เปิดแชทแล้วพิมพ์ว่า "คอมมิตการเปลี่ยนแปลงเหล่านี้"
Agent จะไม่เพียงแค่เรียกใช้ 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/ ทักษะจะสั่งให้ Agent อ่านไฟล์นี้เมื่อจำเป็นเท่านั้น

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
Agent จะอ่าน license-header-adder/resources/HEADER_TEMPLATE.txt
จากนั้นจะวางเนื้อหาลงในไฟล์ของคุณแบบตรงตัวทุกประการ

ระดับที่ 3: การเรียนรู้จากตัวอย่าง (json-to-pydantic)

รูปแบบ "ไม่กี่ช็อต"

การแปลงข้อมูลแบบหลวมๆ (เช่น การตอบกลับของ JSON API) เป็นโค้ดที่เข้มงวด (เช่น โมเดล Pydantic) ต้องมีการตัดสินใจหลายสิบครั้ง เราควรตั้งชื่อคลาสอย่างไร ควรใช้ Optional ไหม snake_case หรือ camelCase การเขียนกฎ 50 ข้อนี้เป็นภาษาอังกฤษนั้นน่าเบื่อและมีแนวโน้มที่จะเกิดข้อผิดพลาด

LLM เป็นเครื่องมือจับคู่รูปแบบ

การแสดงตัวอย่างที่ดีที่สุด (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 ซึ่งทั้ง 2 ไฟล์แสดงอยู่ด้านล่าง

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 แก่ Agent (วางในแชทหรือชี้ไปยังไฟล์)

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

พิมพ์ว่า Convert this JSON to a Pydantic model
Agent จะดูคู่ 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 ดูถูกต้อง

มามอบหมายการตรวจสอบนี้ให้กับสคริปต์เชิงกำหนดกัน เราใช้ทักษะเพื่อกำหนดเส้นทางให้ Agent เรียกใช้สคริปต์ Python ที่เราเขียน สคริปต์จะให้ความจริงแบบไบนารี (จริง/เท็จ)

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
Agent จะไม่คาดเดา แต่จะเรียกใช้สคริปต์ ซึ่งจะล้มเหลว (รหัสออก 1) และจะรายงานให้เราทราบว่า "การตรวจสอบล้มเหลวเนื่องจากตาราง 'users' ไม่มีคีย์หลัก"

ระดับที่ 5: สถาปนิก (adk-tool-scaffold)

รูปแบบนี้ครอบคลุมฟีเจอร์ส่วนใหญ่ที่มีอยู่ในทักษะ

งานที่ซับซ้อนมักต้องใช้ลำดับการดำเนินการที่รวมทุกสิ่งที่เราได้เห็นมาแล้ว ได้แก่ การสร้างไฟล์ การทำตามเทมเพลต และการเขียนตรรกะ การสร้างเครื่องมือใหม่สำหรับ ADK (Agent Development Kit) ต้องใช้ทุกสิ่งนี้

เราจะรวมสิ่งต่อไปนี้

สคริปต์ (เพื่อจัดการการสร้าง/การจัดโครงสร้างไฟล์)
เทมเพลต (เพื่อจัดการโค้ดเริ่มต้นในทรัพยากร)
ตัวอย่าง (เพื่อแนะนำการสร้างตรรกะ)

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

ไฟล์ SKILL.md แสดงอยู่ด้านล่าง คุณสามารถดูที่เก็บทักษะ เพื่อตรวจสอบไฟล์ในโฟลเดอร์สคริปต์ ทรัพยากร และตัวอย่าง สำหรับทักษะที่เฉพาะเจาะจงนี้ ให้ไปที่ทักษะ 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 (การจัดโครงสร้าง): Agent จะเรียกใช้สคริปต์ Python ซึ่งจะสร้าง StockPriceTool.py ทันทีด้วยโครงสร้างคลาส การนำเข้า และชื่อคลาส StockPriceTool ที่ถูกต้อง
ขั้นตอนที่ 2 (การใช้งาน): Agent จะ "อ่าน" ไฟล์ที่เพิ่งสร้าง และเห็น # TODO: Implement logic.
ขั้นตอนที่ 3 (คำแนะนำ): Agent ไม่แน่ใจว่าจะกำหนดสคีมา JSON สำหรับอาร์กิวเมนต์ของเครื่องมืออย่างไร จึงตรวจสอบ examples/WeatherTool.py
การดำเนินการให้เสร็จสมบูรณ์: Agent จะแก้ไขไฟล์เพื่อเพิ่ม requests.get(...) และกำหนดอาร์กิวเมนต์ตัวย่อในสคีมา โดยให้ตรงกับสไตล์ ADK ทุกประการ

6. ขอแสดงความยินดี

คุณทำแล็บเกี่ยวกับทักษะ Antigravity ได้สำเร็จและสร้างทักษะต่อไปนี้

ตัวจัดรูปแบบคอมมิต Git
ตัวเพิ่มส่วนหัวของใบอนุญาต
JSON เป็น Pydantic
โปรแกรมตรวจสอบสคีมาฐานข้อมูล
การจัดโครงสร้างเครื่องมือ ADK

ทักษะของ Agent เป็นวิธีที่ยอดเยี่ยมในการใช้ Antigravity เพื่อเขียนโค้ดในแบบของคุณ ทำตามกฎ และใช้เครื่องมือของคุณ

เอกสารอ้างอิง

Codelab : เริ่มต้นใช้งาน Google Antigravity
เว็บไซต์อย่างเป็นทางการ : https://antigravity.google/
เอกสารประกอบ: https://antigravity.google/docs
ดาวน์โหลด : https://antigravity.google/download
เอกสารประกอบเกี่ยวกับทักษะ Antigravity: https://antigravity.google/docs/skills

1. บทนำ

2. เหตุผลที่ต้องมีทักษะ

วิธีแก้ปัญหา: ทักษะของ Agent

วิธีการทำงาน

3. ทักษะของ Agent และ 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` )