Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

เวิร์กโฟลว์การพัฒนาร่วมกับ AI

หากคุณเคยพัฒนาระบบร่วมกับ AI coding agent คุณอาจสังเกตเห็นว่าพวกมันเก่งมากเรื่องการปั่นโค้ดออกมาอย่างรวดเร็ว แต่กลับแย่มากในการทำความเข้าใจกฎเฉพาะ ของ โปรเจกต์คุณ บทนี้จะมาช่วยเชื่อมช่องว่างดังกล่าว เราจะมาดูวิธีนำหลักการจากคู่มือเล่มนี้ไปแปลงเป็นคำสั่งระดับรีโพสิทอรีที่เอเจนต์ AI (Claude Code, Codex, Cursor, Aider) สามารถนำไปใช้งานได้อย่างมีประสิทธิภาพ เพื่อให้พวกมันเลิกคาดเดาและเริ่มปฏิบัติตามสถาปัตยกรรมของคุณอย่างถูกต้อง

ปัญหาของการวางคู่มือทั้งเล่มลงไป

ผมเข้าใจดีครับว่าแรงดึงดูดใจมันสูงมาก หลายคนเลือกคัดลอกเนื้อหาคู่มือทั้งเล่ม วางลงในหน้าแชท แล้วสั่งให้เอเจนต์ “สร้างแอป Rust ขึ้นมา” ผมเองก็เคยทำแบบนั้น ผลลัพธ์ที่ได้คือ… ไม่ค่อยน่าประทับใจเท่าไหร่ เพราะโมเดลแยกแยะไม่ออกว่าอะไรคือกฎเหล็กที่ห้ามละเมิด และอะไรเป็นเพียงคำแนะนำเสริม มันจึงเลือกทำเฉพาะส่วนที่ดูง่ายที่สุดแล้วมองข้ามส่วนที่เหลือไปทั้งหมด

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

โครงสร้างไฟล์คำสั่งในรีโพสิทอรี

เครื่องมือเขียนโค้ดด้วย AI ส่วนใหญ่ในปัจจุบันรองรับคำสั่งแบบไฟล์ถาวร (persistent instructions) ซึ่งจะถูกโหลดขึ้นมาโดยอัตโนมัติเมื่อเอเจนต์เริ่มเซสชันการทำงาน:

  • Claude Code อ่าน CLAUDE.md ที่รากของรีโพสิทอรี รวมถึง .claude/rules/ สำหรับกฎที่จำกัดขอบเขตเฉพาะส่วน
  • Codex อ่าน AGENTS.md ที่รากของรีโพสิทอรี รวมถึงไฟล์ AGENTS.md ที่ซ้อนอยู่ในซับไดเรกทอรีต่างๆ
  • Cursor อ่าน .cursor/rules/ หรือ AGENTS.md
  • Aider ใช้ repo map เพื่อทำความเข้าใจโครงสร้าง และสามารถกำหนดไฟล์ข้อตกลง (conventions) ได้

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

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

คำสั่งระดับราก

ไฟล์ AGENTS.md (หรือ CLAUDE.md) ที่รูทของโปรเจกต์ ควรบรรจุเฉพาะกฎที่ต้องใช้ร่วมกันในทุกเซสชันและทุกไฟล์เท่านั้น ผมแนะนำให้รักษาความยาวไว้ไม่เกิน 40 บรรทัด ลองมองว่ามันคือสิ่งที่คุณจะบอกสมาชิกใหม่ในทีมตั้งแต่วันแรกที่เริ่มงาน:

  • โครงสร้างเลเยอร์ของโปรเจกต์และกฎทิศทางของดีเพนเดนซี
  • กฎสไตล์โค้ดแบบเข้มงวด (ห้าม unwrap ในแฮนด์เลอร์, ใช้ newtype สำหรับค่าโดเมน ฯลฯ)
  • คำสั่งตรวจสอบความถูกต้องที่ใช้นิยามว่างาน “เสร็จสมบูรณ์” (done)
  • การชี้ทางไปยังไฟล์คำสั่งย่อยสำหรับกฎเฉพาะของแต่ละเลเยอร์
templates/
  AGENTS.md                          # Root rules (copy to your repo root)

จงตั้งใจรักษาไฟล์นี้ให้มีขนาดกะทัดรัดเข้าไว้ ส่วนกฎเกณฑ์ใดที่เจาะจงเฉพาะเลเยอร์ ให้แยกไปใส่ไว้ในไฟล์ย่อยที่ซ้อนอยู่ด้านใน ซึ่งเราจะมาดูกันในหัวข้อถัดไป

คำสั่งระดับเลเยอร์ย่อย

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

templates/
  src/http/AGENTS.md                 # Handler, DTO, middleware, routing rules
  src/domain/AGENTS.md               # Model, service, port, error rules
  src/infra/db/AGENTS.md             # Repository, query, migration rules

คำสั่งของเลเยอร์ HTTP จะครอบคลุมขีดจำกัดความยาวของแฮนด์เลอร์ ข้อตกลงการใช้ extractor ลำดับของมิดเดิลแวร์ และกฎการสร้าง DTO ส่วนคำสั่งของเลเยอร์โดเมนจะบังคับใช้กฎห้ามพึ่งพาเฟรมเวิร์กภายนอก (zero-framework-dependency) รวมถึงแพตเทิร์น newtype/คอนสตรักเตอร์ที่เราได้พูดถึงไปก่อนหน้านี้ และคำสั่งของเลเยอร์ฐานข้อมูลจะครอบคลุมแพตเทิร์นการคิวรี การแปลงแถวข้อมูล (row) ไปสู่โดเมน และข้อตกลงในการทำไมเกรชัน

สกิลสำหรับเวิร์กโฟลว์แบบขั้นตอน

กฎเกณฑ์ (rules) ทำหน้าที่บอกเอเจนต์ว่า ต้องทำอะไร ส่วนสกิล (skills) ทำหน้าที่บอกมันว่า ต้องทำอย่างไร คุณอาจสงสัยว่าทำไมความแตกต่างนี้ถึงมีความสำคัญ จากประสบการณ์ของผม เอเจนต์ทำตามขั้นตอนแบบเป็นลำดับได้เก่งอย่างน่าทึ่ง แต่กลับแย่มากในการคิดค้นกระบวนการขึ้นมาใหม่ตั้งแต่ต้น สกิลจึงเปรียบเสมือนสูตรสำเร็จสำหรับงานทั่วไปที่เอเจนต์สามารถหยิบมาปฏิบัติตามทีละขั้นเมื่อต้องการ

templates/
  .agents/skills/add-endpoint/SKILL.md    # Domain -> DB -> Handler -> Test flow
  .agents/skills/add-migration/SKILL.md   # Migration creation and verification
  .agents/skills/review-pr/SKILL.md       # Architecture and security review checklist

สกิล add-endpoint จะนำทางคุณผ่านเวอร์ติคอลสไลซ์ทั้งเส้น: ตั้งแต่นิยามชนิดข้อมูลโดเมน สร้างไมเกรชัน อิมพลีเมนต์เมธอดของรีพอสิทอรี ใส่ตรรกะทางธุรกิจในเซอร์วิส เขียน DTO และแฮนด์เลอร์ ลงทะเบียนเส้นทาง เขียนแบบทดสอบ เพิ่ม tracing ไปจนถึงการสั่งรันการตรวจสอบความถูกต้อง นี่คือขั้นตอนที่เราต้องการให้เอเจนต์ทำตามทุกครั้งเมื่อเพิ่มเอนด์พอยต์ API ใหม่ ซึ่งสะท้อนขั้นตอนที่เราจะลงมือทำด้วยตนเองอย่างแท้จริง

ส่วนสกิล review-pr คือเช็กลิสต์ตรวจทานที่ครอบคลุมด้านสถาปัตยกรรม (ทิศทางของดีเพนเดนซี, ความหนาของโค้ดในแฮนด์เลอร์) ความถูกต้อง (ห้าม unwrap, การแปลงข้อผิดพลาดอย่างเหมาะสม) ฐานข้อมูล (คิวรีแบบมีพารามิเตอร์, การแปลงข้อมูลด้วย TryFrom) ความปลอดภัย (การตรวจสอบความถูกต้องของอินพุต, ห้ามมีข้อมูลลับหลุดในล็อก) การทดสอบ (ครอบคลุมทั้ง happy path และ error path) และการปฏิบัติการจริง (tracing, ห้ามมีบล็อกกิ้งคอล, การตั้งค่าการหมดเวลาสำหรับการเชื่อมต่อไปภายนอก)

เช็กลิสต์สำหรับการตรวจทานโดยมนุษย์

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

templates/
  docs/checklists/feature.md              # End-to-end feature implementation checklist

ลูปการสนทนาสามเฟส

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

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

เฟส 2: นำไปใช้ (Implement). ให้เอเจนต์ลงมือเขียนโค้ดทีละสไลซ์ โดยสั่งให้มันหยุดเมื่อโค้ดคอมไพล์ผ่านและรันเทสต์ผ่านเรียบร้อย จากนั้นจึงแสดงให้คุณเห็นว่ามีอะไรเปลี่ยนแปลงไปบ้างและยังเหลือส่วนใดที่ต้องทำต่อ

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

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

อัปเกรดการแก้ไขให้เป็นความทรงจำของรีโพสิทอรี

เมื่อเอเจนต์ทำผิดพลาดในจุดเดิมซ้ำสอง (และเชื่อเถอะว่ามันจะทำแน่ๆ ไม่ว่าจะเป็นการปล่อยให้ชนิดข้อมูลฐานข้อมูลรั่วเข้าไปใน API, การฝัง SQL ไว้ในแฮนด์เลอร์ หรือลืมใส่ instrumentation สำหรับ tracing) อย่าเพียงแค่ทักท้วงและแก้ไขในแชทเท่านั้น แต่จงนำบทเรียนนั้นไปอัปเดตลงในไฟล์คำสั่งระดับรูทหรือไฟล์คำสั่งย่อยทันที เซสชันถัดไปจะเริ่มทำงานได้อย่างฉลาดขึ้น เพราะการแก้ไขดังกล่าวได้กลายเป็นส่วนหนึ่งของบริบทถาวรประจำโปรเจกต์ไปแล้ว

นี่คือจุดกำเนิดของคุณค่าแบบทบต้นอย่างแท้จริง เมื่อเวลาผ่านไป ไฟล์คำสั่งของคุณจะค่อยๆ วิวัฒนาการกลายเป็นมาตรฐานของทีมที่กระชับ แม่นยำ และผ่านการพิสูจน์ใช้งานจริง สิ่งที่ผมค้นพบคือหลังจากผ่านไปเพียงไม่กี่สัปดาห์ ทั้งมนุษย์และเอเจนต์จะปฏิบัติตามกฎเกณฑ์ชุดเดียวกันอย่างสม่ำเสมอ ซึ่งนั่นคือหัวใจสำคัญที่สุดของเรื่องนี้

เริ่มต้นใช้งาน

  1. คัดลอกเนื้อหาทั้งหมดในไดเรกทอรี templates/ ลงในโปรเจกต์ Rust ของคุณ
  2. เปลี่ยนชื่อไฟล์ AGENTS.md เป็น CLAUDE.md หากคุณใช้ Claude Code (หรือจะเก็บไว้ทั้งสองชื่อก็ได้ เพราะไม่มีความขัดแย้งกัน)
  3. ปรับแต่งกฎเกณฑ์ให้เข้ากับโปรเจกต์ของคุณ โดยแก้ไขพาธของเลเยอร์ต่างๆ และใส่ข้อตกลงเฉพาะตัวของโปรเจกต์เข้าไป
  4. ย้ายตำแหน่งไฟล์คำสั่งย่อยให้ตรงกับโครงสร้างไดเรกทอรี src/ ที่แท้จริงของคุณ
  5. เริ่มต้นเซสชันแชทและสั่งให้เอเจนต์อ่านไฟล์คำสั่งของมันก่อนเริ่มลงมือทำงานใดๆ เสมอ

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