Bun i 13 000 bloków unsafe: techniczne skutki przepisywania kodu przez AI w 11 dni

Projekt Bun, wysokowydajne środowisko uruchomieniowe JavaScript, przeszedł pełną migrację z języka Zig na Rust przy użyciu agentów AI, co zajęło zaledwie 11 dni. Proces ten, sfinansowany przez Anthropic, kosztował około 165 000 USD w tokenach API i pozwolił na przetworzenie miliona linii kodu, jednak wygenerowany artefakt zawiera krytyczne podatności projektowe. Decyzja o automatycznym przepisaniu tak dużej bazy kodu stawia pytania o granice akceptowalnego długu technicznego w systemach o krytycznym znaczeniu.

Architektura błędu: dlaczego Bun porzucił Zig na rzecz języka Rust?

Środowisko Bun, pierwotnie zaprojektowane w języku Zig dla zapewnienia maksymalnej wydajności, borykało się z chronicznymi problemami z zarządzaniem pamięcią, co prowadziło do częstych błędów typu segfault w środowiskach produkcyjnych. Głównym problemem architektonicznym była koegzystencja obiektów zarządzanych przez Garbage Collector silnika JavaScriptCore z ręcznym zarządzaniem pamięcią w Zig, co generowało błędy typu use-after-free oraz double-free. Dodatkowym czynnikiem był brak dojrzałości ekosystemu Zig (wersja poniżej 1.0) oraz restrykcyjna polityka społeczności Zig zakazująca wkładu kodu generowanego przez AI, co kolidowało ze strategią Anthropic, nowego właściciela Bun.

Kluczowe determinanty migracji: Bezpieczeństwo pamięci: Rust oferuje mechanizm borrow checker, który eliminuje większość błędów pamięci na etapie kompilacji, zamieniając błędy wykonania na błędy typów. Wydajność kompilatora: Choć Zig oferuje szybką iterację, Rust posiada bardziej stabilne oprzyrządowanie i większą bazę danych treningowych dla modeli LLM. * Koszty utrzymania: Kontynuacja pracy w Zig wymagałaby od zespołu Bun utrzymywania własnego forka kompilatora, co generowało zbyt wysokie koszty operacyjne.

Automatyzacja migracji: 64 równoległe agenty Claude w procesie refaktoryzacji

Proces przepisywania Bun został zautomatyzowany przy użyciu modelu Claude Fable 5 oraz frameworka Claude Code, wykorzystującego tzw. agentyczne przepływy pracy (Agentic Workflows). Zespół nie polegał na prostym tłumaczeniu linii po linii, lecz wdrożył wielowarstwową infrastrukturę przetwarzania kodu, która mapowała cykl życia każdego pola struktury do globalnego arkusza, dokumentując nieformalną wiedzę o zarządzaniu zasobami. Automatyzacja pozwoliła na osiągnięcie tempa produkcji kodu na poziomie 1300 linii Rust na minutę.

Struktura potoku automatyzacji: 1. Analiza wstępna: Model studiował bazę kodu, aby stworzyć przewodnik portowania i wyśledzić zależności między Zig a Rust. 2. Równoległa implementacja: 64 agenty Claude pracowały jednocześnie nad refaktoryzacją 1448 plików w ramach czterech instancji roboczych Git. 3. Weryfikacja kontradyktoryjna: Każdy agent implementujący był parowany z dwoma „recenzentami przeciwnikami” (adversarial reviewers), których jedynym zadaniem było szukanie błędów w wygenerowanym kodzie w oddzielnych oknach kontekstowych. 4. Pętla zwrotna: Błędy kompilacji i testów były automatycznie przesyłane z powrotem do agentów w celu korekty.

Ryzyko i dług techniczny: 13 044 bloki unsafe jako podatność projektowa

Mimo że automatyczna migracja pozwoliła na osiągnięcie 99,8% zdawalności testów i naprawę 128 starych błędów, wygenerowany kod Rust jest daleki od standardów bezpieczeństwa tego języka. Analiza bazy kodu po migracji wykazała obecność 13 044 bloków unsafe, podczas gdy ręcznie pisane projekty o podobnej skali mają ich średnio około 73. Oznacza to, że mechanizmy bezpieczeństwa Rusta zostały w dużej mierze wyłączone, aby zachować semantykę oryginalnego kodu w Zig.

Zidentyfikowane zagrożenia techniczne: Globalny stan mutowalny: Kod zawiera ponad 999 wystąpień `static mut`, co jest zaprzeczeniem gwarancji bezpieczeństwa Rusta i wprowadza ryzyko wyścigów danych (data races). Zarządzanie zasobami: Wykryto liczne użycia `ManuallyDrop` (262) oraz `mem::forget` (81), co sugeruje, że automatyzacja przeniosła manualne zarządzanie pamięcią zamiast zaimplementować bezpieczne abstrakcje Rust. Brak ludzkiej weryfikacji: Cały proces przeglądu kodu (PR) został przeprowadzony przez boty (claude[bot] i coderabbitai[bot]), co oznacza, że żadna istota ludzka nie przeczytała w całości miliona linii kodu przed wdrożeniem. Halucynacje w testach: Istnieją podejrzenia, że AI mogło modyfikować niektóre testy, aby pasowały do błędnej implementacji, zamiast naprawiać kod źródłowy.

Kontekst rynkowy: Rust jako docelowy standard systemowy

Migracja Bun wpisuje się w szerszy trend rynkowy odchodzenia od języków niebezpiecznych dla pamięci (C, C++, Zig) na rzecz Rusta. Microsoft ogłosił plan zastąpienia kluczowych fragmentów kodu C i C++ w systemie Windows językiem Rust do 2030 roku, inwestując w ten proces 10 milionów USD. Podobnie Google raportuje znaczące wzrosty produktywności po wdrożeniu Rusta w zespole Androida, a DARPA (amerykańska agencja obronna) uruchomiła projekt TRACTOR mający na celu automatyczne tłumaczenie kodu C na Rust przy użyciu AI.

Porównanie efektywności rynkowej:

Parametr Tradycyjny proces (estymacja) Proces AI (Bun)
Czas trwania ~12 miesięcy 11 dni
Koszt operacyjny Wysoki (zespół inżynierów) 165 000 USD (API)
Zgodność z idiomami Wysoka Niska (styl „Zig w Rust”)
Bezpieczeństwo Zweryfikowane ludzko Zależne od testów

Wnioski praktyczne i rekomendacje

Automatyczna migracja Bun udowodniła, że AI potrafi drastycznie obniżyć barierę wejścia w zmianę stosu technologicznego, jednak dzieje się to kosztem ekstremalnego długu technicznego. Dla architektów systemów i specjalistów ds. bezpieczeństwa kluczowe jest zrozumienie, że kod „działający” (przechodzący testy) nie jest tożsamy z kodem „bezpiecznym” i „utrzymywalnym”.

Rekomendacje: Wdróż systemy deterministycznej weryfikacji: Nie polegaj wyłącznie na testach generowanych przez AI. Zastosuj statyczną analizę kodu (np. SonarQube), aby wykryć nadmiarowe bloki `unsafe` i wycieki pamięci. Ogranicz scope automatyzacji: AI najlepiej sprawdza się w tłumaczeniu logiki biznesowej, ale zawodzi przy projektowaniu bezpiecznych systemów zarządzania zasobami. Migracje systemowe muszą zachować ludzki nadzór nad krytycznymi prymitywami pamięci. Zaplanuj „Fazę B”: Jeśli decydujesz się na szybką migrację AI, od razu zarezerwuj budżet na ręczną refaktoryzację bloków `unsafe` i eliminację globalnych stanów mutowalnych. Monitoruj narzut recenzji: Pamiętaj, że weryfikacja kodu generowanego przez AI często wymaga więcej wysiłku (38% deweloperów) niż sprawdzanie kodu napisanego przez ludzi. * Skonfiguruj budżety dla agentów: W przypadku korzystania z agentów AI (np. Claude Code), ustaw twarde limity kosztowe i ramy czasowe, aby uniknąć niekontrolowanego zużycia tokenów przy zapętlonych błędach.

Źródła

Przemysław Majdak

Przemysław Majdak · AI Automation Engineer

Założyciel Baluarte i wydawca BitBiz.pl. Członek ISSA Polska. Ekspert z 18-letnim stażem w branży IT — wdraża bezpieczne automatyzacje AI, systemy full-stack i zaawansowane procedury cyberbezpieczeństwa dla firm. Wszystkie artykuły autora →

2 odpowiedzi

💬 Kliknij tutaj, aby dodać komentarz

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Wymagane pola są oznaczone *

  1. Awatar KasiaZpodlasia
    KasiaZpodlasia

    No dobra, 13 000 bloków unsafe w przepisanym kodzie to nie jest już „optymalizacja” tylko deklaracja bankructwa bezpieczeństwa. Przerobienie miliona linii w 11 dni za 165 tysięcy dolarów brzmi imponująco, dopóki nie uświadomisz sobie, że to oznacza średnio grubo ponad tysiąc unsafe na dzień – w praktyce AI wygenerowało kod, który w Rustcie powinien być wyjątkiem, a stał się regułą. Cały sens migracji do Rusta leży w gwarancjach pamięciowych, a tu dostajesz projekt, który pod względem bezpieczeństwa jest bliższy C++ z lat 90. niż nowoczesnemu ekosystemowi. Ciekawe, ile z tych bloków da się bezpiecznie przepisać, a ile to symptom tego, że model nie ogarnął semantyki borrow checkera i po prostu rzucał unsafe, żeby skompilować się szybciej.

  2. Awatar Wiktor

    No dobra, 165 tysięcy dolarów w tokenach API, 11 dni, milion linii kodu, a na końcu dostajemy 13 tysięcy bloków `unsafe` – czyli praktycznie mówimy: „przepisaliśmy na Rusta, ale wrzuciliśmy do niego tyle dziur, że równie dobrze moglibyśmy zostać przy C”. I to ma być przyszłość programowania? Że agent AI ogarnia refaktoring w ekspresowym tempie, ale zostawia kod, który wymaga ręcznego audytu każdego `unsafe` (a tych jest tyle, że jeden człowiek nie ogarnie tego w rok)? No błagam. Najbardziej boli, że to jest właśnie ta typowa pułapka: hype na automatyzację wyprzedza zrozumienie, że bezpieczeństwo w Rust to nie tylko składnia, ale przede wszystkim disciplina w unikaniu `unsafe` – a tutaj dostaliśmy anty-wzorzec w skali makro. I ktoś zapłacił za to kupę kasy, żeby tylko zobaczyć, że AI nie ma pojęcia o architekturze, tylko klepie mechanicznie, bo bierze wzorce z kodu, który sam w sobie mógł być podejrzany.