Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

ยกระดับคุณภาพของโค้ด: การตรวจสอบโค้ดที่ AI ช่วยด้วย Antigravity CLI และ SDK

1. บทนำ

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

Codelab นี้จะแก้ปัญหาดังกล่าวด้วยการสอน 2 วิธีในการใช้ Antigravity เป็นผู้ตรวจสอบ ได้แก่ การโต้ตอบระหว่างการพัฒนาด้วย CLI (คุณตรวจสอบ แก้ไข แล้ว PR) และโดยอัตโนมัติในการผสานรวมอย่างต่อเนื่องด้วย SDK (Agent จะตรวจสอบคำขอ Pull ทุกรายการและโพสต์ผลลัพธ์เป็นความคิดเห็น)

สิ่งที่คุณจะได้สำรวจ

คุณใช้ไวบ์โค้ดแอป CRM สำหรับโอกาสในการขาย ซึ่งเป็นเอเจนต์ AI ที่สร้างฟูลสแต็กให้คุณ ได้แก่ แบ็กเอนด์ Express, ฐานข้อมูล SQLite และฟรอนต์เอนด์ React ซึ่งได้ผล จากนั้นคุณได้ขอให้เอเจนต์เพิ่มฟีเจอร์ใหม่ 2 อย่าง ได้แก่ ฟังก์ชันการค้นหาโอกาสในการขาย และการนำเข้า/ส่งออกแบบกลุ่มพร้อมสถิติของผู้ดูแลระบบ ตัวแทนส่งทั้ง 2 อย่างได้อย่างรวดเร็ว โค้ดทำงาน ฟีเจอร์ทำงาน และคำขอส่งรวม (PR) พร้อมใช้งาน

แต่ปัญหาคือคุณไม่ได้เขียนโค้ดนี้ คุณอนุมัติแล้ว คุณทราบได้อย่างไรว่าปลายทางการค้นหาไม่มีช่องโหว่ต่อการแทรก SQL คุณทราบได้อย่างไรว่าเส้นทางของผู้ดูแลระบบไม่มีรหัสผ่านที่ฮาร์ดโค้ด คุณไม่จำเป็นต้องทำเช่นนั้น และการอ่านโค้ดทุกบรรทัดที่ AI สร้างขึ้นจะทำให้คุณเสียเปรียบด้านความเร็วซึ่งเป็นเหตุผลที่ทำให้คุณเขียนโค้ดแบบไวบ์ตั้งแต่แรก

Codelab นี้จะแสดงวิธีแก้ปัญหานี้ 2 วิธี

กรณีที่ 1 - การตรวจสอบแบบอินเทอร์แอกทีฟ: ตรวจสอบกิ่งก้านของฟีเจอร์ที่มีช่องโหว่ ใช้ Antigravity CLI ที่ได้รับการปรับปรุงด้วยทักษะของ Agent เพื่อตรวจสอบ Diff แก้ไขปัญหา และสร้าง PR ที่สะอาด
กรณีที่ 2 – การตรวจสอบแบบอัตโนมัติ: ตั้งค่า GitHub Action ที่ขับเคลื่อนโดย Antigravity SDK ซึ่งจะตรวจสอบ PR โดยอัตโนมัติ โพสต์ผลการค้นหาที่มีโครงสร้างเป็นความคิดเห็น และตอบกลับเมื่อนักพัฒนาซอฟต์แวร์ถามคำถามติดตามผลในการตรวจสอบ

สิ่งที่คุณจะได้เรียนรู้

วิธีที่ Vibe Coding อาจสร้างความเสี่ยงด้านความปลอดภัย และเหตุผลที่การตรวจสอบแบบอัตโนมัติจับสิ่งที่การตรวจสอบด้วยตนเองพลาดไปได้
วิธีติดตั้งและใช้ทักษะของเอเจนต์ที่ชุมชนดูแลเพื่อมอบความเชี่ยวชาญด้านการรักษาความปลอดภัยและรีวิวโค้ดอย่างละเอียดให้กับ Antigravity CLI
วิธีใช้ CLI แบบอินเทอร์แอกทีฟเพื่อตรวจสอบความแตกต่างของกิ่งก้านฟีเจอร์ แก้ไขช่องโหว่ และสร้าง PR ที่สะอาด
วิธีใช้ Antigravity SDK เพื่อสร้างเอเจนต์ตรวจสอบโค้ดแบบอ่านอย่างเดียวด้วยนโยบายความปลอดภัยแบบประกาศและฮุกวงจร
วิธีติดตั้งใช้งานเอเจนต์รีวิวเป็น GitHub Action ที่รีวิว PR และโพสต์ผลลัพธ์เป็นความคิดเห็นใน PR

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

บัญชี Google Cloud
บัญชี GitHub
มีความคุ้นเคยพื้นฐานกับเทอร์มินัล การควบคุมเวอร์ชัน และ CI/CD

2. การตั้งค่าสภาพแวดล้อม

ขั้นตอนนี้จะแยกที่เก็บแอป Leads CRM, โคลนที่เก็บใน Cloud Shell, ตั้งค่า Antigravity CLI และตรวจสอบสิทธิ์

ฟอร์กที่เก็บ

คุณต้องมีสำเนาที่เก็บเป็นของตัวเองเนื่องจากคุณจะพุชคอมมิตและสร้าง PR ด้วย GitHub Actions

ไปที่ที่เก็บต่อไปนี้

จากนั้นคลิกแยก ในหน้าการสร้าง Fork ให้ยกเลิกการเลือกช่องทำเครื่องหมาย "คัดลอกเฉพาะ Branch main" เนื่องจากคุณต้องมี Branch ฟีเจอร์อื่นๆ (feature/lead-search และ feature/bulk-operations) รวมอยู่ใน Fork ด้วย

เปิด Cloud Shell

เปิด Cloud Shell ในเบราว์เซอร์ Cloud Shell มีสภาพแวดล้อมที่กำหนดค่าไว้ล่วงหน้าพร้อมเครื่องมือทั้งหมดที่คุณต้องการสำหรับ Codelab นี้ คลิกให้สิทธิ์เมื่อมีข้อความแจ้งให้ทำ

จากนั้นคลิก "ดู" -> "เทอร์มินัล" เพื่อเปิดเทอร์มินัล อินเทอร์เฟซของคุณควรมีลักษณะคล้ายกับภาพนี้

นี่จะเป็นอินเทอร์เฟซหลักของเรา โดยมี IDE อยู่ด้านบนและเทอร์มินัลอยู่ด้านล่าง

ตรวจสอบสิทธิ์ด้วย GitHub

โดยค่าเริ่มต้น Cloud Shell จะไม่มีข้อมูลเข้าสู่ระบบ GitHub ที่กำหนดค่าไว้ แต่จะมี gh CLI ติดตั้งไว้แล้ว ตั้งค่าการตรวจสอบสิทธิ์เพื่อให้คุณพุชคอมมิตและสร้างคำขอให้รวมการเปลี่ยนแปลงได้ในภายหลัง

gh auth login

เลือก Github.com

เลือก HTTPS ( หรือหากคุ้นเคยกับกลไกอื่นๆ อยู่แล้ว ก็เลือกกลไกนั้นได้)

จากนั้นเลือก Y

จากนั้นเลือก Login with a web browser

**,**ระบบจะขอให้คุณคัดลอกรหัสแบบใช้ครั้งเดียวและป้อนรหัสดังกล่าวเมื่อคุณเปิดหน้าเข้าสู่ระบบในเบราว์เซอร์ คุณสามารถCtrl + Clickใน URL ในเทอร์มินัลเพื่อเปิด URL ของ https://github.com/login/device ระบบจะขอให้คุณเลือกบัญชีที่ต้องการเข้าสู่ระบบและป้อนรหัส

หลังจากนั้น ให้กลับไปที่หน้าคอนโซล Cloud Shell แล้วคุณจะเห็นเอาต์พุตของเทอร์มินัลดังนี้

✓ Authentication complete.
- gh config set -h github.com git_protocol https
✓ Configured git protocol
! Authentication credentials saved in plain text
✓ Logged in as alphinside-joonix

ซึ่งหมายความว่าคุณตั้งค่าการตรวจสอบสิทธิ์บัญชี Github ใน Cloud Shell เรียบร้อยแล้ว

โคลนที่เก็บที่แยก

จากนั้นมาโคลนที่เก็บที่แยกออกมากัน แทนที่ <YOUR_GITHUB_USERNAME> ด้วยชื่อผู้ใช้ GitHub ของคุณ

git clone https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo.git
cloudshell workspace leads-crm-app-demo && cd leads-crm-app-demo

ยืนยันสาขาฟีเจอร์

หลังจากนั้น ให้ตรวจสอบว่าทั้ง 2 สาขาฟีเจอร์ที่มีช่องโหว่ที่สร้างไว้ล่วงหน้าควรพร้อมใช้งานในรีโมต

git branch -a | grep feature/

คุณควรเห็นเอาต์พุตต่อไปนี้

remotes/origin/feature/bulk-operations
remotes/origin/feature/bulk-operations-solution
remotes/origin/feature/email-composer
remotes/origin/feature/lead-search

ยืนยัน Antigravity CLI

จากนั้นมายืนยันว่า Antigravity CLI ได้รับการติดตั้งล่วงหน้าใน Cloud Shell ตรวจสอบว่าฟีเจอร์นี้พร้อมใช้งานหรือไม่

agy --version

คุณควรเห็นเวอร์ชันของ Antigravity CLI ที่ติดตั้ง เช่น 1.0.13

หากยังไม่ได้ตรวจสอบสิทธิ์ Antigravity CLI คุณสามารถไปที่ Codelab นี้เพื่อดูขั้นตอนการตรวจสอบสิทธิ์โดยละเอียด

ตอนนี้คุณควรมีสิ่งต่อไปนี้

โคลนที่เก็บที่แยก
ทั้ง 2 สาขาฟีเจอร์ปรากฏให้เห็น
agy พร้อมใช้งานและได้รับการตรวจสอบสิทธิ์แล้ว

3. ปัญหา - ช่องโหว่ที่ซ่อนอยู่ในฟีเจอร์ที่เข้ารหัสด้วย Vibe

สถานการณ์มีดังนี้ เพื่อนร่วมทีมใช้ AI Agent เพื่อเพิ่ม 2 ฟีเจอร์ลงในแอป CRM ของโอกาสในการขาย ได้แก่ ฟังก์ชันการค้นหาโอกาสในการขาย และการดำเนินการนำเข้า/ส่งออกแบบกลุ่ม ทั้ง 2 ฟีเจอร์ใช้งานได้ ทั้ง 2 รายการจัดส่งอย่างรวดเร็วโดยไม่มีการตรวจสอบความปลอดภัย คุณจะตรวจสอบทั้ง 2 สาขาก่อนที่จะผสานรวม โดยสาขาหนึ่งจะตรวจสอบแบบอินเทอร์แอกทีฟด้วย CLI และอีกสาขาหนึ่งจะตรวจสอบโดยอัตโนมัติด้วย GitHub Action

ตรวจสอบ Branch ของฟีเจอร์แรก

ดูความแตกต่างใน feature/lead-search

git diff main...origin/feature/lead-search

สาขานี้เพิ่มปลายทางการค้นหา สแกน Diff คุณควรพบปัญหาต่างๆ เช่น การต่อสตริงในคำค้นหา SQL, การตรวจสอบอินพุตที่ขาดหายไป, การบันทึกการแก้ไขข้อบกพร่องที่ทำให้รายละเอียดการค้นหารั่วไหล และข้อความแสดงข้อผิดพลาดดิบที่เปิดเผยต่อไคลเอ็นต์

+  app.get("/api/leads/search", (req, res) => {
+    const query = req.query.q as string;
+
+    if (!query) {
+      return res.status(400).json({ error: "Search query is required" });
+    }
...

ตรวจสอบกิ่งฟีเจอร์ที่ 2

git diff main...origin/feature/bulk-operations

สาขานี้เพิ่มปลายทางการนำเข้า/ส่งออกแบบกลุ่มและแดชบอร์ดสถิติผู้ดูแลระบบ ช่องโหว่ในที่นี้รวมถึงข้อมูลเข้าสู่ระบบของผู้ดูแลระบบที่ฮาร์ดโค้ดไว้, ปลายทางของผู้ดูแลระบบที่ไม่ได้ตรวจสอบสิทธิ์, ไม่มีการตรวจสอบอินพุตในการนำเข้าแบบกลุ่ม และความเสี่ยงในการโจมตีแบบ Path Traversal ในการจัดการชื่อไฟล์ส่งออก

...
+  const ADMIN_PASSWORD = "admin123";
+
+  app.post("/api/admin/import", (req, res) => {
+    const { password, leads } = req.body;
+
+    if (password !== ADMIN_PASSWORD) {
+      return res.status(401).json({ error: "Invalid admin password" });
+    }
...

ทั้ง 2 สาขาเพิ่มฟีเจอร์การทำงาน ทั้ง 2 อย่างมีปัญหาด้านความปลอดภัย คำถามคือจะตรวจจับได้อย่างไร ไม่ว่าจะด้วยตนเองด้วย CLI (กรณีที่ 1) หรือโดยอัตโนมัติด้วย GitHub Action (กรณีที่ 2)

4. กรณีที่ 1 : การตรวจสอบแบบอินเทอร์แอกทีฟด้วย Antigravity CLI

การตรวจสอบ CLI แบบอินเทอร์แอกทีฟมีประโยชน์มากที่สุดหลังจากเซสชัน Vibe Coding การตรวจสอบโค้ดที่คุณเพิ่งเขียน หรือการตรวจสอบ Pull Request ของเพื่อนร่วมทีม หากเรากำลังพูดถึงการเขียนโค้ดตามความรู้สึก เอเจนต์ AI จะสร้างโค้ดฟีเจอร์ของคุณได้อย่างรวดเร็ว แต่คุณอาจไม่เข้าใจทุกบรรทัดที่เอเจนต์สร้างขึ้นอย่างถ่องแท้ และเอเจนต์อาจได้รับการเพิ่มประสิทธิภาพเพื่อการทำงาน ไม่ใช่เพื่อความปลอดภัยเสมอไป ทั้งนี้ขึ้นอยู่กับการกำหนดค่าบริบทขณะที่คุณพัฒนาฟีเจอร์

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

หากไม่มีทักษะของเอเจนต์ Antigravity CLI ก็ยังคงตรวจสอบโค้ดได้ แต่จะอิงตามความรู้จากการฝึกทั่วไป ซึ่งอาจพลาดรูปแบบเฉพาะโดเมนหรือใช้เกณฑ์การตรวจสอบที่ไม่สอดคล้องกันในแต่ละเซสชัน ทักษะของตัวแทนจะช่วยให้ตัวแทนมีเพลย์บุ๊กที่มีโครงสร้าง ซึ่งประกอบด้วยการตรวจสอบ 5 ด้านเพื่อคุณภาพ และการติดป้ายกำกับความรุนแรงเพื่อการจัดลําดับความสําคัญ การตรวจสอบจะทำซ้ำได้และละเอียดไม่ว่าคุณจะใช้คำสั่งในรูปแบบใดก็ตาม

ขั้นตอนนี้ใช้ Antigravity CLI กับทักษะของเอเจนต์เพื่อตรวจสอบ Branch feature/lead-search แก้ไขช่องโหว่ และสร้าง PR ที่สะอาด

ตรวจสอบ Branch ฟีเจอร์

ก่อนอื่น ให้เปลี่ยน Branch เป็น Branch Case 1 โดยทำดังนี้

git checkout feature/lead-search

ต่อไป มาอัปเกรด Antigravity CLI ด้วยทักษะของเอเจนต์เพื่อทำการตรวจสอบกัน

ทักษะของตัวแทนคืออะไร

ทักษะคือไฟล์มาร์กดาวน์แบบประกาศที่ให้ความเชี่ยวชาญเฉพาะทางแก่เอเจนต์ เมื่อติดตั้งแล้ว คำสั่งเหล่านี้จะกลายเป็นคำสั่ง Slash (เช่น /code-review-and-quality) ซึ่งเปรียบเสมือนการมอบเพลย์บุ๊กด้านความปลอดภัยของวิศวกรอาวุโสให้กับเอเจนต์อเนกประสงค์

ทักษะสามารถนำไปใช้กับเอเจนต์ต่างๆ (Antigravity, Claude Code, Cursor ฯลฯ) และแชร์ผ่าน Git ได้ สำหรับ Antigravity CLI ทักษะของพื้นที่ทำงาน (โปรเจ็กต์/เครื่อง) จะอยู่ใน .agents/skills/ ที่รูทของโปรเจ็กต์ ส่วนทักษะระดับโลกจะอยู่ใน ~/.gemini/config/skills/ ดูข้อมูลเพิ่มเติมได้ในเอกสารนี้

Codelab นี้จะใช้ทักษะรีวิวโค้ดจาก addyosmani/agent-skills เพื่อแสดงความสามารถของทักษะ Agent

code-review-and-quality - การตรวจสอบ 5 ด้าน (ความถูกต้อง ความสามารถในการอ่าน สถาปัตยกรรม ความปลอดภัย ประสิทธิภาพ) พร้อมการติดป้ายกำกับความรุนแรง

หมายเหตุ: ทักษะของตัวแทนเหล่านี้เป็นตัวอย่างที่ชัดเจนสำหรับบทแนะนำนี้ ไม่ใช่ตัวเลือกเดียว ระบบนิเวศของทักษะเอเจนต์เปิดกว้าง ทุกคนสามารถสร้างและแชร์ทักษะเป็นไฟล์มาร์กดาวน์ในที่เก็บ Git ได้ ที่เก็บ [ agent-skills] เพียงอย่างเดียวก็มีทักษะมากกว่า 20 รายการที่ครอบคลุมการทดสอบ การแก้ไขข้อบกพร่อง CI/CD และอื่นๆ นอกจากนี้ ยังมีคอลเล็กชันทักษะอื่นๆ ที่ชุมชนดูแลด้วย สำรวจตัวเลือกที่มีและเลือกสิ่งที่ตรงกับเวิร์กโฟลว์ของทีม หรือเขียนพรอมต์ของคุณเอง

ติดตั้งทักษะของ Agent รีวิวโค้ด

การใช้คำสั่งด้านล่างจะติดตั้งทักษะใน .agents/skills/ โดยค่าเริ่มต้นในไดเรกทอรีที่ทำงานอยู่ปัจจุบัน ซึ่งเป็นการติดตั้งระดับพื้นที่ทำงาน ซึ่งหมายความว่าไฟล์ดังกล่าวจะกลายเป็นส่วนหนึ่งของที่เก็บและสามารถคอมมิตพร้อมกับโค้ดได้ เพื่อให้นักพัฒนาซอฟต์แวร์ทุกคน (และไปป์ไลน์ CI) ในโปรเจ็กต์ได้รับทักษะการตรวจสอบเดียวกันโดยอัตโนมัติ

npx skills add addyosmani/agent-skills --skill code-review-and-quality -y

ต่อไปนี้คือทักษะแบบละเอียดที่ตรวจสอบได้ในไฟล์ .agents/skills/code-review-and-quality/SKILL.md

name: code-review-and-quality
description: Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.

ความสามารถหลัก

การตรวจสอบใน 5 ด้าน ได้แก่ ความถูกต้อง ความสามารถในการอ่าน สถาปัตยกรรม ความปลอดภัย และประสิทธิภาพ
ติดป้ายกำกับผลการค้นหาตามความรุนแรงเพื่อให้คุณแก้ไขปัญหาร้ายแรงก่อน
ใช้มาตรฐานการอนุมัติ: "อนุมัติเมื่อช่วยปรับปรุงสถานะโค้ดโดยรวมได้อย่างแน่นอน แม้ว่าจะยังไม่สมบูรณ์แบบ"

ตอนนี้เราพร้อมที่จะดำเนินการแล้ว มาตรวจสอบทักษะใน Antigravity CLI กัน

เปิดตัว AGY และยืนยันทักษะ

มาเรียกใช้ Antigravity CLI กัน

agy --dangerously-skip-permissions

จากนั้นเรียกใช้คำสั่งต่อไปนี้

/skills

คุณควรเห็นทักษะ 2 อย่างแสดงดังนี้ในส่วนWorkspace ทักษะ

เรียกใช้รีวิวโค้ดของส่วนต่างของฟีเจอร์

เรียกใช้ทักษะด้านความปลอดภัยและขอให้ตรวจสอบสาขา พิมพ์พรอมต์นี้

Review the git diff between main and my current branch. Find any issues based on the agent skills that are appropriate for this. Write the findings and plan to fix them to code_review.md in the current working directory. Do not apply fixes yet.

เอเจนต์จะตรวจหาcode-review-and-qualityทักษะที่เกี่ยวข้องและเปิดใช้งานโดยอัตโนมัติ โดยจะอ่าน Diff ระบุช่องโหว่ และเขียนผลการค้นหาพร้อมแผนการแก้ไขที่เสนอไปยัง code_review.md

หลังจากสแกนเสร็จแล้ว คุณควรเห็นไฟล์ code_review.md ที่สร้างขึ้นในไดเรกทอรีการทำงานและตรวจสอบได้ในโปรแกรมแก้ไข

ตรวจสอบการค้นพบแต่ละรายการและการแก้ไขที่เสนอ เมื่อพอใจกับแพ็กเกจแล้ว ให้ขอให้ตัวแทนสมัครแพ็กเกจให้คุณโดยทำดังนี้

Apply the proposed fixes from code_review.md

Agent จะอ่านแผนและใช้การแก้ไขที่วางแผนไว้แต่ละรายการกับไฟล์ต้นฉบับ

ตอนนี้หากต้องการ คุณสามารถตรวจสอบว่าแอปทำงานอย่างถูกต้องหรือไม่หลังจากแก้ไขแล้วได้โดยการติดตั้งทรัพยากร Dependency และดำเนินการ

npm install
npm run dev

แอปพลิเคชันควรทำงานได้อย่างถูกต้อง หากไม่ถูกต้อง คุณสามารถทำซ้ำและขอให้ Antigravity CLI แก้ไขได้

Commit และสร้าง PR

ตอนนี้คุณสามารถพุชการเปลี่ยนแปลงไปยังที่เก็บของคุณเองได้หากต้องการ ก่อนที่จะไปที่เคสถัดไป ให้คอมมิตการเปลี่ยนแปลงลงในกิ่งปัจจุบันก่อน

ก่อนอื่นเราต้องกำหนดค่าข้อมูลประจำตัว Git ของคุณ (แทนที่ด้วยชื่อและอีเมลของคุณเอง) หากคุณยังไม่ได้ดำเนินการ

git config --global user.email "you@example.com"
git config --global user.name "Your Name"

จากนั้นให้คอมมิตการเปลี่ยนแปลง

git add .
git commit -m "fix: address security vulnerabilities in lead search feature"

ตอนนี้คุณใช้ Antigravity CLI เป็นผู้ตรวจสอบแบบอินเทอร์แอกทีฟแล้ว ทักษะเหล่านี้ช่วยให้มีวิธีการที่เป็นระบบ นั่นคือการรีวิวโค้ดแบบ 5 แกน วิธีนี้ใช้ได้เมื่อคุณเป็นนักพัฒนาแอปที่ตรวจสอบโค้ดที่ AI สร้างขึ้น โค้ดของคุณเอง หรือโค้ดที่เพื่อนร่วมทีมมีส่วนร่วม ในส่วนถัดไป เราจะทำให้ขั้นตอนทั้งหมดนี้เป็นแบบอัตโนมัติเพื่อให้เป็นกระบวนการอัตโนมัติที่ปรับขนาดได้ในที่เก็บโค้ดโดยใช้ Github เป็นตัวอย่าง

5. กรณีที่ 2 : การตรวจสอบอัตโนมัติด้วย Antigravity SDK - ตอนที่ 1 ( การสร้างเอเจนต์)

ขั้นตอนนี้จะสร้าง Agent การตรวจสอบแบบอัตโนมัติโดยใช้ Antigravity SDK, ทำให้ใช้งานได้เป็น GitHub Action และทดสอบกับ Branch ฟีเจอร์ที่ 2 ตัวแทนจะตรวจสอบคำขอ PR ตามคำขอและโพสต์สิ่งที่พบเป็นความคิดเห็นใน PR

เหตุผลที่ต้องมีการตรวจสอบแบบอัตโนมัติ

การตรวจสอบ CLI แบบอินเทอร์แอกทีฟ (กรณีที่ 1) จะทำงานเมื่อนักพัฒนาแอปตรวจสอบอย่างสม่ำเสมอ ทีมต้องการการตรวจสอบที่ทำงานโดยอัตโนมัติในทุก PR เพื่อตรวจหาปัญหาจากผู้มีส่วนร่วม เครื่องมือ และเวลาใดก็ได้ Antigravity SDK (google-antigravity) มีรันไทม์ของเอเจนต์เช่นเดียวกับ CLI ในรูปแบบไลบรารี Python นโยบายและ Hook ได้รับการกำหนดค่าในโค้ด

GitHub Actions คือแพลตฟอร์มการรวมอย่างต่อเนื่อง/การพัฒนาอย่างต่อเนื่อง (CI/CD) ในตัวของ GitHub โดยจะเรียกใช้เวิร์กโฟลว์ ซึ่งเป็นสคริปต์อัตโนมัติที่กำหนดไว้ใน YAML เพื่อตอบสนองต่อเหตุการณ์ในที่เก็บ เช่น การเปิด PR, การพุชคอมมิต หรือการโพสต์ความคิดเห็น เวิร์กโฟลว์จะทำงานในเครื่องเสมือนที่โฮสต์ใน GitHub และมีสิทธิ์เข้าถึงโค้ดที่เก็บ ในกรณีนี้ คุณจะใช้ GitHub Action เพื่อเรียกใช้เอเจนต์ตรวจสอบความปลอดภัยทุกครั้งที่มีการสร้าง PR

ขั้นตอนการตรวจสอบแบบอัตโนมัติมีดังนี้

Antigravity SDK ( google-antigravity) มีรันไทม์ของเอเจนต์เดียวกันกับ CLI ในรูปแบบไลบรารี Python คุณเขียนสคริปต์ Python ที่กำหนดค่าเอเจนต์ด้วยนโยบายและ Hook ดำเนินการภายใน GitHub Action และโพสต์ผลลัพธ์เป็นความคิดเห็นใน PR

รับคีย์ Gemini API

ก่อนเริ่ม เราจะต้องใช้คีย์ Gemini API เพื่อให้ Antigravity SDK ใช้ได้ ไปที่คีย์ API ของ Google AI Studio แล้วสร้างคีย์ API และคัดลอกคีย์ API ได้ทุกเมื่อที่ต้องการ

ระบบจะใช้คีย์นี้เมื่อเรียกใช้เอเจนต์ตรวจสอบในเครื่องและเป็นข้อมูลลับของ GitHub Actions ในภายหลัง

ส่วน ก: สร้างเอเจนต์รีวิว

ตอนนี้สำหรับกรณีที่ 2 ให้เปลี่ยนไดเรกทอรีการทำงานปัจจุบันเป็นกิ่ง feature/bulk-operations โดยทำดังนี้

git checkout feature/bulk-operations

นี่คือฟีเจอร์สาขาที่ 2 จากสถานการณ์สมมติ ซึ่งจะเพิ่มปลายทางการนำเข้า/ส่งออกแบบกลุ่มและแดชบอร์ดสถิติผู้ดูแลระบบไปยังแอป CRM

ตั้งค่าโปรเจ็กต์ Python

ปัจจุบัน Antigravity SDK พร้อมให้บริการใน Python เท่านั้น ดังนั้นเราจึงต้องมีสภาพแวดล้อม Python เพื่อพัฒนา เราจะใช้ uv สำหรับผู้จัดการโปรเจ็กต์ Python uv เป็นแพ็กเกจ Python และเครื่องมือจัดการโปรเจ็กต์ที่รวดเร็วซึ่งเขียนด้วย Rust ( เอกสาร) Codelab นี้ใช้เพื่อความรวดเร็วและความเรียบง่าย หากใช้ Cloud Shell สำหรับบทแนะนำนี้ ระบบจะติดตั้งไว้ล่วงหน้าในอินสแตนซ์แล้ว ดูบทแนะนำนี้หากต้องการติดตั้งสำหรับเครื่องของคุณ

เริ่มต้นโปรเจ็กต์ Python สำหรับตัวแทนตรวจสอบโดยใช้ uv ดังนี้

uv init code_review_agent
uv add --project code_review_agent google-antigravity==0.1.7

โดยจะสร้างไดเรกทอรีใหม่ code_review_agent ซึ่งจะมีไฟล์ของเอเจนต์รีวิวโค้ดที่จำเป็น

ติดตั้งทักษะการตรวจสอบ

ตัวแทนตรวจสอบต้องมีทักษะด้านความปลอดภัยและการรีวิวโค้ดแบบเดียวกับที่ใช้ในกรณีที่ 1 ติดตั้งลงใน code_review_agent/skills/ เพื่อให้ตัวแทน SDK โหลดได้ในขณะรันไทม์

npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
cp -r .agents/skills code_review_agent/skills

สร้างเอเจนต์รีวิว

หมายเหตุ: คุณยังติดตั้งทักษะเอเจนต์ของ Antigravity SDK เพื่อขอให้ Antigravity CLI สร้างเอเจนต์ให้คุณได้ด้วย ติดตั้งทักษะ SDK อย่างเป็นทางการ (npx skills add google-antigravity/antigravity-sdk-python) เปิดใช้ Antigravity CLI และอธิบายข้อกำหนดของเอเจนต์ โดยทักษะ SDK จะให้ความรู้ที่ถูกต้องเกี่ยวกับ google-antigravity API แก่ AGY เพื่อให้สร้างโค้ดที่ถูกต้อง

ในบทแนะนำนี้ เราจะทำให้การดำเนินการมีความแน่นอนมากขึ้นโดยการให้การใช้งานอ้างอิง

มาสร้าง code_review_agent/review_agent.py กันเลย เรียกใช้คำสั่งต่อไปนี้

cloudshell edit code_review_agent/review_agent.py

จากนั้นคัดลอกเนื้อหาต่อไปนี้ลงในไฟล์

#!/usr/bin/env python3
import asyncio
import json
import os
import sys

import pydantic

from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig
from google.antigravity.hooks import hooks, policy
from google.antigravity import types


class Finding(pydantic.BaseModel):
    file: str
    line: int
    severity: str
    category: str
    description: str
    proposed_fix: str = ""


class ReviewResult(pydantic.BaseModel):
    findings: list[Finding]


SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUT_FILE = "code_review.md"
SKILLS_PATHS = [
    os.path.join(SCRIPT_DIR, "skills", "code-review-and-quality"),
]

review_policies = [
    policy.deny_all(),
    policy.allow("view_file"),
    policy.allow("list_directory"),
    policy.allow("search_directory"),
    policy.allow("find_file"),
    policy.allow("run_command"),
    policy.allow("finish"),
]

@hooks.post_tool_call
async def log_tool_results(data: types.ToolResult):
    result_str = str(data.result) if data.result else ""
    preview = result_str[:200] + "..." if len(result_str) > 200 else result_str
    print(f"[audit] tool={data.name} result_len={len(result_str)} error={data.error} preview={preview}", flush=True)

@hooks.pre_tool_call_decide
async def enforce_safe_tools(data: types.ToolCall) -> types.HookResult:
    print(f"[audit] calling tool={data.name} args_keys={list(data.args.keys())}", flush=True)

    if data.name == "run_command":
        cmd = str(data.args.get("CommandLine", ""))
        if not cmd.startswith("git "):
            return types.HookResult(
                allow=False,
                message=f"Only git commands are allowed. Blocked: {cmd}"
            )
    return types.HookResult(allow=True)

async def review_code(target_dir: str) -> dict:
    prompt = f"""Run `git diff main...HEAD -- ':!.github' ':!code_review_agent'` in {target_dir} to get the changes on this branch.
Review ONLY the changed code for security vulnerabilities and code quality issues.
"""

    config_kwargs = dict(
        system_instructions=(
            "You are a code review agent. "
            "You review code diffs for vulnerabilities and quality issues using the loaded skills. "
            "You can run git commands to inspect the diff. "
            "You NEVER modify files."
        ),
        response_schema=ReviewResult,
        skills_paths=SKILLS_PATHS,
        policies=review_policies,
        hooks=[log_tool_results, enforce_safe_tools],
    )

    if os.environ.get("GEMINI_API_KEY"):
        config_kwargs["api_key"] = os.environ["GEMINI_API_KEY"]
    else:
        config_kwargs["vertex"] = True
        config_kwargs["project"] = os.environ.get("GOOGLE_CLOUD_PROJECT")
        config_kwargs["location"] = os.environ.get("GOOGLE_CLOUD_LOCATION", "global")

    config = LocalAgentConfig(**config_kwargs)

    async with Agent(config) as agent:
        response = await agent.chat(prompt)

        last_step = -1
        final_text_chunks = []
        async for chunk in response.chunks:
            if isinstance(chunk, types.ToolCall):
                final_text_chunks.clear()
            if hasattr(chunk, "text") and hasattr(chunk, "step_index"):
                if chunk.step_index != last_step:
                    final_text_chunks.clear()
                    last_step = chunk.step_index
                final_text_chunks.append(chunk.text)

        final_text = "".join(final_text_chunks)
        if final_text:
            print(final_text)

        data = await response.structured_output()

        if data and "findings" in data:
            return {"findings": data["findings"]}

        try:
            parsed = json.loads(final_text)
            if isinstance(parsed, list):
                return {"findings": parsed}
            if isinstance(parsed, dict) and "findings" in parsed:
                return {"findings": parsed["findings"]}
        except json.JSONDecodeError:
            pass

    return {"findings": final_text}


SEVERITY_EMOJI = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵"}

def format_markdown(result: dict) -> str:
    findings = result.get("findings", [])
    if isinstance(findings, str):
        return f"## AI Security Review\n\n{findings}\n"
    if not findings:
        return "## AI Security Review\n\nNo security issues found.\n"
    lines = ["## AI Security Review\n"]
    for f in findings:
        emoji = SEVERITY_EMOJI.get(f.get("severity", "").lower(), "⚪")
        lines.append(f"### {emoji} [{f.get('severity', 'unknown').upper()}] {f.get('category', '')}\n")
        lines.append(f"**{f.get('file', '')}:{f.get('line', '')}**\n")
        lines.append(f"{f.get('description', '')}\n")
        proposed_fix = f.get('proposed_fix', '')
        if proposed_fix:
            lines.append(f"**Proposed fix:** {proposed_fix}\n")
    lines.append("---\n*Powered by Antigravity SDK*")
    return "\n".join(lines)


if __name__ == "__main__":
    target = sys.argv[1] if len(sys.argv) > 1 else "."
    result = asyncio.run(review_code(target))
    markdown = format_markdown(result)
    with open(OUTPUT_FILE, "w") as f:
        f.write(markdown)
    print(f"Review written to {OUTPUT_FILE}")
    print(json.dumps(result, indent=2))

ดูการตัดสินใจเรื่องการออกแบบที่สำคัญในเอเจนต์นี้

นโยบายปฏิเสธโดยค่าเริ่มต้น: policy.deny_all() บล็อกทุกอย่าง จากนั้นอนุญาตเฉพาะเครื่องมืออ่านไฟล์และ run_command (สำหรับ git)
การบังคับใช้ 2 ชั้น: นโยบายจะจำกัดที่ระดับเฟรมเวิร์ก และฮุก enforce_safe_tools จะเป็นชั้นที่ 2 ซึ่งอนุญาตให้ใช้ได้เฉพาะคำสั่ง git ผ่าน run_command
การกำหนดขอบเขตของ Git diff: Agent จะเรียกใช้ git diff main...HEAD เพื่อตรวจสอบเฉพาะโค้ดที่เปลี่ยนแปลง ไม่ใช่ทั้งฐานของโค้ด
เอาต์พุตที่มีโครงสร้างพร้อมการสำรอง: response_schema=ReviewResult บังคับใช้โครงสร้าง JSON ผ่านเครื่องมือเสร็จสิ้นของ SDK หากแยกวิเคราะห์ไม่สำเร็จ เชนโฆษณาสำรองจะลองแยกวิเคราะห์ text() เป็น JSON จากนั้นจะแสดงผลข้อความดิบ
การสำรองการตรวจสอบสิทธิ์: ใช้ GEMINI_API_KEY หากมี ไม่เช่นนั้นจะกลับไปใช้ Vertex AI ผ่านข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน
เอาต์พุตไฟล์: เขียนผลการค้นหาในรูปแบบมาร์กดาวน์ไปยัง code_review.md ซึ่ง GitHub Action จะอ่านไฟล์นี้และโพสต์เป็นความคิดเห็นใน PR ในภายหลัง

ทดสอบตัวแทนตรวจสอบ

ทดสอบจากรูทของโปรเจ็กต์ SDK จะอ่าน GEMINI_API_KEY จากสภาพแวดล้อม ดังนั้นเรามาใส่คีย์ในสภาพแวดล้อมกัน

export GEMINI_API_KEY=YOUR_API_KEY

จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อดำเนินการในเครื่อง

uv run --project code_review_agent code_review_agent/review_agent.py .

ขณะเรียกใช้ เครื่องมือจะแสดงเอาต์พุตของคอนโซลบางอย่างที่อธิบายเครื่องมือที่ใช้อยู่ในปัจจุบัน และคุณจะเห็นว่ามีการเข้าถึงทักษะของเอเจนต์ security-and-hardening และ code-review-and-quality

[audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile']
[audit] tool=view_file result_len=47 error=None preview=Read security and hardening skill documentation
[audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile']
[audit] tool=view_file result_len=48 error=None preview=Read code review and quality skill documentation
[audit] calling tool=run_command args_keys=['CommandLine', 'Cwd', 'WaitMsBeforeAsync']
...

เอเจนต์จะเรียกใช้ git diff main...HEAD ตรวจสอบเฉพาะโค้ดที่มีการเปลี่ยนแปลง เขียนผลการตรวจสอบที่จัดรูปแบบแล้วไปยัง code_review.md และพิมพ์ JSON ที่มีโครงสร้างไปยังคอนโซล คุณสามารถตรวจสอบ code_review.md ที่เขียนในเครื่องมือแก้ไขได้ดังที่แสดงด้านล่าง

ตอนนี้ฟีเจอร์นี้ใช้งานได้ในเครื่องแล้ว มาดูส่วนถัดไปกัน สร้างการกำหนดค่า GitHub Actions

6. กรณีที่ 2 : การตรวจสอบอัตโนมัติด้วย Antigravity SDK - ตอนที่ 2 ( การกำหนดค่า GitHub Actions)

ก่อนอื่นให้ลบไฟล์ code_review.md ที่สร้างไว้ก่อนหน้านี้หากมี

rm -f code_review.md

ตอนนี้เราจะต้องสร้างไฟล์การกำหนดค่า YAML ของ Github Action

mkdir -p .github/workflows
cloudshell edit .github/workflows/code_review.yml

จากนั้นเพิ่มเนื้อหาต่อไปนี้ลงในไฟล์

name: AI Code Security and Quality Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write

    container:
      image: ghcr.io/astral-sh/uv:python3.12-bookworm

    steps:
      - name: Install git
        run: apt-get update && apt-get install -y git
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Run security review
        env:
          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        run: |
          git config --global --add safe.directory $GITHUB_WORKSPACE
          uv run --project code_review_agent code_review_agent/review_agent.py .
      - name: Post findings as PR comment
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const body = fs.readFileSync('code_review.md', 'utf8');
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.payload.pull_request.number,
              body: body
            });

เวิร์กโฟลว์จะทริกเกอร์โดยอัตโนมัติเมื่อมีการเปิดหรืออัปเดต PR โดยจะตรวจสอบสาขา PR ที่มีประวัติ Git แบบเต็ม (จำเป็นสำหรับ git diff main...HEAD) เรียกใช้ตัวแทนตรวจสอบที่เขียนผลการตรวจสอบไปยัง code_review.md และโพสต์เนื้อหาของไฟล์เป็นความคิดเห็นใน PR

ตอนนี้มาคอมมิตการเปลี่ยนแปลงทั้งหมดและพุชไปยังรีโมตของ Github กัน เราพร้อมที่จะทดสอบการผสานรวมนี้แล้ว

git add .
git commit -m "Add AI code security-quality review agent and GitHub Action"
git push origin feature/bulk-operations

7. กรณีที่ 2 : การตรวจสอบอัตโนมัติด้วย Antigravity SDK - ตอนที่ 3 (การทดสอบการตรวจสอบโค้ดอัตโนมัติ)

ตอนนี้เราจะไปที่หน้าเว็บของที่เก็บที่แยกของคุณ https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo แล้วคลิก Settings

จากนั้นในแผงด้านซ้าย ให้ค้นหา Secrets and variables แล้วคลิกและเลือก Actions

หลังจากนั้น ให้คลิก New repository secret เพื่อกำหนดค่า GEMINI_API_KEY secret

หลังจากนั้น ให้เลือก Pull Request และสร้าง Pull Request ใหม่จาก Branch feature/bulk_operations ไปยัง Branch main ของที่เก็บของคุณเอง

หลังจากสร้าง Pull Request แล้ว ระบบจะเรียกใช้ Github Actions ซึ่งคุณสามารถตรวจสอบได้ในเมนู Checks หรือใกล้กับปุ่ม Merge pull request

คุณคลิกการดำเนินการที่กำลังทำงานเพื่อดูรายละเอียดได้ และเมื่อเสร็จสิ้นแล้ว ระบบจะโพสต์ผลการตรวจสอบเป็นความคิดเห็นในคำขอ Pull ดังที่แสดงด้านล่าง

8. สรุป

ยินดีด้วย

คุณสร้างเวิร์กโฟลว์การรีวิวโค้ดที่สมบูรณ์ 2 รายการเพื่อตรวจหาช่องโหว่ด้านความปลอดภัยในฟีเจอร์ที่เขียนโค้ดด้วย Vibe ดังนี้

กรณีที่ 1 (อินเทอร์แอกทีฟ): Antigravity CLI ที่มีทักษะของเอเจนต์ตรวจสอบความแตกต่างของกิ่งก้านฟีเจอร์ ระบุการแทรก SQL และช่องโหว่อื่นๆ แก้ไขตามรูปแบบ OWASP และสร้าง PR ที่สะอาด
กรณีที่ 2 (อัตโนมัติ): Antigravity SDK ขับเคลื่อน GitHub Action ที่ตรวจสอบ PR ทุกรายการโดยอัตโนมัติ และโพสต์ผลการค้นหาด้านความปลอดภัยที่มีโครงสร้างเป็นความคิดเห็นใน PR

สิ่งที่คุณได้เรียนรู้

วิธีที่ Vibe Coding สร้างความเสี่ยงด้านความปลอดภัย และเหตุผลที่การตรวจสอบแบบอัตโนมัติจับสิ่งที่การตรวจสอบด้วยตนเองพลาดไป
วิธีติดตั้งและใช้ทักษะของเอเจนต์เพื่อให้ Antigravity CLI มีความเชี่ยวชาญด้านความปลอดภัยที่มีโครงสร้าง
วิธีตรวจสอบความแตกต่างของกิ่งก้านฟีเจอร์แบบอินเทอร์แอกทีฟ แก้ไขปัญหา และสร้าง PR ที่สะอาด
วิธีสร้างเอเจนต์ตรวจสอบแบบอ่านอย่างเดียวด้วย Antigravity SDK โดยใช้นโยบายปฏิเสธโดยค่าเริ่มต้นและฮุกวงจร
วิธีติดตั้งใช้งานไปป์ไลน์การตรวจสอบแบบอัตโนมัติเป็น GitHub Action พร้อมการสนับสนุนการติดตามแบบโต้ตอบ

ล้างข้อมูล

ปิดคำขอให้รวมโค้ด

ไปที่ Pull Request แต่ละรายการใน Fork บน GitHub แล้วคลิกปิด Pull Request อย่าผสาน feature/bulk-operations PR เนื่องจากยังมีโค้ดที่มีช่องโหว่ที่ยังไม่ได้แก้ไขอยู่

ลบที่เก็บที่แยกออกมา (ไม่บังคับ)

หากไม่ต้องการใช้ Fork อีกต่อไป ให้ไปที่ Fork ใน GitHub: Settings -> เลื่อนไปที่Danger Zone -> Delete this repository

ขั้นต่อไปคืออะไร

ปลั๊กอินและทักษะของ Antigravity CLI - สร้างทักษะและปลั๊กอินที่กำหนดเอง
สิทธิ์และแซนด์บ็อกซ์ของ Antigravity CLI - นโยบายเครื่องมือแบบละเอียดและแซนด์บ็อกซ์ระดับระบบปฏิบัติการ
Hooks และนโยบายของ Antigravity SDK - รูปแบบขั้นสูง (การจำกัดอัตราคำขอ การแก้ไขข้อผิดพลาด มิดเดิลแวร์)
ตัวอย่าง Antigravity SDK – agent_middleware.py สำหรับรูปแบบการใช้งานจริง