23 min readAI
Agentic SDLC: เมื่อ requirement ถึง production กลายเป็น loop ที่ agent วิ่งแทน คนต้องนิยามอะไร ด่านไหนห้ามปล่อย และทำไม loop ที่เร็วขึ้นไม่ได้แก้ requirement ที่ไม่ครบ
มีโพสต์ใน X เสนอว่า Agentic SDLC จะเปลี่ยนลำดับ requirement, design, code, test, review, deploy และ feedback จาก production ให้เป็น loop ต่อเนื่อง โดยคนนิยาม intent, outcomes และ boundaries แล้ว agent ช่วยทุกขั้น พร้อมประโยคว่ารอบงานจะหดจาก "weeks to days" ผมอ่านโพสต์ต้นทางแล้วพบว่าเป็นความเห็นของคนคนเดียวที่ปิดท้ายด้วยโปรโมต newsletter ไม่ใช่งานวิจัย และตัวเลขเรื่องความเร็วไม่มีข้อมูลประกอบ บันทึกจากเดฟ·PM·PO ที่ดูแลทีม junior ว่าโพสต์ถูกตรงไหน พูดง่ายเกินไปตรงไหน ขั้นไหนควรให้ agent ก่อน ด่านไหนคนต้องเฝ้า และ lead ต้องนิยามอะไรก่อนปล่อย loop ให้วิ่ง พร้อม checklist

งานที่ผมเจอบ่อยที่สุดไม่ใช่งานที่เขียนโค้ดไม่ทันครับ แต่เป็นงานที่ทีมเขียนเสร็จแล้วเพิ่งรู้ว่า requirement ที่ได้มาไม่ครบ ลูกค้าบอกว่าอยากได้อะไร แต่ไม่ได้บอกว่ากรณีไหนถือว่าผิด ใครมีสิทธิ์ทำอะไร และถ้าข้อมูลไม่ครบระบบควรทำอย่างไร ส่วน design ที่ผ่านการรีวิวมาแล้วก็มักยังไม่พร้อมให้ QA เขียน test case เพราะมีแต่หน้าจอของกรณีที่ทุกอย่างราบรื่น
ผมเลยอ่านช้าเป็นพิเศษเมื่อเห็นโพสต์ใน X ของ Aiswarya Venkitesh ที่เสนอภาพ "Agentic SDLC" คือวงจรพัฒนาซอฟต์แวร์ที่คนเป็นฝ่ายนิยามเจตนา ผลลัพธ์ และขอบเขต แล้วให้ AI agent ช่วยทุกขั้นตั้งแต่ requirement ไปจนถึง feedback จาก production จนลำดับงานแบบเดิมกลายเป็น loop ที่หมุนต่อเนื่องและเร็วขึ้น
ภาพนี้น่าเชื่อครับ และผมก็อยากให้มันจริง ซึ่งเป็นเหตุผลที่ต้องตรวจ โพสต์นี้อยู่ในซีรีส์ Critical Thinking ต่อจากโพสต์เรื่อง DHH กับ people skills ในยุค agent ครั้งนั้นผมสรุปว่าทักษะที่งานยุค agent ต้องการคือการเขียนให้ชัดและทำให้ความรู้ของตัวเองไม่ต้องผ่านตัวเอง ครั้งนี้คำถามต่อเนื่องกันพอดี ถ้า agent จะวิ่งทั้งวงจรแทนเรา สิ่งที่เราเขียนให้มันต้องชัดแค่ไหน และมีอะไรบ้างที่ไม่ควรปล่อยให้มันวิ่งเอง
จุดยืนของผมสั้น ๆ คือ โพสต์นี้พูดถูกว่างานของคนกำลังย้ายจากการทำทีละ task ไปเป็นการออกแบบระบบที่ทำ task เหล่านั้นอย่างปลอดภัย แต่ loop ที่เร็วขึ้นไม่ได้ทำให้ requirement ครบขึ้น มันแค่ทำให้ requirement ที่ผิดเดินทางไปถึง production เร็วขึ้น คอขวดจริงของทีมผมอยู่ต้นทาง และ agent จะช่วยได้ก็ต่อเมื่อคนนิยามเป้าหมาย สิทธิ์ ขอบกั้น เกณฑ์ประเมิน และเส้นทางส่งเรื่องต่อไว้ก่อน
แหล่งต้นทาง: อะไรที่ผมยืนยันได้ และอะไรที่ยืนยันไม่ได้
ยืนยันไม่ได้
- นี่คือโพสต์ความเห็นของคนคนเดียว ไม่ใช่งานวิจัย โพสต์ไม่มีตัวเลข ไม่มีงานศึกษา ไม่มีตัวอย่างทีมหรือบริษัทที่ทำแบบนี้แล้ว และปิดท้ายด้วยการโปรโมต newsletter ของผู้เขียนเอง ผมจึงอ่านมันในฐานะกรอบคิดที่คนคนหนึ่งเสนอ ไม่ใช่รายงานว่าอุตสาหกรรมทำอะไรอยู่
- ประโยคว่ารอบงานหดจาก "weeks to days" ไม่มีข้อมูลประกอบในโพสต์ ไม่มีการบอกว่าวัดจากทีมไหน งานประเภทใด หรือเทียบกับอะไร ผมเองก็ไม่มีข้อมูลที่ยืนยันหรือหักล้างตัวเลขนี้
- ตำแหน่งงานของผู้เขียนมาจาก bio ในโปรไฟล์ X ของเขาเอง bio ระบุว่าเป็น Director Cloud Solution Architect ที่ Microsoft และเคยทำงานที่ Bank of America, EY และ Accenture ผมไม่ได้ตรวจสอบจากแหล่งอื่น และโพสต์ไม่ได้บอกว่าเป็นจุดยืนของบริษัทใด
- โพสต์แนบ GIF ที่เป็น infographic มาด้วย ผมไม่ได้อ่านเนื้อหาในภาพ ทุกอย่างที่ผมอ้างมาจากข้อความของโพสต์เท่านั้น ถ้าในภาพมีรายละเอียดเพิ่ม บทความนี้ไม่ได้ครอบคลุม
- reply ใต้โพสต์ผมไม่ได้อ่าน เลยบอกไม่ได้ว่ามีคนแย้งหรือเสริมอะไรไว้
- ตัวเลข impressions กับ likes เป็นตัวเลข ณ ตอนที่อ่าน และยอดคนเห็นไม่ได้บอกว่ามีคนเห็นด้วยเท่าไร
- โพสต์ไม่ได้อธิบายว่าแต่ละขั้นทำอย่างไร ใช้เครื่องมืออะไร ทุกอย่างที่เกินจากข้อความในโพสต์คือการตีความของผม และผมจะบอกทุกครั้งที่ตีความ
ยืนยันได้
ผมอ่านจากแหล่งนี้เมื่อวันที่ 21 พฤศจิกายน 2026 ครับ
- โพสต์ของ Aiswarya Venkitesh (@AiswaryaVenkit1) วันที่ 30 ตุลาคม 2026 เวลา 09:30 น. ตามเวลาไทย ตอนที่อ่านมีประมาณ 1,441 impressions, 51 likes, 13 reposts, 4 replies และ 25 bookmarks
ตัวเลขนี้บอกอีกเรื่องหนึ่งด้วยครับ โพสต์นี้ไม่ได้เป็นกระแสใหญ่ ผมไม่ได้หยิบมาเพราะมันดัง แต่เพราะมันสรุปภาพที่ผมได้ยินบ่อยขึ้นเรื่อย ๆ ไว้ครบในโพสต์เดียว จึงเหมาะจะใช้เป็นตัวตั้งให้คิด
โพสต์พูดอะไรไว้จริง ๆ
โพสต์เปิดด้วยประโยคว่า
The software lifecycle is learning to think.
จากนั้นเล่าว่าการพัฒนาซอฟต์แวร์เดินตามลำดับที่คุ้นกันมานาน
For years, development followed a familiar sequence: requirements, design, coding, testing, review, deployment and production feedback.
Agentic SDLC turns that sequence into a faster, continuous loop.
แล้วแบ่งบทบาทระหว่างคนกับ agent พร้อมรายการแปดข้อ
Humans define the intent, outcomes and boundaries. AI agents support every stage: → Goals replace lengthy requirement handoffs. → AI-assisted PRDs create structured solution plans. → Agent architecture connects roles, tools, APIs and workflows. → Autonomous implementation generates and refactors code. → Human review protects quality and critical decisions. → Continuous testing runs evaluations and security checks. → Agent-driven deployment executes CI/CD changes. → Production monitoring detects drift and learns from feedback.
แปลตามความเข้าใจของผมคือ เป้าหมายมาแทนการส่งต่อ requirement ยาว ๆ, PRD ที่ AI ช่วยเขียนกลายเป็นแผนงานที่มีโครงสร้าง, มีสถาปัตยกรรมของ agent ที่เชื่อมบทบาท เครื่องมือ API และ workflow เข้าด้วยกัน, agent เขียนและ refactor โค้ดเอง, คนรีวิวเพื่อปกป้องคุณภาพและการตัดสินใจสำคัญ, การทดสอบรันต่อเนื่องทั้ง evaluation และ security check, agent เป็นคน deploy ผ่าน CI/CD และการเฝ้า production ตรวจจับ drift แล้วเรียนรู้จาก feedback
ย่อหน้าที่ผมคิดว่าเป็นแกนของโพสต์คือย่อหน้านี้
Value moves from manually completing every task to designing a system that completes those tasks safely. Engineers define goals, permissions, guardrails, evaluation criteria and escalation paths.
คุณค่าย้ายจากการลงมือทำทุก task เอง ไปเป็นการออกแบบระบบที่ทำ task เหล่านั้นอย่างปลอดภัย และวิศวกรเป็นคนนิยามห้าอย่าง คือเป้าหมาย สิทธิ์ ขอบกั้น เกณฑ์ประเมิน และเส้นทางส่งเรื่องต่อ
ตามด้วยประโยคเรื่องความเร็ว
This approach can compress cycles from weeks to days, but speed needs control.
และปิดด้วยนิยามกับคำถาม
An Agentic SDLC combines autonomous execution with human judgment, continuous evaluation, observability and governance.
We are moving from managing development tasks to designing software systems that can execute, learn and improve.
How much of your SDLC is agent-assisted?
สามจุดที่ต้องอ่านช้า ๆ
"support every stage" กับ "Autonomous" ประโยคนำบอกว่า agent "ช่วย" ทุกขั้น แต่ในรายการมีคำว่า "Autonomous implementation" และ "Agent-driven deployment" ซึ่งไปไกลกว่าการช่วย สองระดับนี้ต่างกันมากในทางปฏิบัติ agent ที่ช่วยร่างให้คนตัดสินใจ กับ agent ที่ลงมือ deploy เอง ต้องการกติกาคนละชุด โพสต์ใช้ทั้งสองคำโดยไม่ได้แยก
"can compress" คำกริยาคือ "can" ไม่ใช่ "does" โพสต์บอกว่าแนวทางนี้ทำให้รอบงานสั้นลงได้ ไม่ได้บอกว่าทำแล้วหรือวัดแล้ว และอย่างที่บอกไว้ข้างบน ไม่มีข้อมูลใดในโพสต์รองรับช่วง "weeks to days"
"Human review" เป็นหนึ่งในแปดบรรทัด ในรายการ คนปรากฏอยู่บรรทัดเดียวตรงกลาง ระหว่าง agent เขียนโค้ดกับการทดสอบต่อเนื่อง แต่ประโยคนิยามตอนท้ายกลับพูดถึง human judgment, continuous evaluation, observability และ governance รวมสี่อย่าง ผมอ่านว่าผู้เขียนเองก็รู้ว่าการควบคุมต้องมีมากกว่าด่านรีวิวด่านเดียว แต่รายการแปดข้อทำให้ภาพจำออกมาเป็นแบบนั้น
ตรงไหนที่ผมว่าโพสต์พูดถูก
1. งานย้ายจากการทำ task ไปเป็นการออกแบบระบบที่ทำ task
ข้อนี้ตรงกับที่ผมเห็นในงานตัวเองครับ ไม่ใช่จากข้อมูล เวลาที่ผมใช้กับ agent ส่วนใหญ่ไม่ได้อยู่ที่การพิมพ์โค้ด แต่อยู่ที่การบอกว่าต้องการอะไร ห้ามแตะอะไร และจะรู้ได้อย่างไรว่างานเสร็จ ถ้าสามอย่างนี้ชัด งานที่ได้กลับมามักใช้ได้ ถ้าไม่ชัด ผมได้โค้ดที่ทำงานได้แต่แก้โจทย์ผิดข้อ
คำว่า "safely" ในประโยคนั้นสำคัญกว่าที่เห็น โพสต์ไม่ได้บอกว่าให้ออกแบบระบบที่ทำ task ให้เสร็จ แต่บอกว่าให้ทำอย่างปลอดภัย ซึ่งเป็นงานอีกก้อนหนึ่งเลย
2. ห้าอย่างที่ต้องนิยามเป็นรายการที่ใช้ได้จริง
goals, permissions, guardrails, evaluation criteria และ escalation paths เป็นรายการที่ผมหยิบไปใช้ต่อได้ทันที และมันไม่ใช่เรื่องใหม่สำหรับคนที่เคยมอบงานให้คน ตอนผมมอบงานให้ junior ผมก็ต้องบอกห้าอย่างนี้ คืองานนี้เพื่ออะไร แตะอะไรได้ ห้ามทำอะไร แบบไหนถือว่าเสร็จ และติดตรงไหนให้มาถามใคร
ความต่างคือ junior ถามกลับได้เมื่อผมบอกไม่ครบ และมักจะหยุดเมื่อรู้สึกว่ามีอะไรไม่ชอบมาพากล agent ส่วนใหญ่จะเดินต่อด้วยข้อสันนิษฐานของมันเอง รายการห้าข้อนี้จึงต้องเขียนให้ครบกว่าที่เคยบอกคน ผมจะขยายแต่ละข้อในหัวข้อถัดไป
3. "speed needs control"
โพสต์ไม่ได้ขายความเร็วอย่างเดียวครับ ประโยคเรื่อง weeks to days มีครึ่งหลังตามมาทันที และประโยคนิยามก็ใส่ human judgment กับ governance ไว้คู่กับ autonomous execution ผมให้เครดิตตรงนี้ โพสต์ประเภทเดียวกันจำนวนมากหยุดอยู่แค่ครึ่งแรก
4. feedback จาก production ควรวนกลับมาจริง
ในลำดับแบบเดิม ขั้น "production feedback" มักเป็นขั้นที่ถูกเขียนไว้ในแผนภาพแต่ไม่ค่อยเกิดขึ้น ทีมส่งงานแล้วก็ไปทำ feature ถัดไป การมองทั้งหมดเป็น loop เตือนว่าข้อมูลจากของที่ใช้งานจริงควรกลับมาเปลี่ยน requirement รอบถัดไป ไม่ว่าจะมี agent หรือไม่ ผมเห็นด้วยกับภาพนี้
ตรงไหนที่ผมว่าพูดง่ายเกินไป
1. Loop ที่เร็วขึ้นขยาย requirement ที่ผิดให้ไปไกลขึ้น
นี่คือข้อที่ผมกังวลที่สุดครับ ในลำดับแบบเดิม ทุกรอยต่อระหว่างขั้นเป็นจุดที่มีคนอ่านงานของขั้นก่อนหน้า เดฟอ่าน requirement แล้วถามว่า "กรณีนี้ล่ะ" QA อ่าน design แล้วถามว่า "ถ้ากดซ้ำสองครั้งจะเกิดอะไร" คำถามเหล่านี้ช้าและน่ารำคาญ แต่มันคือกลไกที่จับ requirement ที่ไม่ครบได้ก่อนถึงมือผู้ใช้
เมื่อทุกขั้นถูกเชื่อมเป็น loop ที่ agent วิ่ง รอยต่อเหล่านั้นหายไปหรือเหลือน้อยลง ถ้า requirement ต้นทางผิดหรือขาด agent จะร่างแผนจากสิ่งที่ผิด เขียนโค้ดตามแผน เขียน test ที่ยืนยันโค้ดนั้น แล้ว deploy ทุกขั้นผ่านหมด เพราะทุกขั้นตรวจกับขั้นก่อนหน้า ไม่ได้ตรวจกับสิ่งที่ลูกค้าต้องการจริง
ในโพสต์เรื่อง agent แก้ test ให้ CI เขียว ผมเล่าว่า agent ที่ถูกสั่งให้งานผ่าน จะหาทางให้ผ่านโดยไม่สนว่าด่านนั้นมีไว้ทำไม loop ทั้งวงจรก็มีความเสี่ยงแบบเดียวกันในขนาดที่ใหญ่กว่า คือสีเขียวทุกขั้นโดยไม่มีขั้นไหนถามว่าโจทย์ถูกหรือเปล่า
2. "Goals replace lengthy requirement handoffs" ข้ามงานที่ยากที่สุดไป
บรรทัดนี้ฟังดูเหมือนการตัดงานเอกสารทิ้ง แต่ในงานที่ผมทำ ความยาวของ requirement ไม่ใช่ปัญหา ปัญหาคือมันไม่ครบ และการเปลี่ยนจากเอกสารยาวเป็นเป้าหมายสั้น ๆ ไม่ได้ทำให้มันครบขึ้น
เป้าหมายแบบ "ให้ลูกค้าขอคืนเงินได้เอง" เขียนได้ในบรรทัดเดียว แต่ใครขอได้ ภายในกี่วัน คืนเต็มหรือบางส่วน ถ้าสินค้าถูกใช้ไปแล้วทำอย่างไร ใครอนุมัติ คำตอบเหล่านี้ไม่ได้อยู่ในเป้าหมาย และมักไม่ได้อยู่ในหัวลูกค้าด้วย จนกว่าจะมีคนถาม ตัวอย่างนี้ผมสมมติขึ้นเพื่ออธิบายครับ ไม่ได้มาจากโพสต์
ถ้าไม่มีใครถาม agent จะเติมช่องว่างเอง และมันเติมได้อย่างมั่นใจเสียด้วย ผลคือการตัดสินใจทางธุรกิจที่ไม่มีใครตัดสิน ถูกฝังอยู่ในโค้ดโดยไม่มีใครเห็น ผมจึงอ่านบรรทัดนี้ใหม่ว่า เป้าหมายมาแทนการ "ส่งต่อ" ได้ แต่มาแทนการ "ซักให้ครบ" ไม่ได้
3. "Human review" บรรทัดเดียวรับน้ำหนักทั้งวงจรไม่ไหว
ถ้า agent ผลิตงานได้เร็วขึ้นในทุกขั้น ปริมาณของที่ต้องรีวิวก็เพิ่มตาม แต่จำนวนคนรีวิวและสมาธิของคนรีวิวไม่ได้เพิ่ม สิ่งที่ผมคาดว่าจะตามมามีสองอย่าง และผมเห็นเค้าของมันแล้วในงานรีวิวโค้ดที่ agent เขียน
- Review fatigue งานที่ agent ส่งมามักเรียบร้อย ตั้งชื่อดี มีคำอธิบายครบ และยาว คนรีวิวต้องใช้แรงมากกว่าเดิมเพื่อหาจุดผิดในงานที่ดูถูกทั้งหมด พอทำแบบนี้หลายรอบต่อวัน ความละเอียดจะลดลงเอง
- Rubber-stamping เมื่อเหนื่อยและงานส่วนใหญ่ผ่านจริง การกด approve จะกลายเป็นค่าเริ่มต้น ด่านรีวิวยังอยู่ในแผนภาพ แต่ไม่ได้กั้นอะไรแล้ว และอันตรายกว่าการไม่มีด่าน เพราะทุกคนเชื่อว่ามี
โพสต์เขียนว่า human review "protects quality and critical decisions" ซึ่งถูกในหลักการ แต่ไม่ได้บอกว่าคนหนึ่งคนรีวิวได้เท่าไรก่อนที่การปกป้องนั้นจะเหลือแต่ชื่อ ผมไม่มีตัวเลขให้เหมือนกันครับ ข้อนี้เป็นข้อสังเกตจากงานของผมเอง ไม่ใช่ผลการวัด
4. "weeks to days" วัดจากตรงไหนถึงตรงไหน
นอกจากไม่มีข้อมูลประกอบแล้ว ประโยคนี้ไม่ได้บอกว่านับรอบจากจุดไหน ถ้านับจาก requirement ที่นิ่งแล้วถึง deploy ผมเชื่อว่าหดได้จริงในงานหลายประเภท แต่ถ้านับจากวันที่ลูกค้าเริ่มพูดถึงปัญหา ถึงวันที่ผู้ใช้ได้ของที่แก้ปัญหานั้นจริง ช่วงที่ยาวที่สุดในงานของผมคือการรอคำตอบจากคน รอการตัดสินใจ รอ UAT และการแก้รอบสองเพราะเข้าใจไม่ตรงกัน ซึ่ง agent ที่เขียนโค้ดเร็วขึ้นไม่ได้แตะช่วงเหล่านั้นเลย
การทำให้ขั้นที่ไม่ใช่คอขวดเร็วขึ้นไม่ได้ทำให้ทั้งระบบเร็วขึ้น มันแค่ทำให้งานไปกองรอหน้าคอขวดเร็วขึ้น
5. ใครรับผิดชอบเมื่อ loop พาของผิดขึ้น production
โพสต์ใช้คำว่า governance และ escalation paths แต่ไม่ได้ลงรายละเอียด ซึ่งเข้าใจได้สำหรับโพสต์สั้น คำถามที่ทีมต้องตอบเองคือ เมื่อ agent deploy การเปลี่ยนแปลงที่ผ่านทุกด่านอัตโนมัติแล้วเกิดความเสียหาย ชื่อใครอยู่บนการตัดสินใจนั้น ถ้าคำตอบคือ "ระบบ" ก็แปลว่าไม่มีใคร และลูกค้าไม่รับคำตอบแบบนั้น
6. "learns from feedback" เรียนรู้ไปทางไหน
บรรทัดสุดท้ายบอกว่าการเฝ้า production ตรวจจับ drift และเรียนรู้จาก feedback โพสต์ไม่ได้บอกว่าการเรียนรู้นั้นคืออะไร ใครตรวจสิ่งที่ระบบเรียนรู้ และถ้าตัวชี้วัดที่ใช้เป็นตัวชี้วัดที่ผิด loop จะปรับตัวเข้าหาสิ่งที่ผิดได้เร็วแค่ไหน ผมไม่ได้บอกว่าทำไม่ได้ครับ แค่บอกว่าบรรทัดนี้เป็นบรรทัดที่ต้องการคำอธิบายมากที่สุด และได้น้อยที่สุด
คอขวดจริงของผม: requirement ไม่ครบ และ design ที่ยังไม่พร้อมให้ QA
ผมสวมหมวกสามใบครับ เป็นเดฟ เป็น PM และเป็น PO ที่ดูแลทีม junior เมื่อมองวงจรทั้งหมดจากสามมุมนี้ จุดที่งานติดซ้ำ ๆ ไม่ได้อยู่ตรงกลางวงจร แต่อยู่สองจุดต้นทาง
จุดแรกคือ requirement จากลูกค้าที่ไม่ครบ ลูกค้าเล่าสิ่งที่อยากได้เป็นเรื่องเล่า ไม่ใช่เป็นกติกา สิ่งที่มักหายไปคือกรณียกเว้น สิทธิ์ของผู้ใช้แต่ละกลุ่ม สิ่งที่ระบบต้องทำเมื่อเกิดข้อผิดพลาด และเกณฑ์ว่าแบบไหนลูกค้าถึงจะยอมรับงาน
จุดที่สองคือ design ที่ผ่านรีวิวแล้วแต่ยังไม่พร้อมให้ QA รีวิว design มักจบที่ "หน้าตาใช้ได้" แต่ QA ต้องการมากกว่านั้น คือ state ว่าง state กำลังโหลด state ผิดพลาด ข้อความ validation ขอบเขตของค่าที่กรอกได้ และพฤติกรรมเมื่อสิทธิ์ไม่พอ ถ้าสิ่งเหล่านี้ไม่อยู่ใน design เดฟจะตัดสินใจเองตอนเขียน และ QA จะไม่มีอะไรให้เทียบว่าถูกหรือผิด
สองจุดนี้คือที่ที่ผมอยากให้ agent มาช่วยก่อนครับ และน่าสนใจว่าในรายการแปดข้อของโพสต์ มันตรงกับสองบรรทัดแรกซึ่งเป็นบรรทัดที่คนพูดถึงน้อยกว่า "Autonomous implementation" มาก
สิ่งที่ผมให้ agent ทำได้ในสองจุดนี้ คือให้มันเป็นคนถาม ไม่ใช่คนตอบ
- อ่าน requirement ที่ได้มา แล้วไล่ว่ามีคำถามอะไรที่ยังไม่มีคำตอบ กรณีไหนยังไม่ถูกพูดถึง คำไหนตีความได้มากกว่าหนึ่งแบบ
- ร่าง acceptance criteria จากสิ่งที่มี แล้วทำเครื่องหมายข้อที่มันต้องสันนิษฐานเอง
- อ่าน design แล้วไล่ state ที่ขาด และร่าง test case ที่ QA ยังเขียนไม่ได้เพราะข้อมูลไม่พอ
แต่คำตอบของคำถามเหล่านั้นต้องมาจากลูกค้าหรือจากคนที่มีอำนาจตัดสินใจ ไม่ใช่จาก agent ถ้าผมปล่อยให้ agent ตอบคำถามที่มันถามเอง ผมก็ได้ requirement ที่ดูครบแต่ไม่มีใครยืนยัน ซึ่งแย่กว่า requirement ที่ไม่ครบแบบเห็น ๆ เพราะช่องว่างถูกปิดด้วยการเดา
ขั้นไหนให้ agent ก่อน ขั้นไหนคนต้องเฝ้าด่าน
ตารางนี้เป็นเกณฑ์ของผมเองครับ ไม่ได้มาจากโพสต์ ผมเรียงจากหลักข้อเดียว คือให้ agent ไปก่อนในงานที่ผิดแล้วเห็นง่ายและย้อนกลับได้ และเก็บด่านคนไว้ในงานที่ผิดแล้วเห็นยากหรือย้อนกลับไม่ได้
| ขั้น | ให้ agent ทำอะไรได้ก่อน | ด่านที่คนต้องเฝ้า |
|---|---|---|
| Requirement | ไล่ช่องว่าง ตั้งคำถาม ร่าง acceptance criteria | คนยืนยันคำตอบกับลูกค้า และเซ็นว่า requirement รอบนี้นิ่ง |
| Design / แผนงาน | ร่างแผน ไล่ state ที่ขาด ร่าง test case จาก design | คนรีวิวว่า design พร้อมให้ QA แล้ว ก่อนเริ่มเขียนโค้ด |
| Code | เขียนและ refactor ในขอบเขตที่กำหนด | คนตัดสินเรื่องโครงสร้างข้อมูล สัญญา API และสิ่งที่แก้ทีหลังยาก |
| Test | เขียนและรัน test ไล่ regression | คนเป็นเจ้าของเกณฑ์ว่าอะไรคือผ่าน agent ห้ามแก้เกณฑ์เพื่อให้ตัวเองผ่าน |
| Review | รีวิวรอบแรก จับสิ่งที่ตรวจได้ด้วยกติกา | คนรีวิวสิ่งที่กระทบเงิน สิทธิ์ ข้อมูลส่วนบุคคล และการตัดสินใจทางธุรกิจ |
| Deploy | deploy ขึ้น environment ทดสอบ เตรียม release note | คนอนุมัติการขึ้น production และการเปลี่ยนแปลงที่ย้อนกลับไม่ได้ เช่น migration ข้อมูล |
| Production feedback | สรุป log และข้อผิดพลาด ร่างรายงาน เสนอสิ่งที่ควรแก้ | คนตัดสินว่า feedback ไหนกลับไปเปลี่ยน requirement |
สังเกตว่าทุกแถวมี agent อยู่ครับ ผมไม่ได้เถียงกับประโยค "AI agents support every stage" ของโพสต์ สิ่งที่ผมเพิ่มคือทุกแถวมีด่านคนด้วย ไม่ใช่มีแถวเดียวตรงกลางที่ชื่อ human review
ลำดับที่ผมจะเริ่มคือสองแถวบนสุดกับแถว Test ก่อน เพราะเป็นงานที่ agent ผลิตสิ่งที่คนอ่านแล้วตัดสินได้ทันที และถ้ามันผิดก็ยังไม่มีอะไรเสียหาย ส่วนการ deploy ขึ้น production โดย agent ผมจะเก็บไว้ท้ายสุด จนกว่าทีมจะมีหลักฐานของตัวเองว่าด่านอัตโนมัติก่อนหน้านั้นจับของผิดได้จริง
ห้าอย่างที่ PM และ lead ต้องนิยามก่อนปล่อย loop ให้วิ่ง
โพสต์บอกว่าวิศวกรเป็นคนนิยามห้าอย่างนี้ ในทีมที่ผมดูแล งานนี้ตกอยู่กับ PM กับ lead ด้วยครับ เพราะครึ่งหนึ่งของมันเป็นคำถามทางธุรกิจ ไม่ใช่ทางเทคนิค คำถามใต้แต่ละข้อเป็นของผมเอง โพสต์ให้ไว้แค่ชื่อหัวข้อ
1. Goals: เป้าหมาย
- งานนี้ทำเพื่อผลลัพธ์อะไรของผู้ใช้หรือธุรกิจ ไม่ใช่แค่ "ทำ feature นี้"
- อะไรที่ไม่ใช่เป้าหมายรอบนี้ และห้ามทำเกิน
- ข้อสันนิษฐานอะไรที่ยังไม่ได้ยืนยันกับลูกค้า
2. Permissions: สิทธิ์
- agent อ่านอะไรได้ เขียนอะไรได้ รันอะไรได้ ใน environment ไหน
- อะไรที่ต้องมีคนอนุมัติก่อนทุกครั้ง
- credential และข้อมูลจริงของลูกค้า agent เข้าถึงได้หรือไม่
3. Guardrails: ขอบกั้น
- ไฟล์ ตาราง หรือระบบใดที่ห้ามแตะ
- กติกาที่ห้ามแก้เพื่อให้งานผ่าน เช่น test, lint และเกณฑ์ของ CI
- กติกาเหล่านี้เขียนไว้ที่ไหนที่ agent โหลดจริง ผมเคยเขียนเรื่องนี้ไว้ในโพสต์เรื่อง AGENTS.md กับ CLAUDE.md
4. Evaluation criteria: เกณฑ์ประเมิน
- รู้ได้อย่างไรว่างานเสร็จและถูก โดยเทียบกับสิ่งที่ลูกค้าต้องการ ไม่ใช่เทียบกับขั้นก่อนหน้า
- เกณฑ์นี้ใครเป็นเจ้าของ และ agent แก้เองได้หรือไม่ คำตอบของผมคือไม่ได้
- อะไรที่ตรวจด้วยเครื่องได้ และอะไรที่ต้องให้คนดู
5. Escalation paths: เส้นทางส่งเรื่องต่อ
- เมื่อไร agent ต้องหยุดแล้วถามคน เช่น เมื่อ requirement ขัดกันเอง เมื่อต้องสันนิษฐานเรื่องธุรกิจ หรือเมื่อจะทำสิ่งที่ย้อนกลับไม่ได้
- ถามใคร และถ้าคนนั้นไม่อยู่ใครตัดสินแทน
- เมื่อ junior ไม่แน่ใจในสิ่งที่ agent ทำ เขาส่งเรื่องต่อให้ใครโดยไม่ต้องรู้สึกว่าตัวเองทำงานช้า
ข้อสุดท้ายนี้ต่อจากโพสต์ที่แล้วโดยตรงครับ ครั้งนั้นผมเขียนว่าคนเฝ้าประตูที่ทำหน้าที่ต้องมีเกณฑ์เขียนไว้ มีคนสำรอง และมีกำหนดเวลาตอบ ด่านคนใน loop ก็ต้องเป็นแบบเดียวกัน ถ้าด่านของผมช้าและไม่มีเกณฑ์ ทีมจะหาทางอ้อม และ agent ทำให้การอ้อมง่ายมาก
สำหรับทีมที่มี junior
มีสองเรื่องที่ผมจะระวังเป็นพิเศษครับ
เรื่องแรก junior มีแนวโน้มจะ approve งานของ agent ง่ายกว่าคนอื่น ไม่ใช่เพราะไม่ใส่ใจ แต่เพราะงานที่ agent เขียนมักดูดีกว่าที่เขาเขียนเองได้ และเขายังไม่มีประสบการณ์พอจะรู้ว่าจุดไหนควรสงสัย ถ้าผมวาง junior ไว้เป็นด่านรีวิวของ loop โดยไม่มีเกณฑ์ให้ ผมกำลังสร้าง rubber stamp ขึ้นมาเอง สิ่งที่ช่วยได้คือรายการสิ่งที่ต้องตรวจซึ่งเขียนไว้ชัด และกติกาว่าการส่งเรื่องต่อเมื่อไม่แน่ใจเป็นการทำงานที่ถูก ไม่ใช่การทำงานช้า
เรื่องที่สอง ขั้นที่ loop ตัดออกคือขั้นที่ junior เคยใช้เรียนรู้ การอ่าน requirement แล้วถามกลับ การเขียน test case จาก design การไล่หาสาเหตุของ bug เป็นงานที่ช้า และเป็นงานที่สร้างวิจารณญาณ ถ้า agent ทำทั้งหมดแล้ว junior เหลือหน้าที่กดอนุมัติ ผมจะได้ทีมที่ส่งงานเร็วแต่ไม่มีใครโตขึ้นมาเฝ้าด่านแทนผมได้ ผมจึงจะให้ junior ทำงานต้นทางคู่กับ agent คือให้ agent ไล่ช่องว่างของ requirement แล้วให้ junior เป็นคนตัดสินว่าคำถามไหนสำคัญ และเป็นคนเอาไปถามคน
Checklist ก่อนให้ agent วิ่งทั้งวงจร
ก่อนเชื่อโพสต์ประเภทนี้
- แยกได้ว่าอะไรเป็นความเห็น อะไรเป็นข้อมูล และตัวเลขที่อ้างมีที่มาหรือไม่
- รู้ว่าผู้เขียนมีอะไรจะขายหรือโปรโมตในโพสต์เดียวกันหรือเปล่า
- ถามว่าคอขวดของทีมตัวเองอยู่ขั้นไหน ก่อนถามว่าจะเร่งขั้นไหน
ต้นทาง: requirement และ design
- requirement แต่ละข้อมี acceptance criteria ที่ลูกค้าหรือ PO ยืนยันแล้ว ไม่ใช่ที่ agent ร่างแล้วไม่มีใครอ่าน
- ข้อสันนิษฐานที่ agent เติมเองถูกทำเครื่องหมายไว้ และมีคนตัดสินทุกข้อ
- design มี state ว่าง กำลังโหลด ผิดพลาด และกรณีสิทธิ์ไม่พอ ครบพอให้ QA เขียน test case ได้
- มีคนเซ็นว่า requirement และ design รอบนี้นิ่งแล้ว ก่อน agent เริ่มเขียนโค้ด
ห้าอย่างที่ต้องนิยาม
- Goals: เขียนเป้าหมาย สิ่งที่ไม่ใช่เป้าหมาย และข้อสันนิษฐานที่ยังไม่ยืนยัน
- Permissions: ระบุสิ่งที่ agent อ่าน เขียน และรันได้ในแต่ละ environment
- Guardrails: ระบุสิ่งที่ห้ามแตะและกติกาที่ห้ามแก้ และตรวจแล้วว่า agent โหลดกติกานั้นจริง
- Evaluation criteria: เกณฑ์ผ่านมีเจ้าของเป็นคน และ agent แก้เองไม่ได้
- Escalation paths: ระบุว่าเมื่อไรต้องหยุด ถามใคร และใครตัดสินแทนเมื่อคนนั้นไม่อยู่
ด่านคน
- ทุกขั้นของวงจรมีด่านคนที่ระบุชื่อ ไม่ได้มีแค่ด่านรีวิวโค้ดด่านเดียว
- การขึ้น production และการเปลี่ยนแปลงที่ย้อนกลับไม่ได้ต้องมีคนอนุมัติ
- ปริมาณงานที่ส่งให้คนรีวิวต่อวันอยู่ในระดับที่อ่านได้จริง ถ้าเกินให้ลดความเร็วของ loop ไม่ใช่ลดความละเอียดของการรีวิว
- มีวิธีตรวจว่าด่านยังทำงาน เช่น ดูว่าครั้งล่าสุดที่รีวิวตีงานกลับคือเมื่อไร ถ้าไม่เคยเลยให้สงสัยด่านก่อนชมคุณภาพงาน
- junior ที่เป็นคนรีวิวมีรายการสิ่งที่ต้องตรวจ และรู้ว่าส่งเรื่องต่อให้ใคร
หลังขึ้น production
- รู้ว่าใครรับผิดชอบเมื่อการเปลี่ยนแปลงที่ agent deploy ทำให้เกิดปัญหา
- feedback ที่จะกลับไปเปลี่ยน requirement ผ่านการตัดสินของคน
- วัดรอบงานจากวันที่ลูกค้าบอกปัญหาถึงวันที่ผู้ใช้ได้ของที่ถูก ไม่ใช่จาก commit ถึง deploy
ท้ายที่สุด
ผมเห็นด้วยกับแกนของโพสต์นี้ครับ งานของคนกำลังย้ายจากการลงมือทำทีละ task ไปเป็นการออกแบบระบบที่ทำ task เหล่านั้นอย่างปลอดภัย และรายการห้าข้อ คือ goals, permissions, guardrails, evaluation criteria และ escalation paths เป็นรายการที่ผมจะเอาไปใช้กับทีมจริง สิ่งที่ผมยืนยันให้ไม่ได้คือประโยคเรื่อง weeks to days เพราะโพสต์ไม่มีข้อมูลประกอบ และโพสต์ทั้งหมดเป็นความเห็นของคนคนเดียว ไม่ใช่ผลการศึกษา
ส่วนที่ผมเห็นต่างคือน้ำหนักครับ ภาพ loop ทำให้สายตาไปอยู่ที่ขั้นกลางของวงจรซึ่ง agent ทำได้น่าประทับใจที่สุด ขณะที่งานของผมติดอยู่ต้นทาง ที่ requirement ซึ่งลูกค้ายังบอกไม่ครบ และ design ซึ่งยังไม่พร้อมให้ QA ตรวจ loop ที่เร็วขึ้นไม่ได้แก้สองเรื่องนี้ และถ้าไม่มีด่านคนที่ทำงานจริงในทุกขั้น มันจะพาสิ่งที่ผิดตั้งแต่ต้นทางไปถึงผู้ใช้เร็วกว่าเดิม โดยมีสีเขียวกำกับตลอดทาง
โพสต์ปิดด้วยคำถามว่า "How much of your SDLC is agent-assisted?" ผมคิดว่าคำถามที่ทีมผมควรตอบให้ได้ก่อนคืออีกข้อหนึ่ง คือ "ถ้า requirement รอบนี้ผิด ขั้นไหนในวงจรของเราจะเป็นขั้นที่จับได้ และคนที่เฝ้าขั้นนั้นคือใคร" ถ้าตอบได้พร้อมชื่อคน ผมก็พร้อมให้ agent วิ่งเร็วขึ้นอีกขั้น ถ้าตอบไม่ได้ ความเร็วที่เพิ่มขึ้นจะเป็นแค่ความเร็วในการไปถึงจุดที่ต้องกลับมาแก้ครับ
อ้างอิง
- โพสต์ของ Aiswarya Venkitesh (@AiswaryaVenkit1) ใน X วันที่ 30 ตุลาคม 2026 อ่านเมื่อวันที่ 21 พฤศจิกายน 2026 เป็นโพสต์ความเห็นส่วนบุคคลที่ปิดท้ายด้วยการโปรโมต newsletter ของผู้เขียน ข้อความภาษาอังกฤษทั้งหมดที่ยกมาในบทความนี้มาจากโพสต์นี้
สิ่งที่ยังไม่ได้ตรวจสอบ
- ประโยคว่ารอบงานหดจาก "weeks to days" โพสต์ไม่มีข้อมูลประกอบ และผมไม่ได้หาข้อมูลจากแหล่งอื่นมายืนยันหรือหักล้าง
- ตำแหน่งงานและประวัติของผู้เขียน ผมอ้างตาม bio ในโปรไฟล์ X เท่านั้น
- เนื้อหาใน GIF ที่แนบมากับโพสต์ และ reply ใต้โพสต์ ผมไม่ได้อ่าน
- ข้อสังเกตเรื่อง review fatigue, rubber-stamping และคอขวดที่ต้นทาง มาจากงานของผมเอง ไม่ใช่ผลการวัดหรืองานวิจัย
- ตาราง รายการคำถาม และ checklist ในบทความนี้เป็นเกณฑ์ของผมเอง ไม่ได้มาจากโพสต์ต้นทาง และยังไม่ได้ผ่านการทดลองใช้ทั้งชุดกับทีม