ความจำของ AI เต็มเมื่อไหร่ มันก็ลืมโปรเจกต์คุณ
ทำงานกับ AI ไปได้สักพัก มันเริ่มลืมว่าโปรเจกต์เป็นยังไง แล้วไปพังของที่เคยทำไว้ดี ๆ หรือคุณกลับมาดูเองหลังหายไปเดือนนึง ก็จำไม่ได้ว่าทำไมตั้งค่าแบบนี้ บทนี้อธิบายว่าความจำของ AI มีขนาดจำกัดจริง ๆ และสอนวิธีย้ายความจำออกจากหัวมันมาไว้ในไฟล์ที่มันอ่านซ้ำทุกครั้ง
ความจำของ AI เต็มเมื่อไหร่ มันก็ลืมโปรเจกต์คุณ
คุณนั่งสร้างของกับ AI มาทั้งบ่าย ตอนเช้ามันยังเข้าใจโปรเจกต์ดีมาก รู้ว่าหน้าไหนเชื่อมกับหน้าไหน รู้ว่าทำไมคุณตั้งค่าแบบนี้ คุณสั่งอะไรมันก็ทำได้ตรงเป๊ะ
พอบ่ายแก่ ๆ คุณสั่งให้มันเพิ่มของเล็ก ๆ อย่างหนึ่ง มันทำให้ แต่ในขณะที่ทำ มันดันไปแก้อีกส่วนที่คุณอุตส่าห์ทำไว้ดีแล้วตอนเช้า ราวกับมันลืมไปแล้วว่าส่วนนั้นมีอยู่ คุณทักว่า "เมื่อเช้าเราทำส่วนนี้ไว้แล้วนะ" มันขอโทษ แล้วก็พังต่ออีกจุด
หรืออีกแบบหนึ่ง คุณกลับมาเปิดโปรเจกต์เดิมหลังจากหายไปเดือนนึง เจอการตั้งค่าแปลก ๆ อันหนึ่งที่ตัวคุณเองในอดีตเป็นคนตั้ง คุณนั่งมองมันแล้วคิดในใจว่า "ทำไมกูตั้งแบบนี้วะ" จะแก้ก็กลัวพัง จะปล่อยไว้ก็ไม่สบายใจ เพราะคุณจำไม่ได้แล้วว่าตอนนั้นคิดอะไรอยู่
ทั้งสองอาการนี้คือเรื่องเดียวกัน คือความจำหายไป ของ AI ก็ดี ของคุณเองก็ดี และบทนี้คือยารักษามันโดยตรง พอจบบท คุณจะมีวิธีย้ายความจำของโปรเจกต์ออกมาไว้ข้างนอก ในที่ที่ทั้งคุณและ AI หยิบมาอ่านได้ทุกครั้ง และจะเลิกพึ่งความจำสั้น ๆ ของ AI อีกต่อไป
ความจริงที่ต้องยอมรับก่อน: ความจำของ AI มีขนาดจำกัด
เริ่มจากตรงนี้ก่อน เพราะมันคือต้นตอของทุกอย่าง
ตอนคุณคุยกับ AI ในแชทเดียว มันดูเหมือนจำได้หมดว่าคุยอะไรกันมา แต่จริง ๆ แล้วมันไม่ได้จำ มันแค่ได้อ่านบทสนทนาทั้งหมดใหม่ทุกครั้งที่คุณกดส่ง (ถ้ายังไม่ชัดว่าทำไม แนะนำให้อ่าน เกิดอะไรขึ้นจริง ๆ ตอนคุณกด Enter ก่อน บทนั้นเปิดให้ดูว่าเบื้องหลังเกิดอะไรขึ้น) สิ่งที่ AI อ่านได้ในแต่ละครั้ง คือทุกอย่างที่อยู่ในพื้นที่อ่านของมัน ณ ตอนนั้น
พื้นที่อ่านนี้แหละคือหัวใจ มันคือพื้นที่ทำงานของ AI ที่ใส่ข้อความได้จำนวนหนึ่ง ไม่ใช่ไม่จำกัด ในวงการเรียกพื้นที่นี้ว่า context window แปลเป็นภาษาคนได้ว่า "ช่องที่ AI มองเห็นได้ในครั้งหนึ่ง" ทุกอย่างที่คุณอยากให้ AI รู้ตอนตอบ ต้องอยู่ในช่องนี้ ถ้ามันไม่อยู่ในช่อง AI ก็ไม่เห็น เหมือนมันไม่เคยมีอยู่
แล้วช่องนี้มีขนาดตายตัว ใส่ได้ถึงจุดหนึ่งก็เต็ม พอเต็มแล้วมีของใหม่จะเข้า ของเก่าที่สุดก็ต้องหลุดออกจากช่องไปเพื่อเปิดที่ว่าง นี่คือเหตุผลที่แชทยาว ๆ ถึงเริ่ม "ลืม" สิ่งที่คุณบอกไว้ตอนต้น ไม่ใช่เพราะ AI โง่ลง แต่เพราะสิ่งที่คุณบอกไว้ตอนต้น มันหลุดออกจากช่องไปแล้ว AI มองไม่เห็นมันอีกต่อไป
💡 ใจความสำคัญ: AI ไม่ได้มีคลังความจำไว้เก็บโปรเจกต์ของคุณ มันมีแค่ช่องอ่านขนาดจำกัดช่องเดียว สิ่งที่อยู่นอกช่อง คือสิ่งที่มันลืมไปแล้ว และยิ่งโปรเจกต์โต ช่องนี้ก็ยิ่งเต็มเร็ว
ทำไมโปรเจกต์ที่โตขึ้นถึงทำให้ช่องนี้ล้นเสมอ
ทีนี้มาต่อให้เห็นว่าทำไมมันถึงเป็นปัญหาแน่ ๆ เมื่อโปรเจกต์โตขึ้น ไม่ใช่แค่อาจจะ
ตอนโปรเจกต์ยังเล็ก มีไม่กี่หน้า ไม่กี่ไฟล์ ทุกอย่างใส่ลงในช่องได้สบาย AI เห็นทั้งโปรเจกต์พร้อมกัน มันเลยตอบได้ฉลาดและตรง แต่พอคุณทำต่อไปเรื่อย ๆ เพิ่มหน้า เพิ่มฟีเจอร์ เพิ่มไฟล์ แถมบทสนทนาในช่วงงานก็ยาวขึ้นเรื่อย ๆ ทั้งโค้ดที่ AI อ่าน ทั้งคำสั่งที่คุณพิมพ์ ทั้งคำตอบที่มันตอบ ทุกอย่างกินที่ในช่อง สุดท้ายช่องก็เต็มเกินกว่าจะใส่ทั้งโปรเจกต์ลงไปได้ แล้วของเก่าก็เริ่มหลุด
นี่คือจุดที่อาการ "มันลืมแล้วไปพังของเก่า" เกิดขึ้น ส่วนของโปรเจกต์ที่คุณทำไว้เมื่อเช้า มันหลุดออกจากช่องไปแล้วตอนบ่าย AI เลยไม่เห็นว่ามันมีอยู่ พอคุณสั่งให้ทำของใหม่ มันก็ทำโดยไม่รู้ว่ามีของเก่าที่ต้องระวัง มันไม่ได้ตั้งใจพัง มันแค่ทำงานบนข้อมูลที่มองเห็น ซึ่งตอนนั้นไม่มีของเก่าอยู่ในนั้นแล้ว
สำคัญตรงนี้ ปัญหานี้ไม่ใช่เรื่องของ AI ตัวไหนเก่งกว่าตัวไหน ทุกตัวมีช่องขนาดจำกัดเหมือนกัน บางตัวช่องใหญ่กว่า ใส่ได้เยอะกว่า แต่ก็ยังมีเพดาน และพอโปรเจกต์โตพอ มันก็ล้นอยู่ดี ขนาดช่องที่ใหญ่ขึ้น แค่เลื่อนวันที่จะล้นออกไป ไม่ได้แก้ปัญหาที่ราก เพราะฉะนั้นทางออกจึงไม่ใช่การรอ AI ที่ช่องใหญ่ขึ้น แต่คือการเปลี่ยนวิธีคิดเรื่องความจำเสียใหม่
ทางออก: ย้ายความจำออกจากหัว AI มาไว้ในไฟล์
หลักการของบทนี้สั้นมาก พูดได้ประโยคเดียว ความจำที่อยู่ข้างนอก เอาชนะความจำที่อยู่ในหัว
ถ้าความจำของ AI หายเพราะมันหลุดออกจากช่อง ทางแก้ก็คืออย่าฝากความจำสำคัญไว้ในช่อง ให้ย้ายมันออกมาเขียนไว้ในไฟล์แทน เป็นไฟล์ธรรมดาที่อยู่ในโปรเจกต์ของคุณ แล้วทำให้ AI อ่านไฟล์นั้นตอนเริ่มทำงานทุกครั้ง
ทำไมวิธีนี้ถึงได้ผล ลองคิดตามดี ๆ ปัญหาคือของเก่าหลุดออกจากช่องเมื่อช่องเต็ม แต่ถ้าความจำสำคัญถูกเขียนไว้ในไฟล์ มันไม่ได้อยู่ในช่องตลอดเวลา มันอยู่ในไฟล์ รอให้ AI หยิบมาอ่านใหม่ตอนต้นของแต่ละช่วงงาน พอ AI อ่านไฟล์นั้นปุ๊บ ความจำก็กลับเข้ามาในช่องสด ๆ อีกครั้ง ราวกับคุณเพิ่งเล่าให้มันฟังใหม่ ของในไฟล์ไม่มีวันหลุดหาย เพราะมันไม่ได้พึ่งช่องในการอยู่รอด มันอยู่ในไฟล์ที่คุณควบคุมได้เอง
พูดอีกอย่าง คุณกำลังเลิกหวังว่า AI จะ "จำ" โปรเจกต์ได้ แล้วหันมาเขียนโปรเจกต์ลงเป็นบันทึก ที่ทั้งคุณและ AI หยิบมาอ่านซ้ำได้เสมอ ความต่อเนื่องไม่ได้มาจากความจำของ AI แต่มาจากบันทึกที่ถูกอ่านใหม่ทุกครั้ง
เปรียบเทียบให้เห็นภาพ: เพื่อนร่วมงานที่เก่งมาก แต่ตื่นมาลืมทุกเช้า
ลองนึกภาพแบบนี้ คุณมีเพื่อนร่วมงานคนหนึ่งที่เก่งสุด ๆ ทำงานละเอียด คิดเร็ว แก้ปัญหายากได้หมด แต่เขามีอาการแปลกอย่างหนึ่ง คือทุกเช้าที่ตื่นมา เขาลืมทุกอย่างที่ทำเมื่อวานเกลี้ยง ลืมว่าโปรเจกต์คืออะไร ลืมว่าตกลงอะไรกันไว้ ลืมว่าทำไมถึงทำแบบนั้น เริ่มจากศูนย์ใหม่ทุกเช้า
ถ้าคุณต้องทำงานกับคนแบบนี้ คุณจะทำยังไงให้งานเดินต่อได้ คำตอบคือคุณเขียนโน้ตหนึ่งหน้าไว้ บอกว่าตอนนี้เราทำอะไรอยู่ ทำไมถึงทำแบบนี้ และไปถึงไหนแล้ว ทุกเช้าที่เขามาถึง คุณยื่นโน้ตนั้นให้เขาอ่าน เขาอ่านจบปุ๊บก็กลับมาเข้าใจงานทันที พร้อมทำงานต่อได้เลย เหมือนไม่เคยลืม ทั้งที่จริงเขาลืมหมดแล้ว แต่โน้ตหนึ่งหน้านั้นพาเขากลับเข้าที่ได้ในไม่กี่นาที
AI ก็คือเพื่อนคนนี้ และไฟล์ความจำที่คุณจะเขียน ก็คือโน้ตหนึ่งหน้าที่ยื่นให้มันอ่านทุกเช้า
จุดที่การเปรียบเทียบนี้ใช้ไม่ได้ คือโน้ตที่ดีต้องสด เพื่อนคนนี้เชื่อโน้ตของคุณร้อยเปอร์เซ็นต์ เขาไม่มีความจำเก่ามาเถียงกับโน้ต เพราะฉะนั้นถ้าโน้ตเขียนผิดหรือเก่าค้างไม่ตรงกับงานจริง เขาก็จะทำตามโน้ตที่ผิดนั้นเป๊ะ ๆ โดยไม่รู้ตัว โน้ตที่เก่าค้าง ทำให้หลงทางหนักกว่าไม่มีโน้ตเลยด้วยซ้ำ เพราะมันพาไปผิดทางอย่างมั่นใจ นี่คือเหตุผลที่บทนี้จะย้ำเรื่องการทำให้ไฟล์อยู่เสมอ ไม่ใช่แค่เขียนทิ้งไว้
สามไฟล์ที่ควรมี
ทีนี้มาดูของจริง ก่อนอื่นต้องเข้าใจตรงกันว่าไฟล์ความจำพวกนี้ไม่ใช่ของลึกลับที่ไหน มันคือไฟล์ข้อความธรรมดาที่อยู่ในโปรเจกต์ของคุณ ในโฟลเดอร์เดียวกับโค้ด (จำได้ไหมว่าโปรเจกต์คือโฟลเดอร์ไฟล์บนเครื่องคุณ ที่เราคุยกันไว้ในบท โปรเจกต์ ไฟล์ และ repo) พอมันนั่งอยู่ในโฟลเดอร์เดียวกับโค้ด AI ก็เปิดอ่านได้ทันทีเหมือนอ่านไฟล์อื่นในโปรเจกต์ และมันก็ถูกเก็บประวัติไปพร้อมโค้ดด้วย ไม่หายไปไหน
ความจำของโปรเจกต์ไม่ต้องเขียนเป็นไฟล์เดียวยาวเหยียด แบ่งเป็นสามไฟล์ตามหน้าที่จะใช้ง่ายกว่ามาก เพราะแต่ละไฟล์ตอบคำถามคนละข้อ และคุณจะรู้ว่าต้องไปแก้ไฟล์ไหนเมื่อมีอะไรเปลี่ยน
ไฟล์ที่ 1 แผนที่ระบบ (System Map): มีอะไรบ้าง และเชื่อมกันยังไง
ไฟล์นี้ตอบคำถามว่า "โปรเจกต์นี้ประกอบด้วยอะไรบ้าง และแต่ละส่วนเชื่อมกันยังไง" มันคือแผนผังของบ้านทั้งหลัง เขียนเป็นภาษาคนธรรมดา ไม่ต้องเป็นโค้ด
ในนั้นบอกว่ามีหน้าอะไรบ้าง แต่ละหน้าทำหน้าที่อะไร ส่วนไหนคุยกับส่วนไหน ข้อมูลของผู้ใช้เก็บไว้ที่ไหน ระบบล็อกอินเชื่อมกับส่วนไหน อะไรที่ถ้าแตะแล้วจะกระทบหลายที่ เขียนให้คนที่ไม่เคยเห็นโปรเจกต์อ่านแล้วเห็นภาพรวมได้ใน 2 นาที นี่คือสิ่งที่ทำให้ AI เลิกพังของเก่า เพราะก่อนมันจะแก้อะไร มันได้เห็นแล้วว่าส่วนนั้นเชื่อมกับอะไรบ้าง
หน้าตาในไฟล์เป็นแค่บรรทัดสั้น ๆ ประมาณว่า "หน้าแรกแสดงรายการที่ผู้ใช้บันทึกไว้ ดึงข้อมูลจากฐานข้อมูลผ่านระบบล็อกอิน ถ้าแก้ตรงนี้กระทบหน้าโปรไฟล์ด้วย" ไม่ต้องสวย ขอแค่ตรง
ไฟล์ที่ 2 บันทึกการตัดสินใจ (Decision Log): ทำไมถึงเลือกแบบนี้
ไฟล์นี้ตอบคำถามว่า "ทำไมเราถึงทำแบบนี้ ไม่ทำแบบอื่น" เฉพาะการตัดสินใจที่ไม่ชัดในตัวเอง ที่คนมาเห็นทีหลังจะงงว่าทำไม
ทุกครั้งที่คุณเลือกอะไรที่แปลกหรือเฉพาะเจาะจง ให้จดสั้น ๆ ว่าเลือกอะไร และเลือกเพราะอะไร หน้าตาก็แค่บรรทัดเดียวต่อหนึ่งการตัดสินใจ เช่น "ตั้งค่านี้เป็นแบบนี้เพราะเบราว์เซอร์ Safari ไม่รองรับอีกแบบ" หรือ "ไม่สร้างระบบล็อกอินเอง เพราะใช้ของสำเร็จรูปปลอดภัยกว่า" นี่แหละคือยาแก้อาการ "กลับมาดูเองแล้วจำไม่ได้ว่าทำไมตั้งแบบนี้" เพราะตัวคุณในอนาคต กับ AI ที่ลืมทุกเช้า ทั้งคู่จะได้อ่านเหตุผล แทนที่จะต้องเดา หรือแย่กว่านั้นคือไปแก้สิ่งที่ตั้งไว้ถูกแล้วโดยไม่รู้ว่ามันมีเหตุผล
ไฟล์ที่ 3 สถานะปัจจุบัน (Status): ตอนนี้ไปถึงไหนแล้ว
ไฟล์นี้ตอบคำถามว่า "ตอนนี้เราอยู่ตรงไหน กำลังทำอะไรค้างไว้ และอะไรคือก้าวต่อไป" มันคือไฟล์ที่เปลี่ยนบ่อยที่สุด เพราะมันบันทึกปัจจุบัน
ในนั้นบอกว่าเพิ่งทำอะไรเสร็จ กำลังทำอะไรอยู่ มีอะไรค้างที่ยังไม่จบ และสิ่งต่อไปที่ตั้งใจจะทำคืออะไร หน้าตาก็เหมือนลิสต์สั้น ๆ เช่น "เสร็จแล้ว: ปุ่มบันทึก / กำลังทำ: หน้าแสดงรายการที่บันทึก / ค้างอยู่: ยังไม่ได้เทสต์ตอนล็อกเอาต์ / ต่อไป: เพิ่มปุ่มลบ" ไฟล์นี้คือสิ่งที่ทำให้คุณเปิดงานวันใหม่แล้วรู้ทันทีว่าจะเริ่มตรงไหน ไม่ต้องนั่งนึกอยู่สิบนาทีว่าเมื่อวานค้างอะไรไว้
💡 ใจความสำคัญ: แผนที่ระบบบอกว่า "มีอะไรและเชื่อมกันยังไง" บันทึกการตัดสินใจบอกว่า "ทำไมถึงเลือกแบบนี้" สถานะบอกว่า "ตอนนี้อยู่ตรงไหน" สามไฟล์นี้รวมกันคือความจำของโปรเจกต์ที่อยู่นอกหัว AI อ่านได้ทุกคน และไม่มีวันหลุดหาย
พิธีกรรมที่ทำให้ไฟล์ยังมีชีวิต
ไฟล์พวกนี้มีประโยชน์ก็ต่อเมื่อมันตรงกับงานจริง เหมือนโน้ตของเพื่อนที่ลืมทุกเช้า ถ้าโน้ตเก่าค้าง มันพาหลงทางหนักกว่าไม่มีโน้ต เพราะฉะนั้นต้องมีจังหวะที่คุณทำให้มันสดอยู่เสมอ ทำเป็นนิสัยสองจังหวะง่าย ๆ
ตอนเริ่มงาน ก่อนจะสั่ง AI ทำอะไร ให้บอกมันก่อนว่า "อ่านไฟล์แผนที่ระบบ บันทึกการตัดสินใจ และสถานะ ให้เข้าใจโปรเจกต์ก่อน แล้วค่อยเริ่ม" แค่นี้ AI ก็ดึงความจำของโปรเจกต์เข้าช่องของมันสด ๆ มันจะทำงานบนภาพที่ครบ ไม่ใช่บนความว่างเปล่า สำหรับเครื่องมือบางตัวอย่าง Claude Code คุณตั้งให้มันอ่านไฟล์พวกนี้อัตโนมัติทุกครั้งได้ด้วยซ้ำ โดยใส่ไว้ในไฟล์ตั้งค่าชื่อ CLAUDE.md แต่ถึงไม่มีระบบอัตโนมัติ แค่บอกมันด้วยมือทุกครั้งก็ได้ผลเหมือนกัน
ตอนจบงาน ก่อนปิดเครื่อง ให้สั่ง AI ว่า "อัปเดตไฟล์สถานะ ว่าวันนี้ทำอะไรเสร็จ ค้างอะไรไว้ และก้าวต่อไปคืออะไร และถ้าวันนี้มีการตัดสินใจอะไรที่ไม่ชัดในตัวเอง จดลงบันทึกการตัดสินใจด้วย" นี่คือจังหวะที่ทำให้ไฟล์ไม่เก่าค้าง พรุ่งนี้เมื่อคุณหรือ AI เปิดมันขึ้นมา มันจะตรงกับความจริง
สองจังหวะนี้ใช้เวลารวมกันไม่ถึงห้านาทีต่อวัน แต่มันคือสิ่งที่ทำให้ความจำภายนอกของคุณเชื่อถือได้ ไม่ใช่กองไฟล์เก่าที่ทำให้หลงทาง
นี่คือจุดสำคัญเรื่องวินัยอย่างหนึ่ง อย่าเขียนไฟล์พวกนี้ครั้งเดียวแล้วทิ้ง ความจำภายนอกที่ดีไม่ใช่ของที่เขียนเสร็จแล้วจบ แต่เป็นของที่คุณดูแลให้สดอยู่ตลอด เหมือนยื่นโน้ตที่อัปเดตแล้วให้เพื่อนทุกเช้า ไม่ใช่โน้ตใบเดิมจากเดือนก่อน
ความเข้าใจผิดสองข้อ
หลายคนคิดว่า AI จำโปรเจกต์ของเราได้ทั้งหมด จริง ๆ แล้วมันจำได้แค่สิ่งที่อยู่ในช่องอ่านของมัน ณ ตอนนั้นเท่านั้น โปรเจกต์ที่คุณทำมาทั้งสัปดาห์ ส่วนใหญ่ไม่ได้อยู่ในหัวมัน ความรู้สึกว่ามัน "จำได้" มาจากการที่มันได้อ่านของซ้ำ ไม่ใช่จากความจำจริง พอของหลุดออกจากช่อง การจำก็หายไปด้วย
อีกข้อที่คนเข้าใจผิดบ่อยคือ ยิ่งป้อนข้อมูลให้ AI เยอะยิ่งดี เลยจับทุกไฟล์ในโปรเจกต์ยัดเข้าไปให้มันอ่านหมด คิดว่ายิ่งเห็นเยอะยิ่งฉลาด จริง ๆ ตรงกันข้าม การยัดทุกอย่างเข้าไปทำให้ช่องเต็มเร็วขึ้น และทำให้ของสำคัญจริง ๆ จมหายไปในกองข้อมูลที่ไม่เกี่ยว AI หาเจอยากขึ้น ตอบแย่ลง สิ่งที่ได้ผลกว่าคือป้อน "ส่วนที่ใช่" ไม่ใช่ "ทุกส่วน" และนี่แหละคือเหตุผลที่สามไฟล์ข้างบนถึงเป็นสรุปสั้น ๆ ไม่ใช่การก็อปทั้งโปรเจกต์มาแปะ มันคือส่วนที่ใช่ที่ถูกกลั่นมาแล้ว ให้ AI เห็นภาพครบโดยไม่ทำให้ช่องล้น
คุณทำสิ่งนี้อยู่แล้ว แค่ย้ายมาที่โค้ด
ตรงนี้คือส่วนที่อยากให้คุณรู้สึกดีกับตัวเอง เพราะนิสัยที่บทนี้สอน คุณทำมันอยู่แล้วในงานอีกด้านหนึ่ง
เว็บ AI ภาษาคน ที่คุณกำลังอ่านอยู่นี้ ถูกสร้างโดยคนที่ไม่ใช่โปรแกรมเมอร์ เป็นผู้บริหารสายธุรกิจที่สร้างมันขึ้นมาด้วยการสั่ง AI และในการทำงานกับเนื้อหาของเว็บนี้ เขาเก็บไฟล์ชื่อ STATUS.md ไว้ไฟล์หนึ่ง พร้อมกับชุดไฟล์ความจำอีกหลายไฟล์ เป็นบันทึกที่เขียนไว้ว่าโปรเจกต์เป็นยังไง ตัดสินใจอะไรไว้บ้าง และไปถึงไหนแล้ว ทุกครั้งที่กลับมาทำงาน เขากับ AI จะอ่านไฟล์พวกนี้ก่อน เพื่อให้ทั้งคู่กลับมาเข้าใจตรงกันว่าโปรเจกต์อยู่ตรงไหน
ฟังดูคุ้น ๆ ไหม นั่นแหละคือแผนที่ระบบ บันทึกการตัดสินใจ และสถานะ ที่บทนี้พูดถึงมาทั้งบท เขาทำมันกับงานเนื้อหาโดยที่อาจไม่ได้เรียกชื่อมันแบบนี้ด้วยซ้ำ แต่มันคือนิสัยเดียวกันเป๊ะ คือการย้ายความจำของโปรเจกต์ออกจากหัว มาไว้ในไฟล์ที่อ่านซ้ำได้ทุกครั้ง
นี่คือนิสัยของคนทำงานที่ผ่านงานใหญ่มาเยอะ พวกเขาไม่พึ่งความจำของตัวเอง พวกเขาเขียนมันลง และถ้าคุณทำสิ่งนี้กับงานเขียน งานเอกสาร หรืองานโปรเจกต์อะไรก็ตามอยู่แล้ว แปลว่าคุณมีนิสัยนี้ในมือแล้ว สิ่งที่ต้องทำมีแค่ย้ายมันมาที่โค้ด ปัญหา "AI ลืมโปรเจกต์แล้วไปพังของเก่า" กับปัญหา "กลับมาดูเองแล้วจำไม่ได้ว่าทำไม" ทั้งคู่รักษาด้วยยาตัวเดียวกัน คือยาที่คุณใช้เป็นอยู่แล้ว
สรุป
ความจำของ AI เรื่องโปรเจกต์ของคุณ ไม่ได้ถาวร มันอยู่ในช่องอ่านขนาดจำกัด พอช่องเต็มของเก่าก็หลุดหาย และพอโปรเจกต์โตขึ้น ช่องนี้ก็ล้นเสมอ นี่คือเหตุผลที่ทำงานยาว ๆ ไป AI ถึงเริ่มลืมแล้วไปพังของที่เคยทำไว้ดี
ทางแก้ไม่ใช่การหวังว่า AI จะจำได้ดีขึ้น แต่คือการย้ายความจำออกจากหัวมันมาไว้ในไฟล์ที่มันอ่านซ้ำทุกครั้ง สามไฟล์ คือแผนที่ระบบที่บอกว่ามีอะไรและเชื่อมกันยังไง บันทึกการตัดสินใจที่บอกว่าทำไมถึงเลือกแบบนี้ และสถานะที่บอกว่าตอนนี้อยู่ตรงไหน รักษาให้มันสดด้วยสองจังหวะง่าย ๆ คืออ่านตอนเริ่มงาน อัปเดตตอนจบงาน
ความจำที่อยู่ข้างนอก เอาชนะความจำที่อยู่ในหัว และนี่คือนิสัยที่คุณอาจทำกับงานอื่นอยู่แล้ว ตอนนี้แค่ย้ายมันมาที่โค้ด
อ่านต่อ: ชี้ให้ตรงจุด