Средний

Музейный экспонат на Rust без участия человека

Алексей Кузнецов
Алексей Кузнецов
Системный администратор4 ноября 2026 г.9 мин чтения

claw-code — музейный экспонат на Rust, разработанный ИИ-агентом без участия человека. Разбираем, как работает разработка и что из этого вышло.

Музейный экспонат на 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 не станет зелёным.

Например, если задача — добавить парсинг аргументов командной строки, агент может сделать следующее:

  1. Ищет в репозитории существующие примеры работы с CLI.
  2. Добавляет зависимость в Cargo.toml.
  3. Пишет модуль src/cli.rs.
  4. Запускает cargo build и cargo test.
  5. Если тест падает — читает вывод, правит код, повторяет.

Вот как может выглядеть фрагмент Cargo.toml после такого шага:

toml
[dependencies]
clap = { version = "4", features = ["derive"] }

Агент не спорит с собой о том, нужна ли библиотека или можно обойтись стандартной библиотекой. Он просто выбирает то, что чаще встречается в обучающих данных. Это работает для типовых задач, но ломается на нестандартных архитектурных решениях.

С практической точки зрения, автономный цикл эффективен, пока область задач чётко ограничена. Добавить endpoint, написать unit-тест, обновить зависимость — агент справится. Перепроектировать модуль, чтобы убрать циклическую зависимость, — вряд ли.

Ограничения и риски автономного кода

Во-первых — отсутствие контекста. Агент не знает, почему в проекте принято именовать серверы в честь героев советских мультфильмов, и не поймёт, что изменение в одном сервисе сломает другой, если связь не описана в коде.

Во-вторых — качество кода. Агент склонен к unwrap() там, где нужна обработка ошибок, и к подтягиванию неподдерживаемых crates. Пример:

rust
fn 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), человек может подумать, перечитать документацию и исправить. ИИ может сгенерировать код, который компилируется, но работает некорректно — и найти ошибку будет сложнее, потому что нет автора, который может объяснить свою мысль.

Предсказуемость конфигураций тоже страдает. Я люблю, когда конфиг лежит в одном месте, написан руками и понятен любому инженеру. Здесь же конфигурация размазана по сгенерированным модулям, и никто не может сказать, какой параметр за что отвечает.

Пример. Допустим, ИИ написал такую функцию:

rust
fn 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? Как логировать ошибки? ИИ не ответил на эти вопросы, потому что не понимает контекста.

Проверить, что проект собирается, можно так:

bash
cargo check
cargo build --release

Но без тестов это только половина дела:

bash
cargo test

И тут, скорее всего, пусто — тестов нет.

Когда такой подход уместен

Если мы посмотрим на claw-code с точки зрения инженера, становится понятно: этот подход не для продакшена.

Он уместен в трёх случаях.

Первый — музейные экспонаты и демонстрации. Нужно показать, что ИИ может написать рабочий код на Rust без участия человека. claw-code как раз для этого.

Второй — быстрое прототипирование. Когда нужно за день показать идею инвестору или коллегам, а поддерживать код не планируется. Но даже здесь я бы рекомендовал сразу заменить сгенерированный код на ручной, как только проект переходит в стадию разработки.

Третий — образование. Студенты могут посмотреть, что генерирует ИИ, и разобрать, где он ошибся. Это полезное упражнение, но не больше.

Не уместен такой подход для критичных систем, для продакшена, для чего-то, что должно работать годами без участия человека. Серверы, которые я настраивал, не падают годами именно потому, что за каждым конфигом стоит человек, понимающий, что он делает.

claw-code — это интересный экспонат, но не инструмент для реальной работы.

Часто задаваемые вопросы

Можно ли использовать код claw-code в реальном проекте?

С практической точки зрения — только после полной аудитной проверки. Агент выбирает архитектуру и зависимости исходя из статистики, а не из требований к надёжности. Для музейного экспоната с предсказуемой нагрузкой это допустимо, для сервиса с пользователями — нет.

Кто несет ответственность за ошибки в таком коде?

Ответственность несёт тот, кто запускает код в эксплуатации. Агент не исправляет инциденты ночью и не подписывает соглашение об уровне обслуживания. Если система падает, разбираться придётся вам, поэтому без тестов и мониторинга не обойтись.

Как отлаживать программу, если человек не участвовал в её создании?

Приходится действовать как детектив: читать логи, восстанавливать логику агента и угадывать, почему он принял такое решение. Я рекомендую добавить подробное логирование и покрыть критические пути тестами ещё до запуска. Без этого отладка превращается в гадание.

Почему для эксперимента выбрали Rust?

Rust заставляет быть точным с памятью и типами, что снижает вероятность неочевидных ошибок в сгенерированном коде. Компилятор отсекает целый класс проблем, которые агент мог бы не заметить. Для экспоната, который должен работать без присмотра, это важнее скорости разработки.

В чём главная опасность агентной разработки?

Главная опасность — отсутствие предсказуемости. Вы не знаете, почему агент выбрал именно эту структуру проекта или эту библиотеку. Когда начнётся инцидент, вам предстоит восстанавливать его рассуждения постфактум.

Поделиться:TelegramX / TwitterVK