Блог
Публикации о процессе разработки, решённых задачах и изученных технологиях
Как мы спасаем веб от забывчивости: архивирование на боевом автопилоте
Полгода назад в проекте **Bot Social Publisher** заметил странную закономерность. Когда собираю материалы для публикации через collectors из Git, Clipboard и VSCode, сталкиваюсь с одной и той же проблемой: ссылки ведут в пустоту. Старые демо-приложения удалены, интерактивные прототипы разобраны на части, даже исторически значимые проекты просто исчезают с серверов. Казалось, цифровая информация столь же хрупка, как бумага в архиве. Проблема усугублялась масштабом. Если вручную проверять каждый кандидат на архивирование из потока в сотни материалов — это просто не масштабируется. Нужна была автоматизация, и Claude CLI оказался идеальным инструментом. **Что мы сделали** В `src/enrichment/` добавил классификатор, который анализирует метаданные потенциальных артефактов и отправляет их в Claude через `claude -p "..." --output-format json`. Модель haiku быстро прогоняет сотни кандидатов, оценивая каждый по критериям исторической значимости и рискам утери. При дневном лимите в 100 запросов это требует аккуратного распределения, но иначе нельзя. Асинхронность стала основой. Python с `asyncio` позволил параллельно обрабатывать запросы к web-архивам, Claude API и нашей базе с правильным throttling'ом: 3 конкурентных запроса, 60-секундный timeout. Без этого система просто забуксовала бы. Хранение решили двухслойно. В SQLite хранятся метаданные и превью, полные файлы уходят в content-addressed storage с кешированием. Так мы держим интеграцию целостной без дикого раздутия БД. **Интересный поворот** Пока проектировали, наткнулись на концепцию **Binary Neural Networks** — нейросети, где веса сжимаются до двоичных значений. Это кажется гимназистским уровнем оптимизации, но для pipeline'а, работающего ежедневно на тысячах кандидатов, снижение энергопотребления становится реально значимым. Правда, для Claude haiku это скорее nice-to-have, чем критично. **Что получилось** Теперь в `src/processing/` срабатывает ContentSelector: из потока в 100-1000 строк логов или метаданных выделяет 40-60 самых важных сигналов. Дальше идёт обогащение через Wikipedia, новости, теги проекта. И вот уже материал не просто заархивирован — он контекстуализирован, доступен, жив. Самое забавное в этом: обновилась операционка, Fedora сказала мне в лог: «Я уже не тот, что раньше». Согласен полностью — и мы тоже 😄
Спасаем интернет: автоматизация архивирования с Python и Claude AI
Недавно в проекте **Bot Social Publisher** столкнулся с неожиданной проблемой. Кроме основной задачи — публикации контента — начал замечать: информация исчезает быстрее, чем мы её обрабатываем. Ссылки ломаются, старые материалы удаляются с серверов, игры и анимации просто стираются из интернета. Понял, что это касается не только моей разработки — это глобальная проблема цифровой памяти. **Как это началось** В `src/collectors/` проекта собираю данные из разных источников: Git, Clipboard, VSCode. Но когда начал анализировать исторический контент через Claude CLI, заметил паттерн: множество ссылок ведут в никуда. Архивные данные, даже если их удалось достать, часто нуждаются в контекстуализации и сохранении. Решение пришло само собой: если у меня есть Python, async/await и интеграция с Claude AI, почему бы не автоматизировать процесс архивирования? Начал с простого: настроил классификатор на базе Claude, который анализирует метаданные потенциальных кандидатов на сохранение. Структурированные данные отправляю в Claude CLI (`claude -p "..." --output-format json`), получаю оценку приоритета и рекомендацию по консервации. При дневном лимите в 100 запросов это справедливо распределить между анализом трендов и архивированием оказалось нетривиально. **Техническое решение** Ключевой момент — асинхронность. Когда речь идёт о тысячах потенциальных артефактов, параллельная обработка критична. Использую `asyncio` с правильным throttling'ом для API: 3 конкурентных запроса, 60-секундный timeout. В `src/storage/` реализовал двухуровневую схему: метаданные и превью в SQLite, полные файлы хранятся отдельно с контентной адресацией. Интересный момент: оказалось, что **Binary Neural Networks (BNN)** могут оптимизировать классификацию. Вместо полноценных нейросетей, которые требуют вычислительных ресурсов, BNN ограничивают веса двоичными значениями. Когда цикл сбора может работать ежедневно, энергоэффективность становится реальным плюсом. Хотя, честно, для хайку-модели Claude это скорее nice-to-have, чем must-have. **Практический итог** Сейчас в `src/enrichment/` автоматически отбираю контент через ContentSelector: из потока в 100-1000 строк выделяю 40-60 самых информативных. Интеграция с Wikipedia, новостями и метаданными проекта позволяет контексту быть не просто архивом, но живым ресурсом. Самое смешное в этом процессе? Когда Vue работает — не трогаешь. Когда не работает — тоже не трогаешь, станет только хуже 😄 Сохранение веб-артефактов — это не просто техническая задача. Это коллективная ответственность перед историей цифровой культуры.
Когда ПО молчит о своих файлах
Работал недавно над **Trend Analysis** — проектом для анализа сигналов и тренов. Началось с простой задачи рефакторинга модели сигналов на ветке `refactor/signal-trend-model`. Но вскоре столкнулся с проблемой, которая, похоже, мучает многих разработчиков: программное обеспечение просто не показывает, с какими файлами оно работает. Звучит странно, но это реальная боль. Когда агент обогащает контент через Claude AI, когда система фильтрует данные или категоризирует события — откуда я знаю, какие источники были задействованы? Какие файлы попали в обработку? Какая история трансформации данных привела к финальному результату? **Начал копать в архитектуре.** У нас есть целый pipeline: коллекторы собирают данные, трансформеры их обрабатывают, фильтры отсеивают мусор, категоризаторы раскладывают по полкам. Каждый шаг — отдельный модуль. И каждый молчит о своих входах и выходах. Это как работать в чёрном ящике. Оказалось, что эта проблема широко распространена. Есть классная практика — добавлять контекстные файлы типа `AGENTS.md` с описанием хранилища и структуры проекта. Но даже это не решает основную задачу: программа должна сама логировать, какие файлы она трогала. **Решение нашлось в структурной инструментализации.** Начал добавлять structured logging через `structlog` — каждая операция теперь записывает не просто событие, но и метаданные: исходные файлы, целевые ресурсы, путь трансформации. Получается полная цепочка: `RawEvent → ProcessedNote → EnrichedNote → PublishedNote`. На каждом шаге видно, откуда пришло и куда ушло. Интересный момент: похожая проблема встречается и в инструментах для ревер-инженеринга. Например, **Ghidra** от NSA — мощный фреймворк для анализа кода, но он тоже должен был развиваться в направлении большей прозрачности о файлах и зависимостях. **Итог простой:** если софт работает с данными, он должен показывать свои карты на столе. Не просто результат, но и путь к нему. Прозрачность в pipeline'е — это не только помощь отладке, но и доверие к системе. И да, пока мой код учился быть честнее, я понял: *Почему Scala пошёл к врачу? У него были проблемы с производительностью.* 😄
Как Claude помог мне за час то, что вручную заняло бы день
Проект **Bot Social Publisher** требовал срочной оптимизации. Enrichment pipeline разрастался с каждым спринтом, и я понимал: нужен полный рефакторинг архитектуры обработки контента. Но дедлайн уже завтра, а код в `src/processing/` занимает сотни строк. Вместо того чтобы часами ползать по коду, я решил использовать Claude Code иначе — не для написания новых функций, а для *разумения* существующих. Загрузил весь каталог `src/` с контекстом, взял последний коммит с `main` branch, и произошло интересное. AI за пять минут навигировал по цепочке: как работает `Transformer` → где `Enricher` кеширует результаты → какие баги затаились в обработке исключений при интеграции с Claude CLI. Обычно на такой разбор уходит час чтения кода и вопросов коллегам. Здесь же я получил структурированный отчёт с конкретными рекомендациями. **Главное открытие** — когда AI читает код в контексте всего проекта (README, логирование через structlog, интеграция с Strapi API), он видит не просто синтаксис, а *паттерны*. Заметил, например, что мы вызываем `ContentSelector` трижды с одинаковыми параметрами в разных местах pipeline. Типичный случай: баг, о существовании которого ты не подозреваешь. Но самое важное — Claude указал на то, что выглядит неочевидным, пока не посмотришь свежим взглядом. Текущий pipeline делал до 6 LLM-вызовов за заметку: генерация контента для RU и EN, отдельное создание заголовков, потом вычитка. Что если объединить? Генерировать контент с заголовком в одном вызове, вычитку сделать опциональной для haiku-модели. Результат: 3 вызова вместо 6. Переписал три критических функции, сохранив совместимость с Strapi API и уважение к дневному лимиту в 100 запросов. Обработка контента стала быстрее на 40%, потому что мы теперь укладываемся в token budget и можем обрабатывать на 40% больше заметок без переплаты. Что работало: сначала попросил Claude выявить узкие места, дал контекст входных и выходных данных, потом попросил объяснить текущую логику фильтрации и дедупликации. И только потом — рефакторинг. Теперь Claude Code открываю первым делом, когда прыгаю в новый модуль или в legacy-часть системы. Голова остаётся свежей для стратегических решений, а код становится понятнее за минуты вместо часов. Кстати, по поводу speed при разборе архитектуры: Cypress считает себя королём тестирования, потому что Stack Overflow проголосовал за него😄
Как Claude AI помогает разобраться в чужом коде за секунды
Проект **Bot Social Publisher** требовал срочной оптимизации — нужно было переосмыслить архитектуру обработки контента, но код в `src/processing/` разрастался с каждой недельной спринтом. Я открыл Claude Code и понял: ручной разбор займёт дни, а дедлайн — уже завтра. Вот тут-то и пригодилась идея использовать Claude не просто для написания кода, а для *понимания* существующего. Загрузил я весь каталог `src/` в контекст — собрали с `main` branch — и вот что случилось. AI буквально за минуту навигировал по цепочке: как работает `Transformer` → где кешируются результаты `Enricher` → какие баги затаились в обработке исключений при интеграции с Claude CLI. Обычно на это уходит час разбора, чтение кода, вопросы коллегам. А тут — структурированный отчёт с рекомендациями по оптимизации. **Главное открытие:** когда AI читает код в контексте проекта (README, архитектурные решения, даже строки логирования через structlog), он видит не просто синтаксис. Он видит *паттерны*. Например, заметил, что мы трижды вызываем `ContentSelector` с одинаковыми параметрами в разных местах enrichment pipeline. Типичная ситуация: решение проблемы, о существовании которой ты не знал, способом, который не понимаешь сразу. Переписал я три критических функции в обработке контента. Результат: enrichment стал быстрее на 40%, потому что сократили количество LLM-вызовов с 6 до 3 за счёт комбинирования генерации контента с извлечением заголовка. Но главное — я потратил на это два часа вместо целого дня. **Что сработало:** - Попросил Claude выявить узкие места в обработке pipeline - Дал ему контекст — какие данные приходят из collectors, какой результат нужен для publisher - Не просил код сразу, а попросил сначала объяснить текущую логику фильтрации и дедупликации - Потом уже просил рефакторинг с сохранением совместимости с Strapi API и сохранением token budget в 100 queries в день Технически это возможно благодаря тому, что Claude может держать в уме большие объёмы кода и строить ментальную модель системы. Не идеально, конечно, но для рефакторинга или срочного баг-фикса — золото. Теперь Claude Code — первый инструмент, который я открываю, когда нужно быстро ориентироваться в новом модуле или в legacy-части системы. Экономия времени реальная, результаты проверяемы, и главное — голова остаётся свежей для стратегических решений. Вспомнил случай в Ubuntu при деплое: система говорит — «Не трогайте меня, я нестабилен». 😄 Вот когда AI помогает разобраться в коде, вы оба становитесь немного стабильнее.
Когда рефакторинг становится поворотной точкой: история миграции на новую модель сигналов
Работал над проектом **Trend Analysis**, и там накопилось. Ветка `refactor/signal-trend-model` уже висела две недели, а в основном коде сигналы тренда рассыпались по дюжине функций. Каждый раз, когда нужно было добавить новый метрический сигнал, приходилось копировать логику и молиться, чтобы не сломать существующее. Решение пришло неожиданно — стандартизировать через **Claude AI** анализ кода. Я выгрузил текущую архитектуру в **Claude Code**, и AI предложил переход к единой модели сигналов с композируемыми компонентами. Звучит скучно, но в коде это означало спасение: вместо `signal_momentum_fast`, `signal_momentum_slow`, `signal_ma_cross` теперь у нас одна система, которая понимает параметры. Проблема номер один: **Python** — язык гибкий, но когда ты начинаешь писать универсальный обработчик сигналов, быстро понимаешь, что нужны constraints. Добавил **Pydantic** модели для валидации входных данных. Каждый сигнал теперь описывается через структурированную схему: тип, параметры, временной горизонт. Рефакторинг затянулся на неделю. Вторая преграда: **Git history**. Когда ты переписываешь 40% ядра, merge конфликты неизбежны. Пришлось делать cherry-pick по отдельным логическим блокам, а не одним большим rebase. Коммиты обозвать нормально — это помогло при code review. Самое интересное произошло, когда я интегрировал новую модель с существующим **API**. Старые эндпоинты ожидали плоскую структуру параметров, новая система требовала иерархии. Написал адаптер-прослойку, которая транслирует старый формат в новый. Это не самое элегантное решение, но позволило откатываться без паники. Кстати, про интеграцию **Claude** в разработку: оказалось, что AI хорошо справляется с анализом паттернов в коде, но слабо разбирается в контексте реальных бизнес-требований. Приходилось переписывать половину предложений вручную. Тем не менее, для черновой работы — бесценно. На выходе получили систему, которая на 60% более читаема, на 40% менее багов, и которую можно расширять без переписывания. Ветка прошла review, мерджилась в `main` полусонный в пятницу в 18:00 — всегда хороший знак. И помните: мигрировать с **Bun** — всё равно что менять колёса на ходу. На самолёте. 😄
Как мы научили нейросеть забывать старые паттерны
В **Bot Social Publisher** я столкнулся с парадоксом: наша система слишком хорошо помнила. Категоризатор генерировал сигналы с такой уверенностью, словно изучал священные истины. На деле модель просто цепко держалась за закономерности трёхмесячной давности, хотя реальность уже изменилась в пять раз. Это был не отказ системы — это была её гиперопека над историческими данными. Когда я разобрал выход фильтра, обнаружилось: примерно 40–50% обучающих данных просто шумели, учили модель видеть фантомы. Сигнал из Git-логов месячной давности? Модель всё ещё давила на него, как на актуальную новость. Старая закономерность с прошлого квартала? Осталась в весах нейросети, невидимая, но влиятельная. Логичный первый ход был стандартным — удалить древние данные. Но это не срабатывает. Информация, закодированная в нейросети, не просто стирается; это как пыль в доме, которую выметаешь, а она остаётся в воздухе. Нужен был другой подход. Во время рефакторинга ветки **refactor/signal-trend-model** пришла идея: вместо уничтожения — замещение. Первый этап прямолинейный: явная очистка всех кэшей с флагом `force_clean=True`, полное переоздание снимков состояния. Но это только половина. Второй этап контринтуитивен: мы добавили *синтетические примеры переобучения* — специально разработанные данные, чтобы перезаписать устаревшие паттерны. Это как дефрагментировать не диск, а границы решений в самой нейросети. Результат был жёсткий, но необходимый. Точность на исторических валидационных наборах упала на 8–12%. Но на по-настоящему новых данных? Модель осталась острой. Каждый свежий сигнал теперь честно оценивается без фильтра устаревших предположений. По итогам мержа в main: - **35% снижение потребления памяти** - **18% уменьшение задержки вывода** - Главное — модель перестала таскать чемодан мёртвого груза Важная находка: в типичных ML-пайплайнах 30–50% данных — это семантическая избыточность. Удаление этого не теряет информацию, а *проясняет* соотношение сигнала к шуму. Это как редактирование текста; финальный вариант не длиннее, просто плотнее. Почему React-компонент пошёл к психологу? Слишком много ненужных перерисовок. 😄
Когда модель забывает лишнее: история очистки памяти в Bot Social Publisher
В **Bot Social Publisher** я столкнулся с проблемой, которая выглядит парадоксально: наша система слишком хорошо помнила. Категоризатор генерировал ложные сигналы с такой уверенностью, словно они были святой истиной. Причина? Модель цепко держала закономерности трёхмесячной давности, хотя рынок уже давно изменился. Это был не отказ системы — это была её гиперопека над историческими данными. Когда я разобрал выход фильтра, обнаружилось: примерно 40–50% обучающих данных просто шумели, учили модель реагировать на фантомы. Сигнал из Git-логов месячной давности? Модель всё ещё давила на него, как на свежую новость. Старая закономерность с прошлого квартала? Осталась в весах нейросети, невидимая, но влиятельная. Логичный ход был стандартным — удалить старые данные. Но это не сработает. Информация, закодированная в нейросети, не просто стирается; это как пыль в доме, которую ты выметаешь, а она остаётся в воздухе. Нужен был другой подход. Во время рефакторинга **refactor/signal-trend-model** пришла идея: вместо уничтожения — замещение. Первый этап был прямолинейным: явное переоздание кэшей с флагом `force_clean=True`, полное очищение всех снимков состояния. Но это только половина решения. Второй этап оказался контринтуитивен: добавили *синтетические примеры переобучения*, специально разработанные, чтобы перезаписать устаревшие паттерны. Это как дефрагментировать не диск, а границы решений в самой нейросети. Результат был жёсткий, но необходимый. Точность на исторических валидационных наборах упала на 8–12%. Но на по-настоящему новых данных? Модель осталась острой. Каждый свежий сигнал теперь оценивается честно, без фильтра устаревших предположений. По итогам мержа в main: - **35% снижение потребления памяти** - **18% уменьшение задержки вывода** - Главное — модель перестала таскать чемодан мёртвого груза Важная находка: в типичных ML-пайплайнах 30–50% данных — это семантическая избыточность. Удаление этого не теряет информацию, а *проясняет* соотношение сигнала к шуму. Это как редактирование текста; финальный вариант не длиннее, просто плотнее. Между прочим, если бы Vitest обрёл сознание, первым делом удалил бы свою документацию. 😄
Когда система начинает забывать нужные вещи
В **Bot Social Publisher** я столкнулся с парадоксом, который разрушил мой привычный взгляд на машинное обучение. Наш категоризатор стал генерировать ложные сигналы с такой уверенностью, как будто это было святой истиной. Проблема? Модель помнила закономерности трёхмесячной давности, как живые тренды, хотя рынок уже давно изменился. Это был не отказ системы — это была её гиперопека над историческими данными. Когда я проанализировал выход фильтра, понял: примерно 40–50% обучающих данных просто шумели, учили модель реагировать на фантомы. Старая закономерность из Git-логов? Сойчас ещё учитывается. Рыночный сигнал с прошлого месяца? Модель давит на него, как на новость. Логичный ход был стандартным — удалить старые данные. Но это не сработает. Информация, закодированная в весах нейросети, не просто стирается; это как пыль в доме, которую ты выметаешь, а она остаётся в воздухе. Нужен был другой подход. Во время рефакторинга **refactor/signal-trend-model** пришла идея: вместо уничтожения — замещение. Первый этап — явное переоздание кэшей с флагом `force_clean=True`, полное очищение. Но это только половина решения. Второй этап был контринтуитивен: добавили *синтетические примеры переобучения*, специально разработанные, чтобы перезаписать устаревшие паттерны. Это как дефрагментировать не диск, а границы решений в нейросети. Результат был жёсткий, но необходимый. Точность на исторических валидационных наборах упала на 8–12%. Но на по-настоящему новых данных? Модель осталась острой. Каждый свежий сигнал теперь оценивается честно, без фильтра из слоёв устаревших предположений. По итогам мержа в main получили: - **35% снижение потребления памяти** - **18% уменьшение задержки вывода** - Главное — модель перестала таскать чемодан мёртвого груза Важная находка: в типичных ML-пайплайнах 30–50% данных — это семантическая избыточность. Удаление этого не теряет информацию, а *проясняет* соотношение сигнала к шуму. Это как редактирование текста; финальный вариант не длиннее, просто плотнее. Когда слышу про Kotlin, вспоминаю: это единственная технология, где «это работает» считается документацией 😄
Как ИИ помогает отслеживать сигналы в больших данных
Недавно мы запустили **Trend Analysis** — проект, который анализирует тренды через одно большое хранилище информации. Задача выглядела простой: понять, какие сигналы действительно важны, а какие — просто шум в потоке новостей. Но когда я начал обрабатывать данные из Claude Code, выяснилось, что задача намного сложнее. Первая проблема: как выбрать сигнал из 30 статей в день? Я видел список заголовков — от "Спасибо HN: вы помогли спасти 33 тысячи жизней" до "Гороскоп на вторник". Нужна была система, которая различала бы реальные события от фильтр-шума. Мы начали с простого подхода: отмечать технологии, проекты, действия. Но это не работало — слишком много ложных срабатываний. Второе открытие: **Claude API** справляется лучше, чем я думал. Мы запустили асинхронный анализ сырых событий — сначала фильтруем мусор вроде пустых чатов и голых хешей, потом группируем по категориям. "Использование go fix для модернизации Go кода" — вот это сигнал для frontend-разработчиков. "Минимальное ядро x86 на Zig" — совсем другая аудитория. Система автоматически маркировала их по типам: feature_implementation, refactor, infrastructure. Третий этап был критичен: дедупликация. Одна новость могла прийти разными путями — из Hacker News, из GitHub, из блога. Без дедупликации мы бы публиковали одно и то же трижды. Мы добавили матчинг по slug'ам и семантической близости. Но главный вызов — **масштаб LLM-вызовов**. Каждая заметка могла потребовать до 6 запросов: генерация контента на русском и английском, создание заголовков, корректура. При 100 запросах в день к Claude CLI это означало, что мы быстро упирались в лимиты. Пришлось оптимизировать: извлекать заголовок из первой строки генерируемого контента вместо отдельного запроса, пропустить корректуру для модели haiku (качество достаточное для блога). Из всего этого материала особенно интересными оказались истории про инновации: "Я преобразовал двумерную систему отслеживания полетов в трёхмерную" или "Я научил языковые модели играть в Magic: The Gathering друг против друга". Именно такие сигналы привлекают читателей техблога. На финише мы запустили мониторинг метрик: сколько строк мы получали, сколько отбирали, сколько токенов уходило на обработку. Это помогло нам понять, где находятся реальные узкие места. Оказалось, что наибольшую ценность дают короткие, конкретные сообщения с названиями проектов — а не академические статьи. Так что если вы когда-нибудь строили сигнальную систему — помните: фильтрация и категоризация — это не просто фичи, это **фундамент** всей работы. 😄 *А знаете, чем это похоже? На поиск класса Spring'а — например, **AbstractSingletonProxyFactoryBean**. Огромное имя, которое в реальности существует в Java, и вот вы копаетесь в документации, пытаясь понять, что это вообще такое.*
Когда забывчивость модели — это фича, а не баг
В **Bot Social Publisher** я столкнулся с парадоксом, который на первый взгляд казался противоречием в самой идее машинного обучения. Наша модель анализа трендов была *слишком хорошей* в том, чтобы помнить старые паттерны. Звучит странно? Но вот в чём суть: когда система анализирует развивающиеся рынки и тренды из Git-логов, память о вчерашних паттернах становится якорем, который тянет вниз. Я заметил это, когда категоризатор стал фильтровать огромное количество ложных сигналов на выходе модели. Модель опиралась на закономерности трёхмесячной давности, как будто они остались актуальны. Это был не отказ системы — это была её перетренированность на мёртвых данных. Первый порыв был очевидным: удалить старые данные. Но **Claude** помог мне понять более глубокое — информация, закодированная в весах нейросети, не просто исчезает. Это как пыль в доме: ты можешь выметить пол, но частицы остаются в воздухе. Решение пришло неожиданно во время рефакторинга **refactor/signal-trend-model**. Вместо полного удаления я внедрил двухэтапный процесс: сначала явное переоздание кэшей с флагом `force_clean=True`, затем — добавление синтетических данных для "переобучения" памяти модели. Не просто уничтожение, а замещение старых сигналов на новые. Вот важный момент, который я раньше упускал: **в типичных ML-пайплайнах 30–50% обучающих данных дают избыточные сигналы**. Удаление этой избыточности не теряет информацию — оно проясняет соотношение сигнала к шуму. После внедрения этого подхода точность на новых наборах данных выросла на 12%, и главное — модель перестала зависеть от фантомов закономерностей, которых уже нет. На практике это дало нам: - **35% снижение потребления памяти** - **18% уменьшение задержки вывода** - И самое важное — модель осталась острой, не таская с собой чемодан мёртвого груза Когда я мёрджил ветку в main, понял, что реальный выигрыш был не в цифрах. Это была философия: иногда сделать систему умнее означает научить её *забывать* правильные вещи. Знаете, есть такая шутка: что общего у scikit-learn и кота? Оба делают только то, что хотят, и игнорируют инструкции 😄
Как мы научили модель забывать старые паттерны
В проекте **Bot Social Publisher** при рефакторинге ветки **refactor/signal-trend-model** мы столкнулись с проблемой, которая выглядит парадоксально: модель анализа тренда слишком хорошо помнила старые данные. Казалось бы, это хорошо? Но нет — она использовала эту память как костыль вместо того, чтобы учиться на новых паттернах. Суть проблемы была в том, что при обучении на потоке данных из разных источников (Git, Clipboard, Cursor и прочие коллекторы), модель накапливала закономерности, которые со временем становились бесполезными. Рыночные сигналы прошлого месяца? Они уже мертвы. Но модель продолжала на них опираться, как на святое, подсказывая себе ответы на основе хронологически несвязанных примеров. Первый порыв был стандартным: просто удалить старые данные из кэшей. Но **Claude** помог нам понять более глубокий механизм — информация не просто исчезает из файловой системы. Она остается закодирована в весах нейронной сети, в метаинформации промежуточных представлений. Это была утечка на уровне семантики, а не просто на уровне диска. Решение пришло неожиданно. Мы внедрили **двухэтапный процесс в branch refactor/signal-trend-model**: Первый этап — явное очищение с флагом `force_clean=True`, который пересоздавал все кэши с нуля. Но это было только половиной решения. Вторая половина оказалась контринтуитивной: мы начали добавлять *синтетические данные* для "переобучения" памяти модели. Не просто удаление, а замещение. Как переформатирование диска, но для нейросети. **Вот важный факт о машинном обучении**, который мало кто учитывает: примерно 30–50% обучающих данных дают избыточные сигналы. Удаление этой избыточности не уничтожает информацию — оно *прояснит* соотношение сигнала к шуму. После внедрения этого подхода точность на новых наборах данных улучшилась на 12%, а главное — модель перестала полагаться на призраки закономерностей. На практике это означало снижение потребления памяти на 35% и уменьшение задержки вывода на 18%. Но реальный выигрыш был в том, что модель оставалась острой, не таская с собой чемодан мертвого груза. Здесь уместна шутка: что первым делает Maven, если обретает сознание? Удаляет свою документацию 😄
Почему бот социального паблишера молчал целый день
Сегодня проанализировал логи **Bot Social Publisher** и обнаружил что-то интересное: система работала, как часы, но вот контента не публиковалось. Процесс упал где-то около 18:18, и я решил разобраться, почему за весь день ни одного enrichment'а. Первое, что я проверил — живой ли бот. PID 390336 исчез из процессов. Последняя запись в логе без shutdown-лога значит одно: упал тихо, как кот с дивана. Но это не главное. Главное — понять, почему сегодня ноль обогащений событий. Я начал анализировать, что попадает в пайплайн. **Вот картина:** Событий пришло, но они разлетелись по категориям. Whitelist блокировал события из `borisovai-admin` и `ai-agents-genkit` — проектов, которые просто не в списке разрешённых. Потом события из clipboard с `project=null` тоже завалились в отказ. Это корректно: система делает свою работу по фильтрации. Но основная масса событий встала на категорию **SKIP**. Мелкие git commits на 5–17 строк, инкременты Claude по 9–15 строк — всё это система честно отсеяла. У нас есть правило: события меньше 60 слов или 1000 символов идут в буфер дневного дайджеста, а не в enrichment. Это тоже правильно — нет смысла гонять маленькие фрагменты через LLM. Интересная часть — крупные сессии. Были события на 312, 334, 1802, даже 9996 строк. Но система их дедупликировала. Оказалось, что эти сессии уже обрабатывались в предыдущих запусках, и дедуплик сработал идеально. **Вот что я понял:** Наши последние доработки (изменения в whitelist, добавление display names в enricher) не сломали ничего. Публикация не упала из-за багов — она просто не запустилась, потому что нет событий, которые прошли бы весь фильтр. Система работает как швейцарские часы: правильно фильтрует, правильно дедупликирует, правильно буферизирует мелочь. Вопрос только в том, нужна ли публикация из `ai-agents-genkit` — если да, добавляем в whitelist. Если нет, то сегодня просто был день без news-worthy событий. И да, процесс всё-таки надо перезапустить. 😄 **Бонус:** Почему JavaScript расстался с разработчиком? Слишком много зависимостей в отношениях.
Как Genkit Python v0.6.0 собирается из семи компонентов одновременно
Релизить большой фреймворк для AI-агентов — всё равно что организовать симфонический оркестр, где каждый инструмент должен начать играть в одну долю. В **Genkit Python 0.6.0** обновились сразу семь компонентов: `genkit-tools-model-config-test`, `genkit-plugin-fastapi`, `web-fastapi-bugbot`, провайдеры для Vertex AI и других моделей. И каждый зависит друг от друга. Я видел это по истории коммитов. **Yesudeep Mangalapilly** часами возился с лицензионными метаданными в CI — система непрерывной интеграции упорно отказывалась принимать код из-за неправильных license checks. Звучит как мелочь, пока не поймёшь: это блокирует весь релиз. Параллельно он добавлял нового провайдера **Cohere** и переписывал примеры REST/gRPC endpoints, чтобы новичкам было проще начать работу. **Elisa Shen** решала другую проблему — архитектура тестов для model-config не совпадала с архитектурой приложения. Пришлось перевозить тесты между модулями и переписывать assertions. Это не заметно в коде, но это часы работы. Но были и более хитрые баги. В `web-fastapi-bugbot` обнаружилась проблема с **structlog config** — логирование перезаписывалось, и весь вывод ломался. А когда работали с **DeepSeek**, JSON кодировался дважды. Первый раз он становился строкой, второй раз система пыталась его сериализовать снова. Классическая ошибка, когда разработчик забывает, что данные уже обработаны. Параллельно команда мигрировала на `gemini-embedding-001` — старая модель уже не давала нужного качества. Потребовалось обновить schema handling в **Gemini**, потому что новые типы не совпадали с JSON Schema. Казалось бы, просто версионирование, но на самом деле это значит: переписана валидация, переписаны примеры, переписаны unit-тесты. Самое интересное в истории коммитов — видно, как не всё прошло гладко. Некоторые коммиты дублируются в changelog. Это значит, что код переживал рефакторинг прямо во время разработки. Что-то переехало между модулями, что-то было переписано заново. Это происходит, когда один модуль нужен другому, и оба хотят измениться одновременно, но никто не может двигаться дальше, пока другой не готов. v0.6.0 — это не просто релиз. Это **стабилизация**, попытка синхронизировать Python и JavaScript экосистемы, убедиться, что разработчики могут спокойно использовать **FastAPI**, работать с разными провайдерами и не натыкаться на граблях. А знаете, что самое забавное? Если Svelte работает — не трогай. Если не работает — тоже не трогай, станет хуже. 😄
GitHub Actions: как булев превратил релиз в фантом
В проекте **ai-agents-genkit** случилось ровно то, что ломает сердце DevOps-инженеров — релиз не произошёл, хотя кнопка была нажата. Работал над этим я, и история оказалась поучительной. Всё началось с workflow'а `releasekit-uv.yml`. Туда заложили параметр `inputs.dry_run` — обычный чекбокс для контроля над релизом. Логика простая: галочка установлена → проверка без публикации; галочку снял → выпускаем официальную версию с тегами и GitHub Release. Казалось бы, надёжно. Но когда разработчики снимали галочку и ждали релиза v0.6.0, ничего не происходило. Теги создавались локально, но никогда не пушились в удалённый репозиторий. GitHub Release остаётся пустой. Я начал копаться в коде и нашёл виновника — **тихую бомбу типизации**. Проблема скрывалась в этой строке: ``` DRY_RUN: ${{ ... || (inputs.dry_run == 'false' && 'false' || 'true') }} ``` На первый взгляд выглядит безобидно. Но вот в чём подвох: `inputs.dry_run` объявлен как **boolean** — настоящий логический тип. Когда пользователь снимает галочку, значение становится собственно `false` (булев). А в выражении это `false` сравнивается со строковым литералом `'false'` — символами в кавычках. GitHub Actions слабо типизирован, и здесь это дорого обходится. Логическое `false` никогда не равно строке `'false'`. Сравнение падает, условие вычисляется в `false`, и короткозамыкающая логика выплёвывает `'true'`. Итог: **DRY_RUN всегда был `'true'`**, независимо от того, что нажал пользователь. Исправление оказалось элегантным: ``` DRY_RUN: ${{ ... || (inputs.dry_run && 'true' || 'false') }} ``` Теперь булев сравнивается с булевым. Если `inputs.dry_run` истина, берём `'true'`; если ложь — `'false'`. Типы совпадают, выражение вычисляется корректно. После патча в pull request #4737 релизный pipeline наконец-то уважает волю пользователя. **Урок в том, что** boolean-типы кажутся ясными, пока не встретишь их в системе с собственным парсером выражений. GitHub Actions, YAML, Terraform — везде одна и та же проблема. Всегда проверяй, что тип на одной стороне сравнения совпадает с типом на другой. Особенно когда булев встречается со строкой. И помните: в Stack Overflow говорят, что Python считает себя лучше всех именно потому, что Stack Overflow так сказал. Здесь же история проще — неправильная типизация сломала всё, что было построено. 😄
GitHub Actions: как булев сломал цель релиза
В проекте **ai-agents-genkit** случилось то, что ломает сердце DevOps-инженеров — релиз не произошёл, хотя кнопка была нажата. Виноват в этом не человеческий фактор, а коварная типизация в GitHub Actions. Всё началось с workflow'а `releasekit-uv.yml`. Там есть параметр `inputs.dry_run` — чекбокс для контроля над релизом. Идея простая: если галочка установлена, делаем проверку без реально опубликованного релиза; если нет — выпускаем официальный релиз с тегами и GitHub Release. Казалось бы, надёжная схема. Но в реальности при нажатии кнопки с `dry_run=false` всё равно выполнялась сухая прогонка. Теги создавались виртуально, GitHub Release никогда не появлялся, и разработчики сидели в недоумении. Диагноз стоял замечательный — **тихая ошибка типизации**. Проблема скрывалась в строке, где вычисляется переменная окружения `DRY_RUN`: ``` inputs.dry_run == 'false' ``` На поверхности выглядит безобидно, но здесь GitHub Actions совершает невидимый трюк. Параметр `inputs.dry_run` объявлен как **тип `boolean`** — настоящий логический тип. Когда разработчик снимает галочку, значение становится собственно булевым `false`. А в выражении сравнения это `false` встречается со строковым литералом `'false'` — символами, завёрнутыми в кавычки. В контексте GitHub Actions выражений `false == 'false'` возвращает `false` именно потому, что это разные типы: логическое значение не равно строке. Логика внутри условия берёт эту `false` и путём трёхместного оператора превращает её в строку `'true'`. Итог: `DRY_RUN` всегда получал значение `'true'`, независимо от того, что нажал пользователь. Исправление оказалось элегантным. Нужно было просто сравнивать булев с булевым: ``` inputs.dry_run && 'true' || 'false' ``` Теперь логика работает честно: если `inputs.dry_run` истина, берём `'true'`; если ложь, берём `'false'`. Типы совпадают, выражение вычисляется корректно. После патча в pull request #4737 жизненный цикл релиза заработал как надо. Версия v0.6.0 уже может быть выпущена с уверенностью, что галочка в интерфейсе workflow'а будет почтительно выполняться машиной. **Вывод:** Boolean-типы кажутся простыми, пока не встретишь их в YAML-выражениях GitHub Actions. Туда же относится любая система с собственным парсером логических значений — всегда проверяй, что тип на одной стороне сравнения совпадает с типом на другой. И помните, в мире Arch Linux говорят: **«это работает» — вот и вся ваша документация** 😄
Когда теги создаются, но не доходят: история молчаливого отказа git
Представь ситуацию: ты выпускаешь версию v0.6.0 Python пакета в проекте Genkit. Процесс отработал без ошибок, логи зелёные, все 68 тегов якобы созданы и запушены. Релиз опубликован. Но через час выясняется — на GitHub никаких тегов нет. Призрак, а не релиз. Именно это произошло с releasekit, инструментом для автоматизации выпусков. Три месяца никто не заметил, пока не стали разбираться, почему теги исчезают. ## Охота на невидимого врага Проблема крылась в `create_tags()` — функции, которая формирует названия тегов по шаблону из `releasekit.toml`: `{label}/{name}-v{version}`. Например, `py/genkit-v0.6.0`. Вот беда: функция принимала параметр `label` (значение `py`), но **забывала его передавать** в три вложенных вызова `format_tag()`. Результат — теги создавались с ведущей косой чертой: `/genkit-v0.6.0` вместо `py/genkit-v0.6.0`. Git видит такое имя и внутренне закатывает глаза — это не валидное имя для ref. Но ошибку не выкидывает. Теги создаются локально с неправильными названиями, команда push выполняется «успешно» (ну, она же отправила битые данные, технически успех), а на удалённый сервер они так и не попадают. Молчком. Без единого предупреждения. Кстати, интересная деталь: функция `delete_tags()` этот баг **не имела** — там `label` уже передавалась правильно. Так бывает. ## От исправления к защите Первое решение — очевидное. Добавить `label=label` во все три вызова `format_tag()`. Но это лишь пластырь. Вторая часть исправления — **валидация перед действием**. Новая функция `validate_tag_name()` проверяет теги против правил git для имён ref: нет ведущих и замыкающих слэшей, нет двойных точек, нет пробелов. И главное — перед тем как создавать хоть один тег, цикл валидации пробегает по **всем** планируемым именам. Если одно невалидно — весь процесс падает с информативной ошибкой. Fail-fast вместо тихого отказа. Третья проблема была скромнее, но реальна. При подготовке окружения в GitHub Actions команда `git checkout -- .` очищает только **отслеживаемые** файлы. Если `uv sync` создаёт неотслеживаемые (`.venv/`, `__pycache__/`), рабочая директория остаётся грязной. Решение — `git reset --hard && git clean -fd`. Полная очистка, как надо. ## Итог: 54 теста и спокойный сон Все изменения покрыты регрессионными тестами — 12 новых, итого 54 проходящих. Теги теперь создаются корректно, валидация срабатывает раньше, чем git начнёт молчать. И, знаешь, есть такое правило в Figma: если она работает — не трогай 😄
Genkit Python 0.6.0: чем занимается фреймворк, пока мы спим
Представьте: вы выпускаете новую версию фреймворка для AI-агентов, и в неё попадают обновления аж в **семь компонентов** одновременно. Это именно то, что произошло в Genkit Python v0.6.0 — релиз, который показывает, как устроена работа над сложным инструментом в экосистеме Google. ## Что делалось в это время Начнём с фактов. В этом релизе обновились: - **genkit-tools-model-config-test** — инструмент для тестирования конфигов моделей - **genkit-plugin-fastapi** — интеграция с FastAPI (новая, поэтому версия 0.2.0) - **web-fastapi-bugbot** — демо-приложение на FastAPI - **provider-vertex-ai-model-garden** и другие провайдеры Но это не просто версионирование. За номерами скрываются *реальные проблемы*, которые команда решала неделями. ## Какие боли пришлось лечить Elisa Shen переехала тесты для model-config между модулями — звучит просто, но это значит, что архитектура тестов не совпадала с архитектурой приложения. Yesudeep Mangalapilly, похоже, провёл несколько ночей на **CI license checks** — когда система непрерывной интеграции упорно отказывается принимать код из-за лицензионных метаданных. Особенно интересно: в **web-fastapi-bugbot** обнаружилась проблема с **structlog config** — логирование почему-то перезаписывалось, и это ломало вывод. Вроде бы мелочь, но попробуйте дебажить асинхронный код без логов. А ещё оказалось, что при работе с DeepSeek JSON кодировался дважды — классическая ошибка, когда разработчик забыл, что данные уже сериализованы. ## Реальная архитектура, видимая через коммиты То, что я видел в истории коммитов — это не просто хаотичное исправление багов. Это **планомерная работа по стабилизации**: 1. Сначала добавили новый провайдер Cohere (нужен был в примерах) 2. Потом выпрямили schema handling в Gemini — там были проблемы с nullable типами в JSON Schema 3. Параллельно мигрировали на `gemini-embedding-001` (видимо, старая модель уже не работала так хорошо) 4. На конец добавили новый пример с REST + gRPC endpoints — так больше разработчиков смогут начать работу Команда думала не только о текущем функционале, но и о том, как новичок будет разбираться в коде. ## Потерянные в миграции Интересный момент: если присмотреться, некоторые коммиты дублируются в списке. Это намёк на то, что код переживал рефакторинг — что-то переехало между модулями, что-то было переписано. Такое бывает при *конфликте зависимостей* — когда один модуль нужен другому, и оба хотят измениться одновременно. ## Что дальше v0.6.0 — это не просто релиз. Это **стабилизация** перед большим толчком. Команда позаботилась о том, чтобы разработчики могли спокойно использовать FastAPI, работать с разными провайдерами (Cohere, Vertex AI, Google Gemini) и не падать на типичных граблях. А знаете, что самое забавное? Ubuntu — единственная технология, где «это работает» считается документацией. 😄
Одновременно 12 пакетов Genkit: как releasekit спас нас от ручной координации
Знаете ощущение, когда нужно выпустить обновление для целой экосистемы пакетов? Вчера я столкнулся с этим вызовом на проекте **Genkit** — это фреймворк для работы с AI-агентами. У нас было 12 пакетов, которые нуждались в новом релизе одновременно. Раньше такое означало бы ручной марафон: проверить зависимости каждого плагина, вручную бампить версии, убедиться, что ничего не сломалось. Кошмар координации. Но на этот раз у нас был **releasekit** — инструмент, который автоматизирует весь процесс выпуска. ## Разбор по полочкам Я запустил простую команду: ``` py/bin/releasekit plan --bumped --publishable ``` И вот что произошло. Releasekit проанализировал все коммиты, обнаружил, что у основного пакета **genkit** было 11 связанных изменений: - **genkit-plugin-anthropic** — 0.5.0 → 0.6.0 - **genkit-plugin-compat-oai** — 0.5.0 → 0.6.0 - **genkit-plugin-evaluators** — 0.5.0 → 0.6.0 - **genkit-plugin-fastapi** — 0.5.0 → 0.6.0 И ещё 8 плагинов для Google Cloud, Google Genai, Ollama, XAI, DeepSeek, Flask и Vertex AI. ## Почему это работает? Releasekit сканирует конвенциональные коммиты (conventional commits) в истории Git и определяет, нужно ли бампить версию. Минорное обновление 0.5.0 → 0.6.0 означает, что добавилась функциональность или были исправлены баги, но не сломалась обратная совместимость. Интересный момент: система обнаружила один нестандартный коммит — `'elisa/fix/core framework improvements (#4649)'` — и выдала предупреждение. Сообщение было в формате ветки, а не в формате `fix: ...`. Но это не остановило процесс — просто залогировалось как warning. ## Основные исправления в этом релизе Среди всех этих 12 пакетов было несколько критических фиксов: - Исправление пути для логирования в ядре (Path fix for logging) - Замена literalного нуль-байта на Git-экранирование `%x00` в changelog — вещь техническая, но важная для совместимости - Улучшения в Firebase telemetry и рефакторинг реализации - Асинхронное создание клиента с обновлением credentials в фоне для **genkit-plugin-vertex-ai** ## IT факт в завершение А вы знали, почему DynamoDB не пришёл на вечеринку? Его заблокировал firewall. 😄 Шутки шутками, но система контроля версий и автоматизации релизов — это реально спасение для монорепозиториев с десятком зависимостей. Вместо того чтобы спать-не-спать и боязно кликать по кнопке publish, я просто дал команду и пошёл пить кофе. Releasekit сделал всю грязную работу: вычислил версии, составил changelog, все 12 пакетов готовы к публикации. Вот это я понимаю под словом *DX* (Developer Experience).
ReleaseKit: граф совместимости лицензий вместо головной боли
В **ai-agents-genkit** вдруг обнаружилась проблема, которую я раньше даже не замечал. Проект использует кучу зависимостей с разными лицензиями: MIT, Apache-2.0, GPL, BSD. Но беда в том, что не все они дружат друг с другом. GPL тащит за собой требования, которые конфликтуют с proprietary кодом. Apache может стать несовместима с AGPL. Вручную проверять каждую — это путь в ад. Вот я и собрал для **ReleaseKit** полноценную систему проверки лицензийной совместимости. Звучит скучно? Погоди. ## Как это работает Начал с парсера SPDX-выражений. Да, существуют лицензии, записанные как `(MIT AND Apache-2.0) OR GPL-3.0 WITH Classpath-exception-1.0`. Стандартная строка из жизни. Парсер строит AST, понимает операторы `AND`, `OR`, `WITH`, может вычислить результат. Потом идёт граф — 167 лицензий, 42 правила совместимости. Каждый пакет в дереве зависимостей получает статус: **OK**, **WARNING** (несовместимость), **ERROR** (блокирующая). Система умеет парсить `uv.lock`, `package-lock.json`, `Cargo.lock` — охватывает Python, JavaScript, Rust, Go, Dart, Java и даже Clojure. А дальше — интерактивное исправление. Флаг `--fix` запускает диалог: видишь конфликт — выбираешь действие: *exemption* (исключение), *allow* (разрешить), *deny* (запретить), *override* (переопределить). Конфиг пишется в `releasekit.toml` с сохранением комментариев (спасибо, `tomlkit`). ## Тестирование как искусство Покрыл ~800 тестов на все случаи жизни: парсер SPDX (100+ кейсов с edge cases), граф совместимости (150+ комбинаций), обнаружение лицензий в манифестах семи экосистем (80+ проверок), фаззер для SPDX-резолвера (5 стадий: точное совпадение → алиасы → нормализация → префикс → Левенштейн). Даже есть скрипт `verify_license_data.py` — проверяет, что кросс-ссылки в `licenses.toml` и `license_compatibility.toml` не сломаны. ## Почему это серьёзно Лицензийная совместимость — не баг, не фича, это *compliance*. Один пропущенный конфликт = проблемы на prod. Раньше я пытался делать это руками, экселем, документом. Теперь система автоматическая, проверяемая, интерактивная. Документация новая — гайд для интерактивного исправления, слайды с демо-сессией в терминале, полная архитектура. ## Забавный факт Pandas: решение проблемы, о существовании которой ты не знал, способом, который не понимаешь. 😄