Alles rückentwickeln mit Opus 5.5 (Komplettkurs)

Die meisten, die versuchen, eine Binärdatei per Reverse Engineering zu knacken, öffnen sie in einem Hex-Editor, scrollen zwanzig Minuten lang herum – und geben auf.

Sie wissen nicht, mit welchem Tool die Datei geladen wird. Sie wissen nicht, welcher Prompt die Logik ans Licht bringt. Und sie haben keine Ahnung, wie man aus einer unübersichtlichen Wand voller Assembler-Code etwas macht, das sich tatsächlich nachbauen lässt.

Dieser 11-Schritte-Kurs verwandelt Claude Opus 5.5 in eine Open-Source-Maschine für einfach alles.

Folge meinem Substack für frische AI-Alpha:

movez.substack.com

Beim Reverse Engineering geht es nicht ums Knacken. Es geht darum, eine Sache so gut zu verstehen, dass du deine eigene Version bauen kannst.

Am 7. Oktober 2026 postete Amjad Masad, der CEO von Replit, eine einzige Zeile:

https://x.com/amasad/status/2107671204639465961

Darunter antwortete ein Entwickler namens @morluto mit dem Beweis: einem Set an Tools, mit denen Agents Hopper und Ghidra steuern und dabei erstaunlich weit kommen können.

Dieses Projekt heißt REA und hat innerhalb weniger Tage über 110.000 GitHub-Stars gesammelt.

https://github.com/morluto/rea

Das ist kein leeres Marketing-Versprechen. In derselben Woche veröffentlichte das Open-Source-Projekt WordCraft einen Clean-Room-Nachbau von Microsoft & Adobe in purem Rust:

https://getartcraft.com/apps

Entstanden ist er ausschließlich durch Beobachtung des Verhaltens von Word & Adobe sowie das Lesen öffentlicher Dateiformat-Spezifikationen – ohne jemals deren Code anzusehen.

Dieser Kurs zeigt dir den gesamten Weg von einer versiegelten Binärdatei bis zu genau so einem Nachbau – wobei Opus 5.5 das Lesen übernimmt.

01. Die Engine – wie ein Agent eine Binärdatei liest

Opus 5.5 kann keinen Disassembler selbst ausführen. Das Modell liest Text und schreibt Text.

Reverse Engineering mit einem Agent funktioniert, weil ein Tool zwischen dem Modell und der Binärdatei sitzt: Es lädt die Datei in eine echte Disassembly-Engine, stellt die Ergebnisse als aufrufbare Funktionen bereit und lässt das Modell Fragen stellen.

Dieses Tool ist REA, und die Engine dahinter ist Hopper, Ghidra oder IDA.

Der Ablauf ist simpel und wiederholt sich ständig: Das Modell bittet REA, das Ziel zu untersuchen, REA liefert Ergebnisse samt exakter Belege (Adressen, Bytes, Pseudocode, Call Sites), und das Modell nutzt diese Erkenntnisse, um die nächste Frage zu stellen oder eine Neuimplementierung zu schreiben und zu testen.

Alles läuft lokal auf deinem Rechner. Hochgeladen wird nichts außer den Erkenntnissen, die das Modell zum Schlussfolgern braucht – und jede Schlussfolgerung wird als Beobachtung, Ableitung oder Unbekannt markiert.

**

02. Die Installation – rea-agents plus ein Disassembler

Beim Setup wird der MCP-Server von REA bei deinem Agent registriert und die passenden Workflow-Anweisungen werden installiert.

Ein einziger Befehl erledigt das. Er zeigt dir jede Änderung, bevor etwas geschrieben wird, und erstellt Backups von allem, was er anfasst.

Den Disassembler bringst du selbst mit: Hopper unter macOS ist der einfachste Weg, Ghidra ist kostenlos und plattformübergreifend, IDA nimmst du, wenn du es bereits besitzt.

1# 1. REA bei deinem Agent registrieren (Claude Code, Codex, Cursor, Gemini CLI ...)
2npx rea-agents setup            # zeigt geplante Änderungen, fragt vor dem Schreiben
3
4# 2. Ein Anbieter für Tiefenanalysen. Hopper läuft unter macOS am rundesten;
5#    das Setup kann ihn nach Bestätigung installieren. Ghidra und IDA bringst du selbst mit.
6# 3. Die rea-CLI für Terminalnutzung und Skripting installieren
7npm install --global rea-agents
8rea --help
9
10# 4. Deinen Agent neu starten und prüfen, ob die Tools aktiv sind
11claude
12> /mcp
13  rea: connected
14    open_binary, binary_overview, analyze_function, decompile,
15    list_procedures, search, xrefs, trace, inspect_artifact,
16    analyze_javascript_application, inspect_managed_artifact ...

Die Anforderungen sind bescheiden: Node.js 22 oder neuer und npm. Für native Analysen brauchst du eine der drei Engines; statische JavaScript- und .NET-Untersuchungen kommen ganz ohne Engine aus. Halte REA aktuell, denn die Releases bringen häufig Fixes.

1# Spielregeln fürs Reverse Engineering ( CLAUDE.MD )
2
3## Autorität
4- Analysiere nur Ziele, die mir gehören oder für die ich autorisiert bin. Nenne die Grundlage einmalig.
5- Jede Aussage wird markiert: Beobachtung (gesehen), Ableitung (erschlossen) oder unbekannt.
6- Belege zitieren: Adresse, Bytes, Pseudocode oder Call Site. Keine Aussagen ohne Quelle.
7
8## Workflow
9- Starte mit der kleinstmöglichen Übersicht, nicht mit einem vollständigen Dump. Nur bei konkreten Lücken erweitern.
10- Nutze die offene Session weiter; identische Analysen niemals erneut ausführen.
11- Statische Fakten von Laufzeit-Fakten trennen. Aus statischem Lesen niemals auf Ausführung schließen.
12
13## Rekonstruktion
14- Baue anhand von VERHALTEN und öffentlichen Spezifikationen, niemals anhand kopierten Codes oder kopierter Assets.
15- Führe ein Pflichtenheft: Jedes wiederhergestellte Verhalten braucht einen bestandenen Test, bevor es als „fertig“ gilt.

Opus 5.5 bietet fünf Aufwand-Level: low, medium, high, xhigh und max. Nutze:

• Medium, um zu inspizieren und zu navigieren
• High, um gewöhnliche Funktionen zu annotieren
• Max für obfuskierten Code und alles mit viel Pointer-Arithmetik.

Der Aufwand ist der wichtigste Qualitätsregler im gesamten Kurs.

03. Der Router – 20 Zieltypen, je ein Tool

Der erste Fehler, den Anfänger machen: Sie greifen zum Disassembler, obwohl das Ziel eine Electron-App ist, deren JavaScript direkt vor ihnen liegt.

REA leitet das Ziel an das richtige Tool weiter – und dein erster Prompt sollte das auch tun. Nenne die Datei, nenne das Feature und lass den Agent das Einstiegs-Tool wählen.

1Ich möchte verstehen, wie [FEATURE] in [APP] funktioniert, das unter [ABSOLUTER PFAD] liegt.
2
3Sag mir zuerst, um welche Art von Ziel es sich handelt (nativ, Electron/JS, .NET, Go, APK, WASM)
4und wähle das passende REA-Tool, um es zu öffnen. Beginne noch nicht mit der Tiefenanalyse.
5
6Gib mir dann eine Zusammenfassung in einem Absatz: Womit die App gebaut wurde, wie groß sie ist und
7wo du zuerst nach [FEATURE] suchen würdest. Halte Beobachtungen, Ableitungen und Unbekanntes
8getrennt und belege alles, was du behauptest.

Wenn du REA auf eine Electron-App ansetzt, liefert es Module, Imports und IPC-Grenzen in Sekunden – ganz ohne Disassembler.

Setzt du es auf eine native Mach-O- oder ELF-Datei an, öffnet es eine Hopper-Datenbank und nimmt den schwierigeren, aber tiefergehenden nativen Weg. Zu wissen, in welchem Szenario du dich befindest, spart Stunden.

https://x.com/_vmlops/status/2106690704244420687

04. Aufklärung – Übersicht, Strings und der Call Graph

Öffne noch keinen Code. Bitte REA zuerst um eine Karte der gesamten Datei. Ein Befehl verrät dir, auf welcher Maschine sie läuft, wie viele Funktionen darin stecken und welcher lesbare Text in ihr verborgen ist.

Dieser Text ist dein schnellster Hinweis: Webadressen, Fehlermeldungen und Feature-Namen zeigen dir, was die App tut, bevor du auch nur eine Zeile Code gelesen hast.

1rea.open_binary        { path: "/Applications/Target.app/Contents/MacOS/Target" }
2rea.binary_overview    {}
3  arch:        arm64
4  functions:   1.284 identifiziert
5  segments:    __TEXT __DATA __LINKEDIT
6  entry:       _main @ 0x1000051c0
7
8rea.search             { query: "http" }  # Strings + Code-Referenzen
9  0x10004a2c0  "https://api.target.app/v3/sync"
10  0x10004a300  "Authorization: Bearer "
11  0x10004a330  "offline cache miss, falling back"
12
13rea.xrefs              { address: "0x100012ab0" }  # Wer ruft das auf?
14  147 Referenzen  ->  Core-Config-Loader, wird überall aufgerufen

REA zählt außerdem, wie oft jede Funktion aufgerufen wird (diese Zahl nennt man Cross-References oder Xrefs).

Eine Funktion, die 147-mal aufgerufen wird, ist das Herzstück der App und verdient deine volle Aufmerksamkeit. Eine, die zweimal aufgerufen wird, ist ein kleiner Helfer, den du ignorieren kannst, bis er relevant wird. Fang oben in dieser Liste an und arbeite dich nach unten vor.

05. Dekompilieren – eine Funktion in Pseudocode

Wähle nun eine dieser stark genutzten Funktionen aus und mach daraus etwas Lesbares. Ein Decompiler nimmt die rohen Maschinenbefehle und schreibt sie als C-nahen Code um.

Das sieht erst mal holprig aus: Namen wie var_28, verschachtelte Logik, Typecasts überall. Aber du kannst es lesen – und lesbar ist alles, was Opus 5.5 braucht.

Führe es über die Kommandozeile aus, um das Ergebnis zu speichern, oder direkt im Chat.

1# Eine Funktion per Adresse dekompilieren, als JSON zum Weiterleiten oder Speichern
2rea decompile /Applications/Target.app/.../Target 0x100012ab0 \
3  --provider hopper --json > fn_config_loader.json
4
5# Oder eine Funktion nach Namen suchen und Referenzen verfolgen
6rea function /path/to/Target parseConfig --provider hopper --json
7rea xrefs    /path/to/Target 0x100012ab0 --provider hopper --json
8rea trace    /path/to/Target "sync" --provider hopper --json

1// 0x100012ab0  xrefs: 147
2void sub_100012ab0(void* arg0) {
3    void* var_20 = objc_msgSend(cls_NSJSONSerialization,
4        sel_JSONObjectWithData_options_error, arg0, 0x0, 0x0);
5    if (var_20 != 0x0) {
6        void* var_28 = objc_msgSend(var_20, sel_objectForKey, @"endpoints");
7        void* var_30 = objc_msgSend(var_20, sel_objectForKey, @"auth_mode");
8        void* var_38 = objc_msgSend(var_20, sel_objectForKey, @"retry_count");
9        objc_msgSend(g_sharedConfig, sel_setEndpoints, var_28);
10        objc_msgSend(g_sharedConfig, sel_setAuthMode, var_30);
11        objc_msgSend(g_sharedConfig, sel_setRetryCount,
12            objc_msgSend(var_38, sel_intValue));
13    }
14}

REAs eigenes Showcase folgt einem Sound-Aufruf im alten Spiel DX-Ball bis hinunter zu dem Helfer, der die Links-Rechts-Audiobalance bestimmt, und verwandelt den halbfertigen Pseudocode dann in C.

Das Ergebnis besteht alle 3.205 ursprünglichen Testfälle und reproduziert jedes einzelne der 63 kompilierten Bytes.

Die komplette Anleitung findest du unter rea.tools/showcase.

06. Annotieren – lass Opus jede Variable benennen

Dieser rohe Code ist erst die halbe Miete. Gib ihn jetzt an Opus 5.5 und bitte das Modell, ihn zu erklären und aufzuräumen.

Es benennt die kryptischen Variablen in echte um, erklärt in einem Satz, wofür die Funktion da ist, erkennt das zugrunde liegende Muster und weist sogar auf Bugs hin, die die Original-App hinterlassen hat.

Füge diesen Prompt in Claude ein:

1Hier ist dekompilierter Pseudocode einer Funktion mit 147 Cross-References.
2
3Für diese Funktion:
41. Benenne jede Variable aussagekräftig um, basierend darauf, wie sie verwendet wird.
52. Beschreibe ihren Zweck in einem Satz.
63. Liste die Datenstrukturen auf, die sie liest und schreibt.
74. Benenne das Muster (Singleton, Factory, State Machine, Observer ...).
85. Schreibe sie als sauberen, idiomatischen Swift-Code um (oder in der Sprache, die die
9   Aufrufkonventionen nahelegen), inklusive Doc-Kommentaren.
106. Markiere fehlendes Error Handling, fehlende Eingabevalidierung oder fehlende Sicherheitsprüfungen.
11
12Denke vor der Antwort mit Aufwand „xhigh“ gründlich nach: Überlege, was jeder Wert bedeutet,
13bevor du dich auf Namen festlegst. Markiere alles, worüber du dir unsicher bist.
14
15[Pseudocode hier einfügen]

Die Dekompilierung zeigt dir, was der Code tut. Opus 5.5 liefert dir das Warum – und die Namen, um ihn neu aufzubauen.

https://x.com/0x0SojalSec/status/2108389060192706674

https://x.com/0x0SojalSec/status/2108031166502896035

Nicht jedes Ziel braucht einen Disassembler. Im Notion-Showcase von REA wird das Clipboard-Feature im JavaScript der App gefunden, durch die Electron-Schichten hindurch bis in den Main Process verfolgt und exakt gezeigt, wie die Rich-Clipboard aufgebaut wird – ein vollständiger Trace, komplett ohne Assembler. Siehe

07. Obfuskation – der Tigress-Benchmark

Manche Apps sind genau dafür gebaut, dir das Leben schwer zu machen. Ihr Code ist absichtlich verschleiert: Die Logik ist durcheinandergewürfelt, Texte sind verschlüsselt, und falsche Verzweigungen kosten dich Zeit.

Das nennt man Obfuskation – und genau hier kommt selbst das beste Modell ins Schwitzen. Elastic Security Labs hat das gemessen, indem sie Claude Opus in 20 Aufgaben auf den Tigress-Scrambler angesetzt haben. Behalte diese Zahlen im Kopf.

In diesen Zahlen stecken zwei praktische Lehren.

• Erstens: Ein fehlgeschlagener Versuch kostet etwa doppelt so viel wie ein erfolgreicher, weil das Modell immer härter probiert, bevor es aufgibt. Setze also ein Ausgabenlimit pro Funktion und brich frühzeitig ab.
• Zweitens: Entferne den Müll aus dem dekompilierten Code, bevor du ihn abschickst (ein kostenloses Tool namens Caveman entfernt etwa 75 % davon), damit das Modell seine Aufmerksamkeit auf die echte Logik richtet und nicht auf Füllmaterial.

Die fünf Tricks, die dir in der Praxis begegnen, und wie sie aussehen, wenn du den Code öffnest:

1Diese Funktion wirkt obfuskiert. Arbeite mit maximalem Aufwand.
2
31. Identifiziere die verwendeten Techniken (Control-Flow Flattening, Opaque Predicates,
4   Dead Code, String-Verschlüsselung, Function Splitting) und zeige, wo genau sie
5   in diesem Code auftauchen.
62. Löse sie auf: Entferne tote Verzweigungen, evaluiere Opaque Predicates, entflache
7   den Dispatch, entschlüssele Inline-Strings, falls der Schlüssel rekonstruierbar ist.
83. Zeige die saubere Funktion, die übrig bleibt.
94. Bewerte deine Sicherheit auf einer Skala von 1–10. Unter 6 sag mir genau, welche Teile unsicher sind
10   und welcher Kontext aus der Umgebung sie klären würde. Rate nicht stillschweigend.
11
12[Obfuskierten Pseudocode hier einfügen]

08. Der Schwarm – ein Controller steuert Worker

Ein einzelner Chat kann 500 Funktionen nicht sauber lesen. Er vergisst, was er gesehen hat, nennt dieselbe Sache mit drei verschiedenen Namen und widerspricht sich irgendwann selbst.

Die Lösung ist ein kleines Team: ein Controller-Chat, der die Arbeit verteilt, und mehrere Worker-Chats, die jeweils eine Funktion übernehmen.

Der Controller behält das große Ganze im Blick und fügt die Teile wieder zusammen.

Dafür musst du nichts Besonderes bauen – die beiden folgenden Prompts sind das gesamte Setup.

1Du bist ein Reverse-Engineering-Controller. Die Funktionskarte liegt in functions.json
2(Adresse, Name, Größe, xref_count).
3
41. Gruppiere Funktionen nach Nähe im Call Graph; sortiere die Cluster nach Xref-Anzahl.
52. Weise jeden Cluster einem Worker zu. Analysiere niemals selbst eine Funktion.
63. Injiziere bereits aufgelöste Structs in das Briefing jedes Workers, damit die Namen konsistent bleiben.
74. Wenn ein Worker eine Sicherheit unter 6 zurückgibt, plane einen zweiten Durchlauf mit Kontext
8   aus seinen aufgelösten Nachbarfunktionen ein.
95. Verfolge den kumulierten Token-Verbrauch und melde ihn nach jedem Cluster.

1Du bist ein Worker. Du erhältst eine dekompilierte Funktion und die bisher aufgelösten Structs.
2Liefere exakt: Adresse, Zweck, Sicherheit (1–10), structs_used, structs_new,
3clean_source, flags. Nutze bestehende Struct-Namen weiter; erfinde niemals einen zweiten Namen für
4ein Struct, das der Controller dir bereits gegeben hat. Nur eine Funktion. Stoppe, wenn du fertig bist.

https://x.com/victor_explore/status/2109466356454510612

09. Clean Room – vier Regeln, die es legal halten

Ein Clean-Room-Nachbau bedeutet: Du kopierst, was die App tut, niemals den Code darin. Machst du es richtig, gehört das Ergebnis komplett dir. Machst du es falsch, trägst du das Urheberrecht eines anderen mit dir herum.

Vier Regeln halten dich auf der sicheren Seite – und das WordCraft-Team prüft bei jedem Build automatisch alle vier.

1. Beobachten, niemals kopieren. Führe das Ziel als Blackbox aus, beobachte sein Verhalten, mache Screenshots nur vom eigenen Fenster. Lies, disassembliere oder kopiere niemals seinen Code. Übernehme keine Formulierungen außer reinen Feature-Namen.
2. Spezifikationen statt Quellcode. Dateiformate stammen aus öffentlichen Standards (OOXML ist ECMA-376 / ISO 29500, dazu die veröffentlichten RTF- und ODF-Specs), niemals aus dem Lesen des Parsers eines Konkurrenten oder irgendeines GPL/LGPL-Codes.
3. Nur eigene Assets. Jedes Icon, jeder Font, jedes Template und jeder Sound wird im Code gezeichnet, ist Public Domain oder offen lizenziert – mit einer Zeile in einer Attributionsdatei. Andernfalls schlägt ein CI-Check den Build fehl.
4. Trenne die beiden Aufgaben. Ein Agent rekonstruiert das Verhalten und schreibt eine Spezifikation. Ein anderer Kontext implementiert ausschließlich nach dieser Spezifikation, ohne jemals die ursprüngliche Analyse zu sehen. Diese Trennung ist die Clean-Room-Grenze.

1Erstelle aus der abgeschlossenen Analyse eine Clean-Room-Spezifikation für eine Neuimplementierung.
2
3Beschreibe NUR das VERHALTEN. Inkludiere: jede öffentliche Schnittstelle, das Datenmodell, jedes
4für Nutzer sichtbare Feature als testbare Anforderung, die gelesenen und geschriebenen Dateiformate
5(nach beobachtetem Verhalten und öffentlicher Spezifikation) sowie das Fehlerbehandlungsverhalten.
6
7NICHT inkludieren: Adressen oder Offsets, Variablennamen aus der Dekompilierung, Assembler
8oder irgendetwas aus dem Original kopiertes. Ein Entwickler, der die Binärdatei nie gesehen hat, muss
9allein aus diesem Dokument eine kompatible Version implementieren können.
10
11Ausgabe als Markdown mit Abschnitten: Architektur, Datenmodell, Öffentliche API, Dateiformate,
12Testfälle.

Nach einer Beschreibung zu arbeiten, ist nicht nur rechtliche Absicherung. Es erlaubt dir, die richtigen Entscheidungen für deine eigene Sprache und deine Bedürfnisse zu treffen, statt Designentscheidungen zu erben, die der Originalautor vor Jahrzehnten getroffen hat.

WordCraft ist stellenweise schneller als Word, gerade weil es das Innenleben von Word nicht kopiert hat.

10. Apps schmieden – zwölf Profi-Tools, eine Methode

WordCraft ist kein Einzelfall. Es ist eine von zwölf Apps im Regal des ArtCraft-Teams – jede ein Clean-Room-Nachbau eines Tools, für das du sonst bezahlst, alle von Grund auf in Rust geschrieben und kostenlos sowie offen auf GitHub veröffentlicht.

Ihr eigener Slogan lautet „Twelve apps. One craft“, und dieses eine Handwerk ist die Methode aus Schritt 9: Beobachte das Original, lies die öffentlichen Spezifikationen, baue eine frische Version allein anhand des Verhaltens.

Der Vorteil dieser gemeinsamen Methode ist überall derselbe. Kein Electron: Jede App ist nativ auf macOS, Windows und Linux, und alle außer FilmCraft laufen dank WebAssembly auch im Browser-Tab.

Und weil jede Aktion darin ein benannter Befehl ist, lassen sich alle zwölf sofort von einem KI-Agent steuern.

Jede Craft-App ist gleich aufgebaut, und diese Struktur lohnt sich zum Kopieren. Alle sind in Schichten gestapelt, wobei jede Schicht nur die darunterliegende nutzt – von grundlegenden Berechnungen ganz unten bis zum sichtbaren Fenster ganz oben.

Hier sind die Schichten von WordCraft:

Und jede Aktion ist einfach ein benannter Befehl, sodass ein Mausklick, ein Tastenkürzel und ein KI-Agent exakt dasselbe auslösen. Genau das macht jede dieser Apps per Agent steuerbar.

1WordCraft über MCP steuern
2
3# Headless-Dokumentenautomatisierung
4claude mcp add wordcraft -- wordcraft-cli mcp
5
6# Oder die laufende Desktop-App steuern
7wordcraft --control 7981 &
8claude mcp add wordcraft-app -- wordcraft-cli mcp --connect 127.0.0.1:7981
9
10# Tools: list_commands, execute, batch, type_text, select_text,
11#        inspect_document, render_page, save_document (+ Screenshot/Klick/Taste live)
12> Öffne report.docx, setze alle Überschriften auf 14pt fett, exportiere als PDF
13  ✓ select.all-headings -> 12 ausgewählt
14  ✓ format.font-size 14 · format.bold
15  ✓ export report.pdf (auswählbarer Text, Lesezeichen erhalten)

https://x.com/yuhasbeentaken/status/2109235513102057828

11. Prüfen und veröffentlichen – Parität beweisen, MCP bereitstellen

Du hattest nie den Quellcode des Originals, also kannst du ihn nicht Zeile für Zeile vergleichen.

Stattdessen vergleichst du das Verhalten: Gib dem Original und deinem Nachbau dieselben Eingaben und prüfe, ob sie denselben Output liefern.

1Baue ein verhaltensbasiertes Test-Harness, das die originale Binärdatei und meinen Nachbau vergleicht.
2
3Generiere 50 Eingaben: 30 normale, 10 Grenzfälle (leer, maximale Größe, Unicode, Sonderzeichen),
410 Fehlerfälle (fehlerhaft formatiert, fehlende Felder, korrupt). Jage jede durch beide Versionen. Vergleiche den Output
5wo möglich Byte für Byte, andernfalls semantisch. Berichte Trefferquote, eine Abweichungsliste
6und einen Schweregrad für jede Abweichung (kosmetisch / verhaltensbezogen / kritisch). Speichere in report.md.

Das ist gleichzeitig der überzeugendste Beweis, den du irgendjemandem zeigen kannst (der RE-Slot ganz oben im Artikel).

Veröffentliche deinen Nachbau dann genauso wie REA und WordCraft: als MCP-Server, damit der Agent der nächsten Person ihn genauso steuern kann, wie du REA gesteuert hast.

Gib jeder Funktion einen klaren Namen und eine Beschreibung, verpacke sie in ein simples Kommandozeilen-Tool und ermögliche die Installation mit einer einzigen Zeile.

https://x.com/0xMovez/status/2108884063515746410

Und teste unterwegs, nicht erst am Ende – denn ein Fehler, den du entdeckst, nachdem du drei Schichten darauf gebaut hast, ist deutlich teurer zu beheben.

Sechs Fehler, die ein Wochenende kosten

1. Einen Disassembler auf eine Electron-App loslassen. Wenn das JavaScript direkt vorliegt, route zu analyze_javascript_application und überspringe den nativen Weg komplett.
2. Alles dumpen, bevor man etwas gelesen hat. Bitte REA zuerst um eine Zusammenfassung. Die ganze App auf einmal zu ziehen, begräbt die echte Logik unter Rauschen und treibt deine Kosten hoch.
3. Funktionen in Dateireihenfolge lesen. Sortiere nach Anzahl der Cross-References. Die Funktion mit 147 Xrefs ist die Architektur; der Helfer mit 2 Xrefs kann warten.
4. Sich an Stufe-3-Obfuskation abarbeiten. Der Benchmark löst 0 % der mehrschichtigen Fälle. Setze ein Budget, sichere den Kontext der Nachbarfunktionen, komm später zurück.
5. Das Modell Code in deinen Nachbau kopieren lassen. Das bricht den Clean Room. Zuerst die Spezifikation in einem Kontext, dann die Implementierung nach Spec in einem anderen.
6. Ohne Paritätsbericht veröffentlichen. „Ich glaube, es passt“ ist kein Beweis. 50 Verhaltenstests und eine Trefferquote schon.

Fazit:

Installiere REA. Lies die Binärdatei. Baue sie als deine eigene nach.

Route das Ziel, kartografiere seine Oberfläche, dekompiliere die heißen Funktionen, lass Opus 5.5 alles benennen, knacke die Obfuskation, die es wert ist, skaliere mit einem Schwarm, spezifiziere es sauber und veröffentliche den Nachbau über MCP.

Elf Schritte. Ein Modell. Null kopierter Code.