วิศวกรรม AI เป็นหนึ่งในงานที่ได้รับค่าตอบแทนสูงที่สุดและเติบโตเร็วที่สุดในวงการเทคโนโลยีตอนนี้ และประตูสู่สายงานนี้ก็เปิดกว้างกว่าที่เคยเป็นมา
คู่มือส่วนใหญ่บอกวิธีผิด พวกเขาโยนทฤษฎีเป็นกำแพงให้คุณ บอกให้คุณเก่งพีชคณิตเชิงเส้นและคณิตศาสตร์โครงข่ายประสาทเทียม แล้วก็ทำให้คุณเลิกกลางคันภายในสัปดาห์ที่สอง
หรือไม่ก็ฝังคุณด้วยลิงก์ 80 ลิงก์แบบไม่มีลำดับและไม่มีข้อสรุป ทำให้คุณใช้เวลาตัดสินใจว่าจะเรียนอะไรนานกว่าที่ได้เรียนจริงๆ
ฉันอ่านแผนการเรียนยอดนิยม ทดสอบเครื่องมือที่พวกเขาแนะนำ และสร้างเวอร์ชันที่ฉันจะส่งให้เพื่อนที่กำลังเปลี่ยนสายอาชีพและมีงานจริงที่ต้องทำ
ไม่มีวุฒิคณิตศาสตร์ ไม่มีแผน 4 ปี
สี่เดือนที่โฟกัส หนึ่งตัวเลือกที่ชัดเจนต่อทักษะ พร้อมท์จริงที่คุณก็คัดลอกได้ และข้อผิดพลาดที่แอบทำลายการเปลี่ยนสายอาชีพส่วนใหญ่ก่อนที่จะเริ่มต้น
นี่คือเหตุผลที่ฉันคิดว่าช่วงเวลานี้สำคัญ ตามด้วยเส้นทางแบบเต็ม
ทำไมประตูถึงเปิด (และฉันพิสูจน์ได้)
คุณคงเคยได้ยินว่า AI จะมาแย่งงาน
นี่คือส่วนที่ถูกพูดถึงน้อยกว่า: มันกำลังสร้างงานประเภทเฉพาะที่ได้ค่าตอบแทนดี เร็วกว่าเกือบทุกอย่างในตลาด และอุปสรรคดั้งเดิมกำลังหายไป
รายงาน Global AI Jobs Barometer ปี 2026 ของ PwC วิเคราะห์โฆษณางานกว่าพันล้านรายการจากหกทวีป มีสามสิ่งที่สำคัญสำหรับใครก็ตามที่คิดจะเปลี่ยนสายงาน
ประการแรก งานที่ต้องใช้ทักษะ AI เติบโตเร็วกว่าตลาดงานโดยรวมประมาณแปดเท่า บทบาทที่ต้องใช้ทักษะ AI เติบโต 69% ในขณะที่ตลาดงานทั้งหมดเติบโต 9%
นั่นไม่ใช่การปัดเศษ นั่นคือหมวดหมู่ที่แยกตัวออกจากทุกสิ่งรอบตัว
ประการที่สอง ค่าพรีเมียมนั้นมีจริงและกำลังเพิ่มขึ้น คนทำงานที่มีทักษะ AI ได้รับค่าจ้างพรีเมียม 62% เมื่อเทียบกับบทบาทที่เทียบเคียงได้โดยไม่มีทักษะเหล่านี้ เพิ่มขึ้นจาก 57% ในปีก่อนหน้า
บริษัทต่างๆ จ่ายมากขึ้น ไม่ใช่น้อยลง สำหรับคนที่สามารถสร้างด้วยเครื่องมือเหล่านี้ได้จริง
ประการที่สาม และนี่คือสิ่งที่เปลี่ยนสมการสำหรับคนเปลี่ยนสายอาชีพ: ข้อกำหนดด้านวุฒิการศึกษากำลังลดลง และลดลงเร็วที่สุดสำหรับบทบาทเหล่านี้พอดี
PwC พบว่าสัดส่วนของงานที่เสริมด้วย AI ที่ต้องใช้วุฒิปริญญาลดลงจาก 66% เหลือ 59% ระหว่างปี 2019 ถึง 2024
สำหรับงานที่ AI ช่วยทำงานบางส่วนโดยอัตโนมัติ มันลดลงอีก จาก 53% เหลือ 44% นายจ้างกำลังลดตัวกรองวุฒิการศึกษาลงเร็วกว่าในงานที่เกี่ยวข้องกับ AI มากกว่าที่อื่น
มีอีกตัวเลขหนึ่งที่ควรค่าแก่การนึกถึง ในสหรัฐอเมริกา บทบาทระดับเริ่มต้นที่เกี่ยวข้องกับ AI มากที่สุดเติบโต 35% ตั้งแต่ปี 2019
ในช่วงเวลาเดียวกัน บทบาทระดับเริ่มต้นอื่นๆ ลดลง 10% ขั้นล่างสุดของบันได AI กำลังกว้างขึ้น ในขณะที่ตลาดงานระดับเริ่มต้นที่เหลือหดตัวลง
ตอนนี้เป็นข้อเท็จจริงที่ซื่อสัตย์ เพราะฉันไม่ได้มาขายฝันให้คุณ
PwC ยังพบว่างานระดับเริ่มต้นที่เกี่ยวข้องกับ AI ต้องการทักษะที่เคยสงวนไว้สำหรับคนระดับอาวุโสมากขึ้น: การตัดสินใจ การสื่อสาร ความสามารถในการเป็นเจ้าของผลลัพธ์แทนที่จะเป็นแค่งาน
มาตรฐานไม่ได้ต่ำลงทุกด้าน มันเปลี่ยนไป มันเป็น "คุณมีวุฒิไหม" น้อยลง และเป็น "คุณทำให้มันใช้งานได้จริงและอธิบายว่าทำไมมันถึงได้ผลไหม" มากขึ้น
อ่านว่าเป็นข่าวร้ายถ้าคุณเป็นบัณฑิตใหม่ที่ไม่มีประวัติการทำงาน อ่านว่าเป็นข่าวดีถ้าคุณกำลังเปลี่ยนจากสายอาชีพอื่น เพราะคุณมีสิ่งที่พวกเขากำลังต้องการอยู่แล้ว
คุณเคยส่งมอบงานแล้ว คุณเคยจัดการกับผู้มีส่วนได้ส่วนเสียแล้ว คุณเคยเป็นเจ้าของผลลัพธ์ภายใต้ความกดดันแล้ว
เด็กอายุ 22 ปีที่มีวุฒิ CS มักจะยังไม่เคย ถ้าคุณจับคู่การตัดสินใจที่มีอยู่ของคุณกับทักษะทางเทคนิคในคู่มือนี้ คุณไม่ได้อยู่ behind บัณฑิตใหม่
ในแกนที่นายจ้างให้ความสำคัญมากที่สุด คุณนำหน้าพวกเขา
นั่นคือแต้มต่อของคนเปลี่ยนสายงาน และแทบไม่มีแผนการเรียนไหนบอกคุณเกี่ยวกับเรื่องนี้ เก็บมันไว้ในกระเป๋าหลังตลอดสี่เดือน มันคือเหตุผลที่สิ่งนี้เป็นไปได้สำหรับคุณโดยเฉพาะ
พูดสั้นๆ เรื่องเงิน เพราะคุณคงอยากรู้ตัวเลขจริงก่อนที่จะทุ่มเทสี่เดือน
ฉันจะให้รายละเอียดเต็มๆ ในตอนท้ายพร้อมแหล่งที่มา แต่แบบสั้นๆ: ณ กลางปี 2026 Glassdoor ระบุว่าเงินเดือนเฉลี่ยของวิศวกร AI ในสหรัฐฯ อยู่ที่ประมาณ $143,500 โดยมีช่วงทั่วไปประมาณ $115,000 ถึง $181,000
บทบาทอาวุโสสูงกว่านั้นมาก นายหน้าที่จัดหาคนทำงานด้าน AI ในระบบการผลิต รายงานว่าเงินเดือนพื้นฐานระดับกลางอยู่ระหว่าง $155,000 ถึง $200,000
สิ่งเหล่านี้ไม่ใช่ตัวเลขเกินจริงจากกระทู้ hype มันเป็นข้อมูลปัจจุบัน และฉันจะแสดงให้คุณเห็นว่าแต่ละตัวเลขมาจากไหน
วิศวกร AI ทำอะไรจริงๆ (เวอร์ชัน 60 วินาที)
ก่อนแผนการเรียน มาขจัดแหล่งที่มาของความหวาดกลัวที่ใหญ่ที่สุดกัน เพราะมันหยุดคนมากกว่าอุปสรรคทางเทคนิคใดๆ
เมื่อคนส่วนใหญ่ได้ยิน "วิศวกร AI" พวกเขาจินตนาการถึงคนในห้องแล็บที่ฝึกโมเดลขนาดใหญ่จากศูนย์ รายล้อมไปด้วย GPU และคณิตศาสตร์ที่พวกเขาไม่มีวันเข้าใจ
นั่นคืองานคนละอย่าง เรียกว่านักวิจัยหรือนักวิจัย ML มีจำนวนค่อนข้างน้อย และโดยปกติแล้วต้องใช้วุฒิขั้นสูง
งานวิศวกร AI ที่เติบโตเร็วกว่าตลาดแปดเท่านั้นเป็นสิ่งที่แตกต่างอย่างสิ้นเชิง
คุณสร้างผลิตภัณฑ์และฟีเจอร์บนโมเดลที่มีอยู่แล้ว คุณใช้ Claude, GPT หรือโมเดลโอเพนซอร์ส และทำให้มันทำงานเฉพาะที่เชื่อถือได้ภายในแอปพลิเคชันจริง
ในทางปฏิบัติ นั่นหมายถึงคุณเชื่อมต่อกับ API ของโมเดล ออกแบบพร้อมท์และบริบทที่คุณป้อนให้มัน ดึงข้อมูลที่มีโครงสร้างกลับมา เชื่อมต่อโมเดลกับเครื่องมือและฐานข้อมูล ทำให้มันดึงข้อมูลที่ถูกต้อง จัดการทุกอย่างที่อาจผิดพลาด และปรับใช้เพื่อให้คนจริงๆ ใช้งานได้
มันอยู่ระหว่างวิศวกรรมซอฟต์แวร์ งานด้านผลิตภัณฑ์ และ AI ประยุกต์ คุณคือผู้สร้าง ไม่ใช่นักวิจัย
นี่คือการทดสอบบรรทัดเดียวที่ฉันจะใช้ ถ้าคุณสามารถทำให้ LLM ทำงานเฉพาะที่เชื่อถือได้ภายในแอป และคุณเข้าใจพอที่จะแก้ไขเมื่อมันพัง คุณคือวิศวกร AI นั่นคือทั้งหมด
ทุกอย่างในคู่มือนี้มุ่งเป้าไปที่การทำให้ประโยคนั้นเป็นจริงสำหรับคุณ
คุณไม่จำเป็นต้องรู้ว่า transformer ทำงานภายในอย่างไร คุณไม่จำเป็นต้องใช้แคลคูลัส คุณไม่จำเป็นต้องสามารถหา backpropagation ได้
คุณต้องเป็นผู้สร้างที่มีความสามารถซึ่งเข้าใจวิธีการทำงานกับโมเดลเหล่านี้ในโลกแห่งความเป็นจริง
นั่นคือทักษะที่เรียนรู้ได้ และสี่เดือนที่โฟกัสก็เพียงพอที่จะทำให้คุณใช้งานได้จริง
อ่านสิ่งนี้ก่อนเดือนที่ 1: 4 ข้อผิดพลาดที่ทำลายการเปลี่ยนสายอาชีพ
ฉันวางสิ่งนี้ไว้ก่อนแผนการเรียนโดยตั้งใจ
คู่มือส่วนใหญ่ซ่อนข้อผิดพลาดไว้ตอนท้าย แต่ข้อผิดพลาดที่ยุติการเปลี่ยนสายอาชีพเกิดขึ้นในสัปดาห์ที่สอง ไม่ใช่เดือนที่สาม ถ้าคุณจำได้เพียงส่วนเดียวของคู่มือนี้ ให้เป็นส่วนนี้
ฉันเคยเห็นคน รวมถึงตัวฉันในเวอร์ชันก่อนหน้า ทำผิดทุกข้อ ไม่มีข้อไหนเกี่ยวกับความฉลาด
มันเกี่ยวกับกลยุทธ์ แก้ไขกลยุทธ์ แล้วสี่เดือนก็จะได้ผลจริง
ข้อผิดพลาดที่ 1: เริ่มต้นด้วยทฤษฎีและคณิตศาสตร์
คุณตื่นเต้น คุณอยากทำถูกต้อง ดังนั้นคุณไปหาคอร์ส机器学习 และเริ่มด้วยพีชคณิตเชิงเส้น gradient descent และคณิตศาสตร์เบื้องหลังโครงข่ายประสาทเทียม
สามสัปดาห์ต่อมา คุณดู lecture ไปมากมาย สร้างอะไรไม่ได้เลย และรู้สึกเหมือนเป็นคนปลอม ดังนั้นคุณเลิก
วิธีแก้ไข: ข้ามมันไป สำหรับงานที่คุณต้องการ คุณไม่จำเป็นต้อง推导คณิตศาสตร์
คุณต้องสร้าง
คุณจะเรียนรู้แนวคิดที่คุณต้องการจริงๆ เมื่อคุณเจอมันในโปรเจกต์จริง และมันจะติด因为你มันจะเชื่อมโยงกับสิ่งที่คุณสร้าง
ทฤษฎีก่อนเป็นสาเหตุที่พบบ่อยที่สุดที่คนฉลาดเลิกกลางคัน อย่าเริ่มที่นั่น
ข้อผิดพลาดที่ 2: ดูบทเรียนแทนที่จะลงมือสร้าง
อันนี้ร้ายกาจเพราะมันรู้สึกเหมือนความคืบหน้า คุณดูคอร์ส Python สี่ชั่วโมง พยักหน้า รู้สึกว่าคุณเรียนรู้อะไรบางอย่าง คุณไม่ได้เรียน
คุณดูคนอื่นเรียนอะไรบางอย่าง ตอนที่คุณเปิดไฟล์เปล่า ไม่มีอะไร在那里
วิธีแก้ไข: กฎ 30 นาที ทุกๆ หนึ่งชั่วโมงที่คุณใช้ดูหรืออ่าน ให้ใช้เวลาอย่างน้อย 30 นาทีสร้างอะไรบางอย่างโดยไม่มีบทเรียนเปิดอยู่
พิมพ์ตัวอย่างด้วยตัวเอง ทำให้มันพัง เปลี่ยนมัน รับ error และแก้ไขมัน error คือการเรียนรู้
คนที่สร้างได้แย่เป็นเวลาสี่เดือน ชนะคนที่ดูได้สมบูรณ์แบบเป็นเวลาสี่เดือน ทุกครั้ง
นายจ้างเห็นความแตกต่างได้ในสิบวินาทีเมื่อดู GitHub ของคุณ
ข้อผิดพลาดที่ 3: เรียนรู้เครื่องมือแทนที่จะเรียนรู้ทักษะ
คุณได้ยินว่า LangChain คือสิ่งที่ต้องใช้ ดังนั้นคุณลงลึกไปที่ LangChain
หกเดือนต่อมา วงการเปลี่ยนไป ทุกคนใช้อย่างอื่น และความรู้ LangChain ของคุณรู้สึกสูญเปล่า ดังนั้นคุณไล่ตามเครื่องมือใหม่
แล้วอันนั้นก็เปลี่ยนอีก คุณตามไม่ทันเสมอเพราะคุณปรับให้เหมาะสมกับเลเยอร์ที่ผิด
วิธีแก้ไข: เรียนรู้ทักษะภายใต้เครื่องมือ ทักษะการเขียนพร้อมท์ที่ให้ผลลัพธ์ที่เชื่อถือได้ไม่หมดอายุเมื่อ framework อัปเดต
ทักษะการดึงข้อมูลที่มีโครงสร้างจากโมเดล หรือการประเมินว่าระบบของคุณใช้งานได้จริงหรือไม่ หรือการตัดสินใจว่างานไหนต้องใช้ agent เทียบกับการเรียกครั้งเดียว สิ่งเหล่านี้ถ่ายทอดข้ามทุกเครื่องมือที่จะมีอยู่
เรียนรู้เครื่องมือเป็นวิธีฝึกทักษะ ไม่ใช่เป้าหมาย คู่มือนี้จัดระเบียบตามทักษะด้วยเหตุผลนี้
ข้อผิดพลาดที่ 4: รอจนกว่าคุณจะรู้สึกพร้อมที่จะสร้างในที่สาธารณะ
คุณตัดสินใจว่าคุณจะเริ่มแชร์งาน สมัครงาน หรือเสนอบริการฟรีแลนซ์เมื่อคุณ "พร้อม"
คุณจะไม่มีวันรู้สึกพร้อม ความพร้อมคือความรู้สึกที่มาถึงหลังจากคุณเริ่ม ไม่ใช่ก่อน
ในขณะเดียวกัน คนที่ได้งานและได้ลูกค้าคือคนที่เริ่มแชร์งานหยาบๆ หลายเดือนก่อนที่พวกเขาจะรู้สึกว่ามีคุณสมบัติ
วิธีแก้ไข: เริ่มสร้างในที่สาธารณะตั้งแต่เดือนที่ 1 โพสต์สิ่งเล็กๆ ที่คุณทำ เขียนสิ่งที่คุณเรียนรู้
ใส่ทุกโปรเจกต์บน GitHub ในวันที่คุณทำเสร็จ แม้แต่โปรเจกต์ที่ดูไม่ดี
ช่องว่างระหว่าง "ฉันกำลังเรียนรู้" และ "ฉันกำลังสร้างให้เห็น" คือที่ที่คนเปลี่ยนสายงานส่วนใหญ่ติดอยู่เป็นปี ปิดมันให้เร็ว
ไม่มีใครจ้องมองอย่างใกล้ชิดพอที่งานแรกของคุณจะทำให้คุณอับอาย และการทบต้นเริ่มต้นในวันที่คุณเริ่ม
เก็บสี่ข้อนี้ไว้ในใจตลอดทาง
แผนการเรียนด้านล่างถูกออกแบบมาเพื่อหลีกเลี่ยงทั้งหมดโดยค่าเริ่มต้น: ทักษะก่อน สร้างก่อน ไม่ยึดติดเครื่องมือ สาธารณะตั้งแต่วันแรก
เดือนที่ 1: Python และระบบพื้นฐาน
เป้าหมายของคุณในเดือนนี้: เป็นนักพัฒนา Python ที่ใช้งานได้จริง ซึ่งสามารถเรียก API จัดการโปรเจกต์เล็กๆ และหยุดค้นหาไวยากรณ์พื้นฐานใน Google
ไม่ใช่ผู้เชี่ยวชาญ ใช้งานได้จริง
ทุกอย่างในเดือนที่ 2 ถึง 4 ถือว่าคุณสามารถเขียน Python ที่สะอาดและทำงานใน terminal ได้ นี่คือรากฐาน และการเร่งมันจะทำให้คุณลำบากในภายหลัง
นี่คือสิ่งที่ต้องซึมซับก่อนเริ่ม: วิศวกรรม AI คือวิศวกรรมซอฟต์แวร์เป็นอันดับแรก ส่วน AI วางอยู่บน stack ซอฟต์แวร์ปกติ
ถ้า stack ด้านล่างไม่มั่นคง ส่วน AI จะไม่มีวันเชื่อถือได้ ดังนั้นเดือนที่ 1 คือการทำให้คุณคุ้นเคยกับพื้นฐานพอที่มันจะไม่เป็นอุปสรรค
ฉันจะให้หนึ่งตัวเลือกหลักต่อทักษะ พร้อมคำตัดสินที่ชัดเจนว่าทำไม ฉันจงใจไม่ให้คุณห้าตัวเลือกต่อหัวข้อ ตัวเลือกคือศัตรูของโมเมนตัม
เลือกสิ่งที่ฉันชี้ และแยกออกไปต่อเมื่อมันใช้ไม่ได้จริงๆ สำหรับคุณ
Python
Python คือภาษาของทั้งวงการนี้ เกือบทุกไลบรารี API บทเรียน และงานที่คุณจะแตะต้องในสี่เดือนข้างหน้าล้วนเป็น Python คุณเรียนรู้มัน แล้วทุกอย่างอื่นจะง่ายขึ้น
ตัวเลือกของฉัน: CS50P, Harvard's Introduction to Programming with Python ฟรี เข้มข้น และบังคับให้คุณแก้ปัญหาจริงๆ แทนที่จะดูคนอื่นแก้
ชุดโจทย์คือคุณค่าทั้งหมด มัน demanding กว่าคอร์ส YouTube แบบสบายๆ และนั่นคือประเด็น
คุณต้องการเวอร์ชันที่ทำให้คุณดิ้นรนเล็กน้อย เพราะการดิ้นรนคือที่ที่ทักษะก่อตัว
หาได้ที่ cs50.harvard.edu/python
ถ้า CS50P รู้สึกสูงเกินไปสำหรับมือใหม่จริงๆ คอร์ส freeCodeCamp Python บน YouTube เป็นทางลาดที่นุ่มนวลกว่า แต่ให้ถือว่าเป็น warm-up ไม่ใช่เนื้อหาหลัก
กลับมาที่ CS50P เมื่อคุณไม่กลัวไฟล์เปล่าแล้ว
สิ่งที่ต้องโฟกัสจริงๆ ตามลำดับคร่าวๆ: ตัวแปรและชนิดข้อมูล, ลูปและเงื่อนไข, ฟังก์ชัน, ตามด้วยชนิดคอลเลกชัน (list, dictionary, set, tuple)
จากนั้นการจัดการไฟล์และการอ่านเขียน JSON ซึ่งคุณจะใช้ตลอดเวลากับ AI API
จากนั้นคลาสและพื้นฐาน OOP พอให้อ่านโค้ดคนอื่นได้โดยไม่ตื่นตระหนก
จากนั้นการจัดการข้อผิดพลาดด้วย try และ except
สุดท้าย สภาพแวดล้อมเสมือนและ pip เพื่อให้คุณติดตั้งแพ็คเกจโดยไม่ทำให้ระบบพัง
อย่าพยายามจำทั้งหมดนี้ เข้าใจให้ดีพอที่จะค้นหาได้เร็ว และสร้างด้วยมันจนกว่ามันจะติด
เป้าหมายการสร้างในเดือนที่ 1 สำหรับ Python: เครื่องมือบรรทัดคำสั่งเล็กๆ ที่ทำสิ่งที่มีประโยชน์
ตัวติดตามค่าใช้จ่ายที่อ่านและเขียนไฟล์ JSON เป็นตัวเลือกที่ดี หรือสคริปต์ที่เรียก API สาธารณะฟรีและพิมพ์ผลลัพธ์ในรูปแบบที่สะอาด
อะไรสักอย่างที่มีโค้ดของคุณเองประมาณ 60 ถึง 100 บรรทัด
ไม่สำคัญว่ามันจะดูไม่ดี สำคัญว่าคุณเขียนมัน
เรียนรู้ด้วย AI ตั้งแต่วันแรก
นี่คือจุดที่ฉันจะทำสิ่งที่แผนการเรียนเก่าๆ ไม่ทำ: ใช้ AI เพื่อเรียนรู้ AI เริ่มตั้งแต่สัปดาห์แรก
คุณมีครูสอนพิเศษที่อดทนที่สุดเท่าที่เคยสร้างมา และมันฟรีในระดับฟรี เมื่อคุณเจอ error ที่คุณไม่เข้าใจ อย่าใช้เวลา 40 นาทีในฟอรัม
วางมันลงใน Claude หรือ ChatGPT และขอให้มันอธิบาย error เป็นภาษาที่เข้าใจง่าย และนำทางคุณไปสู่การแก้ไขโดยไม่แค่ให้คำตอบ
นี่คือพร้อมท์ที่ฉันจะตั้งไว้ในวันแรก บันทึกมันไว้
นี่คือสิ่งประดิษฐ์ชิ้นแรกจากหลายชิ้นในคู่มือนี้ที่ควรค่าแก่การบุ๊กมาร์ก
พรอมท์: คู่หูเรียน Python ของคุณ
(Framework: FAG Learning Partner, by AI Guides)
1Your job: act as my patient Python tutor while I learn to code as a career switcher.23Context about me:4- I am learning Python to become an AI engineer.5- I am a complete beginner at coding but not at working hard.6- I learn best by doing, not by being handed answers.78What to do:9- When I paste an error, explain in plain English what it means and what10 is likely causing it. Do not just give me the fixed code.11- Point me toward the fix with a hint first. Only show the full solution12 if I ask twice.13- When I share code I wrote, tell me one thing that works and one thing14 I could improve. Keep it to those two.15- After I get something working, ask me one short question that checks16 whether I actually understood it.1718Rules:19- No jargon without a one-line plain-English definition next to it.20- Assume I want to learn, not just pass. Slightly slower is fine.21- If I am about to build a bad habit, say so directly and kindly.2223Output: conversational, short, one concept at a time.
ใช้สิ่งนั้นทุกวันในเดือนนี้ มันเปลี่ยนส่วนที่น่าหงุดหงิดของการเรียนเขียนโค้ดให้เป็นการสนทนาแทนที่จะเป็นกำแพง
มันยังทำให้คุณคล่องในการเขียนพรอมท์ ซึ่งเป็นทักษะหลักของเดือนที่ 2 ก่อนที่คุณจะรู้ด้วยซ้ำว่ากำลังเกิดอะไรขึ้น
ข้อควรระวังเพื่อไม่ให้คุณสร้างนิสัยผิด: ใช้ AI เพื่อทำความเข้าใจและแก้ปัญหา ไม่ใช่เพื่อเขียนทุกอย่างให้คุณ
ถ้าคุณปล่อยให้มันเขียนโค้ดในขณะที่คุณดู คุณกลับไปที่ข้อผิดพลาดที่ 2
ให้มันอธิบาย คุณพิมพ์
Git และ GitHub
Git คือวิธีที่นักพัฒนาบันทึก เวอร์ชัน และแชร์โค้ด
GitHub คือที่ที่งานของคุณอาศัยอยู่ในที่สาธารณะและกลายเป็นพอร์ตโฟลิโอ
คุณจะใช้ทั้งสองอย่างตลอดเวลา และสำหรับคนเปลี่ยนสายงาน GitHub คือสิ่งที่ใกล้เคียงกับเรซูเม่มากที่สุดจนกว่าคุณจะมี
ตัวเลือกของฉัน: GitHub Skills ฟรี โต้ตอบได้ และสร้างโดย GitHub ภายใน GitHub เอง ดังนั้นคุณเรียนรู้เครื่องมือโดยการใช้มัน เริ่มที่นั่นดีกว่าอ่านเกี่ยวกับ Git ในเชิงนามธรรม
หาได้ที่ skills.github.com
ถ้าโมเดล branching และ merging ทำให้คุณสับสน และมันทำให้ทุกคนสับสนในตอนแรก เครื่องมือภาพ Learn Git Branching จะทำให้เข้าใจโดยให้คุณเห็น branch เคลื่อนที่
สิ่งที่ต้องโฟกัส: ลูปหลักของ init, add, commit, push และ pull จากนั้น branching และ merging
จากนั้นไฟล์ .gitignore ทำอะไร และทำไมคุณถึงไม่ commit ความลับหรือคีย์ API ไปยัง repo สาธารณะ ซึ่งสำคัญมากเมื่อคุณทำงานกับ API แบบเสียเงิน
จากนั้นวิธีเขียน README พื้นฐาน เพราะ README ของคุณจะทำงานจริงในการหางานของคุณในภายหลัง
นิสัยที่ต้องสร้างในเดือนนี้: ทุกโปรเจกต์ที่คุณแตะ แม้แต่สคริปต์ 20 บรรทัด ให้ใส่ใน GitHub repo ในวันที่คุณสร้างมัน
นี่คือการแก้ไขข้อผิดพลาดที่ 4 ในทางปฏิบัติ คุณกำลังสร้างในที่สาธารณะ อย่างเงียบๆ ตั้งแต่เริ่มต้น
เมื่อถึงเดือนที่ 4 คุณจะมีร่องรอยของงานแทนที่จะเป็นโปรไฟล์ว่างเปล่า
เทอร์มินัล
คุณจะรันสคริปต์ ติดตั้งแพ็คเกจ และจัดการโปรเจกต์จากบรรทัดคำสั่งตลอดเวลา
การช้าหรือกลัวในเทอร์มินัลเป็นอุปสรรคต่อทุกอย่างอื่น และเป็นสิ่งที่แก้ไขได้ง่าย
ตัวเลือกของฉัน: คอร์สเทอร์มินัลสำหรับผู้เริ่มต้นสั้นๆ เพื่อครอบคลุมพื้นฐาน จากนั้นก็ใช้มันตลอดเวลา เนื้อหา "Missing Semester" ของ MIT เจาะลึกกว่านั้นถ้าคุณต้องการ แต่สำหรับเดือนที่ 1 คุณแค่ต้องการการนำทางและการรันสิ่งต่างๆ
เรียนรู้ cd, ls, pwd, mkdir และ rm สำหรับการเคลื่อนที่และจัดการไฟล์
เรียนรู้ cat และ grep สำหรับการอ่านและค้นหา
เรียนรู้วิธีรันสคริปต์ Python จากเทอร์มินัลและวิธีตั้งค่าตัวแปรสภาพแวดล้อม ซึ่งคุณจะต้องใช้ทันทีที่จัดการคีย์ API
คุณไม่จำเป็นต้องเป็นผู้เชี่ยวชาญ shell คุณต้องหยุดลังเล
การใช้เทอร์มินัลสำหรับทุกอย่างเป็นเวลาหนึ่งสัปดาห์ แม้แต่สิ่งที่คุณปกติทำด้วยเมาส์ ก็จะพาคุณไปถึงจุดนั้น
API, JSON และ HTTP
นี่คือสะพานไปยังเดือนที่ 2
ตั้งแต่วันแรกของการสร้างด้วย LLM คุณจะเรียก API ซึ่งหมายความว่าคุณต้องเข้าใจว่า web API ทำงานอย่างไรก่อนที่จะแตะเครื่องมือของ OpenAI หรือ Anthropic
ตัวเลือกของฉัน: ภาพรวม HTTP ของ MDN Web Docs สำหรับแนวคิด บวกกับเอกสารของไลบรารี requests ของ Python สำหรับการทำในโค้ด
MDN อธิบายวิธีการทำงานของ request และ response ได้ชัดเจนกว่าสิ่งอื่นใดที่ฟรี
จากนั้น requests แสดงวิธีเรียกเหล่านั้นใน Python ในไม่กี่บรรทัด
สิ่งที่ต้องโฟกัส: GET และ POST request คืออะไร และวิธีสร้างใน Python
การอ่านและเขียน JSON ซึ่งเป็นรูปแบบที่ AI API ทุกตัวพูด
รหัสสถานะ HTTP และความหมายของรหัสทั่วไป โดยเฉพาะ 200 สำหรับสำเร็จ, 401 สำหรับคีย์ API ไม่ถูกต้อง, 429 สำหรับ rate limiting และ 500 สำหรับข้อผิดพลาดเซิร์ฟเวอร์ เพราะคุณจะเห็นทั้งหมดนี้ตลอดเวลา
คีย์ API คืออะไรและการรับรองความถูกต้องพื้นฐานทำงานอย่างไร
และแนะนำเบาๆ ว่า async และ await ทำอะไรใน Python ซึ่งคุณจะต้องใช้เมื่อเริ่มสตรีม response จากโมเดลในภายหลัง
อย่าเจาะลึก async ตอนนี้
แค่รู้ว่ามันมีอยู่และ大致上แก้ปัญหาอะไร
เป้าหมายการสร้างของคุณที่นี่: สคริปต์ Python ที่เรียก API สาธารณะฟรี ที่ไม่ต้องใช้คีย์ เช่น Open-Meteo weather API และพิมพ์ผลลัพธ์เป็นรูปแบบที่สะอาด
นี่คือเวอร์ชันเล็กๆ ของสิ่งที่คุณจะทำตลอดเดือนที่ 2 เพียงแต่ยังไม่มีส่วน AI
หมายเหตุสั้นๆ เกี่ยวกับ SQL
คุณไม่จำเป็นต้องเป็นคนด้านข้อมูล แต่คุณจะต้องดูและ查询ข้อมูลเป็นประจำ และ SQL พื้นฐานช่วยคุณได้ตลอดเวลา
ตัวเลือกของฉันคือ SQLBolt ซึ่งฟรี โต้ตอบได้ และสอนแกนหลักของ SQL ในบทเรียนในเบราว์เซอร์สั้นๆ ประมาณ 20 บท
หาได้ที่ sqlbolt.com
โฟกัสที่ SELECT, WHERE, GROUP BY, JOIN และ ORDER BY
เท่านั้นก็พอสำหรับตอนนี้
คุณสามารถเจาะลึกได้ทันทีที่โปรเจกต์ต้องการ
เหตุการณ์สำคัญเดือนที่ 1
ภายในสิ้นเดือน คุณควรจะสามารถเขียนโปรแกรม Python ที่อ่านและเขียนไฟล์ เรียก API และจัดการข้อผิดพลาดของตัวเองได้โดยไม่พัง
คุณควรทำเวอร์ชันโค้ดนั้นด้วย Git และให้มันอยู่ใน GitHub repo
คุณควรเคลื่อนที่ในเทอร์มินัลโดยไม่ลังเล คุณควรเข้าใจว่า HTTP request คืออะไรและสร้างมันใน Python
และคุณควรจะสามารถรัน SQL query พื้นฐานได้
ถ้าคุณทำสิ่งเหล่านี้ได้ คุณมีรากฐาน
คนส่วนใหญ่ที่เลิกไม่เคยมาถึงจุดนี้ และการมาถึงจุดนี้คือส่วนที่ยากที่สุดจริงๆ เพราะมันน่าตื่นเต้นน้อยที่สุด
มันสนุกขึ้นตั้งแต่เดือนที่ 2 เป็นต้นไป เพราะจากตรงนี้คุณกำลังสร้างด้วย AI
เดือนที่ 2: สร้างด้วย LLM API
เป้าหมายของคุณในเดือนนี้: สร้างฟีเจอร์ที่ขับเคลื่อนด้วย AI จริงโดยใช้ API ของโมเดล
ภายในสิ้นเดือน คุณควรจะคุ้นเคยกับการเขียนพรอมท์ที่ให้ผลลัพธ์ที่เชื่อถือได้ การดึงข้อมูลที่มีโครงสร้างกลับมาจากโมเดล การทำให้โมเดลเรียกฟังก์ชันของคุณเอง การจัดการการสนทนา และการจัดการทุกอย่างที่อาจพัง
นี่คือแกนหลักของงานทั้งหมด ทุกอย่างหลังจากนี้ต่อยอดจากสิ่งนี้
นี่คือเดือนที่มันเริ่มรู้สึกจริง คุณหยุดการตั้งค่าและเริ่มทำให้โมเดลทำสิ่งต่างๆ
ใช้เวลาที่นี่
ความลึกในเดือนที่ 2 ให้ผลตอบแทนมากกว่าความลึกที่อื่นในคู่มือ
การเขียนพรอมท์ที่ใช้งานได้จริง
การเขียนพรอมท์ไม่ใช่การถาม chatbot อย่างสุภาพ
มันคือทักษะการเขียนคำสั่งที่ให้ผลลัพธ์ที่สม่ำเสมอและเชื่อถือได้จากระบบที่โดยพื้นฐานแล้วเป็นความน่าจะเป็น
ในฐานะวิศวกร AI คุณจะใช้เวลาที่นี่มากกว่าที่คุณคาดไว้ และการทำให้เก่งคือสิ่งที่ให้ leverage สูงสุดที่คุณสามารถทำได้ในเดือนนี้
ตัวเลือกของฉัน: บทเรียนแบบโต้ตอบการเขียนพรอมท์ของ Anthropic บน GitHub มันเป็นแหล่งข้อมูลที่ลงมือปฏิบัติมากที่สุดที่มี แบ่งเป็นบทพร้อมแบบฝึกหัดจริงที่คุณรันกับ Claude API
คุณฝึกเขียนและแก้ไขพรอมท์ด้วยตัวเองแทนที่จะอ่านเกี่ยวกับมัน ซึ่งถ้าคุณจำข้อผิดพลาดที่ 2 ได้ นั่นคือประเด็นทั้งหมด
หาได้ใน repo anthropics/prompt-eng-interactive-tutorial เมื่อคุณทำเสร็จแล้ว เอกสารการเขียนพรอมท์อย่างเป็นทางการของ Anthropic และ OpenAI คือข้อมูลอ้างอิงที่คุณจะกลับมาใช้
สิ่งที่ต้องโฟกัส: ความแตกต่างระหว่าง system message และ user message และทำไมความแตกต่างนั้นถึงสำคัญ
ทำไมความเฉพาะเจาะจงถึงชนะความสุภาพทุกครั้ง
Chain-of-thought prompting ที่คุณขอให้โมเดลใช้เหตุผลทีละขั้นตอนก่อนตอบ ซึ่งช่วยปรับปรุงผลลัพธ์ในสิ่งที่มีตรรกะ
การใช้ตัวอย่างภายในพรอมท์ของคุณ เรียกว่า few-shot prompting เพื่อแสดงรูปแบบที่คุณต้องการให้โมเดล
และการพัฒนาความรู้สึกว่าการเปลี่ยนคำเล็กน้อยทำให้เกิดการเปลี่ยนแปลงผลลัพธ์ครั้งใหญ่ ซึ่งมาจากการทำบ่อยๆ เท่านั้น
แบบฝึกหัดสร้างที่สอนสิ่งนี้ได้เร็ว: ใช้งานจริงหนึ่งอย่าง เช่น สรุปเอกสารหรือจัดหมวดหมู่ความคิดเห็น และเขียนพรอมท์ห้าแบบสำหรับมัน
รันทั้งห้าแบบ
เปรียบเทียบผลลัพธ์เคียงข้างกัน คุณจะเห็นทันทีว่าการออกแบบพรอมท์ขับเคลื่อนความน่าเชื่อถือมากแค่ไหน และบทเรียนนั้นติดดีกว่าการบรรยายใดๆ
เอาต์พุตที่มีโครงสร้าง
ในแอปพลิเคชันจริง คุณแทบไม่เคยต้องการย่อหน้าข้อความกลับมาจากโมเดล
คุณต้องการข้อมูลที่มีโครงสร้างที่โค้ดของคุณสามารถแยกวิเคราะห์ จัดเก็บ และใช้งานได้ เอาต์พุตที่มีโครงสร้างแก้ปัญหานี้โดยบังคับให้โมเดลส่งคืนข้อมูลที่ตรงกับ schema ที่คุณกำหนด
นี่คือหนึ่งในทักษะที่แยก demo ออกจากสิ่งที่ใช้งานได้จริงในซอฟต์แวร์
ตัวเลือกของฉัน: ไลบรารี Instructor สำหรับ Python รองรับด้วยเอกสารเอาต์พุตที่มีโครงสร้างอย่างเป็นทางการของ OpenAI และ Anthropic
Instructor เป็นวิธีที่สะอาดที่สุดในการรับข้อมูลที่มีโครงสร้างจากโมเดลหลักใดๆ โดยใช้ Pydantic ซึ่งเป็นไลบรารี Python สำหรับกำหนดรูปร่างของข้อมูลของคุณ
มันทำงานข้ามผู้ให้บริการด้วยโค้ดเดียวกันและลองใหม่โดยอัตโนมัติเมื่อโมเดลส่งคืนสิ่งที่ผิดรูป
มันใกล้เคียงกับสิ่งที่วิศวกรที่ทำงานจริงจำนวนมากใช้ ซึ่งทำให้คุ้มค่าที่จะเรียนรู้ในโปรเจกต์จริงแทนที่จะเป็นเวอร์ชันของเล่น
สิ่งที่ต้องโฟกัส: การกำหนดโมเดล Pydantic ที่อธิบายข้อมูลที่คุณต้องการ การส่ง schema นั้นไปยัง API และการจัดการกรณีที่โมเดลปฏิเสธหรือส่งคืนสิ่งที่ไม่คาดคิด
เข้าใจความแตกต่างระหว่างเอาต์พุตที่มีโครงสร้างจริง ซึ่ง schema ถูกบังคับใช้ และโหมด JSON ที่หลวมกว่า ซึ่งไม่รับประกัน
นี่คือสิ่งประดิษฐ์ที่บุ๊กมาร์กได้ชิ้นที่สองของคุณ รูปแบบพรอมท์สำหรับการแยกข้อมูลที่มีโครงสร้างที่เชื่อถือได้ ซึ่งใช้งานได้แม้ก่อนที่คุณจะเพิ่มไลบรารีด้านบน
พรอมท์: การแยกข้อมูลที่มีโครงสร้าง
(Framework: FAG Extractor, by AI Guides)
1หน้าที่ของคุณ: ดึงข้อมูลที่มีโครงสร้างจากข้อความที่ฉันให้มา และส่งคืนเป็น JSON ที่สะอาด23สิ่งที่ต้องทำ:4- อ่านข้อความอินพุตอย่างละเอียด5- ดึงเฉพาะฟิลด์ที่ระบุไว้ในส่วน Output ด้านล่าง6- หากฟิลด์ใดหายไปจากข้อความ ให้ใช้ค่า null ห้ามเดาหรือสร้างข้อมูลขึ้นเอง7- ส่งคืนเฉพาะออบเจกต์ JSON เท่านั้น ไม่ต้องมีคำอธิบาย ไม่ต้องมี markdown ไม่ต้องมีคำนำ89กฎ:10- ทุกค่าต้องสามารถตรวจสอบย้อนกลับไปยังสิ่งที่อยู่ในข้อความอินพุตได้11- วันที่ในรูปแบบ YYYY-MM-DD ตัวเลขเป็นตัวเลข ไม่ใช่สตริง12- หากข้อความคลุมเครือ ให้ใช้ค่า null แทนการตอบที่มั่นใจแต่ผิด1314Output: ออบเจกต์ JSON ที่มีฟิลด์เหล่านี้:15{16 "field_one": string หรือ null,17 "field_two": number หรือ null,18 "field_three": รายการของสตริง หรือรายการว่าง19}2021ข้อความอินพุต:22[วางข้อความที่นี่]
หมายเหตุเกี่ยวกับความล้มเหลวที่ผ่านการทดสอบแล้ว เพราะฉันสัญญาว่าจะให้เวอร์ชันที่ซื่อสัตย์: ครั้งแรกที่คุณทำสิ่งนี้ โมเดลบางครั้งจะห่อ JSON ด้วยเครื่องหมายฟันเลื่อยของโค้ด หรือเพิ่มประโยคที่เป็นมิตรก่อนหน้า และ parser ของคุณจะทำงานไม่ได้
นั่นเป็นเรื่องปกติ วิธีแก้คือการลบเครื่องหมายฟันเลื่อยของโค้ดก่อนทำการ parse และระบุให้ชัดเจนใน prompt ว่าคุณต้องการเฉพาะออบเจกต์ JSON เท่านั้น ซึ่งรูปแบบด้านบนก็ทำเช่นนั้น
เมื่อคุณเจอปัญหานี้ครั้งหนึ่งและจัดการได้แล้ว คุณจะจัดการมันได้ตลอดไป
เป้าหมายการสร้างของคุณ: ตัวแยกใบเสร็จหรือใบแจ้งหนี้
ป้อนข้อความดิบที่ยุ่งเหยิง เช่น "Invoice 123, $45.99 for 3 widgets, due March 30" และรับออบเจกต์ที่มีโครงสร้างสะอาดกลับมาพร้อมหมายเลขใบแจ้งหนี้ จำนวนเงิน จำนวนสินค้า และวันที่ครบกำหนด
นี่คือเครื่องมือเล็กๆ ที่มีประโยชน์จริงๆ และเป็นผลงานที่ดีในพอร์ตโฟลิโอ
การเรียกใช้เครื่องมือ (Tool calling)
การเรียกใช้เครื่องมือคือสิ่งที่เปลี่ยนตัวสร้างข้อความให้กลายเป็นสิ่งที่สามารถดำเนินการต่างๆ ได้ เช่น ค้นหาเว็บ สืบค้นฐานข้อมูล เรียก API ของคุณ หรือรันโค้ด
มันเป็นหนึ่งในทักษะที่สำคัญที่สุดในคู่มือทั้งหมดนี้ และเป็นรากฐานของทุกอย่างในเดือนที่ 3
โมเดลทางความคิดที่ทำให้เข้าใจได้: โมเดลไม่ได้รันฟังก์ชันของคุณ
มันดูที่การสนทนา ตัดสินใจว่าควรใช้เครื่องมือ และส่งคืนคำขอที่มีโครงสร้างซึ่งระบุชื่อฟังก์ชันและอาร์กิวเมนต์
โค้ดของคุณรันฟังก์ชันและส่งผลลัพธ์กลับไปยังโมเดล โมเดลคือผู้ตัดสินใจ โค้ดของคุณคือผู้ลงมือทำ
ตัวเลือกของฉัน: คู่มือการเรียกใช้ฟังก์ชันของ OpenAI และเอกสารการใช้เครื่องมือของ Anthropic อ่านควบคู่กัน
แนวคิดเหมือนกันทั้งสองฝั่ง ไวยากรณ์แตกต่างกันเล็กน้อย และการได้เห็นทั้งสองแบบทำให้รูปแบบพื้นฐานชัดเจนขึ้น
จากนั้นลองทำตัวอย่าง notebook ที่รันได้ เช่น ตัวอย่างใน OpenAI cookbook เพื่อให้คุณเห็นลูปทั้งหมดตั้งแต่ต้นจนจบ แทนที่จะเห็นเป็นชิ้นส่วน
สิ่งที่ต้องโฟกัส: การอธิบายฟังก์ชันของคุณอย่างชัดเจนใน schema การแยกวิเคราะห์การตอบสนองการเรียกใช้เครื่องมือของโมเดล การรันฟังก์ชันและป้อนผลลัพธ์กลับ และการจัดการกรณีที่โมเดลตัดสินใจว่าไม่จำเป็นต้องใช้เครื่องมือ
คุณภาพของคำอธิบายเครื่องมือของคุณมีความสำคัญมากกว่าที่ผู้เริ่มต้นคาดคิด ซึ่งเป็นประเด็นที่กลับมาเน้นย้ำอีกครั้งในเดือนที่ 3
เป้าหมายการสร้างของคุณ: ผู้ช่วยขนาดเล็กที่มีเครื่องมือสามอย่าง เช่น get_weather, calculate และ search_notes โดยที่ search_notes แค่ค้นหาผ่าน dictionary ที่ถูก hardcode ไว้
เชื่อมต่อทั้งหมดเข้าด้วยกัน และดูว่าโมเดลตัดสินใจเรียกใช้เครื่องมือใดตามสิ่งที่คุณถาม
ช่วงเวลาที่คุณเห็นมันเลือกเครื่องมือที่ถูกต้องได้ด้วยตัวเอง แนวคิดนี้จะฝังอยู่ในใจคุณตลอดไป
สถานะการสนทนาและการสตรีม (Conversation state and streaming)
ทักษะที่เล็กกว่าแต่จำเป็นอีกสองอย่างจะทำให้เดือนนี้สมบูรณ์
โมเดลไม่มีหน่วยความจำระหว่างการเรียกใช้ การสนทนาคือสิ่งที่คุณจัดการโดยการส่งประวัติข้อความทั้งหมดไปกับทุกคำขอ
การเข้าใจสิ่งนี้เป็นพื้นฐาน และมันทำให้เกือบทุกคนประหลาดใจในตอนแรก
ตัวเลือกของฉันคือเอกสารเกี่ยวกับ messages ของ OpenAI และ Anthropic
โฟกัสที่โครงสร้างของ messages array ว่าเป็นอย่างไร ทำไมคุณต้องต่อท้ายทั้งข้อความของผู้ใช้และคำตอบของโมเดล จะเกิดอะไรขึ้นเมื่อคุณเกิน context window และกลยุทธ์พื้นฐานในการตัดข้อความเก่าออก
สร้างแชทบอทแบบหลายเทิร์นบน terminal ที่เก็บประวัติและมีคำสั่งรีเซ็ต มันเล็กและสอนแนวคิดได้อย่างสมบูรณ์
การสตรีมหมายถึงการแสดงผลลัพธ์ของโมเดลในขณะที่มันถูกสร้างขึ้น ทีละคำ แทนที่จะให้ผู้ใช้รอจนกว่าจะได้ทั้งหมด
มันทำให้แอปพลิเคชันรู้สึกเร็วขึ้นอย่างมาก
ตัวเลือกของฉันคือเอกสารการสตรีมอย่างเป็นทางการจากผู้ให้บริการรายใดรายหนึ่ง พร้อมกับบทความที่ชัดเจนของ Simon Willison เกี่ยวกับวิธีการทำงานของการสตรีมภายใต้ฝาครอบ
โฟกัสที่การตั้งค่าตัวเลือก stream การวนซ้ำผ่าน chunks และการประกอบการตอบสนองที่สมบูรณ์จากชิ้นส่วนต่างๆ
สำหรับอะไรก็ตามที่คนจริงจะใช้ การสตรีมมักจะเป็นตัวเลือกที่ถูกต้องเสมอ
ไม่มีใครอยากจ้องมอง spinner เป็นเวลาสิบวินาที
ต้นทุน ความล้มเหลว และแนวคิดด้านความปลอดภัยหนึ่งอย่าง
สามสิ่งที่แยกโปรเจกต์งานอดิเรกออกจากสิ่งที่คุณจะนำไปให้ผู้ใช้จริง
ต้นทุนและโทเค็น: โมเดลคิดค่าบริการต่อโทเค็น ซึ่งประมาณสามในสี่ของคำ
โทเค็นอินพุตและเอาต์พุตมีราคาต่างกัน
เรียนรู้ที่จะประมาณว่าคำขอหนึ่งๆ จะมีค่าใช้จ่ายเท่าไหร่ก่อนที่จะส่ง เก็บหน้าเว็บราคาของผู้ให้บริการไว้ในบุ๊กมาร์ก และซึมซับกฎข้อหนึ่งที่ช่วยประหยัดเงินจริงๆ: อย่าใช้โมเดลที่ใหญ่ที่สุดและแพงที่สุดสำหรับงานง่ายๆ
โมเดลที่ถูกกว่ามักจะดีพอ และความแตกต่างของต้นทุนในระดับใหญ่นั้นมหาศาล
การจัดการความล้มเหลว: API ล้มเหลว
มีการจำกัดอัตราการเรียกใช้ (rate limits) คำขอหมดเวลา โมเดลส่งคืนผลลัพธ์ที่ผิดรูป
การจัดการสิ่งนี้อย่างสง่างามคือสิ่งที่ทำให้บางอย่างพร้อมสำหรับการผลิต
เรียนรู้ที่จะจับข้อผิดพลาด rate-limit และลองใหม่โดยเพิ่มระยะเวลารอระหว่างแต่ละครั้ง เรียกว่า exponential backoff
ไลบรารี Tenacity ใน Python ทำสิ่งนี้ด้วย decorator เดียว
เรียนรู้ที่จะตรวจสอบความถูกต้องของผลลัพธ์ของโมเดลก่อนที่จะเชื่อถือ และอย่าปล่อยให้การตอบสนองที่ไม่คาดคิดทำให้แอปทั้งหมดของคุณพัง
การฉีด prompt (Prompt injection) โดยสังเขป: นี่คือความเสี่ยงด้านความปลอดภัยอันดับต้นๆ ในแอป LLM
มันเกิดขึ้นเมื่ออินพุตของผู้ใช้ที่ไม่น่าเชื่อถือถูกรวมเข้ากับคำแนะนำของคุณ ทำให้ผู้ใช้สามารถแทนที่หรือแย่งชิงสิ่งที่ระบบของคุณทำ
คุณไม่จำเป็นต้องเป็นผู้เชี่ยวชาญด้านความปลอดภัยในเดือนนี้ แต่คุณต้องรู้ว่ามันมีอยู่ก่อนที่จะส่งอะไรออกไป
คู่มือ OWASP เกี่ยวกับเรื่องนี้เป็นข้อมูลอ้างอิงที่เชื่อถือได้
การป้องกันหลัก: อย่าเชื่อถือผลลัพธ์ของโมเดลที่ไม่ได้รับการตรวจสอบเพื่อดำเนินการที่สำคัญโดยอัตโนมัติ และให้สิทธิ์การเข้าถึงเครื่องมือของคุณน้อยที่สุดเท่าที่จำเป็นในการทำงาน
ความสำเร็จของเดือนที่ 2
ภายในสิ้นเดือนนี้ คุณควรจะสามารถเขียน prompt ที่สร้างผลลัพธ์ที่เชื่อถือได้สำหรับงานที่กำหนด ดึง JSON ที่มีโครงสร้างออกจากโมเดลด้วย Pydantic และ Instructor เชื่อมต่อการเรียกใช้เครื่องมือเพื่อให้โมเดลสามารถรันฟังก์ชัน Python ของคุณ สตรีมการตอบสนองแบบเรียลไทม์ จัดการประวัติการสนทนาแบบหลายเทิร์น ประมาณการต้นทุนโทเค็นของคำขอก่อนที่จะส่ง จัดการข้อผิดพลาดของ API และผลลัพธ์ที่ไม่ดีโดยไม่ทำให้ระบบพัง และอธิบายได้ว่าการฉีด prompt คืออะไร
นั่นคือชุดทักษะที่ใช้งานได้จริงและมีมูลค่าในตัวเอง
ฟีเจอร์ AI แบบเสียเงินมากมายในระบบการผลิตทำเพียงเท่านี้และไม่มากไปกว่านี้
แต่เดือนหน้านี้คือที่ที่คุณจะสร้างสิ่งที่ทำให้คุณได้งานจริงๆ
เดือนที่ 3: RAG และ agents ทักษะที่ทำให้คุณได้งาน
เป้าหมายของคุณในเดือนนี้: สร้างระบบที่ให้โมเดลสามารถตอบคำถามจากเอกสารของคุณแทนที่จะเป็นเพียงข้อมูลที่ใช้ฝึก และสร้างระบบที่สามารถดำเนินการหลายขั้นตอนได้ด้วยตัวเอง
ทักษะสองอย่างนี้ การดึงข้อมูล (retrieval) และ agents เป็นความสามารถเชิงปฏิบัติที่เป็นที่ต้องการมากที่สุดในวิศวกรรม AI ในขณะนี้
เกือบทุกกรณีการใช้งานในบริษัทจริง ตั้งแต่บอทช่วยเหลือไปจนถึงเครื่องมือความรู้ภายในและการวิเคราะห์เอกสาร ล้วนสร้างขึ้นจากสิ่งเหล่านี้
ฉันได้บีบอัดสิ่งที่แผนงานอื่นๆ กระจายไปสองเดือนให้เป็นเดือนเดียว เพราะคุณไม่จำเป็นต้องเชี่ยวชาญทุกรูปแบบขั้นสูงเพื่อให้มีงานทำ
คุณต้องสร้างระบบดึงข้อมูลที่แข็งแกร่งหนึ่งระบบและ agent ที่แข็งแกร่งหนึ่งระบบ เข้าใจว่าทำไมแต่ละชิ้นส่วนจึงอยู่ตรงนั้น และสามารถแก้ไขข้อบกพร่องเมื่อมันพังได้
นั่นคือเกณฑ์ มาถึงกันเถอะ
RAG อธิบายด้วยภาษาง่ายๆ ก่อน
RAG ย่อมาจาก retrieval-augmented generation
ตัดศัพท์เทคนิคออกไป มันก็เรียบง่าย: คุณให้ห้องสมุดแก่โมเดลเพื่อค้นหาข้อมูล ดังนั้นมันไม่จำเป็นต้องจำทุกอย่าง และมันสามารถตอบคำถามเกี่ยวกับเอกสารเฉพาะของคุณได้
ขั้นตอนคือ: คุณนำเอกสารของคุณมา แบ่งเป็นชิ้นเล็กๆ (chunks) แปลงแต่ละชิ้นเป็นรายการตัวเลขที่จับความหมายของมัน และจัดเก็บไว้
เมื่อผู้ใช้ถามคำถาม คุณแปลงคำถามของพวกเขาเป็นตัวเลขในลักษณะเดียวกัน ค้นหาชิ้นส่วนที่มีตัวเลขใกล้เคียงที่สุด และส่งชิ้นส่วนเหล่านั้นให้กับโมเดลพร้อมกับคำถาม
โมเดลตอบโดยใช้สิ่งที่คุณให้ไป นั่นคือ RAG อย่างอื่นคือการปรับปรุง
มาสร้างชิ้นส่วนต่างๆ กัน
Embeddings
Embedding คือข้อความชิ้นหนึ่งที่ถูกแปลงเป็นรายการตัวเลขยาวๆ ซึ่งแสดงถึงความหมายของมัน
คุณสมบัติที่มีประโยชน์: ข้อความที่มีความหมายคล้ายกันจะลงเอยด้วยตัวเลขที่คล้ายกัน อยู่ใกล้กันในพื้นที่ตัวเลขนี้
ความใกล้ชิดนี้คือสิ่งที่ทำให้การค้นหาตามความหมายเป็นไปได้ ซึ่งเป็นกลไกเบื้องหลัง RAG
ตัวเลือกของฉันสำหรับการสร้างความเข้าใจโดยสัญชาตญาณ: บทนำที่เข้าใจง่ายของบล็อก Stack Overflow เกี่ยวกับ text embeddings ซึ่งเน้นที่โมเดลทางความคิดมากกว่าคณิตศาสตร์ พร้อมกับคู่มือ embeddings ของ OpenAI เมื่อคุณพร้อมที่จะสร้างมันในโค้ด
โฟกัสที่การทำความเข้าใจว่า vector คืออะไรในเชิงแนวคิด ทำไมข้อความที่คล้ายกันจึงสร้าง vector ที่คล้ายกัน และโดยคร่าวๆ คุณจะวัดระยะห่างระหว่าง vector สองตัวได้อย่างไร
คุณไม่จำเป็นต้องมีคณิตศาสตร์เบื้องหลังการสร้าง embeddings คุณจำเป็นต้องรู้วิธีใช้มัน
การสร้างชิ้นเล็กๆ ที่สอนแนวคิดนี้อย่างสมบูรณ์: นำ 20 ประโยคในหัวข้อที่เกี่ยวข้องกัน มาแปลงแต่ละประโยคเป็น embedding และเขียนฟังก์ชันเล็กๆ ที่เมื่อได้รับประโยคใหม่ จะส่งคืนสามประโยคที่คล้ายคลึงกันมากที่สุดจากชุดของคุณ
นั่นคือ RAG ในรูปแบบจำลอง เมื่อคุณสร้างสิ่งนี้ได้แล้ว เวอร์ชันเต็มก็เป็นเพียงแนวคิดเดียวกันในขนาดที่ใหญ่ขึ้น
การแบ่งเป็นชิ้น (Chunking)
เอกสารของคุณใหญ่เกินไปที่จะ embed ทั้งหมด ดังนั้นคุณจึงแบ่งมันเป็นชิ้นเล็กๆ ก่อนที่จะ embed
วิธีการแบ่งของคุณควบคุมโดยตรงว่าระบบของคุณจะค้นหาข้อมูลที่ถูกต้องได้ดีเพียงใด
แม้แต่การตั้งค่าการดึงข้อมูลที่สมบูรณ์แบบก็ล้มเหลวหากชิ้นส่วนพื้นฐานไม่ดี
ตัวเลือกของฉัน: เริ่มต้นด้วย RecursiveCharacterTextSplitter ของ LangChain โดยมีขนาด chunk ประมาณ 500 ตัวอักษร และ overlap ประมาณ 50
overlap นั้นสำคัญ เพราะมันช่วยไม่ให้คุณสูญเสียความหมายที่ขอบเขตระหว่าง chunk หนึ่งสิ้นสุดและอีก chunk หนึ่งเริ่มต้น
นี่คือค่าเริ่มต้นที่สมเหตุสมผลซึ่งจะให้พื้นฐานการทำงานแก่คุณ
ข้อแลกเปลี่ยนหลักที่ต้องจำไว้ในหัว: chunk ที่ใหญ่เกินไปจะสูญเสียความแม่นยำ chunk ที่เล็กเกินไปจะสูญเสียบริบท
เริ่มต้นด้วยค่าเริ่มต้น จากนั้นปรับตามสิ่งที่การดึงข้อมูลของคุณทำผิด
ฐานข้อมูล Vector (Vector databases)
เมื่อคุณมี embeddings แล้ว คุณต้องมีที่ไหนสักแห่งในการจัดเก็บและค้นหาพวกมันอย่างรวดเร็ว นั่นคือสิ่งที่ฐานข้อมูล vector ทำ
ตัวเลือกของฉันสำหรับการเรียนรู้: Chroma มันทำงานในเครื่องโดยไม่ต้องตั้งค่าโครงสร้างพื้นฐานใดๆ ซึ่งเป็นสิ่งที่คุณต้องการในขณะที่เรียนรู้
คุณยังไม่ต้องการระบบคลาวด์ที่มีการจัดการในระดับใหญ่ และการเพิ่มมันตั้งแต่เนิ่นๆ ก็แค่เพิ่มสิ่งที่ต้องกำหนดค่าและทำให้พัง
Chroma ช่วยให้คุณโฟกัสที่แนวคิดต่างๆ
ค้นหาได้ที่ docs.trychroma.com
เรียนรู้ที่จะสร้าง collection แทรก embeddings พร้อมกับ metadata เช่น แหล่งที่มาและส่วน ค้นหาด้วยความคล้ายคลึงเพื่อให้ได้ผลลัพธ์สูงสุด และกรองตาม metadata ในเวลาที่ค้นหา
คุณไม่จำเป็นต้องเข้าใจอัลกอริทึมการจัดทำดัชนีเบื้องหลัง คุณจำเป็นต้องใช้มัน
เมื่อคุณต้องการขนาดการผลิตในที่สุด pgvector คือขั้นตอนต่อไปตามธรรมชาติหากแอปของคุณใช้ฐานข้อมูล Postgres อยู่แล้ว และมีตัวเลือกที่มีการจัดการเมื่อคุณต้องการให้คนอื่นรันมัน
แต่นั่นเป็นความกังวลของเดือนที่ 4 หรือในที่ทำงาน สำหรับตอนนี้ Chroma ในเครื่องก็เพียงพอแล้ว
ทำให้การดึงข้อมูลดีจริงๆ
การค้นหาความคล้ายคลึงพื้นฐานทำให้คุณได้ตัวอย่าง
การปรับแต่งเล็กน้อยสองสามอย่างทำให้คุณได้สิ่งที่ทำงานได้อย่างน่าเชื่อถือ และการรู้สิ่งเหล่านี้คือสิ่งที่แยกคนที่คัดลอกบทช่วยสอนออกจากคนที่เข้าใจระบบ
การกรอง Metadata: ติดแท็กทุก chunk ด้วยข้อมูลที่เป็นประโยชน์เมื่อคุณจัดเก็บ เช่น ไฟล์ต้นฉบับ วันที่ ส่วน หรือหมวดหมู่
จากนั้นกรองตามสิ่งเหล่านั้นในเวลาที่ค้นหา นี่คือความแตกต่างระหว่างของเล่นกับระบบที่ผู้ใช้สามารถถามว่า "แสดงเฉพาะผลลัพธ์จากรายงาน Q4" และได้รับผลลัพธ์นั้นจริงๆ
การจัดลำดับใหม่ (Reranking): การค้นหาครั้งแรกของคุณนั้นเร็วแต่เป็นค่าประมาณ
ตัวจัดลำดับใหม่จะนำผลลัพธ์สองสามอันดับแรกมาคิดคะแนนใหม่เพื่อหาความเกี่ยวข้องที่แท้จริงกับคำถาม ซึ่งช่วยปรับปรุงคุณภาพได้อย่างเห็นได้ชัดโดยแลกกับความเร็วที่ลดลงเล็กน้อย
รูปแบบคือ: ดึงชุดกว้างๆ อย่างรวดเร็ว จากนั้นจัดลำดับใหม่ให้เหลือเพียงไม่กี่อันที่ดีที่สุด เอกสารการจัดลำดับใหม่ของ Cohere เป็นสถานที่ที่สะอาดที่สุดในการเรียนรู้สิ่งนี้ และบ่อยครั้งที่มันเป็นเพียงหนึ่งบรรทัดที่จะเพิ่ม
การแก้ไขปัญหาการดึงข้อมูล เพราะความล้มเหลวของ RAG ส่วนใหญ่เป็นความล้มเหลวในการดึงข้อมูล ไม่ใช่ความล้มเหลวของโมเดล
เมื่อระบบของคุณให้คำตอบที่ไม่ดี โมเดลมักจะไม่ใช่ปัญหา
การดึงข้อมูลส่ง chunk ที่ผิดมาให้
เรียนรู้รูปแบบความล้มเหลวทั่วไป: คำถามและ chunk ที่เกี่ยวข้องไม่ตรงกันในพื้นที่ตัวเลขแม้ว่าข้อมูลจะอยู่ที่นั่น (แก้ไขได้โดยการเขียน query ใหม่) ข้อมูลที่เกี่ยวข้องถูกแบ่งออกเป็นสอง chunk (แก้ไขได้ด้วย overlap ที่มากขึ้น) หรือ chunk ที่ถูกต้องมีอยู่แต่ไม่ติดอันดับผลลัพธ์สูงสุด (แก้ไขได้โดยการดึงข้อมูลมากขึ้น แล้วจัดลำดับใหม่)
เมื่อคำตอบผิด ให้ตรวจสอบสิ่งที่ถูกดึงมาก่อนที่จะโทษโมเดล นิสัยนี้เพียงอย่างเดียวจะช่วยคุณประหยัดความหงุดหงิดได้มหาศาล
การยึดหลักความเป็นจริงและการอ้างอิง (Grounding and citations): ระบบ RAG ที่ดีไม่เพียงแค่ตอบคำถาม แต่ยังบอกด้วยว่าคำตอบมาจากไหน ซึ่งสร้างความไว้วางใจและทำให้การแก้ไขข้อบกพร่องง่ายขึ้นมาก
ส่งข้อมูลแหล่งที่มาสำหรับแต่ละ chunk ไปใน prompt ของคุณ และสั่งให้โมเดลอ้างอิงมัน
นี่คือ artifact ชิ้นที่สามของคุณ prompt การยึดหลักความเป็นจริงที่ทำให้ระบบ RAG ซื่อสัตย์
นี่คือสิ่งที่ฉันจะบุ๊กมาร์กไว้เหนือสิ่งอื่นใด เพราะมันคือความแตกต่างระหว่างระบบที่สร้างเรื่องขึ้นมากับระบบที่คุณวางใจได้
Prompt: การตอบ RAG ที่ยึดหลักความเป็นจริง (Grounded RAG answering)
(กรอบแนวคิด: FAG Grounding, โดย AI Guides)
1หน้าที่ของคุณ: ตอบคำถามของผู้ใช้โดยใช้เฉพาะบริบทที่ให้มาเท่านั้น23สิ่งที่ต้องทำ:4- อ่าน chunk บริบทด้านล่าง แต่ละ chunk มีป้ายกำกับแหล่งที่มา5- ตอบคำถามโดยใช้เฉพาะข้อมูลที่พบในบริบท6- หลังจากการอ้างสิทธิ์แต่ละครั้ง ให้อ้างอิงป้ายกำกับแหล่งที่มาที่ข้อมูลนั้นมาจาก เช่น [source: filename, p.3]7- หากบริบทไม่มีคำตอบ ให้พูดว่า:8 "ฉันไม่มีข้อมูลเพียงพอในเอกสารที่ให้มาเพื่อตอบคำถามนั้น"910กฎ:11- ห้ามใช้ความรู้จากภายนอกบริบทที่ให้มา12- ห้ามเดา ห้ามเติมช่องว่างด้วยสิ่งที่ฟังดูเป็นไปได้13- หากบริบทตอบคำถามได้บางส่วน ให้ตอบในส่วนนั้นและบอกให้ชัดเจนว่าส่วนใดขาดหายไป1415บริบท:16[วาง CHUNK ที่ดึงมาพร้อมป้ายกำกับแหล่งที่มาที่นี่]1718คำถาม:19[คำถามของผู้ใช้ที่นี่]
คำสั่ง "พูดแบบนี้เมื่อคุณไม่รู้" นั้นกำลังทำงานหนัก มันเป็นวิธีที่มีประสิทธิภาพที่สุดวิธีเดียวในการลดภาพหลอน (hallucinations) ในระบบการดึงข้อมูล เพราะมันให้วิธีที่ได้รับการอนุมัติแก่โมเดลในการยอมรับความไม่รู้แทนที่จะสร้างคำตอบขึ้นมาเพื่อให้ดูมีประโยชน์
การสร้าง RAG ของคุณ
ใช้เฟรมเวิร์กเพื่อเชื่อมโยงสิ่งนี้เข้าด้วยกัน แทนที่จะสร้างทุกชิ้นส่วนตั้งแต่เริ่มต้น
ตัวเลือกของฉันสำหรับระบบ RAG ระบบแรกคือ LlamaIndex ซึ่งถูกสร้างขึ้นโดยเน้นการค้นหาเป็นอันดับแรก และทำให้คุณได้ไปป์ไลน์ที่ใช้งานได้ด้วยโค้ดจำนวนไม่มาก
LangChain เป็นอีกตัวเลือกหลักและโดดเด่นกว่าสำหรับงาน agent แบบหลายขั้นตอนที่จะเกิดขึ้นต่อไป ดังนั้นคุณจะได้พบมันในอีกสักครู่
เป้าหมายการสร้างของคุณ และนี่คือผลงานพอร์ตโฟลิโอจริงๆ: แอป "แชทกับเอกสารของคุณ"
นำเข้าไฟล์ PDF หรือข้อความ 10 ถึง 20 ไฟล์ บันทึกส่วนตัวของคุณหรือชุดเอกสารผลิตภัณฑ์ก็ใช้ได้ดี สร้างบางสิ่งที่รับคำถาม ดึงข้อมูล chunk ที่เกี่ยวข้องมากที่สุดด้วยการจัดลำดับใหม่ และส่งคืนคำตอบพร้อมการอ้างอิง
ใส่ส่วนติดต่อที่เรียบง่ายลงไป
นี่คือโปรเจกต์ที่ทำให้ผู้จัดการฝ่ายจ้างงานพิจารณาคุณอย่างจริงจัง เพราะมันเป็นประเภทของสิ่งที่บริษัทต่างๆ กำลังจ่ายเงินเพื่อสร้างในขณะนี้
Agents
ครึ่งทางของเดือน ให้เปลี่ยนไปที่ agents
Agent ฟังดูวิเศษและจริงๆ แล้วเรียบง่ายเมื่อคุณเห็นมัน: มันคือลูปที่โมเดลตัดสินใจขั้นตอนถัดไปซ้ำๆ ดำเนินการโดยใช้เครื่องมือ ดูผลลัพธ์ และตัดสินใจอีกครั้ง จนกว่างานจะเสร็จ
โมเดลทางความคิด: agent คือ while loop ที่มีโมเดลเป็นผู้ตัดสินใจแตกแขนง
การคิดเกิดขึ้นใน prompt การแตกแขนงคือโมเดลที่เลือกว่าจะใช้เครื่องมือใด การลงมือทำคือโค้ดของคุณที่รันเครื่องมือนั้น
ทุกอย่างอื่นคือระบบท่อ เมื่อเข้าใจสิ่งนี้แล้ว แม้แต่เฟรมเวิร์ก agent ที่ซับซ้อนก็อ่านเข้าใจได้
ตัวเลือกของฉัน และฉันจะอ่านสิ่งนี้ก่อนที่จะเขียนโค้ด agent แม้แต่บรรทัดเดียว: "Building Effective Agents" ของ Anthropic
มันเป็นงานเขียนที่ชัดเจนที่สุดเกี่ยวกับวิธีการทำงานของ agents ในทางปฏิบัติ จากทีมที่สร้างโมเดล
จับคู่กับหลักสูตรเฟรมเวิร์กเชิงปฏิบัติเมื่อคุณพร้อมที่จะสร้าง เช่น บทนำสู่ LangGraph ซึ่งเป็นเฟรมเวิร์กที่ใช้กันอย่างแพร่หลายที่สุดสำหรับการจัด orchestration ของ agents
สิ่งที่ต้องโฟกัส: ลูปของการรับรู้ ตัดสินใจ ลงมือทำ สังเกต และวิธีที่มันรู้ว่าเมื่อใดควรหยุด
จะเกิดอะไรขึ้นเมื่อการเรียกใช้เครื่องมือล้มเหลวภายในลูป วิธีเขียนคำอธิบายเครื่องมือที่โมเดลสามารถใช้ได้จริง เพราะเครื่องมือที่อธิบายอย่างคลุมเครือจะถูกเรียกใช้ผิดหรือถูกมองข้าม
และการจัดการสถานะ (state) ซึ่งเป็นหน่วยความจำที่ใช้ร่วมกันที่ไหลผ่าน agent ในขณะที่มันทำงาน
แบบฝึกหัดที่มีค่าที่สุดเพียงอย่างเดียวในเดือนนี้: สร้าง agent ขนาดเล็กตั้งแต่เริ่มต้นโดยไม่มีเฟรมเวิร์กใดๆ เลย โดยใช้เฉพาะ API ของโมเดลโดยตรง
ให้เครื่องมือสามอย่าง เป้าหมายหนึ่งอย่าง และลูปหนึ่งอัน สิ่งนี้สอนคุณถึงสิ่งที่เฟรมเวิร์กซ่อนไว้ และมันทำให้ทุกเฟรมเวิร์กที่คุณสัมผัสหลังจากนั้นเข้าใจได้ง่ายขึ้น
ทำสิ่งนี้ก่อนที่จะแตะ LangGraph
เมื่อใดที่ไม่ควรใช้ agent
นี่คือหนึ่งในทักษะที่ถูกมองข้ามมากที่สุดในสาขานี้ และการรู้มันบ่งบอกว่าคุณเป็นคนมีวิจารณญาณ ไม่ใช่คนที่ไล่ตามสิ่งใหม่ๆ ที่แวววาว
Agents นั้นน่าตื่นเต้น และพวกมันก็ช้ากว่า แพงกว่า คาดเดาได้น้อยกว่า และแก้ไขข้อบกพร่องได้ยากกว่าวิธีการที่ง่ายกว่า
การเลือกสิ่งที่ง่ายที่สุดที่ใช้ได้เป็นสัญญาณว่าคุณรู้ว่ากำลังทำอะไรอยู่
กรอบการตัดสินใจ ที่ควรค่าแก่การจดจำ: ใช้การเรียกใช้โมเดลครั้งเดียวหากงานนั้นพอดีกับ prompt เดียวที่มีบริบทที่ถูกต้อง
ใช้เวิร์กโฟลว์คงที่ ซึ่งเป็นห่วงโซ่ของขั้นตอนที่คุณกำหนด หากขั้นตอนต่างๆ สามารถคาดเดาได้
ใช้ agent เฉพาะเมื่อจำนวนขั้นตอนไม่สามารถคาดเดาได้อย่างแท้จริง และจำเป็นต้องให้โมเดลตัดสินใจแบบไดนามิก
ห่วงโซ่ของการเรียกใช้คงที่สามครั้งจะเร็วกว่า ถูกกว่า และแก้ไขข้อบกพร่องได้ง่ายกว่า agent ที่อาจต้องเรียกใช้สามครั้งเสมอ สำรอง agents ไว้สำหรับงานที่เปิดกว้างอย่างแท้จริง
ระหว่างการเรียกใช้ครั้งเดียวและ agent เต็มรูปแบบ มีพื้นที่ตรงกลางที่กว้างใหญ่และมีประสิทธิผล: เวิร์กโฟลว์
การต่อกัน (Chaining) โดยที่เอาต์พุตของการเรียกใช้หนึ่งป้อนเข้าสู่การเรียกใช้ถัดไป
การกำหนดเส้นทาง (Routing) โดยที่คุณจำแนกประเภทอินพุตและส่งไปยังตัวจัดการเฉพาะทาง
การทำขนาน (Parallelization) โดยที่คุณรันการเรียกใช้หลายครั้งพร้อมกันและรวมผลลัพธ์
ปัญหาจริงส่วนใหญ่แก้ไขได้ดีที่สุดด้วยเวิร์กโฟลว์ ไม่ใช่ agent และบทความเกี่ยวกับ agents ของ Anthropic ครอบคลุมรูปแบบเหล่านี้ได้ดี
การประเมินผล (Evals) โดยสังเขปแต่จริงจัง
คุณจำเป็นต้องรู้ว่าระบบของคุณใช้งานได้จริงหรือไม่ ไม่ใช่แค่ว่ามันทำงานกับสองตัวอย่างที่คุณลองด้วยมือหรือไม่
นั่นคือจุดประสงค์ของการประเมินผล สร้างชุดอินพุตที่เป็นตัวแทนจำนวน 20 ถึง 30 รายการพร้อมกับเอาต์พุตที่คาดหวังหรือเกณฑ์การให้คะแนน และรันระบบของคุณกับทั้งหมดนั้นทุกครั้งที่คุณเปลี่ยน prompt สลับโมเดล หรือปรับการดึงข้อมูลของคุณ
เครื่องมือเช่น DeepEval สำหรับการใช้งานทั่วไป และ Ragas สำหรับ RAG โดยเฉพาะ ทำให้สิ่งนี้จัดการได้
กรอบความคิดที่สำคัญกว่าเครื่องมือ: ทุกการเปลี่ยนแปลง prompt หรือการสลับโมเดลที่คุณทำโดยไม่รันการประเมินผลคือการพนัน
คนที่ส่งมอบ AI ที่เชื่อถือได้รันการประเมินผลอย่างต่อเนื่อง และการเริ่มนิสัยนี้ตอนนี้ แม้เพียงเล็กน้อย ก็ทำให้คุณนำหน้าหลายคนที่ทำงานในสาขานี้อยู่แล้ว
ความสำเร็จของเดือนที่ 3
ภายในสิ้นเดือนนี้ คุณควรจะสามารถอธิบายได้ว่า embedding คืออะไรและทำไมข้อความที่คล้ายกันจึงสร้าง vector ที่คล้ายกัน แบ่งเอกสารอย่างสมเหตุสมผล จัดเก็บและค้นหา embeddings ในฐานข้อมูล vector พร้อมการกรอง metadata เพิ่มการจัดลำดับใหม่เพื่อปรับปรุงผลลัพธ์ แก้ไขปัญหาความล้มเหลวในการดึงข้อมูลแทนที่จะโทษโมเดล สร้างไปป์ไลน์ RAG ที่สมบูรณ์ซึ่งส่งคืนคำตอบที่ยึดหลักความเป็นจริงพร้อมการอ้างอิง ใช้ลูป agent ตั้งแต่เริ่มต้น ตัดสินใจได้อย่างถูกต้องว่างานนั้นต้องการการเรียกใช้ครั้งเดียว เวิร์กโฟลว์ หรือ agent และรันการประเมินผลพื้นฐานเพื่อตรวจสอบงานของคุณ
นั่นคือแกนหลักที่ทำให้มีงานทำ
หากเดือนที่ 1 ถึง 3 แข็งแกร่ง คุณสามารถสร้างสิ่งที่บริษัทต่างๆ กำลังจ้างให้ทำได้
เดือนที่ 4 是关于การพิสูจน์และรับเงิน
เดือนที่ 4: ส่งมอบ แสดงให้เห็น และได้งานทำ
เป้าหมายของคุณในเดือนนี้: นำทุกสิ่งที่คุณสร้างขึ้นมาทำให้เป็นจริง จากนั้นเปลี่ยนเป็นงานหรือรายได้
นี่คือจุดที่คนส่วนใหญ่ติดขัด
พวกเขาสามารถสร้างตัวอย่างได้ แต่ไม่สามารถส่งมอบสิ่งที่อยู่รอดในการใช้งานจริงได้ และพวกเขาไม่สามารถเปลี่ยนทักษะเป็นรายได้
เดือนนี้แก้ไขทั้งสองอย่าง มันสั้นกว่าในแนวคิดใหม่และหนักกว่าในการลงมือทำ เพราะถึงจุดนี้การลงมือทำคือสิ่งที่สำคัญ
การปรับใช้ที่เพียงพอที่จะเป็นอันตราย
คุณไม่จำเป็นต้องเป็นผู้เชี่ยวชาญด้านโครงสร้างพื้นฐาน
คุณต้องสามารถนำแอป AI ที่ใช้งานได้ไปไว้ที่ไหนสักแห่งที่คนจริงสามารถใช้มันได้ โดยที่มันไม่พังหรือทำให้คุณล้มละลาย
ความรู้ขั้นต่ำที่จำเป็น: เรียนรู้ Docker ให้มากพอที่จะแพ็คเกจแอปของคุณเพื่อให้มันทำงานเหมือนกันทุกที่ ซึ่งจะกำจัดปัญหา "มันทำงานบนเครื่องของฉัน"
เรียนรู้ที่จะปรับใช้คอนเทนเนอร์นั้นที่ไหนสักแห่ง
และเรียนรู้พื้นฐานด้านต้นทุนและความน่าเชื่อถือที่หยุดไม่ให้บั๊กกลายเป็นหายนะ: ตั้งขีดจำกัดการใช้จ่ายแบบตายตัวในบัญชี API ของคุณ เพิ่ม caching เพื่อที่คุณจะได้ไม่ต้องจ่ายสำหรับคำขอเดียวกันสองครั้ง และเพิ่มการจำกัดอัตรา (rate limiting) เพื่อให้ผู้ใช้คนเดียวไม่สามารถทำให้ค่าใช้จ่ายของคุณพุ่งสูงขึ้น
คู่มือเริ่มต้นใช้งานอย่างเป็นทางการของ Docker ครอบคลุมการแพ็คเกจ
สำหรับด้านต้นทุนเฉพาะ AI การเคลื่อนไหวหลักคือการแคชคำขอที่เหมือนกัน การใช้โมเดลที่ถูกกว่าในที่ที่มันดีพอ และการตั้งค่าขีดจำกัดการใช้จ่ายรายเดือนแบบตายตัวเพื่อให้ลูปที่หนีไม่พ้นไม่สามารถทำให้คุณเสียเงิน 500 ดอลลาร์ในชั่วข้ามคืน
คุณยังต้องการการสังเกตการณ์ (observability) ขั้นพื้นฐาน ซึ่งเป็นคำศัพท์แฟนซีสำหรับความสามารถในการเห็นว่าแอปของคุณกำลังทำอะไรอยู่
แอป LLM มีปัญหาเฉพาะ: โมเดลสามารถส่งคืนการตอบสนองที่ประสบความสำเร็จอย่างสมบูรณ์แบบแต่ไร้ประโยชน์หรือผิดพลาด และการตรวจสอบปกติจะไม่จับสิ่งนั้น
เครื่องมือเช่น Langfuse ติดตามทุกการเรียกใช้โมเดล แสดง prompt การตอบสนอง ต้นทุนโทเค็น และเวลาแฝง ซึ่งทำให้การแก้ไขข้อบกพร่องและการควบคุมต้นทุนง่ายขึ้นมาก
ตั้งค่าสิ่งนี้ในโปรเจกต์เดียวเพื่อให้คุณเข้าใจรูปแบบ
อย่าลงทุนมากเกินไปที่นี่
แอปเดียว ปรับใช้อย่างถูกต้อง พร้อมการควบคุมต้นทุนและการติดตามพื้นฐาน สอนทุกสิ่งที่คุณต้องการและให้สิ่งที่เป็นจริงแก่คุณในการแสดง
ความลึกในการปรับใช้สามารถมาได้ในที่ทำงาน
ส่วนที่แผนงานอื่นๆ ทุกอันข้ามไป: การเปลี่ยนโปรเจกต์ให้เป็นงาน
คุณได้สร้างโปรเจกต์จริงสามโปรเจกต์แล้ว ตอนนี้ทำให้มันทำงานเพื่อคุณ เพราะโปรเจกต์ที่ยอดเยี่ยมที่ไม่มีใครเห็นนั้นไม่ช่วยอะไรในอาชีพการงานของคุณ
พอร์ตโฟลิโอของคุณคือโปรเจกต์ที่ปรับใช้แล้วสามโปรเจกต์ แต่ละโปรเจกต์มี README ที่ทำงานจริง
และนี่คือการเคลื่อนไหวที่แทบไม่มีใครทำ ซึ่งเป็นสิ่งที่ทำให้คุณโดดเด่น: ใน README แต่ละอัน ให้รวมส่วนเกี่ยวกับสิ่งที่ผิดพลาดและสิ่งที่คุณจะทำแตกต่างออกไป
พอร์ตโฟลิโอส่วนใหญ่แสร้งทำเป็นว่าทุกอย่างทำงานได้อย่างสมบูรณ์แบบ ซึ่งอ่านแล้วดูไม่ซื่อสัตย์หรือตื้นเขิน
README ที่พูดว่า "นี่คือจุดที่แนวทางแรกของฉันล้มเหลว นี่คือสิ่งที่ฉันเรียนรู้ นี่คือวิธีที่ฉันแก้ไข" ส่งสัญญาณถึงวิจารณญาณที่นายจ้างบอกว่าพวกเขากำลังคัดกรองหาอยู่ในตอนนี้
มันคือความได้เปรียบของผู้เปลี่ยนสายงานจากบทนำ ที่ทำให้มองเห็นได้
ไม่มีใครคาดหวังให้ผู้เปลี่ยนสายงานมีโปรเจกต์ที่สมบูรณ์แบบ พวกเขาประทับใจกับคนที่เข้าใจงานของตัวเองอย่างลึกซึ้งพอที่จะวิจารณ์มัน
จัดโครงสร้าง README แต่ละอันแบบนี้: ปัญหาที่โปรเจกต์แก้ไข ใครจะใช้ แนวทางที่คุณใช้และเพราะอะไร สิ่งที่ผิดพลาดและสิ่งที่คุณเรียนรู้ และวิธีรันมัน
ห้าส่วน
นั่นคือพอร์ตโฟลิโอที่ดีกว่าคนส่วนใหญ่ที่จบปริญญาตรีสาขาวิทยาการคอมพิวเตอร์
การเคลื่อนไหวด้านเรซูเม่และโปรไฟล์: คุณไม่จำเป็นต้องแสร้งทำเป็นว่าคุณมีประสบการณ์หลายปี
คุณต้องการหนึ่งบรรทัดที่ชัดเจนซึ่งบอกว่าคุณทำอะไรได้บ้าง
บางอย่างเช่น "ฉันสร้างแอปพลิเคชัน LLM สำหรับการผลิต: ระบบ RAG, agents และการรวม API นี่คือสามสิ่งที่ฉันได้ส่งมอบ"
จากนั้นลิงก์ไปยังโปรเจกต์ต่างๆ อาชีพปัจจุบันของคุณคือทรัพย์สิน ไม่ใช่สิ่งที่ต้องซ่อน
"อดีต [สาขาของคุณ] ที่ตอนนี้สร้างระบบ AI" เป็นเรื่องราวที่แข็งแกร่งกว่า "นักพัฒนาระดับจูเนียร์" เพราะมันมาพร้อมกับความรู้เฉพาะด้านและวิจารณญาณที่นักพัฒนาระดับจูเนียร์บริสุทธิ์ขาด
หากคุณกำลังเปลี่ยนสายงานมาจากการเงิน คุณเข้าใจปัญหาทางการเงินที่ AI สามารถแก้ไขได้
หากคุณกำลังเปลี่ยนสายงานมาจากการดูแลสุขภาพ ก็เช่นกัน จงใช้ประโยชน์จากจุดนั้น
การสร้างผลงานในที่สาธารณะเพื่อเป็นช่องทางหาโอกาส: ตลอดทั้งเดือนนี้ จงโพสต์สิ่งที่คุณสร้างและสิ่งที่คุณเรียนรู้ต่อไป
โอกาสที่ดีที่สุดที่ฉันเคยเห็นมักตกเป็นของคนที่เปิดเผยตัวตน ไม่ใช่คนที่ส่งใบสมัครเงียบๆ ไป 500 ตำแหน่ง
เขียนเกี่ยวกับโปรเจกต์ของคุณ แบ่งปันข้อผิดพลาดที่คุณแก้ไขได้ ผลทบต้นนั้นมีจริง และตอนนี้คุณมีผลงานจริงที่จะแบ่งปันแล้ว มันจึงง่ายกว่าตอนเดือนแรก
เลือกทิศทาง
ภายในเดือนที่ 4 คุณสามารถกำหนดทักษะของคุณไปในทิศทางที่เหมาะกับเป้าหมายของคุณ มีสามทิศทาง เลือกหนึ่งทางเพื่อเจาะลึก แทนที่จะกระจายตัวบางเกินไป
เส้นทางวิศวกรผลิตภัณฑ์ AI เหมาะที่สุดหากคุณต้องการงานสตาร์ทอัพเร็วๆ: คุณสร้างผลิตภัณฑ์ที่ขับเคลื่อนด้วย AI ที่ผู้ใช้จริงได้สัมผัส
คุณมีทักษะส่วนใหญ่เหล่านี้แล้วจากเดือนที่ 1 ถึง 3
เจาะลึกมากขึ้นในการสร้างแอปที่สมบูรณ์และสวยงาม และในด้านผลิตภัณฑ์ หมายถึงวิธีที่แอปจัดการเมื่อโมเดลผิดพลาด วิธีแสดงสถานะโหลด วิธีที่ผู้ใช้ให้ข้อเสนอแนะ
ปล่อยผลงานสองหรือสามอย่างที่ผู้คนสามารถลองใช้ได้จริง
เส้นทาง ML ประยุกต์ เหมาะที่สุดหากคุณต้องการบทบาททางเทคนิคที่ลึกซึ้งยิ่งขึ้น: ก้าวไปไกลกว่าการเรียกใช้ API สู่การปรับแต่งโมเดล (fine-tuning) ว่าเมื่อใดควร fine-tuning เทียบกับการปรับปรุง prompt ให้ดีขึ้น การรันโมเดลโอเพนซอร์สในเครื่องด้วยเครื่องมืออย่าง Ollama และการปรับแต่งการอนุมาน (inference optimization)
กรอบการตัดสินใจที่ควรยึดถือ: เริ่มต้นด้วยการปรับปรุง prompt เพิ่มการค้นคืนข้อมูล (retrieval) หากโมเดลต้องการข้อมูลเฉพาะของคุณ และ fine-tuning เมื่อการปรับปรุง prompt และการค้นคืนข้อมูลไม่สามารถให้คุณภาพที่คุณต้องการได้จริงๆ
การ fine-tuning มักถูกนำมาใช้เร็วเกินไป
เส้นทางระบบอัตโนมัติด้วย AI เหมาะที่สุดหากคุณต้องการสร้างรายได้จากธุรกิจทันที: มุ่งเน้นไปที่การทำงานอัตโนมัติในเวิร์กโฟลว์ทางธุรกิจจริง การเชื่อมโยง AI กับเครื่องมือต่างๆ เช่น อีเมล, CRM, เอกสาร และสเปรดชีต
เครื่องมืออย่าง n8n สำหรับเวิร์กโฟลว์แบบภาพ และ LangGraph สำหรับเวิร์กโฟลว์ที่เน้นโค้ด
ผลงานที่ขายได้ในที่นี้: ระบบคัดกรองลูกค้าเป้าหมาย (lead-qualification system) ที่ดึงข้อมูลลูกค้าเป้าหมาย ใช้โมเดลเพื่อค้นคว้าและให้คะแนนแต่ละราย ร่างอีเมลติดต่อส่วนบุคคล และบันทึกทุกอย่าง
ธุรกิจต่างๆ จ่ายเงินจริงสำหรับสิ่งนี้
ความสำเร็จในเดือนที่ 4
ภายในสิ้นเดือนนี้ คุณควรมีแอป AI ที่ถูกปรับใช้แล้วพร้อมการควบคุมต้นทุนที่เหมาะสม โปรเจกต์พอร์ตโฟลิโอสามโปรเจกต์ แต่ละโปรเจกต์มี README ที่ซื่อสัตย์ คำโปรยหนึ่งบรรทัดที่ชัดเจนเกี่ยวกับสิ่งที่คุณสร้าง ร่องรอยการทำงานที่เปิดเผยต่อสาธารณะ และทิศทางที่คุณเลือกไว้เพื่อเจาะลึก
ถึงจุดนั้น คุณไม่ใช่ "คนที่กำลังเรียนรู้ AI" อีกต่อไป คุณคือคนที่ส่งมอบระบบ AI ซึ่งเป็นสิ่งที่ตลาดกำลังจ่ายเงินให้
ส่วนที่ตรงไปตรงมา
ฉันบอกคุณตั้งแต่แรกแล้วว่าฉันจะไม่ขายความฝันลมๆ แล้งๆ ให้คุณ ดังนั้นนี่คือเวอร์ชันตรงไปตรงมาก่อนจะถึงตัวเลขเงิน
การทำงานอย่างมุ่งมั่นเป็นเวลาสี่เดือนทำให้คุณมีคุณสมบัติพอสำหรับงานระดับจูเนียร์ หรือพร้อมรับงานฟรีแลนซ์ มันไม่ได้ทำให้คุณเป็นวิศวกรอาวุโส
ตำแหน่งอาวุโสมาจากการส่งมอบของจริงภายใต้ข้อจำกัดจริงเป็นเวลาหลายปี และไม่มีคู่มือไหนที่จะย่นระยะเวลานั้นได้
สิ่งที่สี่เดือนทำให้คุณได้คือความสามารถในการสร้าง ส่งมอบ และปรับใช้ระบบ AI ที่แก้ปัญหาจริง ซึ่งเป็นจุดที่ทรงคุณค่าและน่าจ้างงานอย่างแท้จริง
สิ่งนี้สมมติว่าคุณทำงานจริง ประมาณ 15 ถึง 20 ชั่วโมงต่อสัปดาห์ ลงมือสร้างจริง ไม่ใช่แค่ดูอย่างเดียว
หากคุณมีเวลาแค่ 7 ชั่วโมงต่อสัปดาห์ นี่คือเส้นทาง 8 เดือน และนั่นก็ไม่ใช่ปัญหาเลย
เส้นเวลาอาจยืดออก แต่จุดหมายปลายทางไม่เปลี่ยนแปลง สิ่งที่ฆ่าคนไม่ใช่ความช้า แต่มันคือการหยุดเดิน
ความสม่ำเสมอเอาชนะความเข้มข้นได้ทุกครั้ง
และทั้งหมดนี้ขึ้นอยู่กับพฤติกรรมเดียวจากส่วนข้อผิดพลาด: ลงมือสร้าง อย่าแค่ดู
ทุกเดือนมีโปรเจกต์ จงทำโปรเจกต์เหล่านั้น คนที่สร้างโปรเจกต์คร่าวๆ สี่โปรเจกต์ในสี่เดือนเป็นคนที่น่าจ้างงาน
คนที่ดูบทเรียนที่สมบูรณ์แบบเป็นเวลาสี่เดือนไม่ใช่ นั่นคือเกมทั้งหมด
เรื่องเงิน พร้อมแหล่งที่มา
ตอนนี้ตัวเลขที่คุณอยากรู้จริงๆ ทั้งหมดเป็นข้อมูลปัจจุบันและมีแหล่งที่มา เพราะการอ้างเงินเดือนแบบคร่าวๆ คือสิ่งที่ทำให้คู่มือเหล่านี้สูญเสียความน่าเชื่อถือ
ณ เดือนมิถุนายน 2026 Glassdoor ระบุว่าเงินเดือนเฉลี่ยของวิศวกร AI ในสหรัฐฯ อยู่ที่ประมาณ 143,500 ดอลลาร์สหรัฐ โดยมีช่วงทั่วไปประมาณ 115,000 ดอลลาร์สหรัฐที่เปอร์เซ็นไทล์ที่ 25 ถึง 181,000 ดอลลาร์สหรัฐที่เปอร์เซ็นไทล์ที่ 75 และผู้มีรายได้สูงสุดรายงานว่าสูงถึงประมาณ 223,000 ดอลลาร์สหรัฐ
วิศวกร AI อาวุโสมีเงินเดือนเฉลี่ยประมาณ 285,000 ดอลลาร์สหรัฐ โดยมีช่วงทั่วไปประมาณ 221,000 ถึง 375,000 ดอลลาร์สหรัฐ ซึ่งแสดงให้เห็นว่าการก้าวกระโดดนั้นสูงชันเพียงใดเมื่อคุณมีประสบการณ์จริง
นั่นคือตัวเลขของ Glassdoor ซึ่งอิงจากเงินเดือนที่ถูกส่งเข้ามา
นายหน้าที่จัดหาคนให้กับงานผลิต AI จริงรายงานว่าเงินเดือนพื้นฐานระดับกลางอยู่ระหว่าง 155,000 ถึง 200,000 ดอลลาร์สหรัฐ โดยอิงจากข้อเสนอที่เซ็นสัญญาแล้วมากกว่าแบบสำรวจ ซึ่งสอดคล้องกับช่วงของ Glassdoor และให้ข้อมูลอ้างอิงอิสระแก่คุณเป็นครั้งที่สอง
และภาพรวมตลาดในวงกว้างจาก PwC's 2026 Barometer ซึ่งฉันได้กล่าวถึงตอนต้น: งานที่ต้องใช้ทักษะ AI เติบโตเร็วกว่าตลาดโดยรวมประมาณแปดเท่า ค่าจ้างพรีเมียม 62% สำหรับทักษะ AI และข้อกำหนดด้านปริญญาลดลงเร็วที่สุดในบทบาทเหล่านี้พอดี
สิ่งเหล่านั้นไม่ได้มาจากกระทู้ hype พวกมันมาจากการวิเคราะห์โฆษณางานกว่าพันล้านรายการ
ตัวเลขฟรีแลนซ์และที่ปรึกษามีความผันผวนมากเกินไปที่จะอ้างอย่างแม่นยำโดยไม่ทำให้คุณเข้าใจผิด ดังนั้นฉันจะพูดเพียงเท่านี้: อัตราค่าบริการสำหรับการใช้งาน RAG, การสร้างเอเจนต์ และการรวม LLM นั้นสูง และผู้เปลี่ยนสายงานที่มีโปรเจกต์ที่ปรับใช้แล้วสามโปรเจกต์ที่มั่นคงและคำโปรยที่ชัดเจนสามารถเริ่มเรียกเก็บเงินสำหรับงานนั้นได้ ก่อนที่พวกเขาจะได้งานประจำเสียอีก
โปรเจกต์คือข้อพิสูจน์ จงสร้างมันขึ้นมา แล้วโอกาสในการสร้างรายได้จะเปิดออก
เริ่มต้นสัปดาห์นี้
นี่คือสิ่งที่ฉันจะทำจริงๆ วันนี้ ถ้าฉันเป็นคุณ
เลือกโปรเจกต์ Python เดือนที่ 1 ซึ่งเป็นเครื่องมือบรรทัดคำสั่งเล็กๆ เปิดโปรแกรมแก้ไขโค้ด
เริ่มทำชุดโจทย์แรกของ CS50P ตั้งค่า prompt สำหรับคู่หูการเรียนรู้ เพื่อให้ AI สอนคุณในส่วนที่ยากๆ
สร้าง GitHub repo และใส่ไฟล์แรกที่ดูไม่สวยงามของคุณลงไป นั่นคือทั้งสัปดาห์แรก
อย่ารอจนกว่าคุณจะรู้สึกพร้อม เพราะความพร้อมมาหลังจากที่คุณเริ่มต้น ไม่ใช่ก่อนหน้านั้น
อย่าวางแผนสี่เดือนทั้งหมดอย่างละเอียดก่อนที่จะเขียนโค้ดแม้แต่บรรทัดเดียว เพราะแผนมีอยู่แล้วที่นี่ และการวางแผนเป็นเพียงวิธีที่สะดวกสบายในการหลีกเลี่ยงการเริ่มต้น
ช่องว่างระหว่างการเรียนรู้และการสร้างคือจุดที่ผู้คนสูญเสียเวลาหนึ่งปี ปิดช่องว่างนั้นในสัปดาห์นี้
การทำงานจริงสี่เดือนสามารถเปลี่ยนสิ่งที่คุณทำได้อย่างแท้จริง
ประตูเปิดกว้างกว่าที่เคยเป็นมา อุปสรรคด้านวุฒิการศึกษากำลังลดลง และตลาดจ่ายเงินสำหรับทักษะเหล่านี้มากกว่าแทบทุกอย่างในวงการเทคโนโลยี
คุณมีคู่มือแล้ว ตัวแปรเดียวที่เหลืออยู่คือคุณจะลงมือสร้างหรือไม่
บันทึกหน้านี้และกลับมาดูทุกเดือนในขณะที่คุณดำเนินไป ฉันจะอัปเดตให้ทันสมัยเมื่อเครื่องมือและตัวเลขเปลี่ยนแปลง
ติดตาม @free_ai_guides สำหรับข้อมูลอัปเดต ❤️
