Музейный экспонат на Rust без участия человека
claw-code — музейный экспонат на Rust, разработанный ИИ-агентом без участия человека. Разбираем, как работает разработка и что из этого вышло.
Что такое claw-code
Что такое claw-code
claw-code — музейный экспонат, который написан полностью ИИ-агентом. В буквальном смысле: человек не правил код, не коммитил в репозиторий, не правил конфиги. Агент сам придумал архитектуру, выбрал стек, написал и отладил программу.
Для меня, как для инженера с двенадцатилетним стажем, это звучит как эксперимент из категории «посмотрим, что получится». Но с практической точки зрения здесь есть несколько моментов, которые стоит разобрать.
Идея агентного экспоната
Музейный экспонат обычно статичен: плакат, макет, иногда интерактивный стенд с заранее записанным сценарием. claw-code отличается — это живой код, который родился без участия разработчика.
Идея проста: поставить перед ИИ-агентом задачу — создать полноценный программный продукт — и выйти из комнаты. Агент сам решает, что делать, как структурировать проект, какие зависимости добавить. Человек только наблюдает за результатом.
С практической точки зрения это ставит вопрос о предсказуемости. Когда я настраиваю сервер, я хочу знать, что каждая строка в конфиге написана осознанно. Если код написал агент, отладка превращается в детективную историю: нужно понять не только что сломано, но и почему агент принял такое решение.
Пример из реальной практики. Недавно я аудировал инфраструктуру одного стартапа. Разработчики использовали сгенерированный ИИ код для работы с очередями сообщений. Всё работало до тех пор, пока не выросла нагрузка. Оказалось, что агент выбрал неоптимальную стратегию подтверждения доставки, и при пике в пять тысяч сообщений в секунду часть просто терялась. Пришлось переписывать модуль вручную.
claw-code — это попытка посмотреть на ту же проблему с другой стороны. Если агент пишет код для музейного экспоната, где нагрузка предсказуема и аудитория ограничена, риски ниже. Но вопрос остаётся: можно ли доверять такому коду в продакшене?
Стек проекта: Rust, Gajae-Code, LazyCodex
Если мы посмотрим на стек claw-code, первое, что бросается в глаза — выбор Rust. Для музейного экспоната это неочевидное решение. Rust требует времени на компиляцию, строгой типизации и борьбы с borrow checker. Но с точки зрения предсказуемости это логично: если код уже скомпилировался, большая часть ошибок отсечена на этапе разработки.
Gajae-Code — фреймворк для агентной разработки. Он отвечает за то, как ИИ взаимодействует с кодовой базой: создаёт файлы, вносит правки, запускает тесты. LazyCodex — слой над ним, который оптимизирует запросы к модели и кэширует промежуточные результаты.
Вот как может выглядеть структура проекта:
claw-code/
├── Cargo.toml
├── src/
│ ├── main.rs
│ ├── agent.rs
│ └── exhibit.rs
├── tests/
│ └── integration.rs
└── .gajae/
└── config.yaml
Пример конфигурации Gajae-Code:
yaml# .gajae/config.yaml
agent:
model: claude-3-opus
temperature: 0.1
max_iterations: 50
workspace:
path: ./src
allowed_extensions:
- .rs
- .toml
- .yaml
behavior:
commit_on_success: true
run_tests_before_commit: true
fail_on_clippy_warnings: true
И точка входа на Rust:
rust// src/main.rs
use claw_code::exhibit::MuseumExhibit;
fn main() {
let exhibit = MuseumExhibit::new();
exhibit.run();
}
С практической точки зрения, такой стек говорит о том, что авторы эксперимента хотели получить не просто «работающий код», а код с гарантиями. Rust даёт безопасность памяти, Gajae-Code даёт воспроизводимость шагов агента, а LazyCodex — экономию на запросах к модели.
Но здесь есть нюанс. Я привык писать конфиги руками, даже когда есть GUI. GUI для тех, кто не знает, где лежит конфиг. В случае с claw-code конфиг пишет агент. Это значит, что нужно доверять не только коду, но и тому, как агент его структурирует.
claw-code показывает, что разработка без участия человека технически возможна. Но для эксплуатации такого кода нужны те же инструменты, что и для обычного кода: мониторинг, алерты, документация. Иначе через полгода никто не вспомнит, почему агент выбрал именно эту архитектуру.
Как работает разработка без человека
Как работает разработка без человека
claw-code позиционируется как музейный экспонат: Rust-проект, который написал ИИ-агент без участия человека. С точки зрения инженера, интересны не сами строки кода, а конвейер, который их производит. Когда человека убирают из цикла, остаётся только вопрос предсказуемости: получится ли у агента собрать проект, прогонить тесты и не сломать то, что уже работает.
Цикл работы ИИ-агента
Цикл выглядит так: планирование → генерация кода → запуск тестов → анализ ошибок → исправление → коммит. Агент не «думает» как разработчик, он итерируется, пока cargo test не станет зелёным.
Например, если задача — добавить парсинг аргументов командной строки, агент может сделать следующее:
- Ищет в репозитории существующие примеры работы с CLI.
- Добавляет зависимость в
Cargo.toml. - Пишет модуль
src/cli.rs. - Запускает
cargo buildиcargo test. - Если тест падает — читает вывод, правит код, повторяет.
Вот как может выглядеть фрагмент Cargo.toml после такого шага:
toml[dependencies]
clap = { version = "4", features = ["derive"] }
Агент не спорит с собой о том, нужна ли библиотека или можно обойтись стандартной библиотекой. Он просто выбирает то, что чаще встречается в обучающих данных. Это работает для типовых задач, но ломается на нестандартных архитектурных решениях.
С практической точки зрения, автономный цикл эффективен, пока область задач чётко ограничена. Добавить endpoint, написать unit-тест, обновить зависимость — агент справится. Перепроектировать модуль, чтобы убрать циклическую зависимость, — вряд ли.
Ограничения и риски автономного кода
Во-первых — отсутствие контекста. Агент не знает, почему в проекте принято именовать серверы в честь героев советских мультфильмов, и не поймёт, что изменение в одном сервисе сломает другой, если связь не описана в коде.
Во-вторых — качество кода. Агент склонен к unwrap() там, где нужна обработка ошибок, и к подтягиванию неподдерживаемых crates. Пример:
rustfn read_config(path: &str) -> Config {
let content = std::fs::read_to_string(path).unwrap();
toml::from_str(&content).unwrap()
}
Такое скомпилируется, пройдёт тесты, если они не проверяют отсутствие файла, и уйдёт в продакшен. При первом же отсутствии конфига сервер упадёт с паникой.
В-третьих — безопасность и цепочка поставок. Агент может добавить зависимость с вредоносным кодом или устаревшей версией с известной уязвимостью, потому что он не читает changelog и не проводит аудит.
Автономная разработка хороша для зелёного поля с чёткой спецификацией. Она не заменяет инженера при рефакторинге легаси, принятии решений по безопасности или оценке технического долга. Предсказуемость конфигурации — это то, чему пока не научить агентов.
Что из этого получилось
claw-code — это не продукт, который можно взять и запустить в продакшене. Это музейный экспонат: код на Rust, который написал ИИ-агент без участия человека. Он компилируется, запускается, даже делает что-то полезное. Но поддерживать его — отдельная история.
Плюсы и минусы подхода
С практической точки зрения, у подхода есть два очевидных преимущества и несколько критических недостатков.
Во-первых, скорость. ИИ-агент не пьёт кофе, не отвлекается на переписку и не забывает, что хотел сделать полчаса назад. Он может выдать скелет приложения на Rust за несколько минут. Для музея, где нужно показать «вот что может ИИ», этого достаточно.
Во-вторых, отсутствие человеческой лени в начале разработки. Нет «завтра допишу тесты», нет опечаток в именах переменных на первом проходе. Код синтаксически верен с первого взгляда.
Но есть обратная сторона.
ИИ не понимает бизнес-логики. Он пишет синтаксически корректный Rust, но не знает, зачем нужна та или иная структура. Например, может сгенерировать обработчик ошибок, который просто паникует в продакшене, потому что «так проще».
Отсутствие тестов и мониторинга — это уже не недостаток, а проблема. Я терпеть не могу решения на коленке. Если делать, то нормально, с мониторингом, алертами и документацией. У claw-code ничего из этого нет.
Отладка тоже превращается в квест. Когда компилятор ругается на время жизни (lifetimes), человек может подумать, перечитать документацию и исправить. ИИ может сгенерировать код, который компилируется, но работает некорректно — и найти ошибку будет сложнее, потому что нет автора, который может объяснить свою мысль.
Предсказуемость конфигураций тоже страдает. Я люблю, когда конфиг лежит в одном месте, написан руками и понятен любому инженеру. Здесь же конфигурация размазана по сгенерированным модулям, и никто не может сказать, какой параметр за что отвечает.
Пример. Допустим, ИИ написал такую функцию:
rustfn process_data(input: &str) -> String {
let mut result = String::new();
for line in input.lines() {
if line.contains("error") {
result.push_str(line);
result.push('\n');
}
}
result
}
Код компилируется. Но что делать с пустым входом? Что если input содержит не UTF-8? Как логировать ошибки? ИИ не ответил на эти вопросы, потому что не понимает контекста.
Проверить, что проект собирается, можно так:
bashcargo check cargo build --release
Но без тестов это только половина дела:
bashcargo test
И тут, скорее всего, пусто — тестов нет.
Когда такой подход уместен
Если мы посмотрим на claw-code с точки зрения инженера, становится понятно: этот подход не для продакшена.
Он уместен в трёх случаях.
Первый — музейные экспонаты и демонстрации. Нужно показать, что ИИ может написать рабочий код на Rust без участия человека. claw-code как раз для этого.
Второй — быстрое прототипирование. Когда нужно за день показать идею инвестору или коллегам, а поддерживать код не планируется. Но даже здесь я бы рекомендовал сразу заменить сгенерированный код на ручной, как только проект переходит в стадию разработки.
Третий — образование. Студенты могут посмотреть, что генерирует ИИ, и разобрать, где он ошибся. Это полезное упражнение, но не больше.
Не уместен такой подход для критичных систем, для продакшена, для чего-то, что должно работать годами без участия человека. Серверы, которые я настраивал, не падают годами именно потому, что за каждым конфигом стоит человек, понимающий, что он делает.
claw-code — это интересный экспонат, но не инструмент для реальной работы.
Часто задаваемые вопросы
Можно ли использовать код claw-code в реальном проекте?
С практической точки зрения — только после полной аудитной проверки. Агент выбирает архитектуру и зависимости исходя из статистики, а не из требований к надёжности. Для музейного экспоната с предсказуемой нагрузкой это допустимо, для сервиса с пользователями — нет.
Кто несет ответственность за ошибки в таком коде?
Ответственность несёт тот, кто запускает код в эксплуатации. Агент не исправляет инциденты ночью и не подписывает соглашение об уровне обслуживания. Если система падает, разбираться придётся вам, поэтому без тестов и мониторинга не обойтись.
Как отлаживать программу, если человек не участвовал в её создании?
Приходится действовать как детектив: читать логи, восстанавливать логику агента и угадывать, почему он принял такое решение. Я рекомендую добавить подробное логирование и покрыть критические пути тестами ещё до запуска. Без этого отладка превращается в гадание.
Почему для эксперимента выбрали Rust?
Rust заставляет быть точным с памятью и типами, что снижает вероятность неочевидных ошибок в сгенерированном коде. Компилятор отсекает целый класс проблем, которые агент мог бы не заметить. Для экспоната, который должен работать без присмотра, это важнее скорости разработки.
В чём главная опасность агентной разработки?
Главная опасность — отсутствие предсказуемости. Вы не знаете, почему агент выбрал именно эту структуру проекта или эту библиотеку. Когда начнётся инцидент, вам предстоит восстанавливать его рассуждения постфактум.