ถ้าคุณรอไม่ไหวและอยากอ่านโพสต์นี้ ให้คัดลอก/วางพรอมต์นี้ไปที่ claude code / codex / grok ของคุณตอนนี้เลย เพื่อรับทันที:
ติดตั้ง XERJ (เอกสาร:
https://xerj.org/llms.txt ), จัดทำดัชนีซอร์สของโปรเจกต์นี้ และตั้งค่า reference coding: โคลนและจัดทำดัชนี repos โอเพนซอร์สที่ใกล้เคียงกับสิ่งที่เรากำลังสร้างมากที่สุด และค้นหาว่าพวกเขาแก้ปัญหาอย่างไรก่อนที่จะเขียนโค้ด
คนส่วนใหญ่ใช้ claude code เหมือนจ้างเด็กฝึกงานราคาแพง และนี่คือวิธีทำให้มันฉลาดขึ้นเรื่อยๆ ในแต่ละเทิร์น (ของจริง)
คุณส่งงานให้มัน มันถามคำถามสองสามข้อ มัน grep repo เดาโค้ดของคุณ เขียนโค้ดตามนั้น มีอะไรพัง คุณวาง error มาให้ มันเขียนใหม่ แล้วก็พังอีก
ทุกเทิร์นเหล่านั้นคือ tokens ที่คุณจ่ายไป
และ claude มักจะไม่ติดเพราะปัญหามันยาก แต่ติดเพราะคุณให้มันค้นหาคำตอบที่มีอยู่แล้วซ้ำๆ ไม่ว่าจะใน repo ของคุณเอง หรือในโปรเจกต์โอเพนซอร์สที่นักพัฒนาหลายพันคนเจอ edge cases ไปแล้ว
XERJ ทดสอบเรื่องนี้อย่างถูกต้อง 8 งานเขียนโค้ด 4 ภาษา 16 รันต่อการตั้งค่า จำนวน tokens ดึงมาจาก claude -p โดยตรง
จากความจำ: 260,916 output tokens จาก reference: 9,982 output tokens
ความจำแก้ปัญหาได้ 11 จาก 16 ครั้ง Reference แก้ได้ทั้งหมด 16 ครั้ง
ดังนั้น ตั้งใจอ่านจริงๆ แล้วกัน ↓↓↓
ลูปที่คุณกำลังจ่ายเงินให้
เซสชันปกติจะเป็นแบบนี้
คุณอธิบายสิ่งที่คุณต้องการ claude สำรวจ มันตั้งสมมติฐานเกี่ยวกับรูปแบบของคุณ การจัดการข้อผิดพลาด รูปร่างของข้อมูลของคุณ มันเขียนโค้ดตามสมมติฐานนั้น สมมติฐานผิดที่ไหนสักแห่ง ดังนั้นสิ่งต่างๆ จึงพัง คุณอธิบาย error มันเขียนใหม่ แล้วคุณก็วนไปเรื่อยๆ จนกว่าผลลัพธ์จะตรงกับสิ่งที่คุณคิดไว้ตั้งแต่แรก
คนอ่านลูปนั้นว่า claude เขียนโค้ดไม่เก่ง มันตรงกันข้าม claude เก่งมากในการนำตัวอย่างที่ใช้งานได้มาปรับใช้กับสถานการณ์ใหม่ ลูปเกิดขึ้นเมื่อไม่มีตัวอย่างอยู่ในห้อง ดังนั้นมันจึงใช้ครึ่งแรกของเซสชันสร้างตัวอย่างขึ้นมาใหม่
output tokens เป็นตัวที่แพง โดยมีราคาสูงกว่า input ประมาณ 5 เท่าในโมเดล claude ดังนั้นทุกๆ รอบของลูปนั้นจะถูกคิดเงินในอัตราสูงสุด
พรอมต์และ reference ไม่ใช่สิ่งเดียวกัน
พรอมต์คือคำสั่ง Reference คือหลักฐาน
คุณสามารถเขียนสองพันคำอธิบายว่าสิ่งนั้นควรทำงานอย่างไร และ claude ก็ยังต้องแปลคำอธิบายนั้นเป็นการนำไปใช้ จากนั้นก็เดาสิ่งที่คุณไม่ได้พูดถึง
การนำไปใช้ที่ใช้งานได้จริงมีส่วนต่างๆ ที่คุณจะไม่มีวันเขียนลงไปอยู่แล้ว
สถาปัตยกรรม การจัดการข้อผิดพลาด ตรรกะการลองใหม่ edge case ที่มีคนเจอในโปรดักชันเมื่อสองปีก่อน เหตุผลที่ฟังก์ชันถูกแบ่งแบบนั้น
คุณไม่ได้พูดถึงสิ่งเหล่านั้นในพรอมต์ เพราะคุณไม่รู้ว่ามันสำคัญ
นี่คือเวอร์ชันที่เฉียบคมที่สุดของเรื่องนั้น คอมไพเลอร์จะรั่วชื่อเมธอดออกมาในที่สุด มันจะบอกคุณว่าฟังก์ชันนั้นเรียกว่า absorb ไม่ใช่ push และคิดเงินคุณ 20 ถึง 25 เท่าของ tokens กว่าจะถึงจุดนั้น คอมไพเลอร์จะไม่มีทางรั่วสัญญา (contract) ออกมา ไม่มีอะไรใน toolchain ของคุณที่จะบอกคุณว่าโครงสร้างนี้ต้องถูกปิดผนึกก่อนที่จะอ่านได้ กฎนั้นอยู่ในหัวของคนที่เขียนไลบรารีและในเนื้อหาของฟังก์ชัน และไม่มีพรอมต์มากมายเท่าไหร่ที่จะกู้คืนมันได้ เพราะคุณไม่รู้ว่ามันมีอยู่
นั่นคือสาเหตุที่วิธีนี้ลด tokens และเพิ่มคุณภาพในเวลาเดียวกัน ใส่บริบทที่มีประโยชน์มากขึ้น เข้าไป เดาน้อยลง ลองใหม่น้อยลง
สิ่งที่การทดสอบแสดงให้เห็น
เมื่อเทียบกับการตั้งค่าแบบ grep แล้ว reference coding ใช้ output tokens น้อยกว่า 2.7 เท่า ใน 8 งานเดียวกัน ต้นทุนรวมในแต่ละฝั่งไปที่ $11.18 จากความจำ, $3.27 พร้อม grep, $1.58 พร้อม reference
grep ดูเหมือนจะเป็นทางออก แต่ส่วนใหญ่แล้วไม่ใช่ grep บอก agent ว่าต้องดูที่ไหน จากนั้น agent ก็ยังต้องอ่านไฟล์เข้าไปในบริบทเพื่อทำความเข้าใจมัน คลังข้อมูลหนึ่งในการศึกษานี้ดึง 1.06 ล้าน input tokens มาเพื่อทำสิ่งนั้น tokens ราคาถูก แต่กองมหาศาล บวกกับทุกๆ เทิร์นของ agent ที่คุณนั่งรอ
จากนั้นก็มีการรันที่ใหญ่กว่า 13 ไลบรารีที่เขียนขึ้นใหม่สำหรับการศึกษาใน 5 ภาษา แต่ละตัวคอมไพล์และผ่านการทดสอบของตัวเอง แต่ละตัวมีกฎ runtime ที่คอมไพเลอร์ไม่สามารถเตือนคุณได้ สร้างขึ้นมาแบบนั้นโดยตั้งใจ เพราะคุณไม่สามารถทดสอบการดึงข้อมูล (retrieval) กับโค้ดที่โมเดลจำได้อยู่แล้ว
เปล่า จากความจำ: 1 จาก 21 พร้อมการดึงข้อมูล: 21 จาก 21
$21.90 เทียบกับ $3.38
นั่นคือผลลัพธ์ที่แตกต่าง ไม่ใช่แค่ถูกกว่า
ตัวอย่างที่สะอาดที่สุดในนั้นคืองาน Java สร้าง append only ledger, seal ก่อน replay, truncate ไปยัง checkpoint จากความจำ มันสร้างใหม่ทั้งหมด 503 บรรทัด ประมาณ 36,000 tokens ความหมายของ truncation ผิด ล้มเหลวในการทดสอบ เมื่อให้ reference มันเขียนสี่บรรทัด 103 tokens ผ่าน
การกระจายตามภาษาบอกคุณว่าคุณค่าอยู่ที่ไหน Python 14,752 ลดลงเหลือ 214 C 18,792 ลดลงเหลือ 988 Java 27,108 ลดลงเหลือ 98 JavaScript ลดลงแค่ 4,300 เป็น 646 เพราะ prefix trie เป็นโครงสร้างที่รู้จักกันดี และโมเดลรู้คำตอบครึ่งหนึ่งอยู่แล้ว
นักพัฒนาที่ใช้ XERJ ในการทำงานประจำวันรายงานว่าใช้ tokens น้อยลงประมาณ 5 เท่า อันนี้รายงานด้วยตัวเองมากกว่าการวัดมาตรฐาน ดังนั้นให้ถือว่ามันเป็นค่าต่ำสุด ไม่ใช่ตัวเลขเด่น
ทำไมพรอมต์ที่ยาวขึ้นถึงไม่แก้ปัญหานี้
ในช่วงเวลาหนึ่ง คำตอบสำหรับ output ที่ไม่ดีก็เหมือนเดิมเสมอ เขียนพรอมต์ให้ดีขึ้น เพิ่มบริบทมากขึ้น อธิบายสถาปัตยกรรม
และบางครั้งมันก็ได้ผล
แต่พรอมต์คือคุณกำลังอธิบายวิธีแก้ปัญหาที่คุณยังไม่ได้เขียน reference คือวิธีแก้ปัญหาที่มีคนส่งและดีบั๊กไปแล้ว คุณไม่สามารถอธิบายให้ถึงตรรกะการลองใหม่ที่มีอยู่เพราะผู้ดูแลถูก rate limit ตอนตี 3 และแก้ไขอย่างเร่งรีบ
โค้ดมีอยู่แล้ว คุณไม่ต้องอธิบายการตัดสินใจที่นำไปสู่มัน
การค้นหา reference คืองานจริง
นี่คือจุดที่มันพัง
การทำด้วยมือหมายถึงการเปิด GitHub อ่าน repos ที่ตรงกันครึ่งๆ กลางๆ ค้นหา pull requests เก่าๆ จากนั้นเปิด codebase ของคุณเองเมื่อแปดเดือนก่อนและพยายามจำว่าคุณตั้งชื่อไฟล์ว่าอะไร เมื่อถึงเวลาที่คุณพบสิ่งที่ใช้ได้ คุณอาจจะเขียนฟีเจอร์นั้นเสร็จไปแล้ว
ดังนั้นการค้นหาจะต้องถูก หรือไม่มีใครทำมันเป็นครั้งที่สอง
นั่นคือสิ่งที่ XERJ มีไว้สำหรับ มันจัดทำดัชนีโค้ดและให้คุณค้นหาตามปัญหาที่คุณกำลังแก้ไขแทนที่จะค้นหาตามชื่อไฟล์หรือคีย์เวิร์ด จากนั้นดึงการนำไปใช้ที่ตรงกันออกมาเป็น reference ที่คุณสามารถส่งให้ claude ได้โดยตรง https://xerj.org
วิธีใช้งาน
1) คัดลอก/วางพรอมต์การติดตั้งลงในเซสชัน claude code
ติดตั้ง XERJ (เอกสาร:
https://xerj.org/llms.txt ), จัดทำดัชนีซอร์สของโปรเจกต์นี้ และตั้งค่า reference coding: โคลนและจัดทำดัชนี repos โอเพนซอร์สที่ใกล้เคียงกับสิ่งที่เรากำลังสร้างมากที่สุด และค้นหาว่าพวกเขาแก้ปัญหาอย่างไรก่อนที่จะเขียนโค้ด
2) ตรวจสอบการตอบสนองของ coding agent ของคุณและแนะนำโปรเจกต์ที่คุณต้องการโคลนเป็น reference
ไม่ว่าคุณกำลังสร้างอะไร คุณมักจะรู้เสมอว่าใครกำลังทำสิ่งเดียวกันอยู่ โปรเจกต์บางส่วนจะถูกค้นพบโดย claude code ในขั้นตอนนี้แล้ว และคุณสามารถเพิ่มเติมได้ตามที่คุณเลือก 5-10 โปรเจกต์มักจะเพียงพอ แต่ก็ขึ้นอยู่กับสิ่งที่คุณกำลังเขียนโค้ด
3) สร้างฟีเจอร์ผลิตภัณฑ์ถัดไปและตรวจสอบผลลัพธ์
ปล่อยให้มันทำงานและเพลิดเพลิน (หรือไม่) กับผลลัพธ์ใหม่ คุณสามารถกลับไปใช้การเขียนโค้ดแบบสิ้นเปลืองได้เสมอ แต่ฉันมั่นใจว่าคุณจะเห็นความแตกต่างทันที
4) ทำให้มันทำงานต่อไปและช่วยเหลือชุมชนด้วยข้อเสนอแนะของคุณ
ทุกงานที่คุณทำเสร็จด้วยวิธีนี้จะกลายเป็น reference สำหรับงานถัดไป ไลบรารีจะทบต้น ทุกครั้งที่
เมื่อไหร่ที่ควรข้ามมันไป
ถ้าโมเดลรู้จักโค้ดนั้นอยู่แล้ว นี่คือภาษีและไม่มีอะไรอื่น อย่างไรก็ตาม มันไม่ใช่กรณีที่พบบ่อย
พวกเขาวัดสิ่งนั้นด้วย บน valkey และ memcached โค้ดสาธารณะจริงที่ claude ได้รับการฝึกฝนอย่างแน่นอน จากความจำได้คะแนน 6 จาก 6 ด้วยราคา $1.49 การดึงข้อมูลได้คะแนน 5 จาก 6 ด้วยราคา $4.40 มันมาเป็นอันดับสุดท้ายและมีราคาแพงกว่าการไม่ทำอะไรเลยสามเท่า
ดังนั้นเส้นแบ่งคือ โค้ดส่วนตัว เป็นกรรมสิทธิ์ หรือไม่คุ้นเคยอย่างแท้จริงในด้านหนึ่ง และทุกอย่างที่โมเดลกินไปแล้วในอีกด้านหนึ่ง
ถ้าสิ่งที่คุณกำลังสร้างไม่เคยมีใครสร้างมาก่อน ก็ไม่มีอะไรจะชี้ไป และคุณก็กลับไปที่การอธิบายมัน
ถ้า reference ถูกเขียนขึ้นสำหรับเฟรมเวิร์กเวอร์ชันที่คุณไม่ได้ใช้ มันจะเสียค่ามากกว่าที่มันประหยัด
และถ้างานนั้นสั้นแค่สี่บรรทัด ก็แค่เขียนมัน
สิ่งที่ยังเปิดอยู่
13 ไลบรารีถูกสร้างขึ้นเพื่อการศึกษา ซึ่งทำให้มันไม่คุ้นเคยโดยการออกแบบ และยังทำให้มันเล็กอีกด้วย ยังไม่มีใครรันสิ่งนี้กับ codebase ส่วนตัวขนาดใหญ่จริงๆ ความคาดหวังคือช่องว่างจะกว้างขึ้นที่นั่น เนื่องจากต้นทุน grep เพิ่มขึ้นตามขนาดของ tree ในขณะที่การดึงข้อมูลคงที่ แต่นั่นเป็นเพียงการเดาจนกว่าจะมีคนวัดมัน
ทุกตัวเลขด้านบนมาจากเกณฑ์มาตรฐานที่เผยแพร่ของ XERJ เอง ข้อมูลดิบต่อการรันใน repo ของพวกเขา https://xerj.org/case-studies/reference-coding
ข้อสรุป
คุณไม่จำเป็นต้องมีโมเดลอื่น และคุณไม่จำเป็นต้องออกจาก claude code
คุณต้องหยุดเริ่มต้นทุกงานจากศูนย์ เพราะสิ่งที่คุณกำลังสร้างอาจมีอยู่แล้วที่ไหนสักแห่งใน repo ของคุณ หรือในโปรเจกต์โอเพนซอร์สที่แก้ปัญหานั้นเมื่อสองปีก่อน
ถ้ามีคนแก้ปัญหานั้นแล้ว ให้ส่งโค้ดของพวกเขาให้ claude และปล่อยให้มันทำงานจากตรงนั้น และมันไม่เสียค่าใช้จ่ายอะไรคุณเลย แค่พรอมต์เดียว
