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

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

ปัญหาจริงๆ จึงไม่ใช่การที่ AI "ไม่รู้" เพราะแม้แต่คนเราก็ยังมีเรื่องที่ไม่รู้ ปัญหาอยู่ตรงที่ไม่มีอะไรมาหยุดมันตอน "พูดเหมือนรู้" ต่างหาก

โปรเจกต์นี้คือ 2akouwu/reverify บน GitHub เปิดให้ใช้งานภายใต้ไลเซนส์ MIT โดยใช้งานได้ 2 รูปแบบ แบบแรกคือรันเป็นคำสั่งผ่านเทอร์มินัลโดยตรง และแบบที่สองคือรันเป็นตัวกลางเชื่อมต่ออย่าง MCP server ที่เป็นมาตรฐานสำหรับเชื่อมเครื่องมือภายนอกเข้ากับ AI วิธีหลังนี้จะช่วยให้ผู้ช่วย AI เรียกใช้เครื่องมือตรวจสอบข้อมูลได้ทันทีระหว่างทำงาน

สั่งว่าห้ามเดา แต่คนตัดสินก็ยังเป็นคนเดาคนเดิม

ทางแก้ที่ง่ายที่สุดคือเขียนกำกับไว้ในพรอมต์ว่า ห้ามเดา ห้ามแต่งชื่อฟังก์ชันขึ้นมาเอง หรือถ้าไม่แน่ใจก็ให้บอกว่าไม่แน่ใจ

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

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

จากนั้น Reverify จะใช้เครื่องมือตรวจสอบที่ให้ผลลัพธ์แน่นอนเปิดดูไฟล์จริงหรือรันระบบจริง แล้วส่งผลกลับมาว่าคำอ้างนั้นจริงหรือไม่ พร้อมหลักฐานจากผลที่เครื่องมือตรวจพบจริงๆ

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

คำตัดสิน 5 รูปแบบ และแบบที่ยอมรับว่ายังตัดสินไม่ได้

เมื่อส่งคำอ้างเข้าไปตรวจสอบใน Reverify ระบบจะส่งผลการตัดสินกลับมาเป็น 1 ใน 5 รูปแบบนี้:

• VERIFIED ตรวจสอบกับของจริงแล้วพบว่าถูกต้องตามที่อ้าง
• REFUTED ตรวจสอบกับของจริงแล้วไม่ตรง คำอ้างนั้นตกไป
• OBSERVED ไม่มีคำอ้างให้ยืนยัน เป็นเพียงการสั่งให้เครื่องมืออ่านค่าจริงมาให้ดู
• INCONCLUSIVE เครื่องมือตัดสินไม่ได้ เช่น ในเครื่องยังไม่ได้ติดตั้งโปรแกรมวิเคราะห์ที่จำเป็นต้องใช้
• INVALIDATED คำอ้างนี้ใช้อ้างอิงต่อไม่ได้ เพราะใช้คำอ้างอีกข้อที่เพิ่งถูกตัดสินตกไปเป็นสมมติฐานตั้งต้น

สถานะ INCONCLUSIVE คือจุดที่ระบบยอมรับตรงๆ ว่าตัวเองยังตัดสินไม่ได้ ระบบวิเคราะห์พื้นฐานของ Reverify จะส่งสถานะนี้กลับมาทันทีเมื่อเจอข้อมูลที่ยังตรวจไม่ได้ แทนที่จะฝืนเดาคำตอบให้จบไป

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

นอกจากนี้ ทุกคำตัดสินยังแนบหลักฐานกำกับไว้เสมอ ทั้ง SHA-256 รหัสแฮชประจำไฟล์ที่จะเปลี่ยนค่าทันทีถ้าเนื้อหาถูกแก้ไขแม้แต่นิดเดียว เวอร์ชันของ Reverify ที่ใช้ และรายชื่อเครื่องมือที่ใช้ตรวจสอบ รายงานการตรวจสอบจึงส่งต่อให้คนอื่นนำไปรันซ้ำเพื่อพิสูจน์ผลเองได้ โดยไม่ต้องเชื่อตามเฉยๆ

ถ้าอ้างแต่เรื่องจริงที่ไร้สาระ Reverify จะให้คะแนนเกือบศูนย์

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

ผู้พัฒนาคิดถึงปัญหานี้ไว้แล้ว และยกตัวอย่างให้เห็นชัดๆ เช่น AI อาจอ้างว่าไฟล์นี้ขึ้นต้นด้วยตัวอักษร MZ และมีเซกชันชื่อ .text ซึ่งทั้งสองข้อนี้ตรวจยังไงก็ผ่าน แต่ไม่ได้ให้ข้อมูลใหม่ที่มีประโยชน์เลย

Reverify จึงแก้เกมด้วยการนำคำอ้างที่ตรวจผ่านแล้ว มาประเมินน้ำหนักอีกรอบว่าคำอ้างนั้นมีคุณค่าจริงหรือไม่ โดยคำอ้าง 4 รูปแบบนี้จะได้น้ำหนักเท่ากับศูนย์ทันที:

• ข้อความที่แค่พูดซ้ำเอกสารสรุปที่โมเดลได้ดูอยู่แล้วตั้งแต่แรก
• ข้อความที่ซ้ำกับคำอ้างก่อนหน้า
• ข้อความที่อ้างอิงโค้ดหรือข้อมูลที่โมเดลแนบมาเอง โดยไม่ได้มีอยู่ในไฟล์จริง
• ข้อความที่ลอกผลลัพธ์ที่เครื่องมือเพิ่งส่งกลับมาพูดซ้ำ

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

คำตอบทั้งหมดจะถือว่ามีข้อมูลจริงรองรับ ก็ต่อเมื่อเข้าเงื่อนไขครบ 2 ข้อ คือ 1. ไม่มีคำอ้างไหนถูกตีตกเลย และ 2. ได้คะแนนน้ำหนักรวมผ่านเกณฑ์ที่กำหนดไว้ในออปชัน --min-information ซึ่งค่าเริ่มต้นตั้งไว้ที่ 1.0

หลักการนี้ตรงกับที่เราเคยเขียนไว้ในบทความ งานที่ AI ทำแล้วผ่านเทสต์ ไม่ใช่หลักฐานว่าวิธีที่ใช้ถูก เพราะการตอบผ่านแบบกลวงๆ ที่ไม่มีเนื้อหาสำคัญอะไร แม้จะผ่านการตรวจ แต่ก็ไม่มีประโยชน์กับการทำงานจริงเลย

ตัวเลข 97% ที่ต้องเข้าใจให้ถูก และตัวเลขอื่นที่สำคัญกว่า

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

Reverify ออกแบบมาสำหรับงานวิศวกรรมย้อนรอยอย่าง Reverse Engineering ซึ่งเป็นการแกะโปรแกรมเพื่อดูการทำงานภายใน ใน SECURITY.md ผู้พัฒนาระบุขอบเขตการใช้งานไว้อย่างชัดเจนว่า ให้ใช้กับงานที่ได้รับอนุญาตเท่านั้น เช่น การวิเคราะห์มัลแวร์ การแข่งขัน CTF งานวิจัยเพื่อพัฒนาการเชื่อมต่อระหว่างระบบ หรือซอฟต์แวร์ที่เราเป็นเจ้าของและได้รับอนุญาตให้ตรวจสอบ

ปกติถ้าเราถาม AI ลอยๆ ว่าฟังก์ชันนี้เริ่มต้นด้วยคำสั่งอะไร โดยไม่ให้มันเปิดดูไฟล์ โมเดลมักจะตอบตามสูตรสำเร็จในตำรา เช่น push rbp; mov rbp, rsp การทดสอบจึงนำคำตอบตามตำรานี้ไปเทียบกับไฟล์ระบบของจริง แล้วดูว่า Reverify จะตรวจจับได้ถูกต้องแค่ไหน

จากการทดสอบอ้างอิงบน Windows ทั้งหมด 71 ไฟล์ ผลปรากฏว่า:

• ไม่มีไฟล์ไหนเลยที่เครื่องมือตัดสินไม่ได้
• คำตอบตามตำราที่ AI มักเดาขึ้นมานั้น ผิดถึง 69 จาก 71 ไฟล์ คิดเป็น 97%
• Reverify ไม่เคยปล่อยให้คำอ้างผิดหลุดรอดจนถูกยอมรับว่าเป็นจริงเลยแม้แต่ครั้งเดียว คิดเป็น 0 ครั้ง
• และเมื่อป้อนผลลัพธ์จริงที่เครื่องมือตรวจพบกลับไปให้โมเดลดูหนึ่งรอบ โมเดลก็ระบุค่าไบต์ของคำสั่งเริ่มต้นได้ถูกต้องครบทั้ง 71 ไฟล์

อย่างไรก็ตาม ตัวเลข 97% นี้เกิดจากการถามเรื่องคำสั่งเริ่มต้นฟังก์ชันตรงจุดเริ่มทำงานของโปรแกรมในไฟล์ระบบชุดนี้เท่านั้น ซึ่งผู้พัฒนาอธิบายไว้เองว่า โค้ดส่วนนี้ของระบบมักมีรูปแบบเฉพาะตัว ไม่ค่อยเหมือนในตำราทั่วไป ถ้าไปถามฟังก์ชันปกติทั่วไป อัตราความผิดพลาดอาจไม่สูงเท่านี้ จึงไม่ควรเหมารวมว่า AI ตอบผิด 97% ในทุกคำถาม

นอกจากนี้ เบนช์มาร์กไม่ได้ตั้งใจทดสอบเพื่อจับผิดอย่างเดียว เพราะใน 71 ไฟล์ มีอยู่ 2 ไฟล์ที่เริ่มด้วยคำสั่งตามตำราจริงๆ ซึ่ง Reverify ก็ยืนยันความถูกต้องได้อย่างแม่นยำ ส่วนอีก 69 ไฟล์ที่ไม่ตรง Reverify ก็ปฏิเสธครบทั้งหมด

ตัวเลขที่สำคัญกว่า 97% คือ จำนวนครั้งที่ระบบยอมรับคำตอบผิดให้ผ่าน หรือค่า False Verified เพราะโมเดลจะเดาผิดบ่อยแค่ไหน นั่นคือเรื่องของโมเดล แต่หน้าที่สำคัญที่สุดของเครื่องมือตรวจสอบ คือต้องไม่ปล่อยให้คำตอบผิดๆ หลุดรอดไปกลายเป็นข้อเท็จจริง

ผู้พัฒนาเตือนไว้ด้วยว่า ผลลัพธ์ 0 จาก 71 ไม่ได้แปลว่าอัตราความผิดพลาดจะเป็นศูนย์จริงอย่างสมบูรณ์แบบ แต่ในทางสถิติหมายถึงมีโอกาสผิดพลาดต่ำกว่าราว 5% ที่ระดับความเชื่อมั่น 95% และค่าขอบบนนี้จะยิ่งลดลงเมื่อทดสอบกับไฟล์จำนวนมากขึ้นเรื่อยๆ

ผลลัพธ์นี้ไม่ได้มาจากการทดสอบรอบเดียว แต่มาจากทั้งชุดทดสอบอ้างอิง การทดสอบอัตโนมัติบน 3 แพลตฟอร์ม และการทดสอบซ้ำโดยนักพัฒนาภายนอกบนเครื่องสถาปัตยกรรม ARM รวมทั้งหมด 275 ไฟล์ ครอบคลุม 4 รูปแบบไฟล์และสถาปัตยกรรม ผลคือระบบยอมรับคำอ้างผิดเป็นจริง 0 ครั้ง โดยมีขอบบนของความผิดพลาดที่ระดับความเชื่อมั่น 95% อยู่ที่ประมาณ 1.4%

ที่สำคัญคือ เราไม่ต้องเชื่อตัวเลขเหล่านี้แบบลอยๆ เพราะใน BENCHMARK.md มีวิธีรันเบนช์มาร์กให้ทุกคนนำไปทดสอบบนไฟล์ระบบในเครื่องตัวเองได้ โดยผลลัพธ์จะบันทึกเป็นไฟล์ JSON ที่ระบุค่าแฮชของไฟล์ คำตัดสิน และเวอร์ชันเครื่องมืออย่างครบถ้วน ทำให้คนสองคนนำผลมาเทียบกันแบบไฟล์ต่อไฟล์ได้เลย

python benchmarks/prologue_prior.py --per-dir 40 --json my-run.json --fail-on-false-verified

reverify equiv เทียบโค้ดเดิมกับโค้ดใหม่ที่ให้ AI รีแฟกเตอร์

แม้จะไม่ได้ทำงานกับไฟล์ไบนารีเลย Reverify ก็ยังมีคำสั่งหนึ่งที่มีประโยชน์มากกับการเขียนโค้ดทั่วไป

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

คำสั่ง reverify equiv เข้ามาแก้ปัญหานี้โดยตรง โดยจะนำโค้ดต้นฉบับกับโค้ดที่ AI เขียนใหม่มารันด้วยชุดอินพุตเดียวกัน เพื่อดูว่าผลลัพธ์ที่ได้จากอินพุตชุดนั้นตรงกันหรือไม่

reverify equiv reference.py candidate.py --lang python

ปัจจุบันโปรเจกต์รองรับภาษา Python และ C จุดเด่นคือ ถ้าโค้ดทำงานได้ผลลัพธ์ไม่ตรงกัน เครื่องมือไม่ได้แค่บอกว่าไม่ผ่าน แต่จะส่งอินพุตตัวที่ทำให้ผลลัพธ์ต่างกันกลับมาให้ดู พร้อมแสดงผลลัพธ์ของทั้งสองฝั่ง โค้ดที่ AI เขียนใหม่จึงต้องผ่านการพิสูจน์จากการรันจริง ไม่ใช่ผ่านแค่เพราะเราอ่านแล้วรู้สึกว่าน่าจะถูก เป็นแนวคิดเดียวกับ Osloq เครื่องมือที่ทำให้บั๊กจาก GitHub issue เกิดซ้ำจริงพร้อมหลักฐาน

สำหรับการทดสอบความแม่นยำ ผู้พัฒนาเตรียมฟังก์ชันอ้างอิงไว้ 12 ตัว ครอบคลุมทั้งงานคำนวณ การจัดการระดับบิต เงื่อนไขที่ซับซ้อน และการปัดเศษ จากนั้นนำมาเขียนใหม่ฟังก์ชันละ 2 รูปแบบ แบบแรกแก้ไขถูกต้อง และแบบที่สองแอบใส่บั๊กที่แนบเนียน เช่น สลับเครื่องหมาย สลับฟังก์ชัน min กับ max หรือเลื่อนบิตผิดตำแหน่ง พอนำโค้ดที่เขียนใหม่ทั้ง 24 รูปแบบนี้มาทดสอบบน Python พบว่า Reverify ยืนยันโค้ดที่ถูก 12 ตัว และตรวจจับโค้ดที่ผิดได้ถูกต้องครบทั้ง 12 ตัว โดยไม่ยอมรับโค้ดผิดให้ผ่านเลย ส่วนผลการทดสอบฝั่งภาษา C ก็ได้ผลลัพธ์แม่นยำเช่นเดียวกัน

ใช้งานผ่าน MCP Server ข้อมูลที่ตรวจแล้วไม่หาย แม้จะล้างบทสนทนา

การติดตั้งทำได้ง่ายๆ ด้วยคำสั่งเดียว:

pip install reverify

คำสั่งนี้จะได้ฟังก์ชันหลักที่เขียนด้วย Python ล้วน ถ้าต้องการเครื่องมือถอดคำสั่งและอ่านโครงสร้างไฟล์แบบครบชุด เช่น Capstone, Unicorn และ LIEF ให้ติดตั้งด้วยคำสั่ง pip install "reverify[full]" และถ้าต้องการเครื่องมือวิเคราะห์เชิงโครงสร้างด้วย angr ให้ใช้ pip install "reverify[angr]" หรือถ้ายังไม่อยากติดตั้งลงเครื่อง ก็โคลนโค้ดโปรเจกต์มาไว้ในเครื่องแล้วรันคำสั่ง python reverify/cli.py auto sample.bin --json ได้เช่นกัน

สำหรับการใช้งานร่วมกับผู้ช่วย AI ที่เราใช้เขียนโค้ดเป็นประจำ แค่สั่งรัน python reverify/mcp_server.py เพื่อเปิดเป็น MCP Server จากนั้นเครื่องมืออย่าง Claude Code หรือ Cursor ก็จะเรียกใช้เครื่องมือของ Reverify ได้อัตโนมัติ ทั้งการอ่านโครงสร้างไฟล์ ถอดคำสั่ง สแกนไฟล์ หรือส่งคำอ้างไปตรวจสอบความถูกต้อง

เมื่อตรวจสอบเสร็จแล้ว ระบบจะบันทึกผลลัพธ์ที่ผ่านการยืนยันลงในไฟล์ที่ .reverify/ledger/<sha256>.json โดยชื่อไฟล์บันทึกจะผูกกับค่าแฮชของเนื้อหาไฟล์โดยตรง ไม่ได้ผูกกับชื่อไฟล์ ทำให้แม้จะเปลี่ยนชื่อไฟล์ บันทึกนี้ก็ยังใช้งานต่อได้ และทุกครั้งที่ตรวจสอบ ข้อมูลจะบันทึกเก็บไว้เสมอ ทำให้เวลาเราพิมพ์คำสั่ง /clear เพื่อล้างหน้าต่างแชต หรือระบบสรุปย่อบทสนทนาอัตโนมัติ ผู้ช่วย AI ก็ยังดึงข้อเท็จจริงชุดเดิมกลับมาใช้ต่อได้ทันที

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

reverify rollover บันทึกสถานะเพื่อส่งต่องานก่อนพื้นที่ความจำของแชตจะเต็ม

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

reverify rollover จึงใช้วิธีใหม่ โดยดึงสถานะงานมาเขียนเป็นไฟล์สรุปสำหรับส่งต่องานตั้งแต่ตอนที่ข้อมูลและบริบทยังครบถ้วน จากนั้นค่อยเปิดบทสนทนาใหม่โดยเริ่มต้นด้วยการอ่านข้อมูลจากไฟล์นี้ คำสั่งนี้รองรับเครื่องมือสั่งงาน AI ผ่านเทอร์มินัลยอดนิยม ทั้ง Claude Code, Codex, Gemini CLI และ OpenCode

reverify rollover install

คำสั่งนี้จะเข้าไปตั้งค่าในระบบของเครื่องโดยตรง สำหรับ Claude Code โปรแกรมจะเพิ่มคำสั่งอัตโนมัติลงใน ~/.claude/settings.json พร้อมปิดสวิตช์ autoCompactEnabled ที่คอยย่อบทสนทนาอัตโนมัติ ส่วน Codex, Gemini CLI และ OpenCode ก็จะเข้าไปปรับแต่งไฟล์คอนฟิกในลักษณะเดียวกัน โดยระบบจะสำรองไฟล์เดิมไว้ให้เสมอ และยกเลิกการตั้งค่าทั้งหมดได้ด้วยคำสั่ง reverify rollover uninstall รวมถึงมีคำสั่ง reverify rollover doctor ไว้ตรวจสอบสถานะการเชื่อมต่อ

ขอบเขตและสิ่งที่ Reverify ไม่ได้รับประกัน

ข้อแรกและเป็นเรื่องสำคัญที่สุด Reverify ตรวจสอบได้เฉพาะคำอ้างที่มีเครื่องมือตรวจวัดได้จริงเท่านั้น เช่น ค่าตัวเลขที่อ่านจากไฟล์ ชุดคำสั่งที่ถอดออกมาได้ หรือผลลัพธ์จากการรันโค้ดจริง แต่สำหรับคำตอบประเภทความคิดเห็น เช่น โค้ดนี้ออกแบบดีหรือยัง ควรเลือกใช้สถาปัตยกรรมแบบไหน หรือทีมควรย้ายเทคโนโลยีหรือไม่ เรื่องพวกนี้ไม่มีหลักฐานจริงให้เปิดตรวจ ดังนั้น การติดตั้ง Reverify ไม่ได้ทำให้ AI เลิกตอบมั่วในทุกเรื่อง เพียงแต่เรื่องไหนที่ตรวจเช็กได้ คำตอบที่มั่วจะไม่เล็ดลอดไปเป็นข้อเท็จจริงเงียบๆ อีกต่อไป

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

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

คำถามเดียวที่ใช้ได้ทันที โดยไม่ต้องติดตั้งอะไรเลย

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

ส่วนข้อมูลที่ยังตรวจสอบไม่ได้ ให้มองเป็นเพียงข้อเสนอแนะหรือสมมติฐาน อย่าเพิ่งด่วนสรุปว่าเป็นข้อเท็จจริง

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

ที่มา:

• บทความ GitHub - 2akouwu/reverify: Stop your AI from making things up จาก GitHub
• บทความ reverify/BENCHMARK.md at main จาก GitHub