เกิดอะไรขึ้นจริง ๆ ตอนคุณกด Enter

คุณเปิด ChatGPT พิมพ์ว่า "สรุปอีเมลนี้ให้หน่อย" แล้วกด Enter มันคิดอยู่แวบหนึ่ง แล้วพิมพ์คำตอบไหลออกมาทีละคำ คุณถามต่อ "เอาให้สั้นกว่านี้" มันก็ย่อให้ ราวกับมันจำได้ว่าเมื่อกี้คุยอะไรกัน ทั้งหมดดูเป็นธรรมชาติเหมือนคุยกับคนที่นั่งฟังคุณอยู่ตรงนั้น

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

บทนี้คือหัวใจของทั้งหมด ถ้าคุณจำได้แค่บทเดียวจากหนังสือเล่มนี้ ขอให้เป็นบทนี้

ภาพลวงตา: แชทที่ "คุยต่อเนื่อง"

ก่อนอื่นต้องพูดถึงภาพในหัวที่เกือบทุกคนมี เพราะมันคือสิ่งที่หน้าจอตั้งใจทำให้คุณเชื่อ

หน้าจอแชทออกแบบมาให้รู้สึกเหมือนคุยกับคน ข้อความของคุณอยู่ฝั่งหนึ่ง ข้อความของ AI อยู่อีกฝั่ง ไล่ลงมาเป็นบับเบิลต่อเนื่อง พอคุณถามต่อ มันตอบรับกับเรื่องเก่าได้ เลยรู้สึกเป็นธรรมชาติที่จะคิดว่า "มันนั่งฟังเราอยู่ จำเรื่องที่คุยไว้ในหัว แล้วตอบกลับมา" เหมือนคนคนหนึ่งที่ความจำยังอยู่ครบตลอดบทสนทนา

ภาพนี้ผิด ไม่ใช่ผิดนิดหน่อย แต่ผิดที่รากเลย และความเข้าใจผิดตรงนี้แหละที่ทำให้คนใช้ AI แบบงง ๆ มาตลอด โทษมันว่า "โง่ลง" บ้าง "พัง" บ้าง ทั้งที่จริงมันแค่ทำงานตามกลไกของมันอยู่

💡 ใจความสำคัญ: หน้าจอแชทถูกออกแบบมาให้ รู้สึก เหมือนการสนทนาที่ต่อเนื่อง แต่เบื้องหลังไม่มีการสนทนาต่อเนื่องอยู่เลย มีแต่การส่งข้อความก้อนใหญ่ไป-กลับ ทีละครั้ง ที่ไม่เชื่อมต่อกันในความทรงจำของ model

ความจริงข้อแรก: model ไม่มีความจำ

ย้อนกลับไปที่หัวใจของเรื่องนี้ สิ่งที่อยู่หลังจอ ChatGPT หรือ Claude คือตัวที่เราเรียกในวงการว่า model (ถ้ายังไม่ชัดว่า model คืออะไร แนะนำให้อ่าน model คือเครื่องยนต์ ไม่ใช่ทั้งรถ ก่อน) มันทำสิ่งเดียวซ้ำ ๆ คือดูข้อความที่อยู่ตรงหน้า แล้วเดาว่าคำถัดไปควรเป็นอะไร

จุดที่ทุกคนมองข้ามคือคำว่า ตรงหน้า model เดาได้จากสิ่งที่มันเห็นตรงหน้าในขณะนั้นเท่านั้น มันไม่มีคลังความทรงจำเก็บไว้ข้างหลัง ไม่มีสมุดโน้ตที่จดว่าเมื่อกี้คุณพูดอะไร พอมันเดาคำตอบเสร็จออกมาหนึ่งรอบ มันก็จบ ลืมทุกอย่างทิ้ง รอบถัดไปมันเริ่มจากศูนย์ใหม่หมด เหมือนเพิ่งตื่นมาเจอคุณครั้งแรก

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

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

ความจริงข้อสอง: ทุกครั้งที่กด Enter บทสนทนาทั้งหมดถูกส่งไปใหม่

"คน" ที่คอยเล่าเรื่องเก่าให้ model ฟัง คือ harness คือโปรแกรมที่ห่อรอบ ๆ model เพื่อทำให้มันใช้งานได้จริง (รายละเอียดเต็มของ harness อยู่ใน ส่วนที่ไม่มีใครพูดถึง) ในที่นี้ harness ก็คือตัวแอป ChatGPT หรือ Claude ที่คุณเปิดใช้นั่นเอง

นี่คือสิ่งที่เกิดขึ้นจริงในวินาทีที่คุณกด Enter

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

model อ่านก้อนนั้นทั้งก้อน เดาคำตอบออกมา แล้วลืมทุกอย่างทิ้ง พอคุณพิมพ์ข้อความถัดไป แอปก็มัดก้อนเดิมขึ้นมาใหม่ บวกคำตอบที่ AI เพิ่งตอบ บวกข้อความใหม่ที่คุณเพิ่งพิมพ์ แล้วส่งไปให้อ่านอีกรอบตั้งแต่ต้น

พูดง่าย ๆ คือทุกครั้งที่คุณกดส่ง สิ่งที่ถูกส่งไปไม่ได้มีแค่ประโยคใหม่ แต่เป็นบทสนทนาทั้งหมดที่ผ่านมา บวกคำสั่งระบบที่ซ่อนอยู่ บวกข้อความใหม่ของคุณ ของใหม่ถูกต่อท้ายเข้าไปเรื่อย ๆ ส่วนของเก่าไม่เคยหายไปไหน

เพราะฉะนั้น เวลามันดูเหมือน "จำได้ว่าคุณบอกชื่อโปรเจกต์ไว้ตอนต้น" จริง ๆ คือชื่อโปรเจกต์นั้นยังอยู่ในก้อนข้อความที่ถูกส่งไปให้อ่านใหม่ทุกรอบ มันไม่ได้จำ แต่มัน อ่านซ้ำ ต่างหาก

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

นั่นแหละคือสิ่งที่แอปทำให้คุณอัตโนมัติทุกครั้งที่กด Enter คุณเห็นแค่บับเบิลข้อความใหม่หนึ่งอัน แต่เบื้องหลังคือบทสนทนาทั้งกองถูกส่งไปใหม่

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

ความจริงข้อสาม: ข้อความที่ซ่อนอยู่ ที่คุณไม่เคยเห็น

ตรงนี้คือส่วนที่คนตกใจที่สุดเวลารู้ครั้งแรก

ก้อนข้อความที่ถูกส่งไปให้ model ในแต่ละรอบ ไม่ได้มีแค่บทสนทนาของคุณ ก่อนที่ข้อความแรกของคุณจะปรากฏด้วยซ้ำ มีข้อความอีกก้อนใหญ่ถูกแปะไว้ข้างบน เป็นข้อความที่คุณ ไม่เคยเห็น บนหน้าจอ และไม่มีทางเห็นด้วย

ก้อนนี้ประกอบด้วยหลายส่วน ส่วนที่สำคัญที่สุดคือ system prompt แปลคร่าว ๆ ว่า "คำสั่งระบบ" หรือ "คำสั่งตั้งต้น" มันคือชุดคำสั่งที่บริษัทผู้สร้างเขียนไว้ บอก model ว่าให้วางตัวยังไง ตอบด้วยน้ำเสียงแบบไหน ทำอะไรได้ ทำอะไรไม่ได้ จัดรูปแบบคำตอบยังไง คำสั่งชุดนี้ถูกโหลดก่อนเสมอ และคุณไม่มีวันเห็นมันบนหน้าจอ

นอกจาก system prompt ยังมีอีกหลายอย่างที่ถูกแปะเข้าไปในก้อนซ่อนนี้ แล้วแต่ว่าคุณใช้แอปไหนและตั้งค่าอะไรไว้

• นิยามของ tools คือรายการ "เครื่องมือ" ที่ model เรียกใช้ได้ พร้อมคำอธิบายว่าแต่ละตัวทำอะไร เรียกยังไง (เช่น อ่านไฟล์ ค้นเว็บ รันคำสั่ง) model ต้องเห็นรายการนี้ก่อน ถึงจะรู้ว่ามันขอใช้เครื่องมืออะไรได้บ้าง
• ไฟล์หรือบริบทที่ถูกแทรกเข้ามา ถ้าคุณแนบไฟล์ หรือถ้าเครื่องมือมีไฟล์ตั้งค่าอย่าง CLAUDE.md เนื้อหาในนั้นจะถูกมัดเข้าไปในก้อนด้วย
• โน้ตความจำข้ามแชท ถ้าคุณเปิดฟีเจอร์ "Memory" ไว้ สิ่งที่แอปจดเกี่ยวกับคุณก็ถูกแปะเข้ามาตรงนี้
• คำสั่งด้านความปลอดภัย คือกฎที่กันไม่ให้ model ทำสิ่งที่ไม่ควร

ขนาดของก้อนซ่อนนี้ไม่ใช่เล่น ๆ เฉพาะ system prompt อย่างเดียวก็ปาเข้าไปหลายพัน token แล้ว และเมื่อรวมไฟล์ตั้งค่า ความจำ นิยาม tool ต่าง ๆ ก่อนถึงข้อความแรกของคุณ ก้อนซ่อนนี้กินไปได้หลายพัน token สบาย ๆ

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

💡 ใจความสำคัญ: ทุกครั้งที่กด Enter model ไม่ได้รับแค่สิ่งที่คุณพิมพ์ มันได้รับ (1) คำสั่งซ่อนเป็นพัน ๆ token ที่คุณไม่เคยเห็น บวก (2) บทสนทนาทั้งหมดที่ผ่านมา บวก (3) ข้อความใหม่ของคุณ ทั้งหมดมัดเป็นก้อนเดียว ส่งใหม่หมดทุกรอบ

ห่วงโซ่ผลลัพธ์: ทำไมทุกอย่างที่คุณเคยงงถึงสมเหตุสมผลขึ้นทันที

พอคุณเข้าใจสามข้อข้างบน คือ model ไม่มีความจำ ส่งทั้งกองใหม่ทุกรอบ และมีก้อนซ่อนแปะอยู่ข้างบนเสมอ อาการแปลก ๆ ที่คุณเคยเจอเวลาใช้ AI จะอธิบายได้หมด เป็นห่วงโซ่เดียวกัน

ยิ่งคุยยาว กองข้อความยิ่งหนา ทุกข้อความที่เพิ่มเข้าไป ทั้งของคุณและคำตอบของ AI กลายเป็นส่วนหนึ่งของกองที่ต้องส่งใหม่ในรอบถัดไป แชทที่คุยกันมา 50 ข้อความ หมายความว่าทุกครั้งที่คุณพิมพ์ประโยคใหม่ ทั้ง 50 ข้อความนั้นถูกส่งไปด้วย บวกก้อนซ่อนข้างบน กองข้อความไม่เคยหดลง มีแต่หนาขึ้นเรื่อย ๆ

จากตรงนี้ ผลที่ตามมาเป็นลูกโซ่

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

💡 กฎที่ควรจำ: ยิ่งบทสนทนายาวขึ้น ทั้ง token ที่ใช้ และโอกาสที่ model จะตอบพลาดหรือหลอน ต่างก็เพิ่มขึ้น และสำคัญคือมันเพิ่มขึ้นแบบเร่งตัว ไม่ใช่เพิ่มเป็นเส้นตรง

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

เหตุผลเรื่องคุณภาพ: ยิ่งกองข้อความเต็มขึ้น คุณภาพคำตอบก็มีแนวโน้มแย่ลงเร็วขึ้น ไม่ใช่ค่อย ๆ แย่ลงทีละนิดเท่ากันทุกข้อความ พูดสั้น ๆ คือ "ยิ่งยาว ยิ่งแย่เร็วขึ้น"

อาการสุดท้ายนี้ คือ "ยิ่งคุยยาว ยิ่งโง่ลง" มีกฎและกลไกของมันเองที่เราจะเจาะลึกในบท Context window กฎข้อเดียวที่ครอบงำทุกอย่าง ตรงนั้นจะอธิบายว่าทำไมกองข้อความถึงมีขนาด จำกัด ทำไม model ถึงสนใจตรงกลางของกองยาว ๆ ได้แย่ที่สุด และกฎ "เริ่มใหม่ดีกว่าลากยาว" ทำงานยังไง สำหรับบทนี้ แค่เห็นภาพว่า "กองข้อความหนาขึ้นเรื่อย ๆ" คือต้นตอของทุกอาการก็พอ

และนี่คือเหตุผลว่าทำไมแชทใหม่ถึงดีกว่า เพราะเมื่อคุณเปิดแชทใหม่ จำนวนข้อความทั้งหมดที่ส่งเข้าไปให้ model เพื่อประมวลผล มีจำนวนน้อยกว่า เหลือแค่ก้อนซ่อนตั้งต้นกับประโยคแรกของคุณ ไม่มีบทสนทนาเก่า 50 ข้อความมาถ่วง ไม่มีเรื่องที่ไม่เกี่ยวมากวน model อ่านน้อยลง เร็วขึ้น ถูกลง และโฟกัสกับเรื่องตรงหน้าได้ดีขึ้น เวลาเปลี่ยนไปทำงานที่ไม่เกี่ยวกัน การเริ่มแชทใหม่จึงคุ้มกว่าการลากเรื่องเก่าไว้ในแชทเดิมที่ค้างอยู่และเปลือง token ในทุกข้อความถัดไป (สำหรับเครื่องมืออย่าง Claude Code จะมีคำสั่ง /clear ไว้ล้างให้กลับมาเบา ส่วนแอปแชททั่วไปอย่าง ChatGPT การ "เปิดแชทใหม่" ก็คือ /clear เวอร์ชันของคุณนั่นเอง)

ลองทำดู: ดูว่ากองข้อความหนาแค่ไหน

เปิดแชทใหม่ใน ChatGPT หรือ Claude แล้วถามคำถามสั้น ๆ หนึ่งประโยค สังเกตว่ามันตอบเร็วแค่ไหน จากนั้นชวนมันคุยยาว ๆ ให้เขียนเรียงความ สรุปบทความยาว ๆ ตอบคำถามต่อเนื่องสัก 20-30 รอบ ยิ่งยาวยิ่งดี

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

นี่คือนาทีที่คุณ "เห็น" กลไกนี้ทำงานกับตาตัวเอง

ตัวอย่างจริงแบบเห็น ๆ: ข้อความสั้น vs กองที่ถูกส่งจริง

ทีนี้มาดูของจริงกัน สมมติคุณคุยกับ AI มาแล้วสามข้อความ แล้วพิมพ์ข้อความที่สี่

สิ่งที่คุณเห็นบนหน้าจอ คือแค่บับเบิลใหม่หนึ่งอันที่คุณเพิ่งพิมพ์

ทำให้สั้นกว่านี้อีกหน่อย

หกคำ นั่นคือทั้งหมดที่คุณรู้สึกว่าคุณ "ส่ง"

สิ่งที่ถูกส่งให้ model จริง ๆ คือกองหน้าตาประมาณนี้ (ย่อให้ดูเป็นแนวคิด ของจริงยาวกว่านี้และเป็นรูปแบบที่เครื่องอ่าน)

━━━ ส่วนซ่อน: คุณไม่เห็นส่วนนี้บนหน้าจอ ━━━

[SYSTEM PROMPT — ~4,200 token]
คุณคือผู้ช่วย AI ที่... ตอบด้วยน้ำเสียง... ห้ามทำ...
จัดรูปแบบคำตอบแบบ... ถ้าผู้ใช้ถาม X ให้...
(คำสั่งระบบยาวเป็นพัน ๆ คำที่บริษัทผู้สร้างเขียนไว้)

[นิยาม TOOLS]
เครื่องมือที่เรียกใช้ได้: ค้นเว็บ(query), อ่านไฟล์(path), ...
(พร้อมคำอธิบายว่าแต่ละตัวเรียกยังไง)

[ความจำ / ไฟล์ที่แทรกเข้ามา ถ้ามี]
ผู้ใช้คนนี้ชอบคำตอบสั้น เป็นคนทำงานสายการตลาด...

━━━ บทสนทนาทั้งหมด: ส่งใหม่ครบทุกข้อความ ━━━

[ข้อความที่ 1 — คุณ]   ช่วยร่างอีเมลขอบคุณลูกค้าให้หน่อย
[ข้อความที่ 2 — AI]    ได้เลย นี่คือร่างอีเมล: เรียนคุณลูกค้า...
                        (คำตอบเต็มความยาว 3 ย่อหน้า)
[ข้อความที่ 3 — คุณ]   เปลี่ยนน้ำเสียงให้เป็นกันเองกว่านี้
[ข้อความที่ 4 — AI]    ได้ครับ ปรับให้เป็นกันเองแล้ว: สวัสดีค่ะคุณ...
                        (คำตอบเต็มอีก 3 ย่อหน้า)

━━━ ข้อความใหม่ของคุณ: ต่อท้ายตรงนี้ ━━━

[ข้อความที่ 5 — คุณ]   ทำให้สั้นกว่านี้อีกหน่อย

คุณพิมพ์ไป 6 คำ แต่สิ่งที่ถูกส่งให้ model คือทุกอย่างข้างบนนั้น คือก้อนซ่อนหลายพัน token บวกบทสนทนาทั้งสี่ข้อความเต็ม ๆ บวกประโยคใหม่ของคุณ model อ่านทั้งกองถึงจะรู้ว่า "สั้นกว่านี้" หมายถึงอีเมลฉบับไหน และจะย่ออะไร

ลองดูตัวเลขให้เห็นภาพชัด ๆ ประโยคที่คุณพิมพ์จริง ("ทำให้สั้นกว่านี้อีกหน่อย") กินแค่ราว ๆ สิบกว่า token เท่านั้น แค่หยิบมือเดียว แต่ก้อนซ่อนที่ถูกแปะไว้ข้างบนนี่สิ ตามตัวอย่างในเอกสารแต่ละชั้นกินไปประมาณนี้ system prompt ~4,200 บวกความจำข้ามแชท ~680 บวกข้อมูลสภาพแวดล้อม ~280 บวกนิยาม tools ~120 บวกคำอธิบาย skills ~450 บวกไฟล์ตั้งค่าระดับผู้ใช้ ~320 บวกไฟล์ตั้งค่าระดับโปรเจกต์ ~1,800 รวมแล้วราว ~7,800 token ที่ถูกซ่อนไว้ ก่อนที่บทสนทนาของคุณจะเริ่มด้วยซ้ำ นี่เป็นแค่ตัวเลขตัวอย่างเพื่อให้เห็นสัดส่วน ของจริงต่างกันไปตามแอปและการตั้งค่าของคุณ แต่ภาพรวมไม่เปลี่ยน คุณพิมพ์ไปหยิบมือเดียว แต่สิ่งที่ถูกส่งไปจริงคือหลายพัน token แล้วยังต้องบวกบทสนทนาเก่าทั้งหมดเข้าไปอีก

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

พูดกันตรง ๆ คุณ มองไม่เห็น ก้อนซ่อนนี้บนหน้าจอโดยตรง และจะไม่มีวันเห็น นั่นแหละคือประเด็นของมัน มันถูกออกแบบให้ทำงานเงียบ ๆ อยู่หลังฉาก

สรุป: บทสนทนาที่ไม่เคยมีอยู่จริง

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

สิ่งที่เกิดขึ้นจริงทุกครั้งที่คุณกด Enter คือ harness รวบ ทุกอย่าง ทั้งคำสั่งซ่อนเป็นพัน ๆ token ที่คุณไม่เคยเห็น บวกบทสนทนาทั้งหมดที่ผ่านมา บวกข้อความใหม่ของคุณ มัดเป็นก้อนเดียว ส่งให้ model อ่านรวดเดียวตั้งแต่ต้น model อ่านทั้งกอง เดาคำตอบ แล้วลืมหมด รอบถัดไปก็ส่งกองที่หนาขึ้นไปใหม่ ความ "ต่อเนื่อง" ที่คุณเห็น ไม่ได้มาจากความจำของ model แต่มันมาจากการที่กองข้อความเก่าถูกส่งไปให้อ่านซ้ำทุกครั้ง

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

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

แต่ยังมีคำถามที่ค้างอยู่ กองข้อความนั้น "หนาได้แค่ไหน" ก่อนจะเต็ม มันมีเพดานไหม และพอใกล้เต็มเกิดอะไรขึ้น ทำไม model ถึงเริ่มพลาดเป็นพิเศษเมื่อกองยาว และกฎ "เริ่มใหม่ดีกว่าลากยาว" ทำงานยังไงในรายละเอียด ทั้งหมดนี้คือเรื่องของ context window กฎข้อเดียวที่อยู่เบื้องหลังทุกอาการที่บทนี้พูดถึง และเป็นบทต่อไปที่คุณควรอ่าน

---

อ่านต่อ: Context window — กฎข้อเดียวที่ครอบงำทุกอย่าง

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

• https://code.claude.com/docs/en/how-claude-code-works
• https://code.claude.com/docs/en/context-window
• https://code.claude.com/docs/en/prompt-caching
• https://code.claude.com/docs/en/costs