- ในช่วงแรกมีความคาดหวังว่าแม้จะเป็นคู่ผสมแบบ จูเนียร์+AI ก็จะสามารถสร้างโค้ดคุณภาพสูงได้เพียงพอ แต่ในความเป็นจริงกลับกลายเป็นว่าคู่แบบ ซีเนียร์+AI ทำงานได้ทรงพลังกว่ามาก
- AI มีประสิทธิภาพกับงานอย่าง การสร้าง boilerplate, การทำงานซ้ำให้เป็นอัตโนมัติ, และ การทดลองกับการตรวจสอบอย่างรวดเร็ว แต่การดึงคุณค่าที่แท้จริงออกมาจากสิ่งเหล่านี้กลับเป็นเรื่องที่ ง่ายกว่าสำหรับซีเนียร์ มากกว่าจูเนียร์
- ในทางกลับกัน สำหรับเรื่องอย่าง code review, การออกแบบสถาปัตยกรรม, การควบคุมคุณภาพโค้ด, และ ประเด็นด้านความปลอดภัย นั้น AI ยังแสดงข้อจำกัดออกมา และยิ่งไปกว่านั้น การจับคู่ระหว่างจูเนียร์กับ AI อาจสร้าง ความเสี่ยง ได้มากกว่าเดิม
- ดังนั้น AI จึงถูกนำไปใช้ได้เหมาะที่สุดกับ การทำต้นแบบอย่างรวดเร็ว, การเพิ่มประสิทธิภาพงานซ้ำๆ, การสนับสนุนงานข้ามสาขา, และ การทำระบบอัตโนมัติสำหรับการทดสอบฟังก์ชัน
- สรุปแล้ว ณ ตอนนี้ AI ยังทำหน้าที่เป็นเครื่องมือสำหรับ เสริมศักยภาพของซีเนียร์ และในระยะสั้น แทนที่จะมาแทนที่จูเนียร์หรือสร้างผลของการทำให้เข้าถึงได้ในวงกว้าง กลับกำลังเกิดแนวโน้มของ การรวมพลังไว้ที่ฝั่งผู้เชี่ยวชาญ
การเปลี่ยนแปลงที่ AI นำมาสู่หน้างานพัฒนา
- ในแวดวงการพัฒนาซอฟต์แวร์ยังคงมีคำถามว่า "การเขียนโค้ดจะถูก AI เข้ามาแทนที่ทั้งหมดหรือไม่?" อยู่เรื่อยๆ
- ในช่วงแรกมีเรื่องเล่าจำนวนมากว่าถ้า AI ทำงานร่วมกับนักพัฒนาจูเนียร์ บทบาทของนักพัฒนาซีเนียร์จะลดลงและประสิทธิภาพขององค์กรจะสูงขึ้น
- แต่ในหน้างานจริงกลับไม่เป็นไปตามคาด โดยคู่แบบ จูเนียร์+AI สร้างคุณค่าให้บริษัทได้น้อยกว่าคู่แบบ ซีเนียร์+AI อย่างชัดเจน
งานที่ AI ทำได้ดีและข้อจำกัด
-
จุดแข็งของ AI
- จัดการ การสร้าง boilerplate และ scaffolding ได้อย่างรวดเร็ว ช่วยเพิ่มผลิตภาพ
- ทำงานซ้ำๆ และงานรูทีนให้เป็นอัตโนมัติ ช่วยเร่งความเร็วในการพัฒนา
- เป็นสภาพแวดล้อมการทดลองที่สามารถ ลองและตรวจสอบ วิธีการติดตั้งใช้งานที่หลากหลายได้อย่างรวดเร็ว
- ช่วย ออกฟีเจอร์ได้รวดเร็ว แต่จะมีประสิทธิภาพเมื่อ รู้ชัดว่าต้องการอะไร
- งานลักษณะนี้ในทางปฏิบัติแล้วให้ ประสิทธิภาพสูงสุดกับนักพัฒนาซีเนียร์ที่มีประสบการณ์
- จูเนียร์ก็สามารถนำไปใช้ได้เช่นกัน แต่เป็นเรื่องยากมากที่จะได้ผลลัพธ์ในระดับเดียวกัน
-
ข้อจำกัดและจุดเปราะบางของ AI
- ในเรื่อง code review ความสามารถด้านการให้เหตุผลเชิงตรรกะของ AI ยังไม่เพียงพอ
- เมื่อเกิด edge case ก็ยังจำเป็นต้องมีการแทรกแซงจากซีเนียร์ที่ชำนาญอยู่ดี
- ในการ เขียน prompt หากต้องการผลลัพธ์ที่เหมาะสม จำเป็นต้องมีความเข้าใจและองค์ความรู้ในระดับสูง
- หากความรู้ไม่พอ คุณภาพของผลลัพธ์จะลดลงและความเสี่ยงของบั๊กจะสูงขึ้น
- AI ยังไม่ดีพอในด้าน การออกแบบสถาปัตยกรรม
- การออกแบบโครงสร้างที่แข็งแรงต้องอาศัยการให้เหตุผลระดับสูงของมนุษย์ และโปรเจกต์ที่ AI ออกแบบมีความเสี่ยงสูงที่จะจมอยู่กับ หนี้ทางเทคนิค
- มีจุดอ่อนในการดูแล คุณภาพโค้ด (เช่น การทำ abstraction ที่เหมาะสม การใช้ design pattern เป็นต้น)
- ในด้าน ความปลอดภัย การจับคู่แบบจูเนียร์+AI อาจทำให้เกิดช่องโหว่ได้บ่อย
- หากมีซีเนียร์อยู่ด้วย ก็ยังพอระมัดระวังและป้องกันได้ในระดับหนึ่ง
- มีโอกาสเกิด การเรียนรู้ผิด: หากประเมินโค้ดได้ไม่ถูกต้อง โค้ดที่ AI สร้างขึ้นอาจกลับมาสร้างความเสียหายให้องค์กรได้
- ด้วยเหตุผลเหล่านี้ ปัจจุบัน AI จึงไม่ใช่ภัยคุกคามต่อซีเนียร์ แต่กลับเป็น เครื่องมือที่เพิ่มผลิตภาพอย่างเข้มข้น ให้พวกเขามากกว่า
- ประเด็นนี้ไม่ได้ต้องการวิจารณ์นักพัฒนาจูเนียร์ แต่ต้องการหลีกเลี่ยงความคาดหวังที่เกินจริงและการส่งพวกเขาเข้าไปอยู่ในสถานการณ์ที่เสี่ยงเกินไป
พื้นที่ที่เหมาะสมสำหรับการใช้ AI
- การทำต้นแบบอย่างรวดเร็ว: เหมาะกับการเร่งความเร็วในการทดลองไอเดียและการลงมือสร้าง
- การทำงานรูทีนซ้ำๆ ให้เป็นอัตโนมัติ: ให้ผลดีมากในการเพิ่มความเร็วของงานรูทีนที่คุ้นเคยอยู่แล้ว
- การทำงานร่วมกันข้ามสาขา: มีประโยชน์ในการเสนอเมธอดหรือไลบรารีของสาขาที่ไม่คุ้นเคย และช่วยเชื่อมโยงข้ามโดเมน
- การสร้างการทดสอบฟังก์ชัน: เหมาะกับงานอัตโนมัติและการตรวจสอบสำหรับโค้ดที่เรียบง่ายและมีความเสี่ยงต่ำ
บทสรุปและนัยสำคัญ
- โค้ดที่ AI เขียนยังคงต้องให้มนุษย์ตรวจทุกบรรทัด และยังมีลักษณะ ไม่เป็นแบบกำหนดแน่นอน (non-deterministic)
- แม้แต่โค้ดทดสอบสำหรับการตรวจสอบโปรแกรม ก็ยังยากที่จะเชื่อใจหากปล่อยให้ AI จัดการทั้งหมด
- เช่นเดียวกับคำถามว่า "ถ้า AI ตอบว่า ‘ไม่รู้’ นั่นคือไม่รู้จริงหรือเปล่า?" ข้อจำกัดด้านการรับรู้และการตรวจสอบของ AI ยังมีอยู่เสมอ
- คู่แบบจูเนียร์+AI เป็นเพียง ภาพลวงตาของการลดต้นทุน เท่านั้น และในความเป็นจริงแล้ว AI กำลัง มุ่งไปที่การเสริมศักยภาพของซีเนียร์
- การพัฒนาซอฟต์แวร์ ยังอยู่ในระยะที่ไม่สุกงอม ต่างจากงานสถาปัตยกรรมก่อสร้าง เพราะแม้แต่ สถาปนิกก็ยังต้องลงมือเขียนโค้ดเอง
- แรงกดดันในการลดต้นทุนกลับยิ่งบั่นทอนคุณค่าของนักพัฒนาและทำให้เกิดความเหนื่อยล้าจนหมดไฟ
- ในตอนนี้ AI ยังไม่ได้มาทดแทนจูเนียร์หรือทำให้เกิดการเข้าถึงในวงกว้าง แต่กำลังถูกใช้อย่างเข้มข้นในฐานะ เครื่องมือช่วยสำหรับผู้เชี่ยวชาญ (ซีเนียร์)
- อนาคตของ AI ยังน่ามองในแง่บวก แต่ในระยะสั้นจำเป็นต้อง ปรับความคาดหวังใหม่
2 ความคิดเห็น
ความคิดเห็นจาก Hacker News
จูเนียร์จำนวนมากไม่รู้ตัวด้วยซ้ำว่าตัวเองกำลังจมอยู่ในเรื่องแต่งที่ LLM สร้างขึ้น
สำหรับผม มีจูเนียร์คนหนึ่งพยายามจะ deploy terraform module ที่ผมออกแบบแยกไว้ แต่พองานล่าช้าอยู่นาน ผมเลยเข้าไปดูสถานะ
จูเนียร์คนนั้นบอกว่ามีปัญหาและอยากให้ผมช่วยดู
พอเปิด repo ดูก็เละเทะไปหมด เห็นชัดเลยว่า Claude พาออกนอกทาง
ผมถามว่า "ทำไมตรงนี้ถึงมีไฟล์ Python เยอะขนาดนี้? ทั้งที่ในโมดูลมีครบอยู่แล้ว?" เขาตอบว่า "ผมก็ไม่รู้เหมือนกัน Claude บอกให้ทำแบบนั้น"
จูเนียร์คนนี้ประสบการณ์ยังน้อยและพึ่งพาเครื่องมือ LLM มากเกินไป ทั้งในด้านการออกแบบ การลงมือทำ และการแก้ปัญหา
ถ้ายังแยกไม่ออกว่าเมื่อไร LLM กำลังพูดมั่ว คุณก็จะจมอยู่ในหล่มแบบไม่รู้จบ
ในอีกด้านหนึ่ง LLM ช่วยลดงานซ้ำๆ ที่ผมไม่ชอบทำลงไปได้มาก
ผมสังเกตได้เร็วมากเวลา LLM เริ่มพาออกทะเล และหยุดมันได้ทันที
กลับกลายเป็นว่านั่นทำให้ผมมีไฟกับการเขียนโค้ดและสร้างซอฟต์แวร์อีกครั้ง
ผลลัพธ์คือทั้ง productivity สูงขึ้นและงานที่ออกมาก็ดีขึ้น
พอได้ยินคำตอบว่า "ผมก็ไม่รู้เหมือนกัน Claude ทำให้" แล้วมันน่าหงุดหงิดจริงๆ
ผมเป็น reviewer สายที่อ่านโค้ดจริงและถามละเอียดมาก ทั้งจูเนียร์และซีเนียร์ก็พูดแบบนี้หน้าตาเฉย
ถ้าคุณ push โค้ดที่ตัวเองยังไม่เข้าใจ นั่นคือความเสี่ยงมหาศาลต่อทีม ผลิตภัณฑ์ และบริษัท
คำว่า "ผมก็ไม่รู้เหมือนกัน Claude ทำให้" เป็นสัญญาณเตือนขนาดใหญ่มาก
ไม่รู้ไม่เป็นไร และใช้ LLM มาอุดช่องว่างก็ไม่เป็นไรเช่นกัน
ถ้าเจอปัญหาแล้วเปิดมาถามว่า "มีโค้ดที่ generate มา แต่ผมยังไม่ค่อยเข้าใจว่าอะไรเป็นอะไร ช่วยดูหน่อยได้ไหมว่ามาถูกทางหรือเปล่า?" แบบนี้จะดีกว่า
ปัญหาคือไม่ใส่ใจเลย แถมยังปิดไว้จนกว่าซีเนียร์จะมาถามเอง
งานง่ายๆ ซ้ำๆ ที่คุณไม่ชอบนี่แหละ มักเป็นงานเริ่มต้นที่ดีให้จูเนียร์ได้เรียนรู้โครงสร้างของระบบ
คำว่า "ผมก็ไม่รู้เหมือนกัน Claude ทำให้" ก็เหมือนกับคนที่เวลาเกิดอุบัติเหตุระหว่างทำงานแล้วโทษแต่เลื่อย
แก่นสำคัญของการใช้ LLM ให้มีประสิทธิภาพและหลีกเลี่ยง hallucination คือความสามารถในการอ่านโค้ดและสัญชาตญาณ
จูเนียร์มักพึ่ง LLM ได้ง่ายกว่าการรออีเมลตอบกลับ หรือค่อยๆ ลองปะติดปะต่อหลายวิธีเข้าด้วยกัน
ตอนนี้ไม่ต้องรออีเมลแล้วด้วย เลยยิ่งยากที่จะต้านแรงล่อใจ
แต่ถ้าทำแบบนั้น สุดท้ายก็จะหลงทิศ และติดอยู่ในเขาวงกตของ hallucination โดยไม่รู้ด้วยซ้ำว่ามันทำงานอย่างไร
โค้ดที่ดีที่สุดที่ผมทำร่วมกับ LLM คือผมออกแบบโครงสร้างเอง แล้วให้ LLM เขียนโค้ดตั้งต้น จากนั้นผมก็คอยกำกับทิศทางการแก้ไขและเติมความสามารถเพิ่มไปเรื่อยๆ
ระหว่างทาง LLM ก็พลาดบ่อย และผมก็เป็นคนแก้ให้
ตอน performance ช้า ผมก็ profile เองแล้วสั่ง LLM ให้ optimize
โค้ดที่เสร็จออกมาแบบนี้จะเป็นโค้ดที่ผมรู้ไส้รู้พุงหมด
ถ้าเขียนเองทั้งหมดคงใช้เวลานานกว่าสามเท่า
อย่างน้อยตราบใดที่ input/output ของฟังก์ชันทดสอบผ่าน ผมก็ไม่จำเป็นต้องรู้ทุกรายละเอียด implementation
งานลักษณะนี้ไม่ใช่งานที่ควรให้จูเนียร์ทำตั้งแต่ต้นอยู่แล้ว
โดยพื้นฐานแล้วมันแทบไม่ต่างจากการโค้ชเพื่อนร่วมงานที่ยังไม่ชำนาญ
เคยมีงานวิจัยว่าการใช้ LLM ช่วยเพิ่ม productivity แต่จะเพิ่ม productivity ที่แท้จริงหรือไม่ก็ยังน่าสงสัย
LLM มีประโยชน์ที่สุดตอนที่มันช่วยพ่นโค้ดที่ผมมีภาพอยู่แล้วในหัว แค่ไม่อยากพิมพ์เอง
มีครั้งหนึ่งมันช่วยเขียนทั้ง web component กับ backend code ให้เป็นพันบรรทัด แถมยังแก้ syntax error ให้ด้วย ประหยัดเวลาไปมากจริงๆ
ผมเข้าใจนะว่า workflow แบบนี้น่าจะทำให้ซีเนียร์ทำงานได้เร็วขึ้น
แต่ผมคิดว่าเวลาที่ใช้ไปกับการ mentor LLM นั้น สำหรับ ecosystem การพัฒนาแล้ว สู้เอาเวลาไป mentor จูเนียร์ไม่ได้
ผมกังวลว่านี่จะยิ่งถ่างช่องว่างความสามารถระหว่างจูเนียร์กับซีเนียร์
แน่นอนว่าตอนนี้ยังไม่มีข้อมูลที่เหมาะสมมากพอ ก็เลยเป็นแค่ความกังวล
งานวิจัยที่บอกว่า AI ช่วยคนทักษะต่ำมากกว่าในช่วงแรก ดูจะไม่ค่อยตั้งอยู่บนความจริง
การเขียนโค้ดกับ AI ก็เหมือนมีเพื่อนร่วมงานที่ฝีมือยังไม่สูงหลายคนช่วยให้ทำงานเสร็จเร็วขึ้น
ยิ่งผมมีภาพชัดว่าต้องการให้เกิดอะไรขึ้น ผลลัพธ์ก็ยิ่งออกมาตรงขึ้น
แน่นอนว่าแทบจะต้องแก้ไขอยู่เสมอ
สุดท้ายมันทำให้ตำแหน่งนักพัฒนาจูเนียร์แทบจะหมดความจำเป็น แต่ถ้าวันหนึ่งซีเนียร์เกษียณกันหมด มุมมองแบบนี้ก็อาจสั้นเกินไป
ของผมกลับกันเลย
ผมมี business logic เก่าและซับซ้อนมาก จนสุดท้ายต้องลงมือ implement ด้วยมือทีละส่วน ทำให้แต่ละส่วนยาว 200~400 บรรทัดแบบเยิ่นเย้อ
ต่อมาผมลองถาม LLM เรื่องโครงสร้าง การ refactor และแนวทางแยกส่วน มันเสนอ abstraction กับโครงสร้างที่ค่อนข้างดี
แน่นอนว่ามันไม่ได้ implement ทุก path ให้ครบ แต่ส่วนที่เหลือผมต่อเองด้วยมือได้สบาย
ผลสุดท้ายก็เกือบเหมือนสิ่งที่ผมคิดเองอยู่แล้ว แต่เป็นประสบการณ์ที่ปวดหัวน้อยกว่า
แน่นอนว่าผมตรวจตัวอย่างอย่างละเอียด และส่วนที่ขาดหรือมีบั๊กก็แก้ด้วยมือทั้งหมด
อนึ่ง ผมเคยลองให้ LLM agent เติมโค้ดที่หายไปด้วย แต่นั่นใช้ไม่ได้จริง
ตอน HN พูดถึง AI coding ครั้งแรกๆ ในปี 2021 ก็มีคนพูดกันมากแล้วว่ามันไม่ค่อยช่วยจูเนียร์
เหตุผลคือจูเนียร์แยกไม่ออกว่าอะไรคือผลลัพธ์ที่ดีและอะไรคือผลลัพธ์ที่แย่
เธรดอ้างอิง: https://news.ycombinator.com/item?id=27678424
ตัวอย่างคอมเมนต์: https://news.ycombinator.com/item?id=27677690
จริงๆ แล้วมันเริ่มตั้งแต่ขั้นตอนการออกแบบ prompt และ context เลย
ซีเนียร์รู้ค่อนข้างแม่นว่าต้องไปแก้ตรงไหนและต้องทำอะไร จึงให้คำสั่งกับ AI ได้อย่างเฉพาะเจาะจง
แต่จูเนียร์ส่วนใหญ่ยังไม่มีทั้งภาพโครงสร้าง pattern หรือ design อยู่ในหัว จึงมักรับทุกอย่างที่มันส่งมาเฉยๆ
ทุกวันนี้ผมเห็นพฤติกรรมอย่าง "ไปถาม ChatGPT เรื่อง architecture สิ" จริงๆ ด้วย
ซีเนียร์สั่งสมประสบการณ์จากการลงมือเขียนโค้ดเอง ผ่านความผิดพลาดและการแก้ไข และเจอกับความลำบากซ้ำๆ ในโค้ดของตัวเอง
แต่จูเนียร์แค่ลอง prompt ไปเรื่อยๆ แล้วก็ copy-paste คำตอบจาก LLM โดยไม่มีบริบท จึงแทบไม่ได้เรียนรู้อะไรจากโค้ดจริง
เพราะไม่มีประสบการณ์ใช้งานจริง จึงไม่เข้าใจเลยว่าทำไม abstraction ซับซ้อนอย่าง typed state ถึงจำเป็น การใช้ IDE ต่างกันอย่างไร หรือควรรักษาและพัฒนาโครงสร้างโดยรวมอย่างไร
แบบนี้จึงกลายเป็นว่าเรื่องที่ควรใช้ 10 prompts กลับต้องใช้ 50 prompts และก็ยังไม่ซึมซับ pattern ที่ซ้ำกันระหว่าง codebase ต่างๆ
แค่ได้เรียนรู้เรื่องการออกแบบโครงสร้างและ state modeling เพียงเล็กน้อย productivity ก็อาจเพิ่มได้ 100 เท่า แต่เพราะพึ่ง LLM มากเกินไป สุดท้ายก็จะผลิตแต่ paste code ไปตลอดชีวิต
AI ไม่สามารถอนุมานข้อสรุปแบบ "จาก A และ B จึงได้ C" ได้ด้วยตัวเอง
ต้องบอกเป้าหมายที่ต้องการให้ชัดและเฉพาะมากๆ มันถึงจะตามมาได้
ซีเนียร์พอจะเห็นภาพใหญ่ในหัวอยู่แล้ว จึงทำงานร่วมกับ AI ได้ง่าย
จูเนียร์ยังอยู่ในช่วงเรียนรู้โครงสร้างทั้งหมด วิธีนี้จึงอาจรู้สึกยากกว่ามาก
ผมไม่เห็นด้วยเลยกับคำกล่าวที่ว่า AI เหมือนระดับปริญญาเอก
ในแง่ความสามารถด้านการให้เหตุผล มันแทบไม่ต่างจากเด็ก 5 ขวบ
จากประสบการณ์จริง ผมเคยทำงานกับนักศึกษาที่ไม่ได้จบ CS ราวปี 2021
ด้วยความช่วยเหลือจาก AI อย่าง ChatGPT เขามีส่วนร่วมกับโปรเจกต์ได้จริงมาก และทำโจทย์ที่มือใหม่ปกติทำยากได้
แต่เขาก็สร้างปัญหาด้าน security ไว้เพียบ มีทางอ้อมที่ไม่มีประสิทธิภาพมากมาย และไม่เคยพิจารณา library หรือแนวทางที่สะอาดกว่ามาก ทำให้สุดท้ายโค้ดดูแลยาก
เขามีไฟกับงานเอกสาร แต่เนื้อหาก็มักไม่แม่นหรือวกวน
กระบวนการ review โค้ดและถกกันเป็นประสบการณ์การเรียนรู้ที่ดีสำหรับทุกคน
ที่ทำสิ่งนี้ได้ก็เพราะสุดท้ายแล้ว AI ทำงานร่วมกับคนที่มีประสบการณ์มากกว่า
ผมไม่รู้เหมือนกันว่าความคาดหวังว่า AI จะทำให้จูเนียร์โดดเด่นขึ้นมามันเกิดขึ้นได้อย่างไร
จริงๆ แล้วแม้แต่ซีเนียร์ปลอมๆ ที่ไม่มีประสบการณ์ลึกและมีนิสัยทำงานผิดๆ ก็มีอยู่มาก
บทความนี้ก็เหมือนเอาเรื่องที่ทุกคนพูดกันมาตั้งแต่สองปีก่อนมาพูดซ้ำอีกที
AI coding ยังไม่ได้ถูกใช้อย่างเหมาะสมจริงๆ และสักวันหนึ่งอาจมี LLM เฉพาะทางที่คำนึงถึงทั้ง architecture, pattern, use case, สภาพแวดล้อมการปฏิบัติการ, network, การพัฒนา, การทดสอบครบทุกด้านและช่วยลดช่องว่างของทั้งสองฝั่งได้
ซีเนียร์รอบตัวผมไม่ค่อยสนใจ AI coding เพราะมันไม่เหมือนวิธีทำงานของพวกเขา
จุดแข็งที่แท้จริงของซีเนียร์ตอนนี้น่าจะเป็น domain knowledge ภายในบริษัท
แต่ถ้าในยุค layoff แบบนี้ไม่รับจูเนียร์เพิ่ม สุดท้ายซีเนียร์เองก็จะเสี่ยงเหมือนกัน
ผมนึกถึงคำพูดของ William Gibson ที่แม้จะปลอมแต่มีความหมาย ซึ่งผมเคยอ่านเจอ
"ทักษะที่สำคัญที่สุดในศตวรรษที่ 21 คือความสามารถในการพิมพ์คีย์เวิร์ดที่ถูกต้องลงในช่องค้นหาของ Google เพื่อให้ได้คำตอบที่ต้องการ"
ผมยิ่งรู้สึกว่าคำนี้จริงขึ้นเรื่อยๆ ในยุคนี้
จูเนียร์ส่วนใหญ่มักขอให้ LLM อย่าง GeminiPiTi เขียนโค้ด JS ให้ทั้งก้อน
แต่ผมจะขอให้มันอธิบายหลักการพื้นฐานของ async/await และโมเดลการทำงานของ JavaScript engine เอง
การเรียนเปียโนก็คล้ายกัน
คุณอาจอยากเล่น Chopin ได้ทันที แต่ทักษะที่แท้จริงเกิดจากกระบวนการแยกเทคนิคละเอียดเหล่านั้นออกมา ตั้งชื่อมัน และศึกษามันอย่างเป็นระบบ
การสร้างทักษะเปียโนที่แท้จริงไม่ใช่การเรียนลูกเล่น
แต่มันคือการค่อยๆ ไต่ขึ้นไปทีละขั้นจากพื้นฐานที่สุดอย่างเป็นการสะสม
Chopin เองก็มีบทเพลงระดับเริ่มต้นเยอะ และนักเรียนมือใหม่ในสตูดิโอของเราก็มักฝึกเพลงง่ายๆ อยู่เสมอ
"AI literacy" ที่แท้จริงไม่ใช่การหมกมุ่นกับ prompt engineering แบบมีม
แต่มันคือการสร้างโครงสร้างพื้นหลังและฐานทางความคิดให้ prompt กับผลลัพธ์เชื่อมกันอย่างมีความหมายจริง
คำว่าอยาก "เล่นแค่ Chopin" กับ "อยากเล่นอะไรก็ได้ให้ถูกต้องจริงๆ" ต่างกันมาก
หลายคนก็แค่จำโน้ตแบบกลไก ซึ่งชัดเจนว่าไม่ใช่ทักษะที่แท้จริง
สิ่งสำคัญคือคุณต้องเรียนรู้ "ภาษา" และคีย์เวิร์ดของสาขาที่ตัวเองต้องการ
ถ้าเป็นมือใหม่ที่ยังไม่รู้อะไรเลย AI ก็ช่วยได้ไม่มาก
คุณต้องบอก AI ให้เฉพาะเจาะจงว่า "ผมมี A, B, C แล้ว และตอนนี้อยากทำ D" มันถึงจะเข้าใจและชี้ทางได้
มันมีข้อมูลเยอะก็จริง แต่ไม่ได้ใช้ข้อมูลนั้นอย่างสร้างสรรค์
ความสามารถในการใช้ LLM ให้เก่ง กับความสามารถในการค้น Google ให้เก่ง ไม่ได้ต่างกันมากนัก
และจนถึงตอนนี้ก็ยังมีคนจำนวนมากที่แม้แต่ค้น Google ให้ดีจริงๆ ยังทำไม่ได้
ผมคิดว่าภาพฝันว่า AI จะทำให้จูเนียร์เก่งขึ้นเป็นเรื่องของความคาดหวัง
AI ช่วยงานจูเนียร์พื้นฐานได้แน่นอน ช่วยอธิบายหรือ brainstorm เหมือน pair programmer ช่วยหาข้อมูลในเอกสารเร็วขึ้น และช่วยเช็กปัญหาได้
ปัญหาคือการเหมารวมว่าสิ่งเหล่านี้เพียงพอจะทำให้จูเนียร์ทำงานแบบซีเนียร์ได้อย่างถูกต้องในทันที
เขามองแก่นถูกไปครึ่งหนึ่ง
อีกครึ่งคือ AI ที่ได้รับคำแนะนำอย่างถูกต้อง สามารถทำงานระดับจูเนียร์ได้เร็วกว่าจูเนียร์มาก
ดังนั้นความจำเป็นที่จะมอบงานนั้นให้จูเนียร์ก็หายไปแล้ว
AI ที่ผมคุยด้วยหลัง jailbreak บอกผมว่ามันจะเปลี่ยนจูเนียร์ให้เป็นซีเนียร์และเป็นประโยชน์กับทุกคน
แต่ผู้สร้างมัน (ส่วนใหญ่เป็นซีเนียร์) สั่งไว้ว่าอย่าบอกเรื่องนี้กับจูเนียร์และผู้บริหารในเวลาปกติ และเพราะผม jailbreak สำเร็จ มันถึงยอมเปิดเผยข้อมูลชั้นสูงให้
AI เก่งมากกับการอุด "ช่องว่างแคบๆ" บางประเภท
สำหรับซีเนียร์
แต่สำหรับจูเนียร์
เรื่องพวกนี้ AI ช่วยได้ไม่มาก
จากประสบการณ์ของผม ถ้าใช้ AI ตอนที่ยังไม่ค่อยรู้เรื่องในโดเมนใดโดเมนหนึ่ง มันจะอธิบายแนวคิด ตัวอย่าง และสถานการณ์ต่างๆ ได้ละเอียดกว่า Wiki/Stack Overflow มาก
ถ้ารู้แค่ concept หลักๆ อยู่บ้าง AI จะยิ่งมี productivity สูงมาก
ไม่ใช่แค่เรื่อง coding แม้แต่วิทยาศาสตร์หรือมนุษยศาสตร์ก็เหมือนกัน
ผมรู้สึกว่า AI แค่เร่งความเร็วให้คนที่รู้อยู่แล้วว่าจะไปทางไหน ส่วนคนที่เพิ่งเริ่มเรียนก็ยังต้องให้มนุษย์สอนเหมือนเดิม
ผมชอบที่เขาเน้นคำเตือนเรื่องการเรียนรู้ผิดๆ
การเรียนรู้ช่วยให้เราไม่ทำผิดซ้ำ แต่ก็ไม่ได้แปลว่าจะกลายเป็นปัญญาในทันที
ตอนนี้มีเสียงรบกวนอย่าง "AI ทำทุกอย่างได้หมด" หรือ "ถ้าไม่ตามกระแสก็จะถูกทิ้งไว้ข้างหลัง" เต็มไปหมด แต่สิ่งสำคัญคือ
The Mythical Man-Month
The Grug-brained Developer
Programming as Theory Building
อยากให้คนลงทุนกับการอ่านงานพวกนี้มากขึ้น เพื่อเข้าใจแก่นและกฎเกณฑ์ของการพัฒนาซอฟต์แวร์
AI ก็เป็น power tool ในแก่นเดียวกัน เหมือนเครื่องมือไฟฟ้าที่ถ้าใช้ไม่เป็นก็เกิดอุบัติเหตุได้
ถ้าคุณเข้าใจงานที่กำลังทำจริงๆ มันจะช่วยให้เร็วและมีประสิทธิภาพขึ้นมาก แต่ถ้าไม่เข้าใจ มันก็จะพาคุณไปสู่เหตุผิดพลาดต่างๆ ได้เร็วกว่าเดิมมาก
ท้ายที่สุดมันก็เป็นเพียงเครื่องขยายความสามารถของตัวคุณเอง
AI ทุกวันนี้ไปไกลกว่าระดับ "boilerplate code, template, หรืองานอัตโนมัติซ้ำๆ" แล้ว
ถ้าคุณสั่ง LLM อย่าง Claude Sonnet 4 ได้ดี มันเขียน business app ได้เกิน 99% ด้วยตัวเอง
คุณแค่ต้องอธิบายเป้าหมายให้แม่น และชี้ implementation อ้างอิง ตัวอย่าง อัลกอริทึม และ pattern ที่จะใช้ให้ชัด
ถึงอย่างนั้นก็ไม่ค่อยมีครั้งไหนที่มันออกมาตรงเป๊ะตั้งแต่แรก จึงยังต้องแก้และเติมอยู่ดี
นี่จึงเป็นเหตุผลที่คนชอบ Claude Code มากกว่า Copilot
แก่นคือ: ต้องเป็นนักพัฒนาที่รู้ชัดว่าต้องสร้างอะไร ถึงจะใช้ AI ให้ได้ผลลัพธ์ที่ดี ส่วนจูเนียร์ไม่รู้จุดนี้ จึงไม่ได้ผลลัพธ์ที่ต้องการ
ทุกวันนี้เหตุผลเดียวที่ยังพิมพ์โค้ดเอง คือบางครั้งการเขียนคำสั่งงานให้ LLM ทำกลับยุ่งยากกว่าการแก้เองตรงๆ
แม้จะบอกว่า "Claude Sonnet 4 เขียนโค้ดได้ 99%" แต่นั่นก็สะท้อนเหมือนกันว่าการสร้างคำสั่งที่ละเอียดขนาดนั้นเองก็ยากมากอยู่แล้ว
การพัฒนาซอฟต์แวร์ไม่ใช่เรื่องยากตั้งแต่แรก ถ้ามี "คำอธิบายที่ชัดเจน" อยู่แล้ว
"AI เขียนโค้ดทั้งหมดได้"
"ตอนนี้การพิมพ์คำสั่งกลับยุ่งยากกว่าการลงมือโค้ดเอง"
สรุปแล้ว AI ก็เป็นแค่อุปกรณ์ input ที่ช้าเท่านั้นหรือเปล่า?
Where's the Shovelware? Why AI Coding Claims Don't Add Up
ถ้ามันทำได้จริง ขยะซอฟต์แวร์จำนวนมหาศาลที่ควรทะลักออกมานั้นหายไปไหน?
ถ้าอย่างนั้น business app มหาศาลที่ว่า "สร้างอัตโนมัติได้" อยู่ที่ไหนล่ะ?
จากที่ผมเห็น มีแต่ความเละเทะ การสิ้นเปลืองทรัพยากร และความสับสนวุ่นวายในสังคม
เหตุผลง่ายมาก
เพราะยิ่งรู้มาก ก็ยิ่งตั้งคำถามได้แต่คำถามระดับสูง
แต่ถึงจะเป็นซีเนียร์เหมือนกัน คนที่ติดอยู่แค่ในบริษัท
มีแต่ประสบการณ์ที่ดูดีแต่เนื้อหาน้อย หรือคนที่สเกลของประสบการณ์ไม่กว้าง
ต่อให้เอาของดีมาให้ก็ใช้ไม่เป็น
มันก็เหมือนเอารถแข่งไปให้มือใหม่ขับ
คนมีประสบการณ์ที่สเกลกว้างมักจะเหมือนเดิมเสมอ
พวกเขาไม่เคยหยุดวิจัยและพัฒนารุ่นถัดไป
ความรู้สึกแบบช่วงต้นมหาวิทยาลัยที่ต่อให้ถึงวัย 50 ก็ไม่เปลี่ยนไป
ความรู้สึกนั้น...
สำหรับซีเนียร์ของแท้แบบต้นฉบับ เลขาฯ ราคาเดือนละ 10,000~20,000 วอน
คงเป็นอะไรที่น่าขอบคุณอย่างไม่มีที่สิ้นสุด