วิธีเปลี่ยน Opus 5.5 ให้เป็นเครื่อง Reverse Engineering ด้วย 8 ขั้นตอน (คอร์สเต็ม)

เมื่อวันที่ 8 ตุลาคม 2026 มี repository ที่ไม่มีใครเคยได้ยินชื่อเมื่อสามเดือนก่อน พุ่งขึ้นไปอยู่อันดับหนึ่งบน GitHub trending

มันมีชื่อว่า REA หรือ Reverse Engineer Anything ซึ่งมอบ disassembler ของจริงให้กับ agent ของคุณ

**บุ๊กมาร์กหน้านี้ไว้ - ถ้าคุณอยากอ่านฉบับเต็ม หลักสูตร 20 บทเรียนเรื่องนี้มีให้เรียนแล้วที่**

reacourse.xyz

มันจะพาคุณจากหน้าจอ terminal เปล่าๆ ไปจนถึงการ rebuild ที่ผ่านการทดสอบความเท่าเทียม (parity test) ของตัวเองได้ โดยเขียนทุกคำสั่งและ prompt ไว้ให้ครบถ้วน เริ่มที่นี่เลย

ปฏิกิริยาตอบรับในสัปดาห์นั้นเหมือนกันไปหมดทุกที่

Matthew Berman สรุปมันออกมาเป็นสามคำ และมีคนเห็นถึง 3.6 ล้านคน

https://x.com/MatthewBerman/status/2108245653843509415

REA คือ MCP server แบบ open-source พร้อม CLI ที่เสียบเข้ากับ Claude Code, Codex, Cursor และ Gemini CLI ได้ทันที

ใช้ไลเซนส์ MIT สร้างโดย morluto ปล่อยเวอร์ชันแรกเมื่อวันที่ 12 กรกฎาคม 2026 และอีกสามเดือนต่อมาก็ทะลุ 100,000 GitHub stars

ทุกอย่างรันบนเครื่องของคุณเอง และข้อสรุปทั้งหมดจะถูกติดแท็กว่าเป็น observation (สิ่งที่สังเกตได้), inference (การอนุมาน) หรือ unknown (สิ่งที่ไม่ทราบ) พร้อมระบุ address หรือ call site ที่เป็นต้นตอไว้เบื้องหลัง

นี่คือเส้นทางทั้งหมดจาก binary ที่ถูกปิดตาย ไปสู่การ rebuild ที่คุณเป็นเจ้าของ ในแปดขั้นตอน

ก่อนเข้าขั้นตอน: สิ่งที่คนอื่นสร้างเสร็จไปแล้วด้วยเครื่องมือนี้

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

ArtCraft สร้างแอป Adobe ขึ้นมาใหม่เจ็ดตัวในฐานะทางเลือก open-source ฟรี จากนั้นก็หันมาลุย Office ด้วย WordCraft, GridCraft และ DeckCraft

ตอนนี้มีสิบสองแอป เขียนขึ้นใหม่ทั้งหมดตั้งแต่ศูนย์ด้วยภาษา Rust รันแบบ native บนสามแพลตฟอร์ม และยกเว้นเพียงแอปเดียวที่เหลือทั้งหมดรันในแท็บเบราว์เซอร์ผ่าน WebAssembly ได้ด้วย

ในฝั่งเกม หลักฐานยิ่งชัดเจนกว่า:

• Super Mario Sunshine ถูกพอร์ตลง PC แบบ native: ใช้เวลา agent ประมาณ 365 ชั่วโมง และ 17.3 พันล้าน tokens โดยใช้ Claude ร่วมกับ Codex
• เกม Touhou ที่ถูกสร้างใหม่ด้วย agent บนบล็อกทางการของ REA: 697 ฟังก์ชัน ตรงกันเป๊ะ 696 ฟังก์ชัน เล่นได้ในเวลาประมาณ 12 วัน
• แอป Aegis authenticator (3,077 คลาส) ถูกแยกชิ้นส่วนและประกอบกลับขึ้นมาใหม่ โดยเทสต์เคสทั้ง 133 รายการผ่านทั้งหมด
• ฟังก์ชัน sound-pan ของ DX-Ball ถูกเขียนใหม่ด้วยภาษา C ผ่านเทสต์เคส x86 เดิม 3,205 รายการ และสร้างไบต์ที่คอมไพล์แล้วกลับมาได้ครบทั้ง 63 ไบต์

สังเกตให้ดีว่ารายการข้างบน "ไม่ใช่" อะไร

ไม่มีใครแคร็กการตรวจสอบไลเซนส์ ไม่มีใครเผยแพร่ซอร์สโค้ดของคนอื่น

ทุกรายการคือการกู้คืนพฤติกรรม (behavior) จดบันทึกไว้ แล้วเขียนขึ้นมาใหม่ด้วยโค้ดชุดใหม่

01. สำรวจเป้าหมายก่อนเปิดอะไรก็ตาม

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

https://x.com/RoundtableSpace/status/2109165852578992582

รายชื่อนั้นคือการตัดสินใจแรกที่คุณต้องทำ วิธีที่ทำให้เสียเวลาบ่ายไปทั้งวันได้ง่ายที่สุด คือการคว้า disassembler มาใช้ทั้งที่เป้าหมายเป็นแอป Electron ที่มี JavaScript วางอยู่ตรงหน้าแล้ว

ชี้ REA ไปที่แอป Electron คุณจะได้ modules, imports และขอบเขต IPC ภายในไม่กี่วินาทีโดยไม่ต้องใช้ engine ใดๆ เลย ในขณะที่ไฟล์ Mach-O หรือ ELF แบบ native จะเปิดฐานข้อมูล Hopper ซึ่งเป็นเส้นทางที่ลึกกว่าและช้ากว่า

การรู้ว่าคุณกำลังอยู่กับไฟล์แบบไหนช่วยประหยัดเวลาได้หลายชั่วโมง ดังนั้นทำให้มันเป็นหน้าที่ของ prompt แรกของคุณ

1ฉันต้องการเข้าใจว่า [ฟีเจอร์] ทำงานอย่างไรใน [แอป] ซึ่งอยู่ที่ [พาธแบบสมบูรณ์]
2    ก่อนอื่นบอกฉันว่าเป้าหมายนี้เป็นประเภทไหน (native, Electron/JS, .NET, Go, APK, WASM)
3    และเลือกเครื่องมือ REA ที่ถูกต้องเพื่อเปิดมัน อย่าเพิ่งเริ่มวิเคราะห์เชิงลึก
4    จากนั้นสรุปภาพรวมในหนึ่งย่อหน้า: มันสร้างด้วยอะไร ขนาดใหญ่แค่ไหน และคุณจะ
5    เริ่มมองหา [ฟีเจอร์] ที่ไหนก่อน แยก observations, inferences และ unknowns ออกจากกัน

ส่วนที่แทบไม่มีใครพูดถึง: เกม Unity หลายเกมส่ง logic มาในรูปแบบ .NET และ REA ก็อ่าน .NET ได้โดยไม่ต้องใช้ engine เสริม

นั่นคือเหตุผลทั้งหมดที่ทำให้เกม Steam ที่ซื้อมา เปลี่ยนจาก binary กลายเป็น C# ที่แก้ไขได้ภายในครึ่งชั่วโมง

และแอป Electron ทุกตัวในเครื่องของคุณอ่านได้ทันที โดยไม่ต้องแม้แต่จะเปิดมัน:

1# ตำแหน่งที่เก็บ JavaScript
2macOS:   /Applications/<App>.app/Contents/Resources/app.asar
3Windows: C:\Users\<you>\AppData\Local\Programs\<App>\resources\app.asar
4    npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app --json

02. ติดตั้งในห้านาที แล้วเพิ่ม engine หนึ่งตัว

สิ่งที่ทำให้ระบบนี้ทำงานได้ไม่ใช่ prompt ที่ชาญฉลาด แต่มันคือ disassembly engine ของจริงที่เชื่อมต่อกับ agent ซึ่งตรงกับที่นักพัฒนารายหนึ่งอธิบายไว้เป๊ะๆ

https://x.com/techNmak/status/2108431092462338178

การ setup จะลงทะเบียน MCP server กับ agent ของคุณ และติดตั้ง workflow skill ที่จับคู่กัน

มันจะแสดงการเปลี่ยนแปลงทุกครั้งก่อนเขียนอะไรลงไป และสำรองข้อมูลในส่วนที่มันเข้าไปแตะต้อง

node -v # Node 22.19+, 24.11+ หรือ 26+ ไม่รองรับเวอร์ชัน 23 และ 25

1npx rea-agents@latest setup          # ลงทะเบียน MCP server ถามก่อนเขียนทับ
2npm install --global rea-agents      # คำสั่งสั้นๆ อย่าง rea ใช้ได้ตลอดไป
3rea --help
4# รีสตาร์ท agent แล้วตรวจสอบ doctor ทำแค่ตรวจสอบ ไม่เคยเปลี่ยนอะไร
5npx -y rea-agents@latest doctor --client claude_code --json

การรีสตาร์ทสำคัญกว่าที่คิด: เซสชัน terminal ต้องเริ่มใหม่ทั้งหมด และแอปเดสก์ท็อปต้อง quit ออกจริงๆ เพราะแค่ปิดหน้าต่างนั้นไม่พอ

จากนั้นเพิ่ม engine เฉพาะสำหรับสิ่งที่คุณต้องการอ่านจริงๆ:

มีไฟล์หนึ่งที่ควรเขียนก่อนเจอเป้าหมายจริงครั้งแรก: กฎประจำบ้านใน claude-md

วิเคราะห์เฉพาะสิ่งที่คุณเป็นเจ้าของ ติดแท็กทุกข้ออ้างว่าเป็น observation, inference หรือ unknown อ้างอิง address ที่อยู่เบื้องหลัง และอย่าปล่อยให้พฤติกรรมที่กู้คืนมานับว่าเสร็จสมบูรณ์จนกว่าจะผ่านการทดสอบ

1# โปรแกรมและเกมแบบ native: Ghidra 12.1.x และ JDK 21 หรือใหม่กว่า
2    export GHIDRA_INSTALL_DIR=/absolute/path/to/ghidra_12.1.4_PUBLIC
3    export JAVA_HOME=/absolute/path/to/jdk-21
4    npx -y rea-agents@latest doctor --provider ghidra --json
5
6    # แอป Android: JDK 17+ และ jadx-headless-mcp 0.7.1
7    export REA_JADX_MCP_JAR=/absolute/path/jadx-headless-mcp-0.7.1-all.jar
8    rea inspect-android-package /path/App.apk
9
10    # bytecode ของ smart contract ปัจจุบันรองรับ Linux x64
11    rea inspect-evm-interface ./runtime.hex hex --json

03. การลาดตระเวน: แผนที่ต้องมาก่อนโค้ด

อย่าเพิ่งเปิดดูฟังก์ชันใดเลย

คำสั่งเดียวจะบอกคุณว่า binary นี้รันบนเครื่องแบบไหน มีกี่ฟังก์ชันอยู่ข้างใน และมีข้อความที่อ่านได้อะไรบ้างซ่อนอยู่

ข้อความเหล่านั้นคือเบาะแสที่เร็วที่สุดที่คุณจะได้ในวันนี้: endpoints, error strings และชื่อฟีเจอร์ต่างๆ ล้วนอธิบายตัวแอปได้ก่อนที่คุณจะอ่าน logic ใดๆ เสียอีก

1rea.open_binary        { path: "/Applications/Target.app/Contents/MacOS/Target" }
2rea.binary_overview    {}
3  arch:        arm64
4  functions:   1,284 identified
5  entry:       _main @ 0x1000051c0
6
7rea.search             { query: "http" }
8  0x10004a2c0  "https://api.target.app/v3/sync"
9  0x10004a300  "Authorization: Bearer "
10
11rea.xrefs              { address: "0x100012ab0" }
12  147 references  ->  core config loader, called everywhere

REA นับว่าแต่ละฟังก์ชันถูกเรียกใช้กี่ครั้ง และตัวเลขนั้นก็คือ cross-reference number

ฟังก์ชันที่ถูกเรียก 147 ครั้งคือโครงสร้างหลักของแอป ส่วนฟังก์ชันที่ถูกเรียกสองครั้งคือตัวช่วยที่รอได้

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

04. Decompile หนึ่งฟังก์ชัน แล้วให้ Opus ตั้งชื่อทุกอย่างในนั้น

Decompiler จะแปลงคำสั่งเครื่องดิบๆ กลับมาเป็นสิ่งที่ใกล้เคียงภาษา C

ผลลัพธ์ที่ได้จะยังหยาบๆ: ชื่ออย่าง var_28, การ cast เต็มไปหมด, branch ที่พันกันยุ่งเหยิง และความหยาบนั้นก็ไม่มีปัญหา เพราะโมเดลต้องการแค่อ่านออกเท่านั้น

1# หนึ่งฟังก์ชันตาม address เป็น JSON ที่บันทึกและใช้ซ้ำได้
2rea decompile /path/to/Target 0x100012ab0 --provider hopper --json > fn_config.json
3
4# หรือค้นหาตามชื่อแล้วติดตาม reference ของมัน
5rea function /path/to/Target parseConfig --provider hopper --json
6rea xrefs    /path/to/Target 0x100012ab0 --provider hopper --json

แล้วยื่นผลลัพธ์นั้นให้ Opus 5.5 เพื่อให้มันทำในสิ่งที่ disassembler ทำไม่ได้:

1นี่คือ pseudocode ที่ได้จากการ decompile ฟังก์ชันที่มี 147 cross-references
2
31. เปลี่ยนชื่อตัวแปรทุกตัวตามวิธีการใช้งาน และอธิบายวัตถุประสงค์ในหนึ่งประโยค
42. ระบุโครงสร้างข้อมูลที่มันอ่านและเขียน พร้อมตั้งชื่อแพทเทิร์นที่มันใช้
53. เขียนใหม่ให้เป็นโค้ดที่สะอาดและเป็นธรรมชาติในภาษาที่ calling conventions บ่งบอก
64. แจ้งเตือนหากขาดการจัดการ error, การตรวจสอบ input หรือการตรวจสอบความปลอดภัย
7
8คิดที่ระดับ effort xhigh ก่อนตอบ ทำเครื่องหมายในจุดที่คุณไม่แน่ใจ

Opus 5.5 มาพร้อมระดับ effort ห้าระดับ: low, medium, high, xhigh และ max

Medium ใช้ตรวจสอบและนำทาง, high ใช้อธิบายฟังก์ชันทั่วไป, max สำหรับโค้ดที่ถูก obfuscate และการคำนวณ pointer ที่ซับซ้อน

Effort คือปุ่มปรับคุณภาพที่สำคัญที่สุดใน pipeline นี้ และคนส่วนใหญ่ปล่อยไว้ที่ค่าเริ่มต้นแล้วก็มาโทษโมเดล

Decompilation บอกคุณว่าโค้ด "ทำอะไร" ส่วนโมเดลบอกคุณว่า "ทำไม" และให้ชื่อเพื่อนำไปสร้างมันขึ้นมาใหม่

05. Obfuscation: แกะในจุดที่คุ้มค่า จัดสรรงบประมาณให้ส่วนที่เหลือ

บางแอปถูกสร้างมาเพื่อต้านทานสิ่งที่คุณกำลังทำโดยเฉพาะ: สลับตำแหน่ง logic, เข้ารหัส string, เพิ่ม branch ปลอมๆ ขึ้นมาเพื่อกวนสมาธิคุณล้วนๆ

นี่คือจุดเดียวที่แม้แต่โมเดลที่ดีที่สุดก็ยังติดขัด และมีตัวเลขยืนยันเรื่องนี้

Elastic Security Labs ทดสอบให้ Claude Opus เจอกับ Tigress scrambler ใน 20 งาน และได้บทเรียนออกมาสองข้อ

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

กฎที่ใช้ได้จริงคือการจัดสรรงบประมาณ "ต่อฟังก์ชัน" ไม่ใช่ต่อเซสชัน

ตัดส่วนขยะออกไปก่อน เพราะเครื่องมือฟรีที่ชื่อ Caveman กำจัดขยะจากการ decompile ได้ประมาณ 75% ทำให้โมเดลเอาสมาธิไปลงกับ logic จริงๆ ได้

1ฟังก์ชันนี้ดูเหมือนถูก obfuscate ให้ทำงานที่ระดับ effort max
2
31. ระบุเทคนิคที่ถูกใช้ (control-flow flattening, opaque predicates,
4   dead code, string encryption, function splitting) และชี้ให้เห็นแต่ละจุด
52. แก้ไขมัน: ลบ branch ที่ตายแล้ว, ประเมิน opaque predicates, คลี่ dispatch,
6   ถอดรหัส inline string หากกู้ key กลับมาได้ แสดงให้เห็นว่าเหลืออะไรอยู่
73. ให้คะแนนความมั่นใจ 1-10 หากต่ำกว่า 6 ให้ระบุส่วนที่ไม่แน่ใจและบริบทที่จะ
8   ช่วยไขข้อสงสัยได้ อย่าเดาเงียบๆ

06. Swarm: ตัวควบคุมหนึ่งตัว คนงานหลายคน

แชทเดียวไม่สามารถอ่าน 500 ฟังก์ชันได้ดีพอ

มันลืมสิ่งที่เห็นไปเมื่อสี่สิบฟังก์ชันก่อน ตั้งชื่อ struct เดียวกันสามแบบ และเริ่มขัดแย้งกับตัวเองเงียบๆ

ทางแก้ไม่ใช่การเพิ่ม context แต่คือการแบ่งบทบาท: ตัวควบคุม (controller) ที่แจกจ่ายงาน และคนงาน (worker) ที่แต่ละตัวรับไปหนึ่งฟังก์ชันแล้วหยุด

1คุณคือ controller ด้าน reverse-engineering แผนที่ฟังก์ชันอยู่ใน functions.json
2(address, name, size, xref_count)
3
41. จัดกลุ่มฟังก์ชันตามความใกล้ชิดใน call-graph เรียงลำดับกลุ่มตาม xref count
52. ส่งแต่ละกลุ่มให้ worker ห้ามวิเคราะห์ฟังก์ชันด้วยตัวเองเด็ดขาด
63. แทรก struct ที่แก้ได้แล้วลงใน brief แต่ละฉบับเพื่อให้ชื่อสอดคล้องกัน
74. ความมั่นใจที่ต่ำกว่า 6 จะต้องผ่านรอบที่สองโดยใช้ context จากฟังก์ชันข้างเคียงที่แก้แล้ว
85. ติดตามการใช้ token สะสมและรายงานหลังจบแต่ละกลุ่ม
9
10คุณคือ worker คุณจะได้รับฟังก์ชันที่ decompile แล้วหนึ่งฟังก์ชันและ struct ที่แก้ได้ sejauhนี้
11ส่งกลับเฉพาะ: address, purpose, confidence (1-10), structs_used, structs_new,
12clean_source, flags ใช้ชื่อ struct ที่มีอยู่แล้ว ห้ามตั้งชื่อที่สองให้
13struct ที่ controller ให้มาแล้ว วิเคราะห์ทีละหนึ่งฟังก์ชัน หยุดเมื่อเสร็จ

REA ยังมี guided workflow ที่ฝังมากับ MCP server ซึ่งคนส่วนใหญ่ไม่เคยเปิดดู:

• - investigate_feature - ติดตามฟีเจอร์ตั้งแต่ตอนค้นพบไปจนถึงฟังก์ชันที่เกี่ยวข้อง
• - compare_application_versions - เปรียบเทียบสองเวอร์ชันเพื่อดูว่าอะไรเปลี่ยนไปจริงๆ
• - verify_reconstruction - ตรวจสอบการ rebuild ของคุณเทียบกับหลักฐานที่บันทึกไว้
• - audit_residual_unknowns - ระบุว่ายังมีอะไรที่ยังพิสูจน์ไม่ได้บ้าง

07. Clean room: กำแพงระหว่างสอง context คือผลงานที่แท้จริง

การ rebuild แบบ clean-room หมายถึงคุณคัดลอกสิ่งที่แอปทำ แต่ไม่คัดลอกโค้ดข้างในมัน

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

นี่คือวิธีการที่มีอายุ 40 ปี ไม่ใช่สิ่งประดิษฐ์ใหม่ในปี 2026

ในช่วงต้นยุค 80 Compaq สร้าง BIOS ของ IBM ขึ้นมาใหม่ด้วยวิธีนี้ด้วยงบประมาณ 1 ล้านดอลลาร์ ซึ่งเป็นเหตุผลเดียวที่ทำให้ PC แบรนด์อื่นๆ มีตัวตนอยู่บนโลก

ในปี 1992 ศาลในคดี Sega v. Accolade ตัดสินว่าการแยกชิ้นส่วนโค้ดอาจถือเป็นการใช้งานอย่างเป็นธรรม (fair use) หากเป็นวิธีเดียวที่จะเข้าใจว่ามันทำงานอย่างไร และในปี 2000 Sony แพ้คดี Sony v. Connectix ด้วยคะแนน 3-0 เพราะอีมูเลเตอร์ที่สร้างเสร็จไม่มีโค้ดของ Sony อยู่เลยแม้แต่น้อย

อีกฝั่งของเส้นแบ่งก็ชัดเจนไม่แพ้กัน: ในปี 2011 George Hotz ตกลงยอมความกับ Sony และยอมรับว่าจะหยุดหลังจาก root key ของ PS3 ถูกเปิดเผยต่อสาธารณะ

กฎสี่ข้อนี้จะช่วยให้คุณอยู่ถูกฝั่ง และทีม ArtCraft ก็ตรวจสอบทั้งสี่ข้อโดยอัตโนมัติในทุก build:

• - สังเกต แต่ห้ามคัดลอก รันเป้าหมายแบบ black-box ถ่ายภาพหน้าจอเฉพาะหน้าต่างของมัน ห้ามวางโค้ดของมันลงในโปรเจกต์ของคุณ
• - ใช้ spec ไม่ใช่ซอร์ส รูปแบบไฟล์ต้องมาจากมาตรฐานสาธารณะ (OOXML คือ ECMA-376 / ISO 29500 รวมถึง spec ของ RTF และ ODF ที่เผยแพร่แล้ว) ห้ามมาจากการอ่าน parser ของคู่แข่ง
• - ใช้ asset ดั้งเดิมเท่านั้น ไอคอน ฟอนต์ เทมเพลต และเสียงทุกอย่างต้องวาดขึ้นด้วยโค้ด เป็น public-domain หรือใช้ไลเซนส์แบบเปิด พร้อมระบุบรรทัดหนึ่งในไฟล์ attribution
• - แยกสองงานนี้ออกจากกัน agent ตัวหนึ่งกู้คืนพฤติกรรมและเขียน spec อีก context หนึ่งนำไปพัฒนาต่อจาก spec นั้นเพียงอย่างเดียว

กฎข้อสุดท้ายคือข้อที่คนชอบข้ามไป และมันคือเส้นแบ่งที่แท้จริง

agent ที่ทำหน้าที่สืบสวนของคุณปนเปื้อนไปแล้วตามนิยาม เพราะมันอ่าน decompile มาแล้ว ส่วน agent ที่ทำหน้าที่สร้างต้องไม่ปนเปื้อน

1จากการวิเคราะห์ที่เสร็จสมบูรณ์ ให้เขียน clean-room specification สำหรับการนำมาสร้างใหม่
2
3อธิบายเฉพาะพฤติกรรม (BEHAVIOR): ทุก public interface, data model, ฟีเจอร์ที่ผู้ใช้มองเห็นแต่ละอย่าง
4ในรูปแบบ requirement ที่ทดสอบได้, รูปแบบไฟล์ที่อ่านและเขียน, การจัดการ error
5
6ห้ามใส่ addresses, offsets, ชื่อตัวแปรจากการ decompile, assembly หรือสิ่งใดๆ
7ที่คัดลอกจากต้นฉบับ นักพัฒนาที่ไม่เคยเห็น binary นี้ต้องสามารถ
8สร้างเวอร์ชันที่เข้ากันได้จากเอกสารนี้เพียงอย่างเดียว
9
10หัวข้อ: Architecture, Data Model, Public API, File Formats, Test Cases

การทำงานจากคำอธิบายไม่ใช่แค่เกราะป้องกันทางกฎหมาย

แต่มันยังให้คุณตัดสินใจเลือกสิ่งที่เหมาะสมกับภาษาของคุณเอง แทนที่จะต้องรับมรดกการตัดสินใจที่ใครบางคนทำไว้เมื่อสองทศวรรษก่อน ซึ่งเป็นเหตุผลว่าทำไม WordCraft ถึงเร็วกว่า Word ในบางจุด

08. ตรวจสอบความเท่าเทียม แล้วปล่อยมันผ่าน MCP

คุณไม่เคยมีซอร์สโค้ดต้นฉบับ ดังนั้นคุณจึง diff ทีละบรรทัดไม่ได้

คุณต้องเปรียบเทียบพฤติกรรม: ใส่ input เดียวกันลงในทั้งสอง build แล้วได้ output กลับมาเหมือนกัน

1สร้าง behavioral test harness เพื่อเปรียบเทียบ binary ต้นฉบับกับการ rebuild ของฉัน
2
3สร้าง input 50 ชุด: ปกติ 30 ชุด, ขอบเขต 10 ชุด (ว่างเปล่า, ขนาดสูงสุด, unicode), error 10 ชุด
4(รูปแบบผิด, ไฟล์เสีย) รันแต่ละชุดผ่านทั้งสองฝั่ง เปรียบเทียบแบบ byte-for-byte ในจุดที่ทำได้
5และเปรียบเทียบเชิงความหมายในจุดที่เหลือ รายงานอัตราความตรงกัน จุดที่แตกต่าง และระดับความรุนแรงของแต่ละจุด
6(รูปลักษณ์ / พฤติกรรม / วิกฤต) บันทึกลง report.md

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

จากนั้นปล่อยการ rebuild ออกมาในแบบที่ REA และแอปตระกูล Craft ทำ นั่นคือเป็น MCP server เพื่อให้ agent ของคนถัดไปขับเคลื่อนเครื่องมือของคุณได้เหมือนที่คุณขับเคลื่อน REA

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

1claude mcp add wordcraft -- wordcraft-cli mcp
2
3> เปิด report.docx, ทำให้หัวข้อทุกอันเป็นตัวหนาขนาด 14pt, ส่งออกเป็น PDF
4  ok  select.all-headings -> 12 selected
5  ok  format.font-size 14 . format.bold
6  ok  export report.pdf (selectable text, bookmarks kept)

ข้อจำกัด และข้อผิดพลาด 5 ข้อที่ทำให้เสียวันหยุดสุดสัปดาห์ไปฟรีๆ

REA ไม่สามารถแตะต้องเซิร์ฟเวอร์ได้ เพราะมันอ่านเฉพาะสิ่งที่อยู่ในเครื่องของคุณ และโค้ดที่รันอยู่บนเซิร์ฟเวอร์ของบริษัทไม่เคยถูกส่งมาถึงคุณ

โค้ดที่ได้จากการ decompile เป็นการประกอบร่างขึ้นมาใหม่ ไม่ใช่ซอร์สโค้ดต้นฉบับ ซึ่งเป็นเหตุผลทั้งหมดที่ทำให้ต้องมีขั้นตอนที่ 08

binary ภาษา C++ ที่ถูก strip ยังคงยากกว่าเกม Unity .NET มาก และ engine เชิงพาณิชย์ก็ยังต้องใช้ไลเซนส์จริง

• - เปิด disassembler กับแอป Electron ทั้งที่ JavaScript วางอยู่ตรงหน้า
• - ดัมพ์ binary ทั้งหมดก่อนจะอ่านสรุป ซึ่งทำให้ logic จมหายไปและค่าใช้จ่ายพุ่งสูง
• - อ่านฟังก์ชันตามลำดับไฟล์แทนที่จะเรียงตามจำนวน cross-reference
• - ปล่อยให้โมเดลคัดลอกโค้ดเข้ามาในการ rebuild ของคุณ ซึ่งทำลายหลักการ clean room ทันทีที่กดวาง
• - ปล่อยงานโดยไม่ทำ parity report

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

ศึกษาจากต้นฉบับ แล้วปล่อยผลงานของคุณเอง

ทั้งแปดขั้นตอนนี้มีบทเรียนรองรับอยู่ที่

reacourse.xyz พร้อม prompt ที่ใช้จริง รูปแบบความล้มเหลว และจุดที่วิธีนี้ใช้ไม่ได้ผลอีกต่อไป

เมื่อก่อน closed source แปลว่าคุณจะไม่มีวันรู้

ตอนนี้มันแปลว่า เอาหลักฐานมาดูสิ

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

แต่คนส่วนน้อยที่เรียนรู้วิธีอ่านซอฟต์แวร์ จะสร้างอะไรก็ได้ตามที่ใจต้องการ

ติดตามผมและสมัครรับข้อมูลจากช่อง Telegram ของผม:

https://t.me/+75nMf005jRpjMDU1