บทเรียน Cursor Agent Mode: สร้าง REST API ด้วย GPT-5.6 Sol

Cursor คืออะไร?

Cursor เริ่มต้นจาก VS Code ที่เย็บฟีเจอร์ AI เข้าไป และภายนอกยังดูคล้ายเดิม เอดิเตอร์ ผังไฟล์ เทอร์มินัล ส่วนเสริม ทุกอย่างคุ้นตา 

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

หากสนใจฟีเจอร์ใหม่ของ Cursor เพิ่มเติม แนะนำให้อ่านบทเรียน Cursor Automations และ Cursor SDK ของเรา

GPT-5.6 คืออะไร?

GPT-5.6 คือเจเนอเรชันโมเดลล่าสุดของ OpenAI และไม่ใช่โมเดลเดียว แต่มีสามรุ่น: Sol, Terra และ Luna ชื่อนี้เป็นไทร์ความสามารถที่ต่างกัน แทนที่ป้าย "Instant" แบบเดิม

สรุปตระกูลแบบสั้น ๆ:

• Sol คือรุ่นเรือธงและแข็งแกร่งที่สุด เป็นไทร์เดียวที่ปลดล็อกระดับความพยายามให้เหตุผล max และโหมด ultra และเป็นจุดที่ได้เปรียบมากที่สุดในงานโค้ด ชีววิทยา และความปลอดภัยไซเบอร์

• Terra เป็นตัวเลือกเริ่มต้นสำหรับทุกวัน OpenAI วางตำแหน่งให้แข่งขันกับ GPT-5.5 ที่ราคาประมาณครึ่งหนึ่ง

• Luna เป็นไทร์เร็วและราคาถูกสำหรับงานปริมาณมากหรือไวต่อเวลา และแข็งแรงกว่าที่ป้ายราคาแสดง

สำหรับการเดินผ่านงานโค้ด Sol คือไทร์ที่สำคัญ จึงใช้รุ่นนี้ที่นี่ มีการตั้งค่าสองอย่างใน Sol ที่ใหม่ และควรรู้ว่าอันไหนที่จะได้ใช้งานจริง max เป็นระดับความพยายามให้เหตุผลเหนือ xhigh ที่ให้เอเจนต์ตัวเดียวใช้เวลามากขึ้นกับปัญหายาก และเป็นขั้นสูงสุดที่ตั้งได้ใน Cursor ส่วน ultra ซึ่งแบ่งงานข้ามซับเอเจนต์แบบขนาน ทำคะแนนเบนช์มาร์กสูงสุดของ OpenAI (91.9% บน Terminal-Bench 2.1) แต่ใช้ได้เฉพาะใน Codex และ API จึงไม่อยู่ในตัวเลือกของ Cursor

ดูตารางเบนช์มาร์กเต็มและราคาแบบสามไทร์ได้ใน คู่มือ GPT-5.6 Sol, Terra, และ Luna ของเรา

วิธีเข้าถึงและตั้งค่า GPT-5.6 Sol ใน Cursor

GPT-5.6 Sol มีให้เลือกในตัวเลือกโมเดลของ Cursor และมีเรื่องหนึ่งที่ควรรู้ไว้ก่อน: เช่นเดียวกับโมเดลแนวหน้ารุ่นล่าสุดของ Cursor, Sol ทำงานได้เฉพาะใน Max Mode เท่านั้น หมายความว่าใช้หน้าต่างบริบทเต็มและเครื่องมือทั้งหมด และคิดค่าบริการตามการใช้งาน ไม่ใช่ต่อคำขอ จึงควรจับตาการใช้โทเค็นระหว่างการรันยาว ๆ

วิธีเลือกโมเดล:

1. เปิดพาเนลเอเจนต์ด้วย Cmd+L (Mac) หรือ Ctrl+L (Windows/Linux)
2. คลิกปุ่ม Model ที่ก้นช่องอินพุต (จะแสดงชื่อโมเดลปัจจุบันข้างไอคอนเล็ก)
3. สลับ Auto ให้ปิดหากเปิดอยู่
4. หา GPT-5.6 Sol ในรายการและคลิก Edit ข้าง ๆ
5. จะมีพาเนลเปิดทางขวา ซึ่งตั้งค่าหน้าต่างบริบท ระดับการให้เหตุผล และตัวสลับความเร็วได้อย่างอิสระ

การเลือกระดับความพยายามให้เหตุผล

การเลือก Sol คือการเลือกโมเดล ส่วนระดับความพยายามให้เหตุผลคือตัวกำหนดว่ามันจะคิดหนักแค่ไหนกับงานนั้น ๆ โดยเลือกได้:

• None
• Low
• Medium
• High
• Extra High
• Max

None และ Low เร็วและถูก เหมาะกับการเติมโค้ดหรือรีแฟกเตอร์เชิงกลที่รู้แล้วว่าจะเอาอะไร 

High และ Extra High ใช้เวลานานกว่าเพราะคิดผ่านปัญหาก่อน และจะเห็นความต่างชัดเมื่อต้องให้เอเจนต์วางแผนงานที่ข้ามหลายไฟล์หรือดีบักความล้มเหลวที่สาเหตุไม่ชัดทันที 

Max อยู่เหนือ Extra High และให้เวลาเอเจนต์เดี่ยวมากที่สุดกับปัญหายาก โหมดหลายเอเจนต์ของ Sol ultra มีเฉพาะใน Codex และ API จึงไม่เห็นในตัวเลือกของ Cursor

ข้อควรระวังหากมาจาก GPT-5.5: ระดับไม่แมปกัน คำแนะนำของ OpenAI เองคือเริ่มที่ระดับต่ำกว่าที่คุ้นเคยหนึ่งขั้นในงานที่คุ้น และค่อยเพิ่มหากผลลัพธ์ต้องการ บทเรียนนี้ทำตามแนวทางนั้น จึงมีบางขั้นที่ใช้ระดับต่ำกว่าบทเรียน 5.5 ที่เทียบกัน

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

การเลือกขนาดหน้าต่างบริบทและโหมดความเร็ว

ยังสามารถเลือกหน้าต่างบริบท 272K หรือ 1M และเปิดโหมด Fast เพื่อสร้างโทเค็นเร็วขึ้นราว 1.5 เท่า โดยมีค่าเครดิตประมาณ 2.5 เท่า สำหรับการโต้ตอบที่รอคำตอบ Fast มักคุ้มค่า ส่วนงานเบื้องหลังยาว ๆ ที่มอบหมายไว้และทำอย่างอื่นระหว่างรัน ปล่อยให้ปิดไว้ก็ได้

การตั้งค่า Cursor

มาเซ็ตอัปโปรเจกต์ใน Cursor กัน

ข้อกำหนดเบื้องต้นและการตั้งค่าเริ่มต้น

จำเป็นต้องมีแผน Cursor แบบชำระเงิน (Pro ขึ้นไป) เพื่อใช้ GPT-5.6 Sol และเพราะ Sol ทำงานใน Max Mode จึงต้องเปิดการคิดค่าบริการตามการใช้งานในบัญชี สำหรับโปรเจกต์นี้ พึ่งพาในเครื่องอย่างเดียวคือ Python 3.11+ หากยังไม่ได้ติดตั้ง Cursor ให้ดาวน์โหลดที่ cursor.com, ล็อกอิน จากนั้นรันในเทอร์มินัล:

mkdir budget-api && cd budget-api
git init
cursor .

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

ทำความรู้จักพื้นผิว AI ของ Cursor

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

การเติมอินไลน์ คือเลเยอร์ออโต้คอมพลีตเบื้องหลัง ระหว่างพิมพ์จะมีคำแนะนำสีเทาปรากฏตามสิ่งที่พิมพ์และบริบทในไฟลฺ์รอบ ๆ กดยอมรับด้วย Tab ไม่ต้องเรียก มันจะโผล่มาเอง เหมาะเมื่อเขียนโค้ดด้วยมือและอยากให้โมเดลลดการพิมพ์โดยไม่ขัดจังหวะโฟลว์

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

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

กำหนดแนวทางเฉพาะโปรเจกต์ด้วย AGENTS.md

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

นี่คือหน้าที่ของ AGENTS.md: README สำหรับเอเจนต์ ที่เขียนสิ่งที่ชัดสำหรับคุณแต่มองไม่เห็นสำหรับโมเดล AGENTS.md เริ่มเป็นความริเริ่มของ OpenAI ในปี 2025 และตอนนี้เป็นมาตรฐานข้ามเครื่องมือสำหรับไฟล์คำสั่งเอเจนต์ (เป็นส่วนหนึ่งของ Agentic AI Foundation ของ Linux Foundation ควบคู่กับ MCP ของ Anthropic) ดังนั้นคุ้มค่าที่จะเรียนให้คล่องแล้วใช้ทุกที่

สร้างไฟล์ชื่อ AGENTS.md ที่รากโปรเจกต์ พร้อมเนื้อหาดังต่อไปนี้เพื่อกำหนดชุดเครื่องมือ แนวทางเขียนโค้ด และขอบเขต:

# AGENTS.md

## Stack
Python 3.11, FastAPI, SQLModel, SQLite (via aiosqlite), pytest, httpx

## Conventions
- All endpoints under /api/v1/
- Pydantic models in app/models.py
- Database logic in app/database.py
- Route handlers in app/routers/
- Type hints required on all function signatures
- Explicit imports only, no wildcards

## Boundaries
- Do not delete or modify any file in tests/ without asking first
- Do not change the DATABASE_URL; it reads from .env
- Never touch pyproject.toml dependencies without showing the diff first

## Verification
Before considering any task complete:
  pytest tests/ -v
  ruff check .
Both must pass.

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

AGENTS.md เป็นมาตรฐานข้ามเครื่องมือ แต่ถ้าอยากได้ตัวเลือกแบบ Cursor-native ที่ทำงานเดียวกันผ่านไฟล์ .mdc แบบกำหนดขอบเขต บทเรียน Cursor Rules ของเรามีตัวอย่างสำหรับโปรเจกต์เว็บ Python

สร้าง Budget Tracker API ด้วย GPT-5.5

โปรเจกต์นี้คือ REST API สำหรับติดตามรายการงบประมาณส่วนบุคคล สามารถสร้างรายการ แสดงรายการพร้อมตัวกรองหมวดหมู่แบบเลือกได้ ลบรายการ และดึงสรุปการใช้จ่ายรายเดือน 

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

ขั้นที่ 1: วางโครงสร้างโปรเจกต์

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

Set up a FastAPI project for a budget tracker API using SQLModel with 
async SQLite. Structure it with separate files for models, database, and 
routes under an app/ directory. Set up pyproject.toml with uv, install 
dependencies, and create a main.py that starts the app.

Before writing any code, show me the planned directory structure 
and wait for my approval.

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

GPT-5.6 Sol ที่ระดับ High ให้แผนที่เฉพาะเจาะจงพอจะใช้งานได้จริง ไม่ใช่สรุปกว้าง ๆ และการรีวิวโครงสร้างตอนนี้เร็วกว่ารีแฟกเตอร์ทีหลังมาก

เอเจนต์เสนอเลย์เอาต์โปรเจกต์และรอการอนุมัติก่อนลงมือเขียนไฟล์แม้แต่ไฟล์เดียว

เมื่อคุณตอบทำนองว่า "ดูดี ไปต่อได้เลย" เอเจนต์จะเริ่มสร้าง สามารถดูผังไฟล์ทางซ้ายที่ค่อย ๆ เติมไฟล์แบบเรียลไทม์ ขณะที่เทอร์มินัลด้านล่างแสดง uv กำลังติดตั้งแพ็คเกจ

เอเจนต์สร้าง pyproject.toml เป็นส่วนหนึ่งของสเกฟโฟลด์ โดยแสดงเนื้อหาไฟล์เป็นการเพิ่มใหม่

หลังสเกฟโฟลด์เสร็จ ให้เปิด app/models.py และ app/database.py สักครู่ก่อนไปต่อ ยืนยันว่าโมเดล BudgetEntry มีฟิลด์อย่างน้อยคือ id, amount, description, category และ date และว่า database.py ตั้งค่าเอนจิน SQLite แบบอะซิงก์โดยไม่มีอะไรแปลก 

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

ขั้นที่ 2: ทำเอ็นด์พอยต์หลักให้ครบ

คงไว้ที่ High หรือทดลองเริ่มที่ Medium เพราะ Sol ที่ Medium จัดการงานหลายไฟล์ประสานกันได้ในระดับที่ 5.5 ต้องใช้ High ส่งพรอมต์สำหรับลงมือทำ:

Implement endpoints for budget entries under /api/v1/entries/. Include:
- POST /api/v1/entries/ to create a new entry, returning 201
- GET /api/v1/entries/ to list all entries, with an optional ?category= filter
- DELETE /api/v1/entries/{id} to delete an entry, returning 404 if not found

Use typed Pydantic response models and dependency injection for the DB session.
After implementing, start the app and confirm the /docs endpoint loads.

เอเจนต์จะแตะ models.py, database.py, routers/entries.py และ main.py ในคราวเดียวแบบประสานกัน เมื่อแก้แต่ละไฟล์เสร็จ Cursor จะแสดงเนื้อหาใหม่ไฮไลต์ในเอดิเตอร์เพื่อรีวิวก่อนยอมรับ จะเห็นปุ่ม Undo/Keep ที่ด้านล่างของแต่ละไฟล์ที่เปลี่ยน

ภาพแสดงไฟล์เราเตอร์ entries.py หลังเอเจนต์ทำเสร็จ พร้อมยืนยันว่าเริ่มเซิร์ฟเวอร์และเอ็นด์พอยต์ /docs โหลดได้ถูกต้อง 

เมื่อยอมรับการเปลี่ยนแปลงและเซิร์ฟเวอร์รันอยู่ เปิด http://localhost:8000/docs ในเบราว์เซอร์เพื่อตรวจว่าทุกอย่างเชื่อมกันถูกต้อง

เอกสารที่ FastAPI สร้างให้อัตโนมัติที่ /docs แสดงทั้งสามเอ็นด์พอยต์ลงทะเบียนถูกต้อง 

ขั้นที่ 3: เพิ่มการตรวจสอบหมวดหมู่

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

ตอนนี้ API รับสตริงใดก็ได้เป็นหมวดหมู่ ซึ่งจะทำให้ข้อมูลไม่สม่ำเสมอในไม่ช้า มาแก้ไข:

Budget entries should only accept these categories: 
food, transport, housing, entertainment, health, other.

Reject any entry with an invalid category using a 422 status and a clear 
error message. Use a Python Enum for the category type. 
Add tests for both a valid category submission and an invalid one in tests/test_entries.py.

เอเจนต์จะเพิ่ม enum ของหมวดหมู่ใน models.py และอัปเดต Pydantic ให้ใช้งาน enum นั้น เพราะ Pydantic ตรวจสอบค่าเทียบกับ enum อัตโนมัติ หมวดหมู่ที่ไม่ถูกต้องจะถูกปฏิเสธตั้งแต่ก่อนตัวจัดการเส้นทางทำงาน

ควรมีเทสสองตัวเขียนเพิ่ม: ตัวหนึ่งยืนยันว่าหมวดหมู่ที่ถูกต้องบันทึกได้ อีกตัวหนึ่งยืนยันว่าหมวดหมู่ไม่ถูกต้องได้สถานะ 422

การใช้การอ้างอิงด้วย @

หลังยอมรับการเปลี่ยนแปลง ลองใช้ฟีเจอร์บริบท @ ของ Cursor เพื่อถามคำถามตรวจสอบอย่างรวดเร็ว:

@app/models.py Does the CategoryEnum cover all six categories I listed?

การพิมพ์ @ ในพาเนลเอเจนต์จะเปิดตัวเลือกไฟล์ และเมื่อเลือก app/models.py เนื้อหาไฟล์นั้นจะถูกดึงเข้าพรอมต์โดยตรง โดยไม่ต้องให้เอเจนต์ค้นหาหรือเดาเส้นทาง

ขั้นที่ 4: สร้างเอ็นด์พอยต์สรุปรายเดือน

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

Add a GET /api/v1/entries/summary endpoint that accepts month (1-12) and year as query parameters. 
It should return total spending per category for that month and an overall total. 
Use a typed Pydantic response model. 
If no entries exist for the requested month, return an empty summary with zero totals rather than a 404.

นี่คืองานฐานข้อมูลที่น่าสนใจกว่า เพราะต้องคิวรีแบบกรองพร้อมการรวม ไม่ใช่ select-all ธรรมดา สังเกตวิธีที่เอเจนต์โครงสร้างคิวรีใน database.py; ควรใช้อินเตอร์เฟซของ SQLModel แทน SQL ดิบ และผลลัพธ์ควรแมปเข้ากับโมเดลตอบกลับที่นิยามใน models.py ได้อย่างเรียบร้อย

หลังยอมรับการเปลี่ยนแปลง ให้เขียนเทสหนึ่งตัวสำหรับเอ็นด์พอยต์นี้เองใน test_entries.py สร้างรายการสองรายการในเดือนใดเดือนหนึ่ง เรียกเอ็นด์พอยต์สรุปของเดือนนั้น และยืนยันยอดรวมตรงกัน การเขียนเองแทนขอเอเจนต์เป็นวิธีที่ดีในการทำความคุ้นกับโครงสร้างไคลเอนต์เทสและฟิกซ์เจอร์

ไฟล์ test_entries.py แสดงเทสตรวจสอบหมวดหมู่ที่เอเจนต์เขียนไว้เคียงกับฟังก์ชัน test_monthly_summary ที่เขียนเอง 

ขั้นที่ 5: รันลูปการตรวจสอบ

Low หรือ Medium ก็เพียงพอที่นี่ การรันเทสและแก้ปัญหา lint เป็นงานเชิงตอบสนอง เอเจนต์อ่านเอาต์พุตข้อผิดพลาดและแก้เฉพาะจุด ไม่ได้ตัดสินใจเชิงสถาปัตย์ มอบหมายการทดสอบให้เอเจนต์:

Run pytest tests/ -v and fix any failing tests. 
Do not modify test assertions to make them pass, fix the implementation instead.
Once all tests pass, run ruff check . and fix any linting issues.

ดูพาเนลเอเจนต์ระหว่างสตรีมเอาต์พุต pytest 

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

ภาพแสดงรายงานของเอเจนต์หลังจบลูปตรวจสอบเต็ม ในกรณีนี้ ruff เจอปัญหาการหาอินเตอร์พรีเตอร์จากความไม่ตรงกันของ pyenv/.python-version บนเครื่องโลคัล ไม่ใช่ปัญหาโค้ด 

สังเกตสิ่งที่เกิดขึ้น: เอเจนต์เจอปัญหาสภาพแวดล้อมที่ไม่เกี่ยวกับโค้ด เหตุผลหาสาเหตุ และหาทางแก้โดยไม่ต้องสั่ง นี่คือการแก้ปัญหาเชิงบริบทข้ามเครื่องมือที่ GPT-5.6 Sol เด่นกว่าโมเดลก่อน ๆ

และควรใส่ "do not modify test assertions to make them pass" ในพรอมต์ตรวจสอบทุกครั้ง หากไม่กำชับ บางครั้งเอเจนต์จะเลือกทางลัดด้วยการทำให้เงื่อนไขเทสอ่อนลงแทนที่จะแก้พฤติกรรมจริง

ขั้นที่ 6: รอบรีวิวโค้ด

ตั้งกลับเป็น High ก่อนส่งพรอมต์นี้ หรือใช้ Extra High/Max หากอยากให้ Sol ขบคิดเคสขอบที่ High รอบเดียวอาจมองผ่าน ในขั้นนี้ เหตุผลตื้นจะสร้างความอุ่นใจลวง ๆ ควรให้โมเดลทำงานผ่านประเด็นที่เป็นไปได้ทั้งหมด ไม่ใช่แค่แมตช์แพทเทิร์นที่เด่นชัด

ก่อนประกาศว่าจบโปรเจกต์ ใช้เอเจนต์เพื่อรีวิว:

Review the current codebase and report on:
1. Query params or path params that are missing validation
2. Database sessions that might not be closing properly
3. Endpoints returning incorrect HTTP status codes
4. Any places where user input reaches the database without going 
   through the ORM

Do not make any changes yet. List each issue with file and line number.

เอเจนต์เจอว่า DELETE /api/v1/entries/{entry_id} ส่งโค้ด 204 และ 404 ได้ถูกต้อง (พร้อมอ้างอิง ไฟล์:บรรทัด) เส้นทาง GET อาศัยค่าเริ่มต้น 200 ที่ถูกต้อง และยืนยันว่าไม่มีอินพุตผู้ใช้ไปถึงฐานข้อมูลโดยไม่ผ่าน ORM

เมื่อรีวิวรายการแล้ว ส่งคำสั่งติดตามเพื่อใช้การแก้ไข:

Apply the fixes for the status code issues and the session handling. 
Skip any rate-limiting suggestions, that's out of scope for this version.
Run the tests again after applying.

ขั้นที่ 7: README และเวิร์กโฟลว์ CI

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

Write a README.md with setup instructions, a table of all endpoints (method, path, description), and example curl commands for each endpoint.

จากนั้น:

Create a .github/workflows/ci.yml that runs pytest and ruff on Python 3.11 for every push and pull request to main.

หลังทั้งเจ็ดขั้น โครงสร้างโปรเจกต์จะมีหน้าตาแบบนี้:

ข้อคิดส่งท้าย

สิ่งที่สร้างคือ API ขนาดเล็ก แต่เวิร์กโฟลว์นี้ขยายสเกลได้กับอะไรก็ได้ 

เตรียม AGENTS.md ให้พร้อมก่อนเอเจนต์แตะไฟล์ใด ๆ ขอแผนก่อนลงมือสำหรับงานที่ไม่เล็ก แบ่งพรอมต์เป็นช่วง ๆ เพื่อมีจุดตรวจธรรมชาติ แทนการรีวิวดิฟก้อนใหญ่ครั้งเดียว ใช้ @filename เมื่อต้องการถามเฉพาะไฟล์ และทำรอบรีวิวก่อนปิดงาน เพราะมักจะเจอบางอย่างเสมอ

GPT-5.6 Sol บน Cursor เห็นความต่างชัดจากคู่ก่อนหน้าในแง่การโฟกัสงานยาว ๆ ความสม่ำเสมอข้ามไฟล์ และรู้จังหวะหยุดเพื่อเช็กอินแทนการพ突ไปทำอะไรที่อาจพัง แต่มอเดลเป็นเพียงส่วนหนึ่ง สิ่งสำคัญคือบริบทที่ให้ตั้งแต่แรก ลูปตรวจสอบที่รัน และรอบรีวิวตอนท้าย ตรงนั้นแหละที่ยกระดับคุณภาพผลลัพธ์จริง

กฎจำง่ายเกี่ยวกับระดับการให้เหตุผล: ใช้ High สำหรับการตัดสินใจเชิงสถาปัตย์ งานประสานหลายไฟล์ และดีบักสิ่งที่ไม่ชัด ใช้ Medium หรือ Low สำหรับเอกสาร บอยเลอร์เพลต และแก้ไขไฟล์เดียวที่แค่อยากให้โมเดลพิมพ์แทน พิจารณา Extra High หรือ Max สำหรับรีวิวโค้ดและงานที่ความผิดพลาดแพงกว่าการให้เอเจนต์คิดละเอียด