<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Ideen &amp; Einblicke – Autotomy</title><description>AI-First-Entwicklung, Coding-Leitplanken und die Architektur der Entsorgbarkeit erkunden.</description><link>https://autotomy.dev/</link><language>de</language><item><title>Ihr Main-Branch ist kaputt. Sie müssen 200 Commits durchsuchen.</title><link>https://autotomy.dev/de/blog/git-bisect-binary-search-commit/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/git-bisect-binary-search-commit/</guid><description>`git bisect` verwandelt eine manuelle Commit-Suche in eine automatisierte binäre Suche. So finden Sie den exakten Commit, der einen Bug eingeführt hat – ohne jeden einzelnen auszuchecken.</description><pubDate>Tue, 25 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Ihr Error-Tracker weiß, wo der Absturz war. Das hilft nicht bei der Reproduktion.</title><link>https://autotomy.dev/de/blog/production-crash-capture-replay/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/production-crash-capture-replay/</guid><description>Stack Traces sagen Ihnen, wo ein Crash passiert ist, nicht was ihn verursacht hat. Hier ist ein Capture-and-Replay-Pattern, das Produktiv-Crashes in lokale Testfälle verwandelt, die Sie tatsächlich debuggen können.</description><pubDate>Mon, 24 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Symbolische Ausführung hat einen Integer Overflow gefunden, den meine 94-%-Testabdeckung übersehen hat</title><link>https://autotomy.dev/de/blog/symbolic-execution-integer-overflow-coverage/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/symbolic-execution-integer-overflow-coverage/</guid><description>Ihre Unit-Tests prüfen spezifische Eingaben. Symbolische Ausführung prüft jede mögliche Eingabe. So funktioniert es, was es kostet und wo Sie anfangen.</description><pubDate>Sun, 23 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Ihre Logs leaken personenbezogene Daten, und grep rettet Sie nicht</title><link>https://autotomy.dev/de/blog/pii-tracking-code-pipeline/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/pii-tracking-code-pipeline/</guid><description>Die meisten Teams entdecken Leaks personenbezogener Daten erst nach einer Kundenbeschwerde. So verfolgen Sie sensible Daten von der Erfassung bis zur Ausgabe – mit Code-Beispielen, die Sie sofort nutzen können.</description><pubDate>Sat, 22 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Ihre API ist in der Produktion ausgefallen, weil die CI Code statt Contracts getestet hat</title><link>https://autotomy.dev/de/blog/api-contract-testing-ci/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/api-contract-testing-ci/</guid><description>Die meisten CI-Pipelines erkennen Syntaxfehler und Logikfehler. Sie übersehen die API-Contract-Verletzungen, die die Produktion tatsächlich zum Absturz bringen. So beheben Sie das.</description><pubDate>Fri, 21 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Crash-Korrelationen lügen. So lassen Sie sie auf den echten Bug zeigen.</title><link>https://autotomy.dev/de/blog/crash-correlation-triangulation/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/crash-correlation-triangulation/</guid><description>Statistical Debugging findet Prädikate, die mit Abstürzen korrelieren, aber Korrelation ist keine Datei und Zeilennummer. So ranken, filtern und triangulieren Sie sich von einem Korrelationsscore zu einer tatsächlichen Bug-Location.</description><pubDate>Thu, 20 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Sentrys Seer kann Ihre Traces lesen. Das heißt nicht, dass es immer die Root Cause findet.</title><link>https://autotomy.dev/de/blog/sentry-seer-trace-root-cause/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/sentry-seer-trace-root-cause/</guid><description>Seer verarbeitet Trace-Trees, verbundene Fehler und Profiling-Daten, um verteilte Probleme zu diagnostizieren. Hier ist, wie es tatsächlich funktioniert, wo es glänzt und wo es noch menschliche Hilfe braucht.</description><pubDate>Wed, 19 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Statistical Debugging sollte das printf-Debugging beenden. Die meisten Teams haben es nie zum Laufen gebracht.</title><link>https://autotomy.dev/de/blog/statistical-debugging-adoption-challenges/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/statistical-debugging-adoption-challenges/</guid><description>Statistical Debugging versprach, Bugs durch Korrelation von Programmverhalten mit Fehlern zu lokalisieren. Hier ist, warum die Idee nie von Forschungspapieren in Produktionssysteme überging.</description><pubDate>Tue, 18 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Ihre Tests haben bestanden. Ihre Daten sind trotzdem falsch.</title><link>https://autotomy.dev/de/blog/statistical-debugging-production-data-anomalies/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/statistical-debugging-production-data-anomalies/</guid><description>Statistical Debugging behandelt Ihre Produktionsdaten als Signal und Bugs als Anomalien. So finden Sie Datenkorruption, Off-by-One-Fehler und stille Ausfälle, ohne einen einzigen Unit-Test hinzuzufügen.</description><pubDate>Mon, 17 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Metamorphic Testing fand 147 Compiler-Bugs und einen Defekt in einem selbstfahrenden Auto. So funktioniert es.</title><link>https://autotomy.dev/de/blog/metamorphic-testing-production-bugs-compiler/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/metamorphic-testing-production-bugs-compiler/</guid><description>Metamorphic Testing hat echte Bugs in GCC, LLVM, Vulkan-Shader-Compilern und ADAS-Simulatoren aufgedeckt. Dieser Artikel erklärt die Technik mit lauffähigem Code und zeigt, wo sie in Ihre Test-Suite passt.</description><pubDate>Sun, 16 Aug 2026 00:00:00 GMT</pubDate></item><item><title>LLMs können Metamorphic Relations vorschlagen. Sie können sie nur nicht garantieren.</title><link>https://autotomy.dev/de/blog/llm-metamorphic-relations-brainstorming/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-metamorphic-relations-brainstorming/</guid><description>Große Sprachmodelle sind brauchbare Brainstorming-Partner für die Entdeckung von Test Oracles, halluzinieren aber Eigenschaften und übersehen Domänen-Einschränkungen. So verwendest du sie, ohne falsche Tests auszuliefern.</description><pubDate>Sat, 15 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Die meisten Metamorphic Relations sind nutzlos. So findest du die Guten.</title><link>https://autotomy.dev/de/blog/metamorphic-relation-quality/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/metamorphic-relation-quality/</guid><description>Nicht alle Metamorphic Relations finden Bugs. Schwache Relations erwecken falsche Sicherheit, während starke echte Fehler aufdecken. So unterscheidest du sie und baust einen Satz an Relations, der wirklich funktioniert.</description><pubDate>Fri, 14 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Wie teste ich Code, wenn ich die richtige Antwort nicht kenne?</title><link>https://autotomy.dev/de/blog/metamorphic-testing-oracle-problem/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/metamorphic-testing-oracle-problem/</guid><description>Metamorphic Testing erlaubt es dir, die Korrektheit von Code zu prüfen, ohne die exakte erwartete Ausgabe zu kennen. So funktioniert es, wann es an seine Grenzen stößt und wie du damit anfängst.</description><pubDate>Thu, 13 Aug 2026 00:00:00 GMT</pubDate></item><item><title>TypeScript lässt dich diesen Aufruf nicht machen: protocol states im Typsystem kodieren</title><link>https://autotomy.dev/de/blog/typescript-phantom-types-protocol-state/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-phantom-types-protocol-state/</guid><description>Wie du Phantom Types und `this`-Parameter verwendest, um illegale protocol transitions in Compile-Time-Fehler statt Runtime-Bugs zu verwandeln.</description><pubDate>Wed, 12 Aug 2026 00:00:00 GMT</pubDate></item><item><title>OpenAPI gibt dir das Alphabet. Session Types brauchen die Grammatik.</title><link>https://autotomy.dev/de/blog/openapi-session-types-protocol-gap/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/openapi-session-types-protocol-gap/</guid><description>OpenAPI-Spezifikationen beschreiben Request- und Response-Schemas, legen aber keine gültigen Nachrichtensequenzen fest. So extrahierst du, was geht – und wo du die Lücken noch selbst schließen musst.</description><pubDate>Tue, 11 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Session Types funktionieren. Die meisten Sprachen wollten sie einfach nicht implementieren.</title><link>https://autotomy.dev/de/blog/session-types-research-to-production/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/session-types-research-to-production/</guid><description>Session Types kodieren communication protocols im Typsystem und verwandeln runtime protocol errors in Compile-Time-Fehler. Hier ist, warum sie dreißig Jahre in Forschungspapieren verbrachten, bevor Produktivcode sie nutzen konnte.</description><pubDate>Mon, 10 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Wie Session Types Deadlocks in Compiler-Fehler verwandeln</title><link>https://autotomy.dev/de/blog/session-types-deadlock-compiler-errors/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/session-types-deadlock-compiler-errors/</guid><description>Session Types kodieren Kommunikationsprotokolle im Typsystem und verwandeln Message-Passing-Mismatches in Compiler-Fehler, bevor der Code jemals läuft.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Abstract interpretation klingt nach einem Doktorvoraussetzung. Ist es nicht mehr.</title><link>https://autotomy.dev/de/blog/infer-abstract-interpretation-ci/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/infer-abstract-interpretation-ci/</guid><description>Wie man formale statische Analyse in der CI-Pipeline mit Infer betreibt, mit funktionierenden Configs und realistischen Trade-offs.</description><pubDate>Sat, 08 Aug 2026 00:00:00 GMT</pubDate></item><item><title>LLMs können Ihre Static-Analysis-Warnings ordnen. Sie können nur nicht erklären, warum.</title><link>https://autotomy.dev/de/blog/llm-static-analysis-triage/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-static-analysis-triage/</guid><description>Large Language Models können beim Triage von False Positives in der statischen Analyse helfen, aber sie verstehen Programmsemantik nicht so wie Abstract Interpretation. So kombinieren Sie beides.</description><pubDate>Fri, 07 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Facebook parallelisierte Android mit Abstract Interpretation. So funktioniert es.</title><link>https://autotomy.dev/de/blog/facebook-android-abstract-interpretation-races/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/facebook-android-abstract-interpretation-races/</guid><description>Wie Facebook abstract interpretation und intentionale Unsoundness nutzte, um Race Conditions in Millionen Zeilen Android-Code im großen Maßstab zu finden.</description><pubDate>Thu, 06 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Meta fand 100.000 Bugs im Produktivcode mit einem Static Analyzer, der das Programm nie ausführt</title><link>https://autotomy.dev/de/blog/meta-infer-100000-bugs-static-analysis/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/meta-infer-100000-bugs-static-analysis/</guid><description>Metas Infer nutzt Abstract Interpretation und Bi-Abduction, um Null-Dereferenzierungen, Memory Leaks und Race Conditions durch Schlussfolgerungen über die Code-Struktur zu finden – nicht durch Ausführung. So funktioniert es und so setzen Sie es in Ihrer eigenen Codebase ein.</description><pubDate>Wed, 05 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Statische Analyse kann nicht beweisen, dass Ihr Flugzeug nicht abstürzt. Sie kann etwas Nützlicheres beweisen.</title><link>https://autotomy.dev/de/blog/static-analysis-aviation-abstract-interpretation/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/static-analysis-aviation-abstract-interpretation/</guid><description>Die abstrakte Interpretation überapproximiert jeden möglichen Programmzustand. Wenn eine Division durch Null in der Abstraktion unerreichbar ist, ist sie im echten Code unerreichbar. So funktioniert sie – und hier zeigen sich ihre Grenzen.</description><pubDate>Tue, 04 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Wie man beweist, dass Code keine Laufzeitfehler enthält (und warum man wahrscheinlich aufgibt, es zu versuchen)</title><link>https://autotomy.dev/de/blog/abstract-interpretation-runtime-error-proof/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/abstract-interpretation-runtime-error-proof/</guid><description>Abstrakte Interpretation ermöglicht es, Laufzeitfehler vor der Ausführung als unmöglich zu beweisen. So funktioniert es wirklich, warum es schwierig ist und wo es in die Toolchain passt.</description><pubDate>Mon, 03 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Ihr C-Code kann auf Capability-Hardware laufen, ohne ein vollständiges rewrite</title><link>https://autotomy.dev/de/blog/cheri-c-porting-hybrid-abi/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/cheri-c-porting-hybrid-abi/</guid><description>CHERIs hybride ABI ermöglicht die schrittweise Portierung von C-Code auf Capability-Hardware. So kompilieren Sie ihn, was dabei kaputt geht und wie Sie es beheben – ohne Ihre gesamte codebase zu rewrite.</description><pubDate>Sun, 02 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Capability-Hardware ist nicht gescheitert. Es kam 40 Jahre zu früh.</title><link>https://autotomy.dev/de/blog/capability-hardware-cheri-history/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/capability-hardware-cheri-history/</guid><description>Memory Safety auf Hardware-Ebene war seit den 1970ern möglich. Hier ist, warum Capability-Architekturen immer gegen flache Speichermodelle verloren haben – und warum CHERI die Rechnung endlich ändert.</description><pubDate>Sat, 01 Aug 2026 00:00:00 GMT</pubDate></item><item><title>Ihre C-dependency kann Ihren gesamten Prozess zum Absturz bringen. WebAssembly kann das verhindern.</title><link>https://autotomy.dev/de/blog/c-library-wasm-sandbox/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/c-library-wasm-sandbox/</guid><description>Container sind overkill, um eine einzelne C-Bibliothek zu isolieren. Kompilieren Sie sie zu WebAssembly und führen Sie sie in einer WASI-Sandbox aus – für Memory Safety, capability-basierten Dateisystemzugriff und Crash-Containment ohne Docker.</description><pubDate>Fri, 31 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Dein Telefon hat bereits Hardware, die Speicherverfälschung erkennt</title><link>https://autotomy.dev/de/blog/mobile-memory-tagging-extension/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/mobile-memory-tagging-extension/</guid><description>ARM Memory Tagging Extension und GWP-ASan ermöglichen die Erkennung von Speichersicherheitsproblemen in der Produktion auf modernen mobilen Geräten. So funktionieren sie und welche Kompromisse sie erfordern.</description><pubDate>Thu, 30 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Buffer Overflows passieren weiterhin, weil wir sie in Software beheben</title><link>https://autotomy.dev/de/blog/cheri-hardware-buffer-overflow-prevention/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/cheri-hardware-buffer-overflow-prevention/</guid><description>CHERI ist eine Hardware-Erweiterung, die jeden Pointer in eine bounded capability verwandelt. So stoppt es Buffer Overflows auf CPU-Ebene, was es kostet und wie man es auf echter Hardware ausprobieren kann.</description><pubDate>Wed, 29 Jul 2026 00:00:00 GMT</pubDate></item><item><title>LLMs können nicht beweisen, dass Ihr Code korrekt ist, aber sie können das Boilerplate dafür schreiben</title><link>https://autotomy.dev/de/blog/llm-cleanroom-proof-obligation-automation/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-cleanroom-proof-obligation-automation/</guid><description>Die Cleanroom-Verifikation erfordert die Erzeugung und Erfüllung von Proof Obligations. So automatisieren LLMs die Annotation und die VC-Generierung, damit Sie sich auf die eigentlich schwierigen Beweise konzentrieren können.</description><pubDate>Tue, 28 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Cleanroom liefert 0,1 Defekte pro KLOC. Du brauchst nicht den vollen Overhead, um das zu erreichen.</title><link>https://autotomy.dev/de/blog/cleanroom-pragmatic-subset/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/cleanroom-pragmatic-subset/</guid><description>Cleanroom Software Engineering senkt die Defektrate um das 100-fache, aber die vollständige Einführung erfordert separate Testteams und formale Beweise. Hier ist eine pragmatische Teilmenge, die den Großteil des Nutzens ohne den Overhead einfängt.</description><pubDate>Mon, 27 Jul 2026 00:00:00 GMT</pubDate></item><item><title>IBMs Zero-Defect Process lieferte 0,1 Bugs pro KLOC. Die Industrie hat ihn trotzdem aufgegeben.</title><link>https://autotomy.dev/de/blog/ibm-cleanroom-zero-defects-disappearance/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ibm-cleanroom-zero-defects-disappearance/</guid><description>IBMs Cleanroom Engineering erreichte Defektraten, die 100-mal besser waren als der Industriedurchschnitt, und verschwand dann in der Bedeutungslosigkeit. Das Verschwinden hatte nichts damit zu tun, ob es funktionierte.</description><pubDate>Sun, 26 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Hat tatsächlich jemand 10.000 Zeilen mit null Defekten verifiziert? IBM hat es getan, und die Methodik ist seltsamer als das Ergebnis.</title><link>https://autotomy.dev/de/blog/ibm-cleanroom-10000-lines-zero-defects/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ibm-cleanroom-10000-lines-zero-defects/</guid><description>Cleanroom software engineering versprach inkrementelle Zero-Defect-Releases durch mathematical verification statt Debugging. Wir betrachten die tatsächlichen IBM-Projektdaten, um zu sehen, ob die Behauptung standhielt.</description><pubDate>Sat, 25 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Dein Modul hat drei Schichten. Du hast wahrscheinlich nur eine geschrieben.</title><link>https://autotomy.dev/de/blog/cleanroom-box-structure-three-layers/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/cleanroom-box-structure-three-layers/</guid><description>Box Structures zwingen dich, das Verhalten eines Moduls, seinen Zustand und seine Implementierung als drei separate, überprüfbare Schichten zu definieren. So eliminiert Cleanroom das Debugging.</description><pubDate>Fri, 24 Jul 2026 00:00:00 GMT</pubDate></item><item><title>IBM lieferte Software mit 0,1 Defects pro KLOC aus – indem Entwickler ihren eigenen Code nicht ausführen durften</title><link>https://autotomy.dev/de/blog/ibm-cleanroom-01-defects-per-kloc/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ibm-cleanroom-01-defects-per-kloc/</guid><description>IBMs Cleanroom-Engineering-Prozess erreichte Defect-Raten, die 100-mal besser waren als der Industriedurchschnitt, indem Bugs verhindert statt gefunden wurden. So funktionierte es, warum fast niemand es nutzt und was du heute davon übernehmen kannst.</description><pubDate>Thu, 23 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Ihr literates Programm ist kaputt, bis CI es ohne Sie tanglen kann</title><link>https://autotomy.dev/de/blog/ci-literate-programming-tangle/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ci-literate-programming-tangle/</guid><description>Literate Programming verspricht eine einzige Quelle der Wahrheit, aber manuelle Weave- und Tangle-Schritte brechen die CI/CD-Pipeline. So automatisieren Sie Extraktion und Dokumentationsgenerierung, damit Ihre Markdown-Dateien kanonisch bleiben.</description><pubDate>Wed, 22 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Erklärung von Code an ein LLM zuerst senkte meine Bug-Rate um 85%</title><link>https://autotomy.dev/de/blog/llm-rubber-ducking-bug-rate/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-rubber-ducking-bug-rate/</guid><description>Ich verbrachte 30 Tage damit, Design-Erklärungen zu schreiben, bevor ich ein LLM um Code bat. Die Ergebnisse veränderten meine Sicht auf Rubber-Ducking.</description><pubDate>Tue, 21 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Ich habe aufgehört, Code in Docs zu kopieren, indem ich Tests, Code und Prosa in einer Markdown-Datei halte</title><link>https://autotomy.dev/de/blog/literate-programming-markdown-python/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/literate-programming-markdown-python/</guid><description>Literate Programming hält Dokumentation, Tests und Implementierung synchron, indem eine Markdown-Datei zur single source of truth wird. So lässt es sich in dreißig Zeilen Python umsetzen.</description><pubDate>Mon, 20 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Ihr Claude-Thread ist bereits Dokumentation. Er stirbt nur in zwölf Stunden.</title><link>https://autotomy.dev/de/blog/claude-thread-to-documentation/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/claude-thread-to-documentation/</guid><description>LLM-Konversationen enthalten Absicht, abgelehnte Alternativen und funktionierenden Code. Genau das sollte Dokumentation sein. So verwandeln Sie flüchtigen Chat in dauerhafte, durchsuchbare Docs, ohne die Erzählung zu verlieren.</description><pubDate>Sun, 19 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Texteditoren erlauben das Schreiben von ungültigem Code. Tree-Editoren würden das nicht tun.</title><link>https://autotomy.dev/de/blog/structured-editing-ast-text-editors/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/structured-editing-ast-text-editors/</guid><description>Jeder Compiler sieht deinen Code als Baum, aber dein Editor lässt dich rohen Text bearbeiten. So sieht strukturiertes Editieren tatsächlich aus, warum es sich nicht durchgesetzt hat und wie du seine Vorteile nutzen kannst, ohne Tools zu wechseln.</description><pubDate>Sat, 18 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Donald Knuth wollte, dass Programme wie Literatur gelesen werden. Der Compiler hatte andere Pläne.</title><link>https://autotomy.dev/de/blog/knuth-literate-programming-history/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/knuth-literate-programming-history/</guid><description>Literate Programming versprach, dass Code erst für Menschen und dann für Maschinen geschrieben werden sollte. Vier Jahrzehnte später schreibt fast niemand so. Hier ist, warum die eleganteste Idee der Software-Dokumentation die Art und Weise, wie wir arbeiten, nicht verändern konnte.</description><pubDate>Fri, 17 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Den Bug zu beheben ist der einfache Teil. Herauszufinden, warum er existiert, ist das, was zählt.</title><link>https://autotomy.dev/de/blog/fagan-causal-analysis-defects/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/fagan-causal-analysis-defects/</guid><description>Die meisten Teams beheben Defekte und machen weiter. Dieselben Defekte kommen zurück. So führen Sie Kausalanalyse innerhalb einer Fagan-Inspection durch, damit Sie denselben Bug nicht zweimal schreiben.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Pull-Request-Reviews finden 15–30 % der Defekte. Die Daten sagen das seit 50 Jahren.</title><link>https://autotomy.dev/de/blog/pr-reviews-catch-15-to-30-percent-defects/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/pr-reviews-catch-15-to-30-percent-defects/</guid><description>Mehrere Studien bei IBM, AT&amp;T, HP und Microsoft bestätigen, dass informelle Code-Reviews etwa ein Viertel der Defekte finden. Hier ist, was die Daten tatsächlich sagen, warum die Zahl so niedrig ist und wie man das behebt.</description><pubDate>Wed, 15 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Eine generische Checkliste findet nichts. Eine strukturierte findet 60 % der Defekte.</title><link>https://autotomy.dev/de/blog/fagan-structured-checklist-defect-detection/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/fagan-structured-checklist-defect-detection/</guid><description>Die meisten Review-Checklisten sind kopiert-eingefügte Listen guter Absichten. Eine im Stil einer Fagan inspection strukturierte Checkliste wird aus tatsächlichen Defektdaten erstellt, auf bestimmte Artefakttypen zugeschnitten und während der individuellen Vorbereitung verwendet. So baut man eine, die funktioniert.</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Ein LLM kann Ihren Code vorab prüfen. Es kann aber nicht das Meeting leiten.</title><link>https://autotomy.dev/de/blog/llm-fagan-inspection-preparation/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-fagan-inspection-preparation/</guid><description>Fagan-Inspektionen benötigen vier bis sechs Personen und zwei Stunden, um 250 Zeilen zu reviewen. Ein LLM kann diese Kosten senken, indem es Vorbereitung und Checklisten-Überwachung übernimmt, aber es kann die menschlichen Rollen nicht ersetzen, die die teuersten Defekte finden.</description><pubDate>Mon, 13 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Fagan Inspections fanden 90 % der Defekte vor dem Testing. Dann haben wir aufgehört, sie durchzuführen.</title><link>https://autotomy.dev/de/blog/fagan-inspections-disappearance-ibm/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/fagan-inspections-disappearance-ibm/</guid><description>Michael Fagans strukturierter Review-Prozess bei IBM erfasste fast alle Defekte, bevor sie den Compiler erreichten. Er verschlang aber auch 15–20 % des Gesamtprojektaufwands. Hier ist, warum die effektivste Review-Methode in der Softwaregeschichte verschwand und was Teams tatsächlich vermissen.</description><pubDate>Sun, 12 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Dein bester Reviewer übersieht die meisten Defekte. Fagan hat es 1976 bei IBM gemessen.</title><link>https://autotomy.dev/de/blog/fagan-reviewer-defect-detection-variance/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/fagan-reviewer-defect-detection-variance/</guid><description>Selbst Senior Engineers finden nur einen Bruchteil der Defekte in unstrukturiertem Review. Michael Fagans IBM-Forschung zeigte warum, und er baute einen strukturierten Inspection-Prozess, um das zu beheben.</description><pubDate>Sat, 11 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Die meisten Code Reviews finden 20 % der Defekte. Fagan Inspections finden 90 %.</title><link>https://autotomy.dev/de/blog/fagan-inspections-90-percent-defects/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/fagan-inspections-90-percent-defects/</guid><description>Informelles Code Review findet 15–30 % der Defekte. Fagan Inspections, ein strukturierter 50 Jahre alter Prozess, berichten konstant von 60–90 % Entfernungsraten. So funktionieren sie, warum Teams sie vermeiden, und wie man eine leichtgewichtige Version durchführt.</description><pubDate>Fri, 10 Jul 2026 00:00:00 GMT</pubDate></item><item><title>AutoVerus verwandelt 40 Stunden Proof-Writing in 3 LLM-Calls. Der Trick ist, zu wissen, wann man aufgibt.</title><link>https://autotomy.dev/de/blog/autoverus-llm-rust-verification/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/autoverus-llm-rust-verification/</guid><description>AutoVerus nutzt ein Netzwerk von LLM-Agents, um Verus-Correctness-Proofs für Rust-Code zu generieren und über 90% der Proof-Obligations durch eine Generate-Repair-Discharge-Schleife zu automatisieren, die vom Feedback des SMT-Solvers getrieben wird.</description><pubDate>Thu, 09 Jul 2026 00:00:00 GMT</pubDate></item><item><title>LLMs können Rust-Code generieren. Formale Beweise sind ein ganz anderes Problem.</title><link>https://autotomy.dev/de/blog/llm-rust-formal-proofs-hallucination/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-rust-formal-proofs-hallucination/</guid><description>Große Sprachmodelle schreiben erstaunlich guten Rust-Code, aber wenn man sie um einen formalen Beweis bittet, halluzinieren sie Invarianten und erfinden Syntax, die kein Verifizierer akzeptiert. Hier ist, was sie tatsächlich richtig machen, wo sie scheitern und wie man sie dennoch nutzen kann.</description><pubDate>Wed, 08 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Auf Race Conditions zu warten ist eine schreckliche Teststrategie</title><link>https://autotomy.dev/de/blog/model-checking-race-conditions/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/model-checking-race-conditions/</guid><description>Warum Model Checking Tage produktiver Laufzeit für das Finden von Concurrency-Bugs schlägt, und wie du es auf deinen eigenen Code anwendest.</description><pubDate>Tue, 07 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Sie können Code mit einem Model Checker verifizieren, ohne Temporal Logic zu lernen</title><link>https://autotomy.dev/de/blog/is-there-a-model-checker-that-doesnt-require-learning-temporal-logic/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/is-there-a-model-checker-that-doesnt-require-learning-temporal-logic/</guid><description>Bounded Model Checker wie Kani und relationale Model Finder wie Alloy ermöglichen die Verifikation von Eigenschaften mit gewöhnlichen Assertions und Constraints. Sie geben Liveness-Beweise auf, dafür ist die Lernkurve auf Stunden statt Wochen gemessen.</description><pubDate>Mon, 06 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Man kann Rust-Code korrekt beweisen, ohne einen einzigen Beweis zu schreiben – aber der Zustandsraum ist die Rechnung</title><link>https://autotomy.dev/de/blog/rust-model-checking-kani-state-space/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/rust-model-checking-kani-state-space/</guid><description>Model-Checking-Tools wie Kani erlauben es, Rust-Eigenschaften mit Assertions statt formaler Beweise zu verifizieren. Das Problem ist, was passiert, wenn deine Schleifen keine kleinen Grenzen haben.</description><pubDate>Sun, 05 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Du kannst ein verteiltes protocol nicht unit-testen, aber du kannst es model-checken</title><link>https://autotomy.dev/de/blog/distributed-protocol-model-checking-tla/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/distributed-protocol-model-checking-tla/</guid><description>Verteilte Bugs sind nach dem Deployment teuer zu beheben. Model Checking hilft dir, sie zu finden, bevor du eine einzige Zeile Implementierungscode schreibst. So geht&apos;s mit TLA+.</description><pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate></item><item><title>`.env`-Dateien zwischen Umgebungen zu kopieren ist keine Config-Strategie</title><link>https://autotomy.dev/de/blog/infrastructure-config-dsl-per-context/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/infrastructure-config-dsl-per-context/</guid><description>Wie Infrastructure-Teams Konfiguration über dev, staging und production mit per-Context-DSLs verwalten, die Umgebungsunterschiede explizit und typensicher machen.</description><pubDate>Fri, 03 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Grammar-constrained decoding: Wie man LLMs zwingt, bei jedem Token valide Syntax auszugeben</title><link>https://autotomy.dev/de/blog/grammar-constrained-decoding-llm/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/grammar-constrained-decoding-llm/</guid><description>LLMs halluzinieren Syntax, weil sie Tokens probabilistisch sampeln. Grammar-constrained decoding filtert das Vokabular in jedem Schritt, sodass nur Tokens emittiert werden, die die syntaktische Gültigkeit erhalten.</description><pubDate>Thu, 02 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Vom Englischen ins Theme zu übersetzen ist einfach. Es deterministisch zu machen, ist das eigentliche Problem.</title><link>https://autotomy.dev/de/blog/english-to-theme-deterministic-design-tokens/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/english-to-theme-deterministic-design-tokens/</guid><description>Du kannst Design-Tokens aus einfachen englischen Beschreibungen generieren, aber nur, wenn du die Beschreibung als DSL mit begrenztem Kontext, Schema-Vertrag und Snapshot-Tests behandelst.</description><pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate></item><item><title>Weg mit der Grammatikdatei: Schreib deinen DSL-Parser in plain TypeScript</title><link>https://autotomy.dev/de/blog/typescript-parser-combinators-dsl/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-parser-combinators-dsl/</guid><description>Parser-Generatoren sind für die meisten Bounded-Context-DSLs overkill. Parser-Kombinatoren erlauben es dir, einen funktionierenden Parser in derselben Sprache wie deine Anwendung zu bauen – ohne generierten Code und ohne Build-Schritte.</description><pubDate>Tue, 30 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Runtime-Konfigurationsfehler sind Produktionsausfälle, die du zugelassen hast</title><link>https://autotomy.dev/de/blog/config-validation-build-time/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/config-validation-build-time/</guid><description>Wie man Konfigurationsfehler abfängt, bevor die Anwendung Traffic verarbeitet – mit Schema-Validierung und Build-Time-Checks.</description><pubDate>Mon, 29 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Deine dependencies können deine Umgebungsvariablen lesen. JavaScript lässt sie.</title><link>https://autotomy.dev/de/blog/javascript-capability-security-lockdown/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/javascript-capability-security-lockdown/</guid><description>Ambient Authority bedeutet, dass jeder Code in deinem Node.js-Prozess auf das Dateisystem, das Netzwerk und die Umgebung zugreifen kann. Hier erfährst du, wie du sie mit Lockdown, Compartments und expliziter Capability-Übergabe entziehst.</description><pubDate>Sun, 28 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Netzwerknähe ist keine Identität: Wie Services sich ohne Ambient Authority authentifizieren</title><link>https://autotomy.dev/de/blog/service-authentication-without-ambient-authority/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/service-authentication-without-ambient-authority/</guid><description>Das meiste Service-zu-Service-Vertrauen basiert auf dem Netzwerkstandort, nicht auf kryptographischem Beweis. Hier erfährst du, wie Capabilities, mTLS und SPIFFE Services die Authentifizierung ohne Ambient Authority ermöglichen – und warum es schwieriger ist als es sein sollte.</description><pubDate>Sat, 27 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Deine Dependencies können jede Datei auf dem Datenträger lesen. cap-std zwingt sie, um Erlaubnis zu fragen.</title><link>https://autotomy.dev/de/blog/rust-cap-std-capability-filesystem/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/rust-cap-std-capability-filesystem/</guid><description>Die Standardbibliothek von Rust gewährt jeder Dependency umgebungsbasierte Dateisystemberechtigungen. cap-std ersetzt sie durch Capability-basierte APIs, die Code zwingen, nachzuweisen, dass er das Recht hat, auf einen Pfad zuzugreifen, bevor er ihn öffnet.</description><pubDate>Fri, 26 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Ihr Service ist ein unwissentlicher Komplize: So funktionieren Confused-Deputy-Attacken</title><link>https://autotomy.dev/de/blog/whats-a-confused-deputy-attack-and-how-do-i-prevent-it/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/whats-a-confused-deputy-attack-and-how-do-i-prevent-it/</guid><description>Eine Confused-Deputy-Attacke täuscht einen privilegierten Service, damit er seine eigene Autorität gegen sich selbst einsetzt. So nutzen Angreifer implizites Vertrauen aus – und warum Capability-Based Security die Lösung ist.</description><pubDate>Thu, 25 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Deine Berechtigungsprüfungen lügen dich an</title><link>https://autotomy.dev/de/blog/typescript-capability-based-security/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-capability-based-security/</guid><description>Capability-based Security ersetzt verstreute Rollenprüfungen durch unverfälschbare Tokens der Autorität. So implementierst du das in TypeScript, ohne deinen Code unlesbar zu machen.</description><pubDate>Wed, 24 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Was wäre, wenn jede Funktion eine Berechtigung erhalten müsste, statt sie einfach anzunehmen?</title><link>https://autotomy.dev/de/blog/capability-based-security-permissions/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/capability-based-security-permissions/</guid><description>Die meiste Code läuft mit ambient authority: Jede Funktion kann alles berühren. Capability-based Security kehrt dieses Modell um, indem Funktionen gezwungen werden, explizite, eingegrenzte Berechtigungen zu erhalten.</description><pubDate>Tue, 23 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Hör auf, Errors zu werfen, die dein Type-Checker nicht sehen kann</title><link>https://autotomy.dev/de/blog/should-i-stop-throwing-errors-and-start-returning-them/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/should-i-stop-throwing-errors-and-start-returning-them/</guid><description>Geworfene Exceptions verstecken Failure-Pfade vor deinem Typsystem. Hier ist, warum explizite Error-Returns deinen Code ehrlicher machen – und wie du sie übernimmst, ohne dein Leben zu hassen.</description><pubDate>Mon, 22 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Rust-Newtypes machen falsche Zustände zur Compile-Zeit unrepräsentierbar – ohne Extrakosten</title><link>https://autotomy.dev/de/blog/rust-newtypes-zero-cost-safety/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/rust-newtypes-zero-cost-safety/</guid><description>Ein Wrapper-Struct mit einem einzigen Feld fängt Unit-Mixing-Bugs und Typverwechslungen ab, ohne ein einziges Byte Overhead hinzuzufügen.</description><pubDate>Sun, 21 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Switch-Statements lassen Bugs zur Compile-Zeit durch</title><link>https://autotomy.dev/de/blog/is-there-a-better-way-than-switch-statements-for-type-safe-matching/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/is-there-a-better-way-than-switch-statements-for-type-safe-matching/</guid><description>TypeScript-Switch-Statements erlauben es dir stillschweigend, Fälle zu vergessen. So ersetzt du sie durch auf Exhaustiveness geprüfte Patterns, die den Build statt zur Laufzeit fehlschlagen lassen.</description><pubDate>Sat, 20 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Der Compiler sollte fehlende State-Fälle erkennen, nicht dein QA-Team</title><link>https://autotomy.dev/de/blog/typescript-exhaustiveness-state-machines/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-exhaustiveness-state-machines/</guid><description>Einen neuen State zur Machine hinzuzufügen ist einfach. Daran zu denken, jedes switch-Statement zu aktualisieren, nicht. So bringst du TypeScript dazu, die Kompilierung zu verweigern, wenn du einen Fall vergisst.</description><pubDate>Fri, 19 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Ja, aber dein Typsystem muss wissen, was ein Dollar ist</title><link>https://autotomy.dev/de/blog/typescript-currency-types/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-currency-types/</guid><description>TypeScript sieht alle Zahlen als identisch an. So bringst du ihm den Unterschied zwischen USD und EUR bei, damit der Compiler Currency-Conversion-Bugs erfasst, bevor sie in die Produktion gelangen.</description><pubDate>Thu, 18 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Eine Zahl ist nicht nur eine Zahl: So lässt du den Compiler Unit-Bugs erkennen</title><link>https://autotomy.dev/de/blog/typescript-unit-types-compile-time/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-unit-types-compile-time/</guid><description>Milliseconds dort zu übergeben, wo Seconds erwartet werden, ist ein Bug, der jeden Test besteht. Hier ist, wie du Units direkt in TypeScripts Type System encodest, damit Mix-ups zur Compile-Zeit fehlschlagen – ohne Runtime-Kosten.</description><pubDate>Wed, 17 Jun 2026 00:00:00 GMT</pubDate></item><item><title>TypeScript akzeptierte eine User-ID dort, wo eine Order-ID hingehört</title><link>https://autotomy.dev/de/blog/typescript-branded-types-newtypes/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-branded-types-newtypes/</guid><description>Type-Aliase erzeugen in TypeScript keine eigenständigen Typen. Branded Types hingegen schon, und sie können dich davor bewahren, Identifier zur Compile-Zeit zu verwechseln.</description><pubDate>Tue, 16 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Differential Testing funktioniert ohne formalen Beweis, aber Common-Mode Failures sind der Haken</title><link>https://autotomy.dev/de/blog/differential-testing-common-mode-failures/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/differential-testing-common-mode-failures/</guid><description>Differential Testing hilft dir, Bugs zu finden, ohne die korrekte Antwort zu kennen. Das Problem ist, dass korrelierte Fehler wie Übereinstimmung aussehen. So entdeckst du die blinden Flecken.</description><pubDate>Mon, 15 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Tests beweisen nicht, dass zwei Funktionen �quivalent sind. Das hier schon.</title><link>https://autotomy.dev/de/blog/function-equivalence-smt-solvers/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/function-equivalence-smt-solvers/</guid><description>N-version programming setzt voraus, dass deine Implementierungen �bereinstimmen. Wir zeigen, warum Tests nicht ausreichen, wie SMT solver tats�chlich �quivalenz beweisen k�nnen, und wo man die Grenze zwischen gut genug und formal verifiziert zieht.</description><pubDate>Sun, 14 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Was ist, wenn meine LLM-Varianten uneins sind? Welche hat recht?</title><link>https://autotomy.dev/de/blog/llm-variant-disagreement-resolution/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-variant-disagreement-resolution/</guid><description>Die parallele Ausführung mehrerer LLMs deckt Fehler auf, die jedes einzelne Modell selbstbewusst ausliefert. So baut man ein Disagreement-Resolution-System, das tatsächlich funktioniert.</description><pubDate>Sat, 13 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Fünf Implementierungen und keine Mehrheit: Wie man tatsächlich die beste wählt</title><link>https://autotomy.dev/de/blog/n-version-implementation-selection/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/n-version-implementation-selection/</guid><description>N-version Programming klingt einfach: mehrere Implementierungen laufen lassen und die beste Antwort wählen. In der Praxis ist &apos;beste&apos; viel schwerer zu definieren als &apos;am häufigsten&apos;.</description><pubDate>Fri, 12 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Das gleiche LLM kann fünf Versionen deiner Funktion schreiben. So machst du sie wirklich unterschiedlich.</title><link>https://autotomy.dev/de/blog/llm-n-version-diverse-implementations/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/llm-n-version-diverse-implementations/</guid><description>N-Version-Programming mit LLMs erfordert keine mehreren Modelle. Du kannst vielfältige, korrekte Implementierungen aus einem einzigen Modell extrahieren, indem du Prompts, Personas und Reasoning-Constraints variierst.</description><pubDate>Thu, 11 Jun 2026 00:00:00 GMT</pubDate></item><item><title>NASA ließ 27 Kopien desselben Programms laufen. Die Bugs stimmten als Block ab.</title><link>https://autotomy.dev/de/blog/nasa-n-version-programming-knight-leveson/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/nasa-n-version-programming-knight-leveson/</guid><description>N-Version Programming versprach, dass unabhängige Teams unabhängige Fehler machen würden. Das Experiment von Knight und Leveson aus dem Jahr 1986 bewies das Gegenteil, und NASA zog sich stillschweigend zurück.</description><pubDate>Wed, 10 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Die Hälfte Ihrer Cucumber-Szenarien wird übersprungen. Hier ist der Grund, warum dieser Status Sie anlügt.</title><link>https://autotomy.dev/de/blog/cucumber-skipped-scenarios-diagnosis/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/cucumber-skipped-scenarios-diagnosis/</guid><description>Cucumbers &apos;skipped&apos;-Status verbirgt drei völlig unterschiedliche Probleme. Hier erfahren Sie, wie Sie diagnosestellen, welches Ihre Test-Suite auffrisst, und wie Sie es stoppen.</description><pubDate>Tue, 09 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Deine Gherkin-Specs lügen dich an</title><link>https://autotomy.dev/de/blog/gherkin-specs-automated-sync/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/gherkin-specs-automated-sync/</guid><description>Gherkin-Specs geraten aus dem Takt, sobald du darauf vertraust, dass Menschen sie manuell aktualisieren. So automatisierst du die Prüfungen, die Feature-Files ehrlich halten.</description><pubDate>Mon, 08 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Dein Compiler prüft die Syntax. Deine Tests sollten die Architektur prüfen.</title><link>https://autotomy.dev/de/blog/architecture-tests-ci-enforcement/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/architecture-tests-ci-enforcement/</guid><description>Die meisten Teams dokumentieren Architektur-Regeln in Wikis. So schreibst du sie als ausführbare Tests, die den CI-Build fehlschlagen lassen, wenn dein Dependency-Graph abdriftet.</description><pubDate>Sun, 07 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Dein Domain-Layer importiert Postgres. Dein CI kümmert es nicht.</title><link>https://autotomy.dev/de/blog/clean-architecture-domain-infrastructure-ci/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/clean-architecture-domain-infrastructure-ci/</guid><description>Clean-Architecture-Diagramme sehen an der Whiteboard gut aus. So bringst du deine Build-Pipeline dazu, die dependency direction durchzusetzen, damit Domain-Code nicht auf Infrastruktur zugreifen kann.</description><pubDate>Sat, 06 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Dein Architekturdiagramm ist schon jetzt eine Lüge</title><link>https://autotomy.dev/de/blog/architecture-docs-code-generated-diagrams/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/architecture-docs-code-generated-diagrams/</guid><description>Architektur-Dokumentation veraltet im Moment des Speicherns. So hältst du Docs ehrlich – mit Code-generierten Diagrammen, ADRs und automatisierten Architektur-Tests.</description><pubDate>Fri, 05 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Deine Retry-Schleife geht davon aus, dass der erste Request fehlgeschlagen ist. Das hat er wahrscheinlich nicht.</title><link>https://autotomy.dev/de/blog/idempotency-keys-api-retries/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/idempotency-keys-api-retries/</guid><description>Ein Timeout oder Crash bedeutet nicht, dass dein API-Request verloren ging. So machen Idempotency-Keys Retrys sicher – und das Storage-Pattern, das tatsächlich Duplikate verhindert.</description><pubDate>Thu, 04 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Ein Lock, der den Prozess überlebt: Wie distributed Leases tatsächlich funktionieren</title><link>https://autotomy.dev/de/blog/distributed-leases-fencing-tokens/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/distributed-leases-fencing-tokens/</guid><description>In-Memory-Mutexes verschwinden, wenn der Server neu startet. Hier erfährst du, wie distributed Leases mit Fencing Tokens und TTLs doppelte Arbeit über Crashes hinweg verhindern – und wo sie trotzdem versagen.</description><pubDate>Wed, 03 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Ein Circuit Breaker ohne Goroutines, ohne Timer und ohne Hintergrund-Overhead</title><link>https://autotomy.dev/de/blog/circuit-breaker-lazy-recovery-no-goroutines/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/circuit-breaker-lazy-recovery-no-goroutines/</guid><description>Die meisten Circuit-Breaker-Bibliotheken starten Hintergrund-Threads, um die Wiederherstellung zu prüfen. Das brauchen Sie nicht. Hier ist ein request-getriebener Entwurf, der jeglichen Hintergrund-Overhead eliminiert – ohne Korrektheit zu opfern.</description><pubDate>Tue, 02 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Dein Web-Service hat einen Graceful-Shutdown-Pfad. Das ist der Bug.</title><link>https://autotomy.dev/de/blog/crash-only-software-web-services/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/crash-only-software-web-services/</guid><description>Crash-only-Software behandelt jeden Fehler als Crash und jeden Start als Recovery. Für Web-Services bedeutet das, die Shutdown-Logik zu löschen und einen Zustand zu entwerfen, der ein `kill -9` überlebt.</description><pubDate>Mon, 01 Jun 2026 00:00:00 GMT</pubDate></item><item><title>Wie man einen überlebenden Mutanten killt, wenn man nicht versteht, was er geändert hat</title><link>https://autotomy.dev/de/blog/killing-surviving-mutants/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/killing-surviving-mutants/</guid><description>Mutation Testing hat einen Überlebenden gefunden und du hast keine Ahnung, was die Mutation überhaupt macht. Hier ist eine Schritt-für-Schritt-Methode, um den richtigen Test zu schreiben, ohne den Mutanten zuerst zu verstehen.</description><pubDate>Sun, 31 May 2026 00:00:00 GMT</pubDate></item><item><title>Auth-Code braucht 90% Mutation Coverage. Deine String-Utils nicht.</title><link>https://autotomy.dev/de/blog/mutation-score-per-module-risk/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/mutation-score-per-module-risk/</guid><description>Warum ein einheitlicher Mutation Score für die gesamte Codebase ein Fehler ist, und wie du pro Modul Schwellenwerte setzt, die dem tatsächlichen Risiko entsprechen.</description><pubDate>Sat, 30 May 2026 00:00:00 GMT</pubDate></item><item><title>Deine Tests laufen durch. Dein Mutation-Score liegt bei 40 %. Das ist es, was überlebende Mutanten dir wirklich sagen.</title><link>https://autotomy.dev/de/blog/my-tests-pass-but-my-mutation-score-is-40-whats-a-surviving-mutant/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/my-tests-pass-but-my-mutation-score-is-40-whats-a-surviving-mutant/</guid><description>Code-Coverage sagt, du bist auf der sicheren Seite. Mutation-Testing sagt, deine Tests sind größtenteils Dekoration. So decken überlebende Mutanten die Lücke auf – und so schließt du sie.</description><pubDate>Fri, 29 May 2026 00:00:00 GMT</pubDate></item><item><title>Mutation Testing in Rust funktioniert, aber deine Compile-Zeiten werden es hassen</title><link>https://autotomy.dev/de/blog/rust-mutation-testing-cargo-mutants/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/rust-mutation-testing-cargo-mutants/</guid><description>cargo-mutants findet die Tests, die nur so tun, als würden sie deinen Code prüfen. Hier erfährst du, wie Mutation Testing in Rust funktioniert, was es findet und ob sich der Compile-Time-Aufwand lohnt.</description><pubDate>Thu, 28 May 2026 00:00:00 GMT</pubDate></item><item><title>Validierungsspektrum: Warum KI Backend am besten coded</title><link>https://autotomy.dev/de/blog/ai-coding-validation-spectrum-backend-web-mobile/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ai-coding-validation-spectrum-backend-web-mobile/</guid><description>KI-Coding folgt einem Gradienten: Backend validiert in Millisekunden, Web in Minuten, Mobile in Stunden. Die Feedback-Schleife bestimmt, wo es funktioniert.</description><pubDate>Wed, 27 May 2026 00:00:00 GMT</pubDate></item><item><title>Affe, Maschinengewehr, Aimbot: AI-Governance für Teams</title><link>https://autotomy.dev/de/blog/monkey-machine-gun-aimbot/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/monkey-machine-gun-aimbot/</guid><description>AI Code Governance nimmt niemandem die Werkzeuge weg. Es installiert Guardrails, damit jeder Schuss ins Ziel trifft – ohne Kollateralschäden.</description><pubDate>Wed, 27 May 2026 00:00:00 GMT</pubDate></item><item><title>Mutation Testing dauert 4 Stunden. Wie nutzen Teams das tatsächlich in CI?</title><link>https://autotomy.dev/de/blog/mutation-testing-takes-4-hours-how-do-teams-actually-use-it-in-ci/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/mutation-testing-takes-4-hours-how-do-teams-actually-use-it-in-ci/</guid><description>Die meisten Teams führen keine vollständigen Mutation-Testing-Suites bei jedem Commit aus. So integrieren Engineering-Teams Mutation Testing tatsächlich in CI, ohne die Build-Pipeline zu blockieren.</description><pubDate>Wed, 27 May 2026 00:00:00 GMT</pubDate></item><item><title>Deine Unit-Tests sind grün, aber deine Daten verschwinden trotzdem</title><link>https://autotomy.dev/de/blog/database-persistence-testing-mocks/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/database-persistence-testing-mocks/</guid><description>Gemockte Datenbank-Tests prüfen deine SQL-Syntax, nicht ob Zeilen Crashes, parallele Writes oder Schema-Mismatches überleben. So testest du Persistence wirklich.</description><pubDate>Tue, 26 May 2026 00:00:00 GMT</pubDate></item><item><title>Angst vs. Durchmarsch: Die zwei Realitäten des KI-Codings</title><link>https://autotomy.dev/de/blog/fear-vs-steamroll-ai-coding-divide/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/fear-vs-steamroll-ai-coding-divide/</guid><description>KI-Coding funktioniert für Elite-Teams, die sich aus jedem Chaos wieder herausarbeiten können. Alle anderen bekommen Angst, fehlgeschlagene CI und abgebrochene Experimente. Die Lücke liegt nicht am Modell.</description><pubDate>Tue, 26 May 2026 00:00:00 GMT</pubDate></item><item><title>Redux testen, ohne in Mock-Actions zu ertrinken</title><link>https://autotomy.dev/de/blog/redux-testing-real-state-transitions/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/redux-testing-real-state-transitions/</guid><description>Jede Redux-Action zu mocken verwandelt deine Tests in einen Changelog-Validator. So testest du deinen Store stattdessen mit echten State-Transitions.</description><pubDate>Mon, 25 May 2026 00:00:00 GMT</pubDate></item><item><title>KI-Coding in der Produktion: Warum die meisten Teams aufgeben</title><link>https://autotomy.dev/de/blog/ai-coding-in-production-autotomy-framework/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ai-coding-in-production-autotomy-framework/</guid><description>Die meisten Teams probieren KI-Coding aus, liefern Code aus, der bei der QA durchfällt, und geben auf. Das Problem ist nicht das Modell – es ist das Fehlen von Leitplanken, die KI-Output vertrauenswürdig machen.</description><pubDate>Sun, 24 May 2026 00:00:00 GMT</pubDate></item><item><title>100 Testläufe sind eine Lüge: Wie du Property-Based Tests richtig dimensionierst</title><link>https://autotomy.dev/de/blog/property-based-testing-run-count/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/property-based-testing-run-count/</guid><description>Die Standardanzahl von 100 Beispielen beim Property-Based Testing ist ein sozialer Kompromiss, keine statistische Strategie. So wählst du eine Anzahl an Läufen, die deinem Vertrauensbedürfnis und deinem CI-Budget entspricht.</description><pubDate>Sun, 24 May 2026 00:00:00 GMT</pubDate></item><item><title>Fuck-u-code: Das deterministische Quality Gate, das deine KI-Pipeline vergessen hat</title><link>https://autotomy.dev/de/blog/fuck-u-code-deterministic-quality-gate-ai-pipeline/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/fuck-u-code-deterministic-quality-gate-ai-pipeline/</guid><description>Du hast Type Checking, Linting und Architekturregeln. Aber dein deterministischer Stack ist blind für Komplexität, Duplikation und Naming-Desaster. Hier ist die Lösung für 0 Dollar.</description><pubDate>Sat, 23 May 2026 00:00:00 GMT</pubDate></item><item><title>Property-Based Tests in Rust finden die Bugs, die deine Unit Tests übersehen</title><link>https://autotomy.dev/de/blog/rust-property-based-testing-quickcheck/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/rust-property-based-testing-quickcheck/</guid><description>Beispielbasiertes Testing deckt nur die Inputs ab, an die du gedacht hast. Property-Based Testing generiert zufällige Daten, prüft Invarianten und reduziert Fehler auf minimale Gegenbeispiele.</description><pubDate>Sat, 23 May 2026 00:00:00 GMT</pubDate></item><item><title>Warum Version Eins nie das Problem ist: KI-Coding und langfristige Wartung</title><link>https://autotomy.dev/de/blog/ai-coding-why-version-one-is-never-the-problem/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ai-coding-why-version-one-is-never-the-problem/</guid><description>KI-Coding-Werkzeuge glänzen beim Generieren von Version Eins. Die eigentliche technische Herausforderung beginnt bei Version Vier, wenn das Team etwas ändern muss, ohne alles andere zu brechen.</description><pubDate>Fri, 22 May 2026 00:00:00 GMT</pubDate></item><item><title>KI-generierter Code und das Ersetzbarkeits-Prinzip</title><link>https://autotomy.dev/de/blog/ai-generated-code-replaceability-principle/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ai-generated-code-replaceability-principle/</guid><description>Das wahre Maß für die Qualität von KI-generiertem Code ist nicht, ob er am ersten Tag funktioniert. Es ist, ob man ihn am dreißigsten Tag ersetzen kann, ohne alles andere neu schreiben zu müssen.</description><pubDate>Fri, 22 May 2026 00:00:00 GMT</pubDate></item><item><title>Deterministische Leitplanken für KI-Codebases</title><link>https://autotomy.dev/de/blog/deterministic-guardrails-ai-codebases/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/deterministic-guardrails-ai-codebases/</guid><description>Menschliches Review ist inkonsistent. KI-Review ist schlechter. Die einzige skalierbare Verteidigung für KI-generierte Codebases ist deterministisches Enforcement: Regeln, die den Build fehlschlagen lassen, keine Vorschläge, die ignoriert werden.</description><pubDate>Fri, 22 May 2026 00:00:00 GMT</pubDate></item><item><title>Deine Unit Tests laufen durch. Dein Produktivcode ist trotzdem kaputt.</title><link>https://autotomy.dev/de/blog/i-write-unit-tests-why-do-bugs-still-slip-through/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/i-write-unit-tests-why-do-bugs-still-slip-through/</guid><description>Code-Coverage-Metriken erzeugen ein falsches Sicherheitsgefühl. Hier ist, warum Unit Tests die Bugs verpassen, die dich tatsächlich schlaflos machen – und was du stattdessen testen solltest.</description><pubDate>Fri, 22 May 2026 00:00:00 GMT</pubDate></item><item><title>Rust-Runtime-Contracts können in Release-Builds kostenlos sein, aber der Compiler macht das nicht für dich</title><link>https://autotomy.dev/de/blog/rust-zero-cost-runtime-contracts/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/rust-zero-cost-runtime-contracts/</guid><description>Rust entfernt Debug-Assertions automatisch, aber echtes Design-by-Contract braucht mehr als debug_assert!. So baust du zero-cost runtime contracts, die aus deinem Release-Binary verschwinden.</description><pubDate>Thu, 21 May 2026 00:00:00 GMT</pubDate></item><item><title>Null, Eins oder Zwölf: Wie viele Assertions eine Funktion im Production-Code wirklich braucht</title><link>https://autotomy.dev/de/blog/production-assertion-decision-framework/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/production-assertion-decision-framework/</guid><description>Entwickler verteilen Assertions entweder wie Konfetti oder meiden sie komplett. Hier ist das Entscheidungs-Framework, das nützliche Invariants von Production-Crash-Triggern unterscheidet.</description><pubDate>Wed, 20 May 2026 00:00:00 GMT</pubDate></item><item><title>Deine Validierungsschicht ist größer als deine Geschäftslogik</title><link>https://autotomy.dev/de/blog/declarative-runtime-contracts-validation/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/declarative-runtime-contracts-validation/</guid><description>Manuelle Validierung bläht deinen Codebase auf und verpasst trotzdem Edge Cases. So erzwingst du Runtime Contracts mit deklarativen Schemas, die dir nicht im Weg stehen.</description><pubDate>Tue, 19 May 2026 00:00:00 GMT</pubDate></item><item><title>TypeScript strictNullChecks ist eine Absicherung zur Compile-Time, kein Schutz zur Laufzeit</title><link>https://autotomy.dev/de/blog/typescript-strictnullchecks-runtime-nulls/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/typescript-strictnullchecks-runtime-nulls/</guid><description>Der Strict Mode fängt die Nulls auf, die du schreibst, nicht die, die zur Laufzeit aus APIs, DOM-Queries und JSON.parse ankommen. Hier endet das Typsystem und deine Verteidigung beginnt.</description><pubDate>Mon, 18 May 2026 00:00:00 GMT</pubDate></item><item><title>Im AI-Zeitalter wird Code Review zur Spezifikationsprüfung</title><link>https://autotomy.dev/de/blog/code-review-becomes-specification-review/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/code-review-becomes-specification-review/</guid><description>Wenn AI aus einer Spezifikation Implementierung, Tests und contracts generieren kann, verlagert sich die menschliche Arbeit mit der größten Hebelwirkung weiter nach vorn. Am genauesten geprüft werden muss dann die Spezifikation selbst.</description><pubDate>Sun, 17 May 2026 00:00:00 GMT</pubDate></item><item><title>Der AI Safety Stack: Types, Contracts, Property Tests und Mutation Gates</title><link>https://autotomy.dev/de/blog/ai-safety-stack-types-contracts-property-tests-mutation/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ai-safety-stack-types-contracts-property-tests-mutation/</guid><description>Wenn AI-generated code in Produktion bestehen soll, reicht Code Review nicht. Du brauchst einen gestuften Safety Stack von Type Constraints bis Mutation Testing und Runtime Containment.</description><pubDate>Sat, 16 May 2026 00:00:00 GMT</pubDate></item><item><title>Meteor development ist real. Deine Codebase muss nicht mit einstürzen</title><link>https://autotomy.dev/de/blog/meteor-development-is-real/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/meteor-development-is-real/</guid><description>Das Meme funktioniert, weil Teams tatsächlich mit beweglichen Zielen, festen Fristen und halb definiertem Umfang entwickeln. Autotomy repariert kein Wunschdenken in der Planung, aber es hält die Entwicklung am Laufen, wenn sich die Route wieder ändert.</description><pubDate>Sat, 16 May 2026 00:00:00 GMT</pubDate></item><item><title>Stanford CS146S hat bei AI Coding recht. Das fehlende Fach ist Architektur</title><link>https://autotomy.dev/de/blog/stanford-cs146s-ai-architecture-gap/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/stanford-cs146s-ai-architecture-gap/</guid><description>Diese kritische Einordnung von Stanford CS146S zeigt, warum der Kurs AI Coding im Kern richtig einordnet, die entscheidende Lektion zur AI-Architektur rund um Ersetzbarkeit und Grenzen aber noch fehlt.</description><pubDate>Sat, 16 May 2026 00:00:00 GMT</pubDate></item><item><title>Warum große Engineering-Ideen Nische blieben, bis AI sie wirtschaftlich machte</title><link>https://autotomy.dev/de/blog/engineering-ideas-ai-economics/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/engineering-ideas-ai-economics/</guid><description>Design by contract, property-based testing, mutation testing und model checking waren keine schlechten Ideen. Sie verlangten zu viel Fachwissen, um sie dauerhaft zu tragen. AI verändert diese Gleichung.</description><pubDate>Fri, 15 May 2026 00:00:00 GMT</pubDate></item><item><title>Von Vibe Code zu Production: Warum deine KI-codierte React-Native-App Guardrails zum Skalieren braucht</title><link>https://autotomy.dev/de/blog/ai-react-native-guardrails-scaling/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/ai-react-native-guardrails-scaling/</guid><description>KI kann dein React-Native-MVP schnell shippen, aber ohne Guardrails kann jede kleine Änderung unzusammenhängende Flows zerlegen. So verhindern deklarative Constraints, dass Geschwindigkeit in Fragilität umkippt.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>Der Vibe-Coder-Guide zum React-Native-App-Lifecycle</title><link>https://autotomy.dev/de/blog/app-lifecycle-resume-status/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/app-lifecycle-resume-status/</guid><description>Deine App funktioniert im Dev-Modus, aber Nutzer sehen nach der Mittagspause einen leeren Screen. Hier ist das Resume-Status-Pattern, das den nativen Lifecycle sauber behandelt.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>Warum deine vibe-codierte React-Native-App beim Start crasht (und wie du das stoppst)</title><link>https://autotomy.dev/de/blog/dependency-tiers-hard-soft-optional/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/dependency-tiers-hard-soft-optional/</guid><description>Wenn optionale SDKs so initialisieren wie Kern-Infrastruktur, können sie deine App schon beim Start crashen lassen. Hier ist das Dependency-Tier-System, das nicht-kritische Tools daran hindert, Production mitzunehmen.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>Warum Vibe Coding mit NativeWind in Cursor deine React-Native-App beim Skalieren zerlegt</title><link>https://autotomy.dev/de/blog/nativewind-vs-stylesheet-contract/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/nativewind-vs-stylesheet-contract/</guid><description>Du hast an einem Wochenende ein MVP mit Cursor ausgeliefert, aber jetzt bricht schon beim Ändern einer Farbe alles in 47 Dateien auseinander. Hier ist der Styling-Contract, der die Blutung stoppt.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>Warum Claude Code deinen Code nicht reviewen sollte (und was du stattdessen nutzen solltest)</title><link>https://autotomy.dev/de/blog/o1-guards-vs-llm-reviews/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/o1-guards-vs-llm-reviews/</guid><description>LLM-Code-Review ist nicht deterministisch, langsam und übersieht Architekturverletzungen. Hier ist der O(1)-Guard-Stack, der deinen Code tatsächlich sauber hält.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>Löschen statt migrieren: Die Refactoring-Strategie für vibe-codierte React-Native-Apps</title><link>https://autotomy.dev/de/blog/refactor-by-replacement/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/refactor-by-replacement/</guid><description>KI-generierten Code zu refaktorieren heißt, eine Absicht rückzuentwickeln, die du nie hattest. Hier ist das interface-getriebene Replacement-Pattern, das Löschen sicher macht.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>Wie Cursor und Claude Code deine React-Native-Architektur zerstören (und wie du das behebst)</title><link>https://autotomy.dev/de/blog/service-boundaries-composition-root/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/service-boundaries-composition-root/</guid><description>KI-generierte Auth fühlt sich stabil an, bis ein neues Feature in den falschen Service greift. Hier ist die interface-getriebene Architektur, die Vendor-Wechsel und Feature-Arbeit davon abhält, Login zu zerlegen.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>Warum Deep Links vibe-codierte React-Native-Apps crashen lassen (und wie du sie mit Zod validierst)</title><link>https://autotomy.dev/de/blog/url-validation-expo-router/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/url-validation-expo-router/</guid><description>Deep Links, Push-Payloads und geteilte URLs sind allesamt nicht vertrauenswürdiger Input. So validierst du sie an der Expo-Router-Boundary, bevor kaputte Params deine Screens erreichen.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item><item><title>useSyncExternalStore: Der React Hook, der deine vibe-codierte App vor State-Bugs rettet</title><link>https://autotomy.dev/de/blog/useSyncExternalStore-pattern/</link><guid isPermaLink="true">https://autotomy.dev/de/blog/useSyncExternalStore-pattern/</guid><description>Hör auf, `useEffect`-Subscriptions zu schreiben, die Memory Leaks verursachen und State Updates verpassen. Hier ist das React-18-Pattern für kugelsicheren externen State.</description><pubDate>Thu, 14 May 2026 00:00:00 GMT</pubDate></item></channel></rss>