Coding Gun

AI Driven Development(ADLC) เมื่อ AIไม่ใช่แค่ผู้ช่วยเขียน Code


ในช่วงที่ผ่านมา Generative AI และ AI Coding Agents ได้เปลี่ยนวิธีการพัฒนาซอฟต์แวร์อย่างรวดเร็ว นักพัฒนาสามารถใช้ AI สร้างโค้ด เขียน Unit Tests วิเคราะห์ข้อผิดพลาด และแก้ไขปัญหาที่ซับซ้อนได้ภายในเวลาอันสั้น แต่คำถามสำคัญคือ หาก AI สามารถเขียนโค้ดได้เร็วขึ้นหลายเท่า ทำไมกระบวนการส่งมอบซอฟต์แวร์ของหลายองค์กรจึงยังไม่ได้เร็วขึ้น?

ทาง Antropic ได้ออกเอกสารชื่อว่า The AI-Native SDLC Playbook ซึ่งระบุว่า คอขวดของการพัฒนาซอฟต์แวร์กำลังย้ายจากขั้นตอนการเขียนโค้ดไปสู่ขั้นตอนอื่นๆ เช่น การวิเคราะห์ความต้องการ(Requirement Development) การตรวจสอบคุณภาพ(Quality Assurrance) การอนุมัติการเปลี่ยนแปลง(Change Management) และการนำระบบขึ้นใช้งานจริง(Deployment)

ฺbottleneck

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

แนวคิด AI-Driven Development หรือการพัฒนาซอฟต์แวร์โดยขับเคลื่อนด้วย AI จึงไม่ควรหมายถึงเพียงการใช้ AI ช่วยเขียนโปรแกรม แต่ควรหมายถึงการออกแบบกระบวนการพัฒนาซอฟต์แวร์ใหม่ โดยนำ AI เข้ามาฝังไว้ในทุกขั้นตอนการผลิดซอฟต์แวร์ Software Development Lifecycle (SDLC)

1. AI-Driven Development คืออะไร?

AI-Driven Development (ADLC) หมายถึงแนวทางการพัฒนาซอฟต์แวร์ที่ใช้ AI เป็นส่วนหนึ่งของกระบวนการทำงานตั้งแต่การวางแผน(Plan), การออกแบบ(Design), การพัฒนา(Build), การทดสอบ(Test), การ Deploy ไปจนถึงการบำรุงรักษาระบบ(Maintenance)

แนวคิดนี้สอดคล้องกับสิ่งที่เอกสารเรียกว่า AI-Native SDLC ซึ่งไม่ได้มอง AI เป็นเพียงเครื่องมือเสริมสำหรับนักพัฒนา แต่เป็นองค์ประกอบสำคัญของกระบวนการทำงานทั้งหมด

ความแตกต่างที่สำคัญคือ การใช้ AI แบบทั่วไปอาจเริ่มต้นจากการที่ Developer พิมพ์ Prompt ลงไปเพื่อให้ AI สร้าง Code มาให้เรา จากนั้นนำผลลัพธ์ไปตรวจสอบและทำงานต่อด้วยตนเอง ขณะที่ AI-Native SDLC พยายามสร้างกระบวนการที่แต่ละขั้นตอนสามารถส่งต่อผลลัพธ์ไปยังขั้นตอนถัดไปได้อย่างเป็นระบบ และสามารถให้ AI ดำเนินงานบางส่วนโดยอัตโนมัติภายใต้เงื่อนไขที่กำหนด

ตัวอย่างเช่น

เป้าหมายไม่ใช่การนำคนออกจากกระบวนการทั้งหมด แต่เป็นการลดงานที่ต้องทำซ้ำ(Re-work) ลดการส่งต่องานที่ไม่จำเป็น และให้คนเปลี่ยนไปใช้เวลากับการตัดสินใจที่ต้องอาศัยประสบการณ์, ความเข้าใจทางธุรกิจ และการประเมินความเสี่ยง

2. จาก Traditional SDLC สู่ AI-Native SDLC

โดยทั่วไป SDLC ประกอบด้วย 6 ขั้นตอนหลัก ได้แก่ Plan, Design, Build, Test, Deploy และ Maintain

ในกระบวนการแบบดั้งเดิม แต่ละขั้นตอนมักรับผิดชอบโดยบุคคลหรือทีมที่แตกต่างกัน เช่น Product Manager รวบรวมความต้องการ Architect ออกแบบระบบ Developer เขียนโค้ด QA ทดสอบ และ Operations ดูแลระบบหลัง Deploy

กระบวนการดังกล่าวมีประโยชน์ในการแบ่งหน้าที่และควบคุมคุณภาพ แต่การส่งต่องานผ่านเอกสาร Ticket การประชุม และการอนุมัติหลายระดับอาจทำให้เกิดความล่าช้า

เมื่อ AI เข้ามาช่วยพัฒนาโค้ดได้อย่างรวดเร็ว จุดที่ใช้เวลามากที่สุดจึงอาจไม่ใช่ Build อีกต่อไป แต่กลายเป็นขั้นตอนก่อนและหลัง Build เช่น การเตรียม Requirements การทดสอบ และการอนุมัติ Release

SDLC_vs_ADLC

ความแตกต่างของสองแนวทางสามารถสรุปได้ดังนี้

ประเด็น Traditional SDLC AI-Native SDLC
การวางแผน รวบรวมความต้องการผ่านเอกสารและการประชุม ใช้ AI ช่วยสังเคราะห์ความต้องการเป็นเอกสารที่นำไปทำงานต่อได้
การออกแบบ Requirements และ Design อาจแยกเป็นหลายขั้นตอน AI ช่วยสร้าง Specification โดยใช้มาตรฐานขององค์กรเป็นข้อกำหนด
การพัฒนา Developer เขียนโค้ดและทดสอบด้วยตนเองเป็นหลัก AI ช่วยวางแผน เขียนโค้ด และตรวจสอบผลลัพธ์
การทดสอบ ทดสอบเป็นช่วง ๆ และรอผลจาก QA มี Feedback Loop และ Continuous Evaluations
การตรวจสอบและ Deploy รอ Human Review และการอนุมัติ ใช้ AI Review ร่วมกับ Automated Gates และ Human Approval
Maintenace ทีมงานรับ Alert และเริ่มวิเคราะห์ปัญหา AI สามารถช่วยวิเคราะห์ Incident และทำการแก้ไขเบื้องต้นได้ด้วย

ข้อสำคัญคือ AI-Native SDLC ไม่ได้หมายถึงการให้ AI เป็นคนทำงานโดยไม่มีการควบคุม แต่เป็นการออกแบบการควบคุมใหม่ให้เหมาะสมกับปริมาณงานที่ AI สามารถสร้างได้

3. เปลี่ยน SDLC จาก Linear ให้เป็น Continuous Feedback Loop

แนวคิดที่สำคัญเรื่องนึงในการทำ AI-Driven Development คือ การเปลี่ยนกระบวนการพัฒนาซอฟต์แวร์จาก Linear Workflow ให้กลายเป็น Continuous Feedback Loop

ในรูปแบบดั้งเดิมงานจะเริ่มจากการวางแผน(Plan) ผ่านการออกแบบ(Desing) การพัฒนา(Build) การทดสอบ(Test) และการ Deploy เมื่อพบปัญหาใน Production ทีมงานต้องเริ่มกระบวนการนี้ใหม่อีกครั้ง

ใน AI-Driven Development ผลลัพธ์จากแต่ละขั้นตอนจะถูกบันทึกเป็น Artifact ที่สามารถส่งต่อให้ขั้นตอนถัดไปอ่านและนำไปใช้ต่อได้เลย เช่น

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

เมื่อเกิดปัญหาใน Production ระบบสามารถใช้ข้อมูลจากการ Monitoring หรือ Incident Ticket เพื่อเริ่มกระบวนการวิเคราะห์และสร้าง intent.md ใหม่ จากนั้นส่งกลับเข้าสู่กระบวนการพัฒนาใหม่อีกรอบ

นี่คือการเปลี่ยนจากการใช้ AI เพื่อสร้างโค้ดเพียงครั้งเดียว ไปสู่การสร้างกระบวนการที่เรียนรู้จากผลลัพธ์และปรับปรุงซอฟต์แวร์ได้อย่างต่อเนื่อง

4. ขั้นตอนการทำ AI-Driven Development

Stage 1: Plan

ขั้นตอนแรกคือการเปลี่ยนปัญหาหรือไอเดียให้เป็นข้อมูลที่ชัดเจนพอสำหรับการพัฒนา

แทนที่จะรอให้ Product Manager หรือ Business Analyst เขียนเอกสารอย่างเป็นทางการ เราสามารถเริ่มงานได้โดยการอธิบายปัญหาให้ AI รับรู้ และช่วยตั้งคำถาม รวมทั้งจัดโครงสร้างความต้องการไปก่อนได้

ผลลัพธ์คือไฟล์ intent.md ซึ่งประกอบไปด้วย

ตัวอย่างเช่น ธุรกิจประกันภัยต้องการให้ลูกค้าตรวจสอบสถานะเคลมได้ด้วยตนเอง AI สามารถช่วยรวบรวมปัญหา เป้าหมาย และข้อจำกัด เช่น การใช้ระบบ Authentication เดิม และการไม่เปิดเผยข้อมูลส่วนบุคคล เป็นต้น

อย่างไรก็ตาม Product Owner ยังคงต้องตรวจสอบและอนุมัติ intent.md ก่อนส่งเข้าสู่ขั้นตอน Design

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

Stage 2: Design

เมื่อ intent.md ผ่านการอนุมัติ AI จะนำข้อมูลดังกล่าวไปสร้าง Requirements และ Design Specification ในไฟล์ spec.md

AI สามารถใช้มาตรฐานขององค์กร เช่น Security Policy, UX Guidelines, Brand Guidelines และ Compliance Requirements เป็นข้อกำหนดในการออกแบบ พร้อมระบุประเด็นที่ขัดแย้งกัน(Conflict)หรือยังต้องการการตัดสินใจจากผู้เชี่ยวชาญ(Human In The Loop: HITL)

สิ่งที่ต้องให้ความสำคัญมากๆเลยคือข้อกำหนดด้าน Security และ Compliance ซึ่งควรนำมาพิจารณาตั้งแต่ตอนขั้นตอนแรกๆ(Shift-to-the-Left) ไม่ใช่รอให้ไปพบปัญหาตอนทำ Pen-Test

Product Owner ยังคงต้องตรวจสอบว่า Specification ตอบโจทย์ธุรกิจจริงหรือไม่ และประเด็นความเสี่ยงที่สำคัญได้รับการแก้ไขแล้วหรือยัง

ผลลัพธ์ที่ได้: ลดระยะเวลาการจัดทำ Specification และลดการแก้ไข Requirements หลังเริ่มพัฒนา

Stage 3: Build

ในขั้นตอน Build ให้เริ่มจากการให้ AI วิเคราะห์ Codebase และสร้างแผนการ Implementation ก่อนเริ่มแก้ไขไฟล์ แผนดังกล่าวควรระบุไฟล์ที่จะเปลี่ยน ลำดับการทำงาน ความเสี่ยง และวิธีทดสอบผลลัพธ์ จากนั้น Developer จึงตรวจสอบและอนุมัติ plan.md

เมื่อแผนได้รับการยอมรับ AI จึงเริ่ม Implementation ตามขอบเขตที่กำหนด

เครื่องมือและแนวทางสำคัญในขั้นตอนนี้ประกอบด้วย

1. CLAUDE.md

หรือ Agents.md เมื่อใช้ Agents อื่นๆ โดยที่ Claude.md หรือ Agent.md ไฟล์ที่รวบรวมบริบทของโครงการ เช่น คำสั่ง Build และ Test, Coding Conventions, Architecture และข้อผิดพลาดที่ AI มักทำซ้ำๆ เพื่อให้ AI ทำงานตามมาตรฐานเดียวกัน

2. Skills

ใช้แปลงความรู้และนโยบายขององค์กรให้เป็นคำแนะนำที่ AI นำไปใช้ได้ เช่น มาตรฐาน Secure API, การออกแบบ API และข้อกำหนดด้าน Compliance

3. Hooks

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

4. Parallel Sessions และ Sub-Agents

ช่วยให้ AI หลาย Session ทำงานที่เป็นอิสระต่อกันได้ โดยแยก Git Worktree เพื่อหลีกเลี่ยงการแก้ไขไฟล์ชนกัน ส่วน Sub-Agents เหมาะสำหรับงานย่อยที่มีขอบเขตชัดเจนและทำซ้ำบ่อย

ข้อควรระวังคือ การเปิด AI หลาย Session ไม่ได้ทำให้เกิดประสิทธิภาพเพิ่มขึ้นโดยอัตโนมัติ จำนวนงานที่ทำพร้อมกันต้องไม่เกินความสามารถในการตรวจสอบของทีม

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

Stage 4: Test

เมื่อ AI สามารถสร้าง Code ได้เร็วขึ้น การรอให้มนุษย์ตรวจสอบทุกอย่างจะกลายเป็นคอขวดใหม่

แนวทางการทำ AI Driven Development จึงกำหนดให้ AI มี Feedback Loop สำหรับตรวจสอบผลลัพธ์ของตนเอง เช่น

สำหรับการแก้ไข Bug ควรเริ่มจากการสร้าง Test ที่ทำให้เห็นปัญหาเดิมก่อน จากนั้นจึงแก้ไขโค้ดและยืนยันว่า Test ผ่าน โดยควบคุมคุณภาพของ Test-case เพื่อทำให้ผลลัพธ์ออกมามีคุณภาพที่ดี

อีกแนวคิดหนึ่งคือ Continuous Evaluations หรือ Evals ซึ่งใช้ทดสอบว่า AI ยังทำงานได้ตามมาตรฐานเมื่อมีการเปลี่ยน Model, Prompt, CLAUDE.md, Skills หรือ Hooks

ตัวอย่างเช่น ทีมอาจรวบรวมงานจริง 20–50 กรณี พร้อมกำหนดผลลัพธ์ที่ยอมรับได้ แล้วนำมารันเป็นชุดทดสอบใน CI

ผลลัพธ์ที่ได้: เพิ่มอัตราการผ่าน CI ตั้งแต่ครั้งแรก ลดเวลา Review และค้นพบ Regression ก่อนถึง Production

Stage 5: Deploy

ในขั้นตอน Deploy AI สามารถช่วยตรวจสอบ Pull Request ในหลายมิติ เช่น

AI ยังสามารถช่วยแก้ไข Review Comments และส่งการเปลี่ยนแปลงกลับเข้าสู่ Pull Request เพื่อให้ตรวจสอบซ้ำได้

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

อย่างไรก็ตาม AI Review ไม่ควรมีสิทธิ์อนุมัติงานของตัวเองโดยอัตโนมัติในกรณีที่ต้องรักษาการแบ่งแยกหน้าที่ โดยเฉพาะระบบสำคัญหรือระบบที่อยู่ภายใต้ข้อกำหนดทางกฎหมาย

องค์กรสามารถใช้ Hooks เป็น Approval Gates เพื่อกำหนดให้การ Deploy ขึ้น Production หรือการแก้ไขทรัพยากรที่มีความเสี่ยงสูงต้องได้รับอนุมัติจากผู้มีอำนาจก่อน

ส่วน CI/CD สามารถทำงานอัตโนมัติในขั้นตอนที่ผ่านเงื่อนไขที่กำหนดไว้แล้ว โดยยังคงเก็บหลักฐานการตรวจสอบและการอนุมัติไว้

ผลลัพธ์ที่ต้องการ: ลดเวลารอ Code Review รักษาคุณภาพและ Security และทำให้กระบวนการอนุมัติตรวจสอบย้อนหลังได้

Stage 6: Maintain

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

เมื่อระบบตรวจพบความผิดปกติ AI สามารถช่วยวิเคราะห์สาเหตุ รวบรวมหลักฐาน และสร้าง intent.md เพื่อเข้าสู่กระบวนการ Plan, Design, Build, Test และ Review ต่อไป

เอกสารยังเสนอแนวคิดการกำหนดระดับการตอบสนองตามความเสี่ยง เช่น

การตรวจจับความผิดปกติควรใช้กฎหรือสคริปต์ที่กำหนดผลได้แน่นอน ส่วน AI รับหน้าที่วิเคราะห์และดำเนินการตามระดับสิทธิ์ที่ได้รับ

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

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

5. Governance และ Human-in-the-Loop ยังคงเป็นหัวใจสำคัญ

การนำ AI มาใช้ใน SDLC ไม่ได้หมายความว่าองค์กรควรให้อิสระ AI ทำทุกอย่างโดยไม่มีการควบคุม

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

หลักการสำคัญประกอบด้วย

1. ทุกขั้นตอนต้องมีหลักฐาน

เอกสาร แผน โค้ด Test Results, Review Findings และการอนุมัติควรถูกจัดเก็บในระบบควบคุมเวอร์ชันหรือระบบที่ตรวจสอบย้อนหลังได้

2. ใช้การควบคุมที่บังคับใช้ได้จริง

Skills ช่วยให้ AI ปฏิบัติตามแนวทางขององค์กร แต่ไม่ใช่กลไกบังคับที่รับประกันการปฏิบัติตามทุกครั้ง นโยบายที่ห้ามละเมิดควรมี Hooks, Automated Checks หรือ Approval Gates รองรับ

3. แยกระดับความเสี่ยงและสิทธิ์การทำงาน

งานทั่วไปที่มีขอบเขตจำกัดอาจเปิดให้ AI ทำงานได้อัตโนมัติมากขึ้น ขณะที่งานที่เกี่ยวข้องกับข้อมูลสำคัญ Security หรือ Production ต้องมีการควบคุมที่เหมาะสม

4. มนุษย์ยังคงรับผิดชอบต่อการตัดสินใจ

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

5. มีแหล่งข้อมูลอ้างอิงที่ชัดเจน

หากองค์กรใช้ Jira, ServiceNow หรือเครื่องมือจัดการ Requirements อยู่แล้ว ไม่จำเป็นต้องย้ายข้อมูลทั้งหมดมาไว้ใน Markdown Repository แต่ควรกำหนดให้ชัดเจนว่าแต่ละ Artifact มีระบบใดเป็น Source of Truth และเชื่อมโยงข้อมูลระหว่างระบบให้ตรวจสอบได้

6. จะวัดความสำเร็จของ AI-Driven Development ได้อย่างไร?

การวัดความสำเร็จไม่ควรใช้จำนวนบรรทัดโค้ดที่ AI สร้าง หรือจำนวนงานที่ AI ทำได้เพียงอย่างเดียว เพราะปริมาณงานที่เพิ่มขึ้นอาจไม่ได้หมายถึงคุณภาพที่ดีขึ้น

จากแนวทางใน Playbook องค์กรควรวัดทั้งตัวชี้วัดระหว่างกระบวนการและผลลัพธ์ปลายทาง เช่น

ขั้นตอน ตัวชี้วัดที่ควรติดตาม
Plan เวลาตั้งแต่เริ่มต้นไอเดียจนได้ intent.md ที่ผ่านการยอมรับ
Design เวลาสร้าง Specification และจำนวนครั้งที่ต้องแก้ Requirements หลังเริ่ม Build
Build ระยะเวลาจากอนุมัติแผนจน Merge PR และจำนวนรอบของ Rework
Test อัตราการผ่าน CI ตั้งแต่ครั้งแรก และจำนวน Regression ที่พบก่อน Merge
Deploy เวลารอ Review จำนวนข้อผิดพลาดที่พบก่อน Merge และข้อผิดพลาดที่หลุดไป Production
Maintain เวลาตั้งแต่ตรวจพบความผิดปกติจนเกิดงานแก้ไข และจำนวน Incident ที่เกิดซ้ำ

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

7. แนวทางเริ่มต้นนำ AI-Native SDLC มาใช้ในองค์กร

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

Phase 1: สร้างมาตรฐานพื้นฐาน

Phase 2: สร้าง Feedback Loop

Phase 3: เพิ่มระบบควบคุมและ AI Review

Phase 4: เชื่อมต่อ CI/CD และ Production Monitoring

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

บทสรุป

AI-Driven Development ไม่ใช่แค่การใช้ AI เขียนโค้ดให้เร็วขึ้น แต่คือการเปลี่ยนวิธีคิดเกี่ยวกับกระบวนการพัฒนาซอฟต์แวร์ทั้งระบบ

เมื่อ AI ทำงานด้าน Implementation ได้รวดเร็วขึ้น องค์กรต้องปรับปรุงวิธีจัดการ Requirements, Testing, Code Review, Governance และ Production Feedback ให้รองรับความเร็วใหม่นี้

แนวทาง AI-Native SDLC จาก Anthropic เสนอให้ใช้ AI ในทั้ง 6 ขั้นตอน สร้าง Artifact ที่ส่งต่อระหว่างขั้นตอนได้ มี Feedback Loop สำหรับตรวจสอบผลลัพธ์ และใช้กลไกควบคุมที่เหมาะสมกับระดับความเสี่ยง

หัวใจสำคัญจึงไม่ใช่การทำให้ AI มีอิสระมากที่สุด แต่เป็นการสร้างกระบวนการที่ AI สามารถทำงานได้อย่างมีประสิทธิภาพ ภายใต้ขอบเขตที่ชัดเจน และมีมนุษย์ช่วยตัดสินใจในขั้นตอนสำคัญๆ


แหล่งอ้างอิง

Louis Claxton, Anthropic. The AI-Native SDLC Playbook: How to transform your software development lifecycle with AI—stage by stage.

Phanupong Permpimol
Follow me