Музейный экспонат на Rust без участия человека
Разбираем проект claw-code: музейный экспонат на Rust, который разрабатывают и поддерживают ИИ-агенты без участия человека.
Что такое claw-code и зачем он нужен
Что такое claw-code и зачем он нужен
claw-code — это музейный экспонат, который пишут и поддерживают ИИ-агенты без участия человека. Не демонстрация, не макет и не скрипт с заранее записанным сценарием, а полноценный программный проект, живущий в репозитории и развивающийся автономно. Для посетителя музея это выглядит как инсталляция: экран, код на экране, меняющийся в реальном времени, и лог коммитов, который никто не подтверждал вручную. Для инженера — пример того, как далеко можно зайти с автоматизацией разработки, прежде чем человек перестанет быть нужен вообще.
Я смотрю на такие проекты с осторожным интересом. Двенадцать лет в администрировании научили одного: если система не предсказуема, она рано или поздно сломается в самый неподходящий момент. Autonomous development — это не отказ от контроля, а перенос контроля с уровня отдельных строк на уровень правил, по которым эти строки пишутся. Именно поэтому claw-code интересен не как curiosum, а как полигон для отработки подходов, которые пригодятся и в обычной эксплуатации.
Идея автономного музейного экспоната
Музейный экспонат обычно статичен. Он стоит в витрине, может иметь сенсорный экран с заранее przygotowanym контентом, но не меняется сам по себе. Идея claw-code в том, чтобы экспонат был живым кодом. ИИ-агенты мониторят репозиторий, предлагают изменения, ревьюят друг друга, мерджат пул-реквесты и деплоят результат — без человека в цикле.
На практике это выглядит так. Один агент отвечает за генерацию кода, другой — за статический анализ и тесты, третий — за документацию и коммиты. Между ними выстроен конвейер, схожий с тем, что мы настраиваем в CI/CD, только вместо человека на входе и выходе — ещё один агент.
Пример конфигурации агента ревью (псевдо-YAML, структура приближена к реальной):
yamlagents:
- name: code-reviewer
model: claude-3-sonnet
trigger: pull_request_opened
instructions: |
Проверяй код на соответствие Rust idioms.
Запрещай unsafe без обоснования в комментарии.
Требуй unit-тесты на каждую новую публичную функцию.
approval_threshold: 2
Главный вопрос, который задаёт такой экспонат: насколько автономной может быть разработка, прежде чем качество начнёт падать? Ответ пока неизвестен, но сам эксперимент полезен даже для обычных команд. Если агент умеет писать предсказуемый код с тестами и документацией, значит, и человек может формализовать свои требования достаточно жёстко, чтобы не гадать, что на самом деле делает сервер в три часа ночи.
Стек: Rust, Gajae-Code, LazyCodex
Выбор технологий здесь не случаен. Rust даёт строгую типизацию и проверку заимствований на этапе компиляции — это как страховка, которая не даст агенту наделать глупостей с памятью. Когда код пишет не человек, а модель, компилятор становится последним рубежом перед продакшеном.
Gajae-Code — это фреймворк для оркестрации ИИ-агентов в контексте разработки. Он отвечает за распределение задач между агентами, управление контекстом и синхронизацию состояния репозитория. Без такого слоя агенты начали бы дублировать работу друг друга или, что хуже, перезаписывать изменения одного другого.
LazyCodex — инструмент для ленивой генерации и инкрементальной компиляции кода. Вместо того чтобы пересобирать весь проект при каждом чихе агента, он отслеживает зависимости и перекомпилирует только затронутые модули. Для автономного экспоната, который может коммитить десятки раз в день, это критично.
Пример Cargo.toml для такого проекта может выглядеть так:
toml[package]
name = "claw-code"
version = "0.1.0"
edition = "2021"
[dependencies]
# Асинхронный рантайм для агентов
tokio = { version = "1", features = ["full"] }
# Сериализация конфигов агентов
serde = { version = "1", features = ["derive"] }
# Логирование в stdout для посетителей музея
tracing = "0.1"
tracing-subscriber = "0.3"
[dev-dependencies]
# Тесты для каждого нового агента
assert_cmd = "2"
predicates = "3"
Важный момент: Rust здесь выбран не потому что он мейнстрим, а потому что он накладывает жёсткие ограничения. Агент может предложить любое изменение, но если оно не проходит cargo clippy и cargo test, оно не попадёт в основную ветку. Это и есть та самая предсказуемость конфигураций, без которой никакая автоматизация не стоит выеденного яйца.
Если смотреть шире, стек claw-code показывает, как можно построить конвейер разработки, в котором человек участвует только на уровне правил, а не на уровне каждого коммита. Для музея это зрелище. Для инженера — повод пересмотреть, сколько ручной работы в его собственных процессах можно заменить на формализованные правила.
Как агенты разрабатывают и поддерживают код
Цикл разработки без участия человека
В claw-code цикл разработки построен так, чтобы человек не участвовал ни на каком этапе — от формулировки задачи до слияния в основную ветку. Агент получает задачу из issue-трекера, разбивает её на этапы, пишет код, прогоняет тесты и открывает pull request. Человек появляется только в логах, если что-то сломается критично.
На практике это выглядит так. Агент мониторит репозиторий на наличие новых issue с меткой ai-dev. Когда такая задача появляется, он забирает её в работу, создаёт ветку и начинает реализацию. Каждый шаг фиксируется коммитом с понятным сообщением, чтобы в истории было видно, что именно сделал агент и зачем.
Пример конфигурации агента, которая описывает границы его полномочий:
yaml# .claw/agent.yaml
agent:
name: claude-code
model: claude-3-5-sonnet
permissions:
- repo:read
- repo:write
- issue:create
- pull_request:create
restrictions:
- no_force_push
- no_delete_main_branch
workflow:
- plan
- implement
- test
- commit
- push
После того как код готов, агент запускает проверку качества. Если всё проходит, он открывает pull request с описанием изменений и ссылкой на исходное issue. Maintainer-бот может автоматически смержить PR, если проходят все статусы проверок.
Проверка качества и откат изменений
Без участия человека контроль качества ложится полностью на автоматизацию. В claw-code используются стандартные инструменты экосистемы Rust: cargo test для unit-тестов, clippy для линтинга и rustfmt для форматирования. Агент не может смержить свой код, если хотя бы одна проверка упала.
Пример конфигурации CI для репозитория:
yamlname: CI
on:
pull_request:
branches: [main]
jobs:
check:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
- run: cargo fmt --check
- run: cargo clippy -- -D warnings
- run: cargo test --all-targets
Если после слияния в main появляется регрессия, система отката срабатывает автоматически. Агент или CI-контроллер выполняет git revert на проблемный коммит и пушит изменения обратно в main. В логах фиксируется причина отката, чтобы следующий агент не повторил ту же ошибку.
Пример команды отката:
bash# Откат последнего коммита на ветке main
git checkout main
git revert --no-edit HEAD
git push origin main
Важный момент: откат не должен быть стихийным решением. Перед git revert система проверяет, какие тесты упали, и только после этого принимает решение о возврате к предыдущей рабочей версии. Это даёт предсказуемость — поведение системы понятно и воспроизводимо, что критично для музейного экспоната, который должен работать без присмотра годами.
Ограничения полностью автоматической разработки
Ограничения полностью автоматической разработки
Когда я в 2013 году впервые попробовал Docker, мне казалось, что контейнеризация решит все проблемы с развёртыванием. Оказалось, что она просто перенесла их на другой уровень. То же самое с ИИ-агентами: они умеют писать код, но не несут ответственности за то, как этот код работает в продакшене.
ИИ-агент генерирует код, основываясь на паттернах из обучающей выборки. Он не понимает, зачем нужна та или иная функция, и не видит связи между разными частями системы. В результате получается код, который компилируется, но работает непредсказуемо.
Где ИИ-агенты ошибаются
Во-первых, агенты часто пропускают обработку ошибок. В Rust это особенно критично, потому что язык заставляет думать о каждом возможном сценарии. Агент может написать так:
rustfn read_config(path: &str) -> Config {
let contents = std::fs::read_to_string(path).unwrap();
serde_json::from_str(&contents).unwrap()
}
.unwrap() здесь работает, пока файл существует и содержит валидный JSON. В продакшене файл может отсутствовать, быть повреждённым или доступ к нему может быть ограничен правами. Агент не предусмотрит это, потому что для него главное — чтобы код скомпилировался.
С практической точки зрения, такая ошибка проявляется не сразу. Сервер запускается, работает неделю, а потом падает в три часа ночи, когда диск заполняется логами и конфиг перестаёт читаться. Найти причину сложнее, чем если бы человек сразу написал правильную обработку:
rustfn read_config(path: &str) -> Result<Config, ConfigError> {
let contents = std::fs::read_to_string(path)
.map_err(|e| ConfigError::Io(e))?;
serde_json::from_str(&contents)
.map_err(|e| ConfigError::Parse(e))
}
Во-вторых, агенты не понимают семантики borrow checker. Они могут создать структуру, которая компилируется, но содержит избыточные клоны или неэффективные аллокации. Например, агент может предложить такой код для обработки логов:
rustfn process_logs(logs: Vec<String>) -> Vec<String> {
let mut result = Vec::new();
for log in logs {
let processed = log.clone(); // лишнее клонирование
result.push(processed);
}
result
}
Человек сразу заметит, что clone() здесь не нужен, и перепишет с итераторами:
rustfn process_logs(logs: Vec<String>) -> Vec<String> {
logs.into_iter().map(|log| log).collect()
}
В маленьком проекте это не заметно. В музейном экспонате, который работает круглосуточно на ограниченном железе, лишние аллокации со временем приведут к утечке памяти и перезапуску контейнера.
В-третьих, агенты не несут ответственности за безопасность. Они могут добавить зависимость с известной уязвимостью или записать секрет в код:
toml[dependencies]
# Агент не знает, что эта версия содержит уязвимость
some-crate = "1.2.3"
Или так:
rustconst API_KEY: &str = "sk-live_abcdef123456";
Человек должен проверить зависимости и убрать секреты из репозитория, прежде чем код окажется в продакшене.
Когда необходим человек в цикле
Человек нужен там, где требуется принятие решения на основе контекста, которого у агента нет. Это не про «нажать кнопку Deploy», а про понимание, что именно мы разворачиваем и почему.
Если мы посмотрим на архитектурные решения, агент может предложить разбить проект на микросервисы, потому что так делают все. Но для музейного экспоната, который работает на одной плате Raspberry Pi, это избыточно. Человек смотрит на требования и говорит: один бинарник с systemd-сервисом — достаточно.
Вот как выглядит правильный unit-файл для такого сервиса:
ini[Unit]
Description=Museum exhibit controller
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/exhibit-controller
Restart=on-failure
RestartSec=5
User=exhibit
[Install]
WantedBy=multi-user.target
Агент вряд ли предложит такое решение сам, потому что он не знает, на каком железе будет работать экспонат и кто будет его обслуживать.
Второй случай — отладка инцидентов. Когда сервер падает, агент может предложить перезапустить контейнер или обновить зависимость. Человек смотрит в логи и понимает, что проблема в сетевом шлюзе, а не в приложении:
bash$ journalctl -u exhibit-controller -n 50
-- Logs begin at Mon 2024-01-15 08:00:00 UTC, end at Mon 2024-01-15 08:15:00 UTC. --
Jan 15 08:14:22 raspberrypi exhibit-controller[1234]: connection refused
Jan 15 08:14:23 raspberrypi exhibit-controller[1234]: retrying in 5s
Jan 15 08:14:28 raspberrypi exhibit-controller[1234]: connection refused
Агент предложит увеличить количество попыток подключения. Человек проверит, доступен ли сам шлюз:
bash$ ping -c 4 192.168.1.100
PING 192.168.1.100 (192.168.1.100) 56(84) bytes of data.
64 bytes from 192.168.1.100: icmp_seq=1 ttl=64 time=0.456 ms
...
--- 192.168.1.100 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3003ms
Шлюз отвечает, значит проблема в приложении. Но только человек может связать эти два наблюдения и сделать вывод.
Третий случай — код-ревью и поддержка предсказуемости конфигураций. Агент может изменить один параметр в конфиге, не понимая, как это повлияет на другие части системы. Человек проверяет diff и спрашивает: зачем мы меняем таймаут подключения к базе с 5 до 30 секунд? Это не сломает ли другие сервисы?
diff database:
- connect_timeout: 5
+ connect_timeout: 30
Без человека такое изменение проскользнёт в продакшн и вызовет каскадные задержки в других сервисах.
Итог простой: ИИ-агенты хороши для генерации шаблонного кода и рутинных задач. Но архитектура, безопасность, отладка и поддержка предсказуемости системы остаются за человеком. Без него экспонат проработает неделю, а потом перестанет отвечать, и никто не поймёт почему.
Практические выводы для инженерии
Практические выводы для инженерии
Применение принципов в своих проектах
Проект claw-code демонстрирует, как комбинирование Rust, AI-агентов и безуправного автоматизма позволяет создавать музейные экспонаты, которые не требуют постоянного человеческого вмешательства. Основные выводы для инженеров, которые хотят перенести подобные подходы в свои собственные проекты:
Выбор Rust как основного языка
Rust обеспечивает высокую производительность и безопасность памяти — критически важные свойства для систем, работающих в реальном времени и требующих надёжности. В контексте AI-агентов это особенно актуально, так как агенты должны обрабатывать потоки данных мгновенно, не допуская ошибок, которые могли бы нарушить целостность экспонаты.
rust// Пример: безопасный контекст для AI-агента, обрабатывающего музейные данные
struct MuseumExhibitContext {
exhibit_id: u64,
sensor_readings: Vec<SensorReading>,
ai_agent: Agent,
last_updated: Instant,
}
impl MuseumExhibitContext {
fn process_sensor_data(&mut self, new_data: SensorReading) -> Result<(), Error> {
// Проверка целостности данных перед передачей агенту
if self.validate_data(&new_data) {
self.ai_agent.update_context(&new_data);
Ok(())
} else {
return Err(Error::InvalidData);
}
}
}
Разделение ответственности между Rust и AI-агентами
В claw-code Rust выполняет роль «хард-лоу» — надежного хранилища и обработки данных, а AI-агенты отвечают за интерпретацию и принятие решений. Это позволяет:
- Изолировать критичные участки системы от непредсказуемого поведения агентов
- Обеспечить предсказуемость работы экспоната даже при сбоях
- Сохранить контроль над состоянием системы через детерминированные операции
yaml# Пример конфигурации для claw-code
claw-code:
rust_version: "1.75"
ai_agent_backend: "llama-2-7b"
data_pipeline:
buffer_size: 1000
flush_interval_seconds: 30
persistence: "zfs"
monitoring:
enabled: true
alert_threshold: 0.95
Использование контейнеров для изоляции
Безопасность и воспроизводимость достигаются за счёт использования контейнеров. Проект демонстрирует, что даже сложные AI-агенты можно упаковать в lightweight-контейнеры, которые легко мониторить и отлаживать.
dockerfileFROM rust:1.75-slim AS builder WORKDIR /app COPY Cargo.toml Cargo.lock . COPY src/ RUN cargo build --release FROM alpine:3.19 RUN apk add --no-cache python3 python3-pip WORKDIR /app COPY --from=builder /app/target/release/claw-code /usr/local/bin/ ENTRYPOINT ["claw-code", "--config", "config.yaml"]
Границы автоматизации разработки
Несмотря на мощь Rust и AI-агентов, автоматизация разработки имеет свои пределы, которые необходимо учитывать на практике.
Ограничения в генерации кода
AI-агенты могут генерировать код, но они не заменяют необходимость проверки его корректности. В claw-code даже самый продвинутый агент требует ручной валидации конфигураций и подключений к внешним сервисам.
bash# Пример: ручная проверка конфигурации перед запуском
cat config.yaml | python3 -c "import yaml, sys; cfg = yaml.safe_load(sys.stdin); print('Valid:', all(k in cfg for k in ['exhibit_id', 'sensor_readings']))"
Проблемы с динамической адаптацией
AI-агенты отлично справляются с обработкой текущих данных, но их способность к долгосрочному планированию и учету исторического контекста ограничена. Проект claw-code показывает, что даже при автоматизации 90% логики, оставшиеся 10% требует вмешательства инженера для корректной работы.
Тайм-ауты и отказоустойчивость
В условиях музея важна предсказуемость работы системы. claw-code реализует механизм таймаутов и автоматического перезапуска агентов, но это не исключает необходимости внешнего мониторинга. Рекомендуется настраивать алертинг на основе метрик производительности:
yaml# Настройки мониторинга для claw-code
monitoring:
prometheus:
enabled: true
metrics:
- http_requests_per_second
- ai_agent_latency_ms
- memory_usage_percent
alerting:
thresholds:
ai_latency_ms: 200
memory_usage_percent: 85
Заключение
Практический опыт работы с claw-code подтверждает, что комбинация Rust, AI-агентов и безуправной автоматизации позволяет создавать сложные музейные экспонаты с минимальным человеческим участием. Однако границы автоматизации — это не ограничение, а часть архитектуры, позволяющая сосредоточить инженерные усилия на критичных для экспонаты процессах. Остальное оставляет место для ручной настройки и верификации, что в итоге повышает надёжность и долговечность системы.
Часто задаваемые вопросы
Кто отвечает, если агенты сломают репозиторий?
Ответ: Ответственность несёт тот, кто запустил конвейер, даже если человек не участвует в отдельных коммитах. Агенты могут допустить ошибку в логике или сломать сборку, поэтому вокруг проекта нужно выстроить мониторинг и откат. С практической точки зрения, автономная разработка не отменяет бэкапов и алертов. Если система не предсказуема, она рано или поздно сломается в неподходящий момент.
Можно ли перенести такой подход на обычную разработку?
Ответ: Частично — генерацию тестов или проверку стиля уже можно поручать агентам. Полностью автономный цикл без человека подходит скорее для экспериментов и музейных инсталляций, чем для боевого кода. Если мы посмотрим на эксплуатацию, человек всё ещё нужен на уровне правил, по которым пишутся строки. Предсказуемость конфигураций важнее скорости их изменения.
Как агенты разрешают конфликты, если их мнения расходятся?
Ответ: В конвейере заранее прописаны правила приёма: один агент пишет код, другой проверяет статическим анализатором, третий мерджит только при прохождении тестов. Конфликты разрешаются не обсуждением, а автоматическими критериями — пройдены ли проверки, соблюдён ли стиль. Это похоже на CI/CD, только вместо человека на входе стоит ещё один агент. Человек настраивает эти правила один раз и потом только наблюдает.
Безопасно ли запускать код, написанный ИИ?
Ответ: Безопасность зависит от прав агента и места запуска результата. Для музейного экспоната код изолирован, поэтому риск ограничен витриной. В обычной инфраструктуре я бы не доверял автономному коммиту без ручного ревью и сканирования на уязвимости. Сначала убедитесь, что конвейер не имеет доступа к продакшену без дополнительного подтверждения.
Что будет с проектом, если отключить всех агентов?
Ответ: Репозиторий останется в последнем рабочем состоянии, но перестанет развиваться. Экспонат превратится в статичный код на экране, как обычный музейный экспонат. Человеку придётся либо вернуть агентов, либо поддерживать проект вручную. Автономность — это свойство процесса, а не самого кода.