01 / Developer Article
Vibe Coding ทำงานเร็ว แต่ทำไม Maintenance ถึงโคตรยาก? | AI EP.1
ประสบการณ์ตรงจากการทำงานร่วมกับคนที่ใช้ AI Vibe Coding หนักเกินไป จน Architecture เริ่มเละ งาน Maintenance ยาก และกระทบทั้ง Frontend, Backend, UX/UI และ Performance
Published
26 AUG 2026
Reading
9 MIN
Author
Thanapon Phorarmat
Tags

ทำไมผมไม่ชอบ Vibe Coding เวลาทำงานเป็นทีม
ช่วงนี้ผมใช้ AI ช่วยเขียนโค้ดเยอะเหมือนกัน ทั้งหา Bug, อธิบาย Code, Generate Function, เขียน Test หรือช่วยจัดการงานซ้ำ ๆ ถ้าใช้ถูกจุด ผมว่ามันช่วยประหยัดเวลาได้เยอะมาก เพราะงั้นบทความนี้ไม่ได้จะมาบอกว่า
"ใช้ AI เขียนโค้ด = ไม่ดี"
ผมเองก็ใช้ และคงใช้ต่อไป แต่สิ่งที่ผมเริ่มไม่ชอบคือการใช้ AI แบบ Vibe Coding โดยเฉพาะเวลาทำงานเป็นทีม ประมาณว่าโยน Requirement ให้ AI แล้วปล่อยให้มันจัดการ Codebase เอง จากนั้นพอ Run ได้ ไม่มี Error หน้าเว็บเปิดได้ ก็ Accept All แล้ว Commit โดยที่บางครั้งคน Prompt เองก็ไม่ได้รู้ทั้งหมดด้วยซ้ำว่า AI ไปแก้อะไรมาบ้าง ตอน Project ยังเล็กมันอาจไม่รู้สึกอะไร
แต่พอ Codebase ใหญ่ขึ้น มี Frontend, Backend, Database และมีหลายคนทำงานพร้อมกัน ปัญหาจะเริ่มโผล่มาทีละอย่าง และสิ่งที่ผมรู้สึกว่าน่ากลัวที่สุดไม่ใช่แค่ Bug แต่คือ Architecture ของ Project ที่ค่อย ๆ เสียไปโดยที่ระบบยัง Run ได้ปกติ
ภาพที่ 0 — vibe-coding-team-maintenance
จุดที่ทำให้ผมหงุดหงิดที่สุด
อันนี้เป็นสิ่งที่ผมเจอจากการทำ Project กับเพื่อนโดยตรง ผมทำ Frontend บางหน้าเสร็จแล้ว ทั้ง Layout, Responsive, Component, Spacing, Animation รวมถึง Flow ของ UX/UI พูดง่าย ๆ คือ หน้านี้จบแล้ว จากนั้นเพื่อนไปทำ Feature ของตัวเองโดยใช้ AI ช่วย พอผม Pull Code ล่าสุดมา...
หน้าที่ผมทำเสร็จแล้วเปลี่ยน ตอนแรกผมก็งง
ไปแก้ทำไมวะ Feature ที่ทำมันไม่ได้เกี่ยวกับหน้านี้เลย
พอเปิด Git Diff ดูถึงรู้ว่า AI เป็นคนไปแก้ บางครั้งเปลี่ยน Class บางครั้งสร้าง Component ใหม่ บางครั้ง Refactor ของเดิม บางครั้งเปลี่ยน Layout
หรือบางครั้งมันเห็น Code บางส่วนแล้วคิดว่า
"ตรงนี้ Improve ได้นะ"
แล้วก็ Improve ให้เลย ปัญหาคือ...
ไม่มีใครสั่งให้มันทำ ในมุม AI มันอาจคิดว่ากำลังช่วยทำให้ Code Clean ขึ้น แต่ในมุมคนที่ทำงานด้วยกันคือ
กูทำตรงนี้เสร็จแล้ว แล้วมึงไปแก้ทำไมวะ
และถ้าคนที่ใช้ AI ไม่ได้เปิด Diff ดูก่อน Commit คนอื่นในทีมก็ต้องมานั่งตามว่าเกิดอะไรขึ้นทีหลัง
ภาพที่ 1 — เมื่อ AI ไม่ได้แก้แค่ Feature ที่สั่ง แต่เริ่มแตะ Component และ UI ของคนอื่นในทีม
Architecture คือสิ่งที่ผมรู้สึกว่า Vibe Coding ทำพังง่ายที่สุด
เรื่อง UI พังยังมองเห็นได้ทันที ปุ่มเบี้ยว เราเห็น Responsive พัง เราเห็น Animation หาย เราก็เห็น แต่ Architecture พัง มันไม่ได้ขึ้น Error สีแดงให้เราเห็น
Project ยัง Build ผ่าน API ยังตอบ 200 หน้าเว็บยังเปิดได้ Database ยัง Query ได้ ทุกอย่างดูเหมือนปกติ
แต่ข้างใน Codebase เริ่มเละขึ้นทีละนิด สมมติเราออกแบบ Structure ไว้ว่า
src/
├── components/
│ ├── ui/
│ └── shared/
├── features/
│ ├── auth/
│ ├── users/
│ └── projects/
├── lib/
├── services/
└── types/เราไม่ได้แบ่ง Folder แบบนี้เพราะอยากให้มันดูสวย แต่มันมีเหตุผล components/ui เอาไว้เก็บ UI ที่ Reuse ได้ shared คือของที่หลาย Feature ใช้ร่วมกัน features แยก Domain ของแต่ละ Feature
services มีหน้าที่ของมัน Developer ในทีมเห็น Structure นี้ก็ควรพอเดาได้ว่า ของใหม่ควรไปอยู่ตรงไหน แต่ AI ไม่ได้เข้าใจ Intent ของ Project โดยอัตโนมัติ ถ้า Context ไม่พอ มันอาจเริ่มสร้าง
src/
├── components/
│ ├── ui/
│ ├── shared/
│ ├── UserModal.tsx
│ ├── ProjectButton.tsx
│ └── NewUserForm.tsx
├── utils/
│ └── userApi.ts
├── helpers/
│ └── projectHelper.ts
├── api/
│ └── users.ts
├── services/
│ └── userService.ts
└── features/ถามว่า Run ได้ไหม? ได้ Feature ใช้งานได้ไหม? ได้ แต่ผ่านไป 6 เดือนแล้วต้องแก้ User API
จะไปหาใน api, utils หรือ services? นั่นแหละคือปัญหา
Architecture ไม่ใช่แค่เรื่อง Folder
ผมคิดว่าตรงนี้เป็นเรื่องที่สำคัญมาก Architecture ไม่ได้หมายถึงแค่
"จัด Folder ให้เป็นระเบียบ"
แต่มันคือการกำหนดว่า แต่ละส่วนของ Software รับผิดชอบอะไร และแต่ละส่วนควรคุยกันยังไง Backend ง่าย ๆ อาจมี Flow ประมาณ
Request
↓
Controller
↓
Service
↓
Repository
↓
DatabaseController รับ Request และจัดการ Response Service ดู Business Logic Repository รับผิดชอบเรื่อง Data Access มันทำให้เรารู้ว่า Logic แต่ละอย่างควรอยู่ตรงไหน แต่พอปล่อย AI เขียนไปเรื่อย ๆ โดยไม่มี Architecture คุม เราอาจเริ่มได้อะไรแบบนี้
app.post('/users', async ({ body }) => {
// validate
// check permission
// query database
// business logic
// send email
// transform data
// log activity
// return response
});ทุกอย่างอยู่ Endpoint เดียว และสิ่งที่ตลกคือ...
มันใช้งานได้ ตอน Demo ก็ไม่มีใครรู้สึกว่ามีปัญหา กดปุ่ม → API ทำงาน → Database มีข้อมูล จบ แต่พอ Requirement เปลี่ยน แล้ว Business Logic เดียวกันต้องใช้ใน Admin หรือ API อีก Endpoint หนึ่ง
เราก็เริ่ม Copy AI ก็ช่วยเรา Copy ได้เร็วมากด้วย สุดท้าย Logic เดียวกันอยู่สามที่ วันหนึ่งแก้สองที่แล้วลืมอีกที่ Bug ก็มา
ภาพที่ 2 — Code ที่ Run ได้เหมือนกัน ไม่ได้หมายความว่าจะ Maintain ง่ายเหมือนกัน
Frontend ก็หนีไม่พ้น
Frontend Architecture สำคัญไม่แพ้ Backend สมมติ Project มี <Button /> กลางอยู่แล้ว
<Button variant="primary">Save</Button>แต่ AI ไม่รู้ว่ามี หรือไม่ได้ Search ก่อน มันสร้างใหม่
<button className="px-4 py-2 bg-blue-500 rounded-lg">Save</button>อีกหน้าหนึ่ง Generate ใหม่อีกแบบ
<button className="flex items-center justify-center ...">Save</button>ผ่านไปสักพักเรามี Button PrimaryButton SubmitButton FormButton
SaveButton ทั้งหมดหน้าตาแทบเหมือนกัน ตอนแรกไม่มีปัญหา จนวันหนึ่งต้องเปลี่ยน Design ของ Primary Button ทั้งระบบ ถ้า Architecture ดี
แก้ <Button /> จุดเดียวจบ แต่ถ้ามี Button กระจายอยู่ 20 แบบ...
ขอให้โชคดีครับ
AI เก่งเรื่องแก้ปัญหาตรงหน้า แต่เราเป็นคนที่ต้องอยู่กับ Code ต่อ
สิ่งหนึ่งที่ผมสังเกตคือ AI เก่งมากในการทำให้ Requirement ปัจจุบันสำเร็จ บอกให้ทำ Modal → ได้ Modal บอกให้เพิ่ม Search → ได้ Search บอกให้แก้ Type Error → Error หาย แต่บางครั้งสิ่งที่ได้คือ Solution ที่ทำให้ปัญหาตรงหน้าหายไป ไม่ใช่ Solution ที่เหมาะกับระบบในระยะยาว
ตัวอย่างง่าย ๆ Type มีปัญหา?
const data = response as any;เรียบร้อย TypeScript เงียบแล้ว หรือ CSS ตีกัน?
!importantเรียบร้อย UI กลับมาแล้ว แต่ Root Cause ยังอยู่เหมือนเดิม จากนั้นอีก Component พัง ก็ Patch อีก
แล้วก็ Patch ทับ Patch ไปเรื่อย ๆ สุดท้ายเราไม่ได้แก้ปัญหา เราแค่ทำให้มันเงียบ
Backend ยิ่งน่ากลัว เพราะบางครั้งเราไม่รู้ด้วยซ้ำว่ามันเริ่มพังแล้ว
Frontend มีข้อดีอย่างหนึ่งคือ ถ้ามันพังเรามักเห็นเร็ว Backend ไม่เหมือนกัน สมมติ AI Generate Search มาแบบนี้
const users = await db.query.users.findMany();
const result = users.filter((user) =>
user.name.toLowerCase().includes(search.toLowerCase())
);ตอน Development มี User 30 คน เร็วมาก ไม่มีปัญหา
Search ได้แล้ว ✔
ปิด Task แต่ถ้าวันหนึ่งมี 300,000 Records ล่ะ? ตอนนั้นเราอาจต้องกลับมาคิดใหม่ทั้งเรื่อง Database Query, Index, Pagination และ Query Plan นี่คือเหตุผลที่ผมรู้สึกว่า Performance เป็นอีกเรื่องที่อันตรายเวลาทำ Vibe Coding เพราะคำว่า
"มันทำงานได้"
ไม่ได้แปลว่า
"มันถูกออกแบบมาดี"
Git Diff 30 Files กับ Feature ที่ควรแก้ 5 Files
อันนี้เป็นอะไรที่คนทำงานเป็นทีมน่าจะเข้าใจ Requirement:
เพิ่ม Forgot Password
สิ่งที่คาดหวัง
5 files changedแต่พอ AI Agent ทำเสร็จ
31 files changed
+2,140
-847แล้วผมก็ต้องมานั่งคิดว่า...
มึงไปทำอะไรมาอีก 26 ไฟล์
บางที Format บางที Rename บางที Refactor บางทีแก้ Type บางทีเห็น Code ซ้ำแล้วถือโอกาส Improve ให้
ถามว่าบางอย่างที่มันแก้ดีไหม? ก็ดี แต่ไม่ใช่ตอนนี้ Pull Request ควรมี Scope ที่ชัดเจน ถ้า PR ชื่อ Forgot Password คน Review ก็ควรได้ Review Forgot Password
ไม่ใช่ต้องมานั่ง Review Architecture ใหม่ครึ่ง Project
สิ่งที่น่ากลัวกว่าคือ เราไม่รู้ว่า AI เขียนอะไร
สำหรับผมตรงนี้คือเส้นแบ่งสำคัญระหว่าง
ใช้ AI ช่วยเขียน Code
กับ
ให้ AI เขียน Code แทนเรา
ถ้า AI Generate Function มา แล้วเราอ่านออก เข้าใจมัน และสามารถอธิบายได้ว่าทำไมมันถึงเขียนแบบนี้ ผมไม่มีปัญหาเลย แต่ถ้า Workflow เป็นแบบนี้
Prompt
↓
Generate
↓
Run
↓
ผ่าน
↓
Accept All
↓
Commitอันนี้เริ่มน่ากลัว เพราะวันหนึ่งมันพัง AI Session เดิมก็ไม่มีแล้ว Context ก็หาย Developer อีกคนเปิด Code มาแล้วถามว่า
"ตรงนี้ทำไมเขียนแบบนี้?"
แล้วคนเขียนตอบว่า
"ไม่รู้ AI เขียน"
Maintenance ของจริงเริ่มตรงนั้นแหละ
ผมใช้ AI แต่ผมไม่อยากให้ AI เป็นเจ้าของ Architecture
สำหรับผม AI ยังเป็น Tool ที่ดีมาก และผมก็ใช้มันแทบทุกวัน แต่ผมคิดว่าหน้าที่ของ Developer กับ AI ควรแยกกันให้ชัด Developer ควรเป็นคนดูเรื่อง
- Architecture
- System Design
- Database Design
- API Contract
- Business Rules
- UX/UI Direction
- Code Review
ส่วน AI เหมาะกับการช่วย
- Generate Boilerplate
- Implement ตาม Architecture ที่กำหนดไว้
- Suggest Solution
- Explain Code
- Write Tests
- Find Bugs
- Refactor ในขอบเขตที่เราอนุญาต
ภาพที่ 3 — Developer เป็นคนกำหนดทิศทาง ส่วน AI เป็นเครื่องมือที่ช่วยให้เราไปถึงจุดนั้นเร็วขึ้น
ผมอยากบอก AI ว่า
"ระบบนี้ออกแบบไว้แบบนี้ ช่วย Implement ส่วนนี้ตาม Architecture นี้ให้หน่อย"
มากกว่า
"ทำ Feature นี้ให้หน่อย จัดการเองเลย"
สองประโยคนี้ดูเหมือนต่างกันนิดเดียว แต่กับ Project ใหญ่ ๆ ผลลัพธ์ระยะยาวต่างกันมาก
ถ้าจะใช้ AI ทำงานเป็นทีม ผมว่าต้องมีกฎ
เวลาใช้ AI Agent กับ Codebase ที่มีหลายคนทำ ผมคิดว่าควรกำหนด Scope ให้มันชัดตั้งแต่แรก อย่างน้อยประมาณนี้
Implement only the requested feature.
Follow the existing architecture.
Do not modify unrelated files.
Do not refactor existing code unless required.
Do not modify completed UI components.
Reuse existing components before creating new ones.
Do not introduce a new architectural pattern.
Do not install new dependencies without approval.
Before editing, identify which files need to change.
After editing, explain every modified file.และต่อให้ Prompt ละเอียดขนาดนี้ ก็ยังต้องอ่าน Git Diff เพราะ Prompt ไม่ใช่ Permission System AI ยังเข้าใจผิดได้ และสุดท้ายชื่อของคนที่อยู่ใน git blame ก็คือชื่อเรา ไม่ใช่ชื่อ AI
AI ไม่ได้ทำให้ Technical Debt หายไป มันทำให้เราสร้างมันได้เร็วขึ้น
เมื่อก่อนเขียน Code 500 บรรทัดอาจใช้เวลาหลายชั่วโมง ระหว่างเขียนเรามีเวลาคิดไปด้วย Logic ควรอยู่ตรงไหน? Component นี้ควร Reuse ไหม? Function นี้ควรแยกหรือเปล่า?
Query นี้จะช้าไหม? แต่วันนี้ AI Generate 500 บรรทัดให้เราได้ภายในไม่กี่วินาที มันเลยมีทั้งข้อดีและข้อเสีย
AI ทำให้เราสร้าง Software ได้เร็วขึ้น
แต่ในขณะเดียวกัน
AI ก็ทำให้เราสร้าง Technical Debt ได้เร็วขึ้นเหมือนกัน
ถ้า Code ที่ Generate มาไม่ได้ผ่านการคิด ไม่ได้ Review และไม่ได้อยู่ภายใต้ Architecture ที่ชัดเจน ช่วงแรก Velocity อาจสูงมาก Feature ออกเร็ว Demo สวย ทุกคน Happy
จนผ่านไปสักพัก...
เพิ่ม Feature หนึ่ง อีกสาม Feature พัง แก้ Component หนึ่ง อีกห้าหน้าเปลี่ยน แก้ Database Schema แล้วไม่รู้ API ไหนโดนบ้าง อยาก Refactor แต่ไม่มีใครกล้าแตะ เพราะไม่รู้ Dependency จริง ๆ สุดท้ายเวลาที่เราประหยัดจาก AI ในช่วงแรก
ถูกเอามาจ่ายคืนตอน Maintenance พร้อมดอกเบี้ย
สุดท้ายผมไม่ได้เกลียด Vibe Coding
จริง ๆ ผมคิดว่า Vibe Coding เหมาะกับหลายอย่างมาก Prototype? เหมาะ MVP? เหมาะ
Personal Project? โคตรสะดวก อยากลอง Idea ตอนตีสองแล้วอยากรู้ว่ามันทำได้ไหม? Prompt ไปเลย แต่ถ้าเป็น Software ที่จะอยู่หลายปี มีหลายคนทำ มี User จริง มีข้อมูลจริง และต้อง Maintenance ต่อ
ผมไม่คิดว่า
"มัน Run ได้"
ควรเป็น Definition of Done เราต้องถามต่อด้วยว่า
Code นี้อยู่ถูก Layer ไหม?
ทำตาม Architecture ของ Project หรือเปล่า?
มี Component เดิมที่ควร Reuse ไหม?
Query นี้ Scale ได้ไหม?
Test ได้ไหม?
Developer คนอื่นเปิดมาแล้วเข้าใจไหม?
และอีก 6 เดือน เรายังกล้าแก้ Code ชุดนี้อยู่หรือเปล่า?
เพราะสุดท้าย AI ไม่ใช่คนที่ต้อง Maintenance ระบบนี้ พวกเราต่างหากที่ต้องทำ สำหรับผม วิธีใช้ AI ที่ดีที่สุดจึงไม่ใช่
"ให้ AI สร้าง Software ให้เรา"
แต่เป็น
"เราออกแบบ Software แล้วใช้ AI ช่วยสร้างมัน"
AI อาจเขียน Code ได้เร็วกว่าเราหลายเท่า แต่ Architecture, Context, Business Logic และการตัดสินใจว่าอะไรควรหรือไม่ควรอยู่ใน Codebase ยังควรเป็นหน้าที่ของ Developer อย่างน้อยก็จนกว่าเราจะพร้อมฝาก main ไว้กับปุ่ม Accept All จริง ๆ
อีกปัญหาที่ผมเจอคือ มันทำให้ปิดงานกับลูกค้ายากขึ้น
เรื่องนี้เป็นอีกจุดที่ผมรู้สึกชัดมากเวลา Project ไม่ได้ทำเล่น ๆ แต่เป็น งานที่ต้องส่งให้ลูกค้าจริง ตอน Develop เราอาจรู้สึกว่า AI ช่วยให้ทำงานเร็วขึ้นมาก ลูกค้าขอ Feature เพิ่ม? Generate เจอ Bug?
ให้ AI แก้ ลูกค้าขอปรับ UI? Prompt ต่อ ทุกอย่างดูเร็วมากในช่วงแรก แต่ปัญหาจะเริ่มชัดตอนใกล้ ปิดงาน
เพราะช่วงนั้นเราไม่ได้ต้องการ Feature ใหม่เยอะแล้ว สิ่งที่เราต้องการคือ ความนิ่งของระบบ ประมาณว่า
ของที่เสร็จแล้ว ไม่ควรกลับมาพังอีก
แต่ถ้า Codebase ถูกแก้ด้วย AI แบบไม่มี Scope ชัดเจน สิ่งที่ผมเจอคือบางครั้งแก้จุด A แล้วจุด B ที่เคยเสร็จไปแล้วกลับพัง แก้ B แล้ว C เปลี่ยน แก้ Responsive หน้า Admin แต่หน้า User โดนไปด้วย แก้ API หนึ่งตัว แต่ Response ที่ Frontend อีกหน้าพึ่งอยู่เปลี่ยนตาม หรือหนักกว่านั้นคือ ลูกค้าบอก
"ตรงนี้เมื่อวานยังใช้ได้อยู่เลย ทำไมวันนี้ไม่ได้แล้ว?"
อันนี้ตอบยากเลย เพราะในมุมลูกค้า เขาไม่ได้สนใจว่า Architecture เป็นยังไง AI แก้กี่ Files Git Diff ใหญ่แค่ไหน
หรือ Developer คนไหนเป็นคน Prompt เขาสนใจแค่ว่า
"ของที่บอกว่าเสร็จแล้ว ทำไมกลับมาพังอีก?"
และตรงนี้แหละที่ทำให้การปิดงานยืดออกไปเรื่อย ๆ
คำว่า "เกือบเสร็จ" บางทีน่ากลัวกว่า "ยังไม่เสร็จ"
ผมว่าคนทำ Software น่าจะเคยเจออาการนี้ Project ดูเหมือนเสร็จไปแล้ว 90% เหลือแก้นิดเดียว แต่ 90% นั้นอยู่อย่างนั้นเป็นอาทิตย์ เพราะทุกครั้งที่แก้ 10% สุดท้าย มันไปกระทบ 90% ที่คิดว่าเสร็จแล้ว
มันจะวนประมาณนี้
ลูกค้าแจ้ง Bug
↓
แก้ Bug
↓
อีก Feature พัง
↓
แก้ Feature
↓
UI อีกหน้าขยับ
↓
แก้ UI
↓
Regression อีกจุด
↓
ลูกค้า Test ใหม่
↓
เจอ Bug ใหม่สุดท้ายจากที่คิดว่า
"พรุ่งนี้น่าจะปิดงานได้แล้ว"
กลายเป็นพูดประโยคเดิมไปอีก 5 รอบ "เหลืออีกนิดเดียวครับ"
ยิ่ง AI แก้กว้างเท่าไร Regression ยิ่งตามมายาก
สมมติลูกค้าบอกว่า
"ช่วยเพิ่ม Validation ช่องเบอร์โทรให้หน่อย"
Requirement จริง ๆ เล็กมาก เราคาดหวังว่าจะกระทบ Form กับ Validation Schema ไม่กี่จุด แต่ถ้า AI Agent ได้ Context ทั้ง Project แล้วตัดสินใจ Refactor Form System ไปพร้อมกัน จาก Task เล็ก ๆ อาจกลายเป็น
Phone validation
↓
Refactor Form
↓
Update Shared Input
↓
Change Error Handling
↓
กระทบ 8 Formsแล้วตอน Test เราไม่ได้ Test แค่เบอร์โทรแล้ว เราต้องกลับไป Regression Test Form อีก 8 หน้า ตรงนี้ทำให้ผมรู้สึกว่า ความเร็วตอน Generate Code ไม่ได้เท่ากับความเร็วในการส่งมอบ Software AI อาจเขียน Feature ให้เสร็จใน 10 นาที แต่ถ้าสิ่งที่มันแก้ทำให้ทีมต้องใช้เวลาอีก 3 ชั่วโมง Regression Test
จริง ๆ แล้วเราไม่ได้ประหยัดเวลาเท่าไร
ปิดงานไม่ได้แปลว่า Feature ครบอย่างเดียว
เมื่อก่อนผมเองก็เคยมองว่า ถ้า Requirement ครบทุกข้อก็น่าจะถือว่างานเสร็จแล้ว แต่พอทำ Project จริงมากขึ้น ผมรู้สึกว่า Definition of Done มันควรมากกว่านั้น
Feature Complete
↓
Integration Test
↓
Regression Test
↓
Performance Check
↓
Bug Fix
↓
UAT / ลูกค้าทดสอบ
↓
Stabilization
↓
Deploy
↓
ส่งมอบโดยเฉพาะช่วง Stabilization ผมคิดว่าช่วงนี้ ไม่ควรเป็นเวลาที่ AI เดิน Refactor ทั่ว Project เพราะเห็นอะไรที่มันคิดว่า Improve ได้ Code ไม่จำเป็นต้อง Perfect ทุกบรรทัดก่อนส่งลูกค้า บางครั้ง Code ที่
"ไม่สวยที่สุด แต่ Stable และทุกคนรู้ว่ามันทำงานยังไง"
มีค่ามากกว่า Code ที่ AI เพิ่ง Refactor ใหม่จนดู Clean แต่ยังไม่มีใครรู้ว่ามันไปกระทบอะไรบ้าง
สุดท้ายลูกค้าไม่ได้จ่ายเงินซื้อ Code ที่ Generate เร็ว
อันนี้เป็นสิ่งที่ผมคิดว่าสำคัญมาก ลูกค้าไม่ได้สนใจว่าเรา Generate Code ได้วันละกี่พันบรรทัด ไม่ได้สนใจว่าเราใช้ AI Model ตัวไหน และไม่ได้สนใจว่า Prompt เราเทพแค่ไหน สิ่งที่ลูกค้าจ่ายเงินซื้อจริง ๆ คือ Software ที่แก้ปัญหาให้เขา และใช้งานได้อย่างเสถียร ถ้า AI ทำให้เราสร้าง Feature จาก 3 วันเหลือ 3 ชั่วโมง ดีมาก แต่ถ้าหลังจากนั้นต้องใช้เวลาอีก 2 วันตามแก้ Regression ที่เกิดจาก Code ที่ Generate มา ความเร็วตรงนั้นก็แทบไม่มีความหมาย เพราะสำหรับงานลูกค้า Metric สุดท้ายไม่ใช่
"เราเขียน Code เร็วแค่ไหน?"
แต่คือ
"เราส่งของที่ใช้งานได้จริงให้ลูกค้าได้เร็วและมั่นใจแค่ไหน?"
นี่เป็นอีกเหตุผลที่ผมไม่ได้ต่อต้านการใช้ AI แต่ผมต่อต้านการปล่อยให้ AI แก้ทุกอย่างที่มันคิดว่าควรแก้ เพราะตอนเริ่ม Project เราอาจสนใจ Velocity แต่ตอนใกล้ปิดงาน สิ่งที่สำคัญกว่า Velocity คือ Stability, Predictability และ Confidence ว่าของที่เสร็จแล้วจะไม่กลับมาพังอีก
AI EP.2: Vibe Coding ยังไงไม่ให้โปรเจคพัง? — ใช้ AI ให้เร็ว แต่ยังคุม Architecture และ Codebase อยู่