Вступление

В этой статье я хочу рассказать про инструмент AI Review. Да, подобных решений уже немало — но этот особенный. Его цель — работать везде, с любыми стеками, на любых CI/CD, быть гибким, быстрым и простым в настройке. Короче, чтобы всё было “как мы любим”: всё есть, ничего не ломается, и при этом — без боли и лишней магии.

Попробуем разобраться, как это работает и почему мне захотелось сделать свой AI Review.

Примечание: это не рекламный пост и не очередной “AI-ревью, который всех спасёт”. AI Review — мой личный open-source проект, сделанный для реальной задачи, с которой я сам столкнулся: быстрые, честные и безопасные ревью прямо в CI/CD.

Инструмент полностью бесплатный — без SaaS, без подписок и без магии. Берите, пользуйтесь, адаптируйте под себя. Просто решил поделиться годнотой — вдруг кому-то пригодится :)

Что такое AI Review?

Для тех, кто не сталкивался с этим понятием: AI Review — это инструмент, который выполняет автоматическое ревью вашего кода с помощью LLM (Large Language Model).

Раньше в этой роли был “злой коллега — сеньор-помидор”, который цеплялся к каждому комментарию и форматированию. Теперь же на его месте — модель, которая анализирует изменения, оценивает их по заданному промпту и оставляет комментарии прямо в вашем Merge Request (или Pull Request — в зависимости от того, где вы работаете).

Сценарий простой: нажали кнопку — получили ревью. Быстро, предсказуемо и без ожиданий “когда же сеньор посмотрит мой MR”.

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

“ai-review run — и поехали”.

Конечно, звучит чересчур хорошо, чтобы быть правдой. Но именно это мне и хотелось реализовать: stack-agnostic решение, которое можно интегрировать за 15 минут, без костылей, без внешних прокси и лишних зависимостей.

Так и появился AI Review — инструмент, который помогает командам ускорять ревью, не превращая процесс в хаос и бюрократию.

История создания

Однажды я решил: пора подключить AI Review ко всем проектам нашей команды. Звучит просто, но сразу возник классический вопрос:

“А есть ли где-нибудь готовое, быстрое, встроенное решение?”

Что-то вроде:

image: ai-review

или хотя бы:

pip install xai-review

и чтобы дальше — пара строк конфигурации, один клик, и всё заработало. Без шаманских плясок и боли.

Сначала я пошёл по очевидному пути — спросил у коллег. В итоге нашёл, кажется, десяток разных реализаций: от микроскриптов на Python до тяжеловесных комбайнов на Java, Go, Kotlin — даже вариант на TypeScript попадался.

Но всё это были локальные самоделки, с намертво прибитыми промптами. Попробовать переиспользовать их означало только одно — скопировать весь код, адаптировать под себя и потом ещё и поддерживать. Короче, быстро стало понятно: готового решения просто нет.

Тогда я пошёл искать дальше — в интернет. Сходу тоже ничего стоящего не нашлось. SonarQube — не в счёт: это вообще про другое. Попался какой-то GitLab Duo, который вроде бы должен уметь делать AI Review прямо из GitLab, но оказалось, что там своя магия, платная лицензия и куча ограничений. Да и в нашем случае он просто был недоступен.

Начал копать глубже — нашёл пару решений вроде CodeRabbit, Codeball и CodiumAI. Все они вроде как “умные”, умеют анализировать Pull Request’ы и писать комментарии прямо в коде, но работают только с GitHub — ни GitLab, ни self-hosted они не поддерживают. К тому же это SaaS-сервисы, которые тащат ваш код через внешние прокси, стоят денег и не дают ни гибкости, ни прозрачности. А ведь хочется чего-то, что можно просто поставить у себя, запустить в CI/CD и не думать, куда и кто сейчас отправил твой приватный код.

Ну вы понимаете, о чём я. В каждом языке есть какая-то дефолтная библиотека, которую используют все, даже не задумываясь. В Python это pytest, в JS — eslint или prettier, в мире UI-тестов — playwright, в API-тестах — requests или httpx. А вот для AI-ревью кода такого инструмента просто не существовало.

Поэтому я решил сделать свой. Причём не просто “очередной скрипт”, а действительно универсальное решение — которое можно интегрировать по щелчку пальцев, в любую CI/CD-систему, на любом стеке, и чтобы без боли.

Спойлер: у меня получилось — и в этой статье я покажу, как.

Архитектура

Под капотом всё довольно просто — без магии, но с инженерной аккуратностью.

Есть ваш VCS — например, GitHub или GitLab. Вы запускаете AI Review, указываете номер Merge Request или Pull Request, добавляете нужные настройки и токены. Дальше всё делает сам инструмент. Он забирает данные из VCS, получает список изменённых файлов, строит аккуратные diff’ы (на основе git), и превращает их в формат, удобный для анализа моделью.

После этого AI Review собирает промпты — подставляет туда диффы, метаданные и инструкции — и отправляет всё это в выбранную LLM-модель (OpenAI, Claude или Gemini). Когда приходит ответ, инструмент аккуратно парсит его и формирует комментарии прямо в ваш MR/PR: строковые замечания, контекстные подсказки, сводки — всё, как в обычном ревью.

Параллельно AI Review:

• считает стоимость запроса (чтобы вы понимали, сколько стоит каждое ревью);

• сохраняет артефакты для отладки — что именно было отправлено в модель, что она ответила и когда;

• пишет логи в консоль, включая сырые ответы модели, чтобы можно было быстро понять, если что-то пошло не так.

Всё это работает асинхронно — запросы к модели идут батчами, а не по одному, поэтому инструмент не “тормозит”, даже если файлов много. На практике ревью среднего Merge Request (10–30 файлов) занимает всего 20–40 секунд. И это без кэшей, без внешних сервисов и без необходимости держать свой сервер. Просто запускаете — и AI Review делает всё сам.

Как интегрировать?

Если коротко — интегрируется просто. Но всё зависит от того, где вы работаете: GitHub, GitLab, Bitbucket (для последнего реализация пока в планах, но обязательно будет).

Для начала разберём самый низкоуровневый способ — тот, что работает везде, независимо от CI/CD, языка или операционной системы.

Вариант 1. Через PyPI

Самый прямой путь:

pip install xai-review
ai-review run

И всё? Ну, по сути — да. Единственное — понадобится добавить небольшой конфиг, но о нём я расскажу чуть позже.

С помощью этой команды вы просто устанавливаете библиотеку Python и можете запускать AI Review где угодно: на CI, на сервере, на локальной машине — неважно.

Но тут закономерный вопрос:

“А если я не на Python? Не хочется ставить питонячие зависимости и возиться с окружением.”

И я вас понимаю. Сам пишу в основном на Go, и тоже не хотел лезть в питоновскую экосистему, таскать за собой venv, pip, requirements.txt и прочие радости. Хотелось что-то по-настоящему stack-agnostic, чтобы просто запустить инструмент и не думать о среде.

Вариант 2. Через Docker

И вот тут нас выручает Docker. На Docker Hub уже лежит готовый образ: nikitafilonov/ai-review. Вы просто вытягиваете его и используете где угодно — локально, в CI/CD, в контейнере, в Kubernetes — без разницы.

Локально:

docker run --rm -v $(pwd):/app nikitafilonov/ai-review:latest run-summary

На CI/CD:

image: nikitafilonov/ai-review:latest

Работает точно так же, как если бы вы использовали:

image: gradle

или

image: node:20

или

image: go:1.24

Таким образом вы сразу получаете готовое окружение, со всеми зависимостями и установленным дистрибутивом ai-review. Вам не нужно лезть в чужие экосистемы, ставить Python, Java или Kotlin — всё упаковано в один чёрный ящик, который просто берёт и работает.

Интеграция с GitLab CI/CD

Теперь давайте посмотрим, как это всё подключается в GitLab CI. На самом деле — ничего сложного. Готовый пример уже лежит тут: docs/ci/gitlab.yaml, а живой пример ревью в действии можно посмотреть здесь — GitLab MR с результатами AI Review. Адаптировать под свой проект — дело 10–15 минут.

Базовая версия выглядит вот так:

ai-review:
  when: manual
  stage: review
  image: nikitafilonov/ai-review:latest
  rules:
    - if: '$CI_MERGE_REQUEST_IID'
  script:
    - ai-review run
  variables:
    # --- LLM configuration ---
    LLM__PROVIDER: "OPENAI"
    LLM__META__MODEL: "gpt-4o-mini"
    LLM__META__MAX_TOKENS: "15000"
    LLM__META__TEMPERATURE: "0.3"
    LLM__HTTP_CLIENT__API_URL: "https://api.openai.com/v1"
    LLM__HTTP_CLIENT__API_TOKEN: "$OPENAI_API_KEY"

    # --- GitLab integration ---
    VCS__PROVIDER: "GITLAB"
    VCS__PIPELINE__PROJECT_ID: "$CI_PROJECT_ID"
    VCS__PIPELINE__MERGE_REQUEST_ID: "$CI_MERGE_REQUEST_IID"
    VCS__HTTP_CLIENT__API_URL: "$CI_SERVER_URL"
    VCS__HTTP_CLIENT__API_TOKEN: "$GITLAB_API_TOKEN"
  allow_failure: true  # Не блокируем пайплайн, если AI Review по каким-то причинам не сработал

Что здесь происходит:

• image — мы используем готовый Docker-образ nikitafilonov/ai-review, в котором уже всё установлено.

• rules — указываем, что запускать задачу нужно только для Merge Request’ов.

• script — основная команда запуска ревью (ai-review run).

• variables — здесь мы задаём всю конфигурацию:

  • параметры модели (model, temperature, max_tokens),

  • API-токен для доступа к LLM,

  • данные GitLab-пайплайна (ID проекта и MR),

  • токен авторизации для комментирования MR.

По сути, этого достаточно, чтобы AI Review начал делать ревью прямо в Merge Request. Промпты по умолчанию универсальные — их можно кастомизировать под свой проект. Об этом я расскажу чуть позже в разделе про конфигурацию.

Интеграция с GitHub Actions

Для GitHub Actions — всё так же просто. Готовый workflow выглядит примерно так:

name: AI Review

on:
  workflow_dispatch:
    inputs:
      review-command:
        type: choice
        default: run
        options: [ run, run-inline, run-context, run-summary ]
      pull-request-number:
        type: string
        required: true
jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: Nikita-Filonov/ai-review@v0.20.0
        with:
          review-command: ${{ inputs.review-command }}
        env:
          # --- LLM configuration ---
          LLM__PROVIDER: "OPENAI"
          LLM__META__MODEL: "gpt-4o-mini"
          LLM__META__MAX_TOKENS: "15000"
          LLM__META__TEMPERATURE: "0.3"
          LLM__HTTP_CLIENT__API_URL: "https://api.openai.com/v1"
          LLM__HTTP_CLIENT__API_TOKEN: ${{ secrets.OPENAI_API_KEY }}

          # --- GitHub integration ---
          VCS__PROVIDER: "GITHUB"
          VCS__PIPELINE__OWNER: ${{ github.repository_owner }}
          VCS__PIPELINE__REPO: ${{ github.event.repository.name }}
          VCS__PIPELINE__PULL_NUMBER: ${{ inputs.pull-request-number }}
          VCS__HTTP_CLIENT__API_URL: "https://api.github.com"
          VCS__HTTP_CLIENT__API_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Пример с живым ревью можно посмотреть здесь: Pull Requests с результатами AI Review

Что важно знать:

• Action не использует Docker-образ, а работает как composite action — он сам поднимает окружение Python, ставит нужную версию xai-review из PyPI и запускает команду. Всё прозрачно и управляемо: никакой чёрной магии, просто обычный Python-скрипт в рантайме GitHub Actions.

• Workflow запускается вручную через вкладку Actions — удобно, если хотите проверить, как AI Review отработает на конкретном Pull Request перед автоматизацией.

  

• В блоке inputs можно выбрать, в каком режиме запустить ревью:

  • run — полный обзор,

  • run-inline — только построчные комментарии,

  • run-context — анализ нескольких файлов,

  • run-summary — короткое итоговое ревью.

  • Это даёт гибкость — вы можете подключить разные режимы под разные ветки или пайплайны.

• Всё взаимодействие идёт через GitHub API, поэтому AI Review пишет комментарии прямо в Pull Request, как будто это сделал живой ревьюер (только быстрее и без кофеина).

Кстати, сам Action доступен в GitHub Marketplace: XAI Review — AI-powered code review tool. Там можно посмотреть исходники, примеры и быстро добавить его в свой workflow.

Как настроить?

Сразу важный момент — токен для LLM (будь то OpenAI, Claude или Gemini) нужно получать самостоятельно. AI Review не генерирует и не проксирует ключи, он просто использует тот токен, который вы ему передаёте.

Безопасность и запуск

AI Review работает целиком на клиентской стороне. Он не проксирует ваш код через сторонние серверы и не сохраняет данные где-то “в облаке”. Все запросы идут напрямую — от вашей машины или CI/CD к:

• выбранному LLM-провайдеру (например, OpenAI API);

• и вашему VCS (GitLab или GitHub).

Никаких промежуточных сервисов, прокси или логгеров между ними нет. Поэтому вы полностью контролируете, что и куда отправляется. AI Review — это не SaaS, а инструмент, который работает у вас.

Форматы конфигурации

Инструмент поддерживает четыре формата конфигов:

• YAML

• JSON

• .env

• переменные окружения

По умолчанию он ищет их в корне проекта, в одном из файлов:

.ai-review.yaml
.ai-review.json
.env

Если таких файлов нет — можно задать свой путь к конфигу. Для этого достаточно установить одну из переменных окружения:

Гибкость и пресеты

Благодаря этому подходу, можно легко создавать разные пресеты конфигураций и промптов. Например:

• строгий режим — с детальным ревью и формальными замечаниями;

• лёгкий режим — только базовые подсказки и рекомендации;

• быстрый режим — минимальные лимиты и короткие ответы.

Храните их в отдельных файлах и просто переключайтесь между ними через переменные окружения.

Всё зависит только от вашей фантазии: AI Review можно настроить под свой проект, стиль ревью и даже настроение команды

Пример конфигурации .ai-review.yaml

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

# ===============================
# AI Review configuration file
# ===============================

llm:
  # Провайдер LLM: OPENAI | GEMINI | CLAUDE
  provider: OPENAI

  # Файл с тарифами (используется для расчёта стоимости ревью)
  pricing_file: ./pricing.yaml

  # Метаданные модели
  meta:
    model: gpt-4o-mini   # Название модели (например, gpt-4o, gpt-3.5-turbo)
    max_tokens: 1200     # Максимум токенов на ответ
    temperature: 0.3     # Креативность модели (0 = детерминированно)

  # Настройки HTTP-клиента для LLM
  http_client:
    timeout: 120
    api_url: https://api.openai.com/v1
    api_token: ${OPENAI_API_KEY}  # Берётся из переменных окружения

# -------------------------------
# Настройки интеграции с GitLab / GitHub
# -------------------------------
vcs:
  provider: GITLAB   # Поддерживается GitLab, GitHub

  pipeline:
    project_id: ${CI_PROJECT_ID}
    merge_request_id: ${CI_MERGE_REQUEST_IID}

  http_client:
    timeout: 120
    api_url: ${CI_SERVER_URL}
    api_token: ${GITLAB_API_TOKEN}

# -------------------------------
# Настройки промптов
# -------------------------------
prompt:
  # Контекстные переменные, доступные внутри шаблонов
  context:
    environment: "staging"
    company_name: "ACME Corp"
    ci_pipeline_url: "https://gitlab.com/pipelines/123"

  # Формат подстановки переменных (по умолчанию <<var_name>>)
  context_placeholder: "<<{value}>>"

  # Автоматическая нормализация промптов перед отправкой в LLM
  normalize_prompts: true

  # ---- Inline Review ----
  # Локальные инструкции для построчного ревью
  inline_prompt_files:
    - ./prompts/default_inline.md

  # Системные контракты для inline-ревью
  system_inline_prompt_files:
    - ./prompts/default_system_inline.md
  include_inline_system_prompts: true

  # ---- Context Review ----
  # Инструкции для контекстного анализа (несколько файлов)
  context_prompt_files:
    - ./prompts/default_context.md

  system_context_prompt_files:
    - ./prompts/default_system_context.md
  include_context_system_prompts: true

  # ---- Summary Review ----
  # Шаблон для итогового ревью (короткий обзор)
  summary_prompt_files:
    - ./prompts/default_summary.md

  system_summary_prompt_files:
    - ./prompts/default_system_summary.md
  include_summary_system_prompts: true

# -------------------------------
# Режим ревью
# -------------------------------
review:
  # Что именно анализировать
  # FULL_FILE_DIFF — сравнивает изменения (по умолчанию)
  mode: FULL_FILE_DIFF

  # Теги для пометки AI-комментариев
  inline_tag: "#ai-review-inline"
  summary_tag: "#ai-review-summary"

  # Количество контекстных строк вокруг изменений
  context_lines: 10

  # Какие файлы включать/исключать из ревью
  allow_changes: []
  ignore_changes: ["docs/*", "README.md"]

  # Ограничения по количеству комментариев
  max_inline_comments: null
  max_context_comments: null

# -------------------------------
# Логирование
# -------------------------------
logger:
  level: INFO
  format: "{time:YYYY-MM-DD HH:mm:ss} | {level} | {extra[logger_name]} | {message}"

# -------------------------------
# Артефакты
# -------------------------------
artifacts:
  # Директория для сохранения ответов модели
  llm_dir: ./artifacts/llm
  # Если включено — сохраняет вход/выход LLM (удобно для отладки)
  llm_enabled: false

Этот файл — сердце настройки AI Review. Вы указываете, с какой моделью работать, где взять токен, как именно формировать промпты, какие файлы анализировать и где сохранять результаты.

Совет: начните с минимального набора — llm, vcs и review. Остальные блоки можно подключать по мере необходимости: например, кастомные промпты, фильтры файлов или собственные форматы логов.

Режимы ревью и диффов

Отдельно хочется рассказать про режимы диффов — их тут целых девять. И это, без преувеличения, одна из киллер-фич инструмента. С их помощью вы можете гибко управлять тем, что именно попадёт в модель:

• целый файл целиком,

• только изменённые строки,

• или добавленные куски кода с контекстом вокруг.

Например:

• FULL_FILE_DIFF — самый универсальный режим. В модель отправляется весь файл с выделенными изменениями — примерно так же, как это делает GitHub или GitLab.

• ONLY_ADDED_WITH_CONTEXT — показывает только добавленные строки и по несколько строк вокруг для контекста. Это удобно, если у вас большие файлы, и вы хотите снизить нагрузку по токенам. Количество строк контекста задаётся через параметр context_lines.

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

Системные промпты

Теперь давайте немного о системных промптах. Если обычные промпты отвечают за "что проверять" (читаемость, баги, стиль и т.д.), то системные — за "как себя ведёт модель".

Через системные промпты можно задать модели строгие рамки:

• в каком формате отвечать (например, строго JSON или только краткие фразы),

• сколько комментариев давать,

• нужно ли приводить пример исправления и т.п.

В AI Review это уже предусмотрено из коробки. Например, с помощью настройки:

prompt:
  system_context_prompt_files:
    - ./prompts/default_system_context.md

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

Если же вы хотите полностью переопределить системное поведение — просто отключите стандартные шаблоны:

prompt:
  include_context_system_prompts: false

и укажите свои:

prompt:
  system_context_prompt_files:
    - ./prompts/my_strict_rules.md

А если оставить include_context_system_prompts: true, то ваши шаблоны добавятся к стандартным, создавая комбинированный контракт.

Это удобно, если вам нужны свои корпоративные правила ревью, но при этом вы не хотите терять встроенные ограничения и форматирование.

Контекст в промптах

И напоследок — про контекстные переменные. AI Review умеет подставлять в промпты значения прямо из вашего пайплайна или Merge Request. Например, вы можете писать такие инструкции:

Если в Merge Request <<review_title>> нет описания или не прикреплена задача,  
упомяни <<review_author_username>> и попроси добавить описание и ссылку на задачу.

Механизм <<{value}>> заменит плейсхолдеры на реальные значения: название MR, автора, ссылку на пайплайн, окружение и т.д. Это позволяет делать ревью максимально контекстным — AI будет учитывать не только код, но и метаданные вашего проекта.

Итого: вы управляете всем — от глубины диффа и структуры ответов до поведения модели и подстановки данных из пайплайна. Всё это доступно через YAML и не требует ни строчки кода.

Режимы ревью

В AI Review есть несколько режимов работы — и все они доступны прямо из CLI. Вы можете выбрать тот, который подходит под ваш сценарий: быстрое ревью, полное, построчное или контекстное.

Полный запуск (inline + summary)

Если хотите, чтобы инструмент сделал всё и сразу, просто выполните:

ai-review run

Эта команда запускает два режима одновременно:

• inline — построчные комментарии прямо в коде;

• summary — короткий итоговый обзор MR.

Такой вариант идеально подходит для стандартных ревью: вы сразу получаете и детальные замечания, и общий вердикт по Pull/Merge Request.

Inline-режим

ai-review run-inline

Inline-режим проходит по каждому файлу в вашем MR, и для каждого файла формирует промпт вида:

[системный промпт] + [inline-промпт] + [дифф]

Это крайне полезно, когда у вас, например, MR на 150 файлов, и в каждом — по 300–500 изменений. Очевидно, что всё это никогда не влезет в один промпт, даже если выставить лимит в 50 000 токенов. Поэтому инструмент делает всё умно — обрабатывает файл за файлом, и оставляет комментарии прямо построчно, как живой ревьюер.

Это оптимальный вариант для больших изменений: модель всегда получает релевантный контекст и не "теряет нить".

Context-режим

ai-review run-context

Context-режим — это уже обзор на уровне всей фичи. В модель улетает:

[системный промпт] + [context-промпт] + [дифф по всем файлам]

То есть AI Review берёт все файлы из MR, собирает по ним диффы, объединяет и отправляет единым контекстом. Идеально, если вы сделали цельную фичу и хотите, чтобы модель оценивала изменения в связке, а не по отдельным кускам.

Именно отсюда и название — контекстное ревью: модель понимает не только “что изменилось”, но и “зачем”.

Summary-режим

ai-review run-summary

Summary-режим делает короткое текстовое ревью в стиле overview. То есть то самое описание, которое вы обычно пишете руками при создании MR:

• что добавлено,

• какие проблемы решены,

• что стоит проверить на ревью.

Удобно, если нужно быстро понять суть MR, не вчитываясь в детали. Можно даже поставить это ревью первым шагом пайплайна — чтобы сразу получить “tl;dr” по изменению.

В итоге у вас есть четыре базовых сценария:

Юз-кейсы

Тут, как говорится, всё зависит от вашего проекта, команды и фантазии. Если у вас в репозитории лежат просто статические картинки или README — ну, очевидно, толку от AI Review будет немного.

Но если у вас живой, активно развивающийся проект, где по 50+ Merge Request’ов на ревью в день — добро пожаловать, это ваш инструмент.

Как можно использовать?

Поделюсь личным примером. У большинства команд есть какие-то гайдлайны, стайл-гайды, архитектурные правила, а иногда даже внутренние мини-курсы в Confluence или Notion — по типу: “как писать фичу”, “какие имена использовать”, “что не забыть при деплое” и т.д. Так вот, всё это — идеальные кандидаты для промптов.

Например, я при настройке особо не заморачивался: просто собрал всё, что у нас было по проекту, и разложил по файлам:

prompts/
 ├─ style.md
 ├─ core.md
 ├─ rules.md
 ├─ context.md
 └─ faq.md

Затем просто списком указал их в конфиге — AI Review сам всё собрал, склеил в единый промпт, добавил дифф и отправил в модель. А вы — получаете ревью, которое знает все ваши внутренние правила.

Можно даже не изобретать велосипед — взять прямо из Confluence или Notion, скопировать куски правил в .md файлы, и просто подключить их. Всё, без магии, просто работает.

И я скажу так: да, пришлось немного помучиться с промптами — пару раз подгонять формулировки, уточнять акценты, перезапускать. Но после нескольких итераций результат стал просто отличным. Ревью — моё почтение: нашёл всё — ошибки, опечатки, неточности, даже такие мелкие вещи, которые я бы под микроскопом не заметил. Особенно в тех MR, где правок много и глаза уже “замыливаются”.

Немного реализма и советов

Теперь давайте честно. Не стоит ожидать, что AI Review превратится в “ревьюера мечты”, который сразу поймёт любую архитектуру и найдёт все баги.

Тут есть несколько нюансов:

1. Провайдер — разница между OpenAI, Claude и Gemini реально чувствуется. Gemini дешевле, но иногда выдаёт более “общие” ответы. Claude часто даёт академичные, вежливые комментарии. GPT — более сбалансирован по качеству и структуре.

2. Модель — не забывайте, что gpt-3.5 и gpt-4o-mini — это две разные вселенные. Чем новее модель — тем точнее ревью, но и дороже запрос.

3. Токены — если вы зададите лимит в 1000 токенов, а засунете MR на 10 000 строк — не удивляйтесь, если модель “сломается”. Она просто не уместит весь контекст.

4. Температура — если AI начинает “фантазировать”, смело снижайте температуру до 0.2–0.3, а то и до 0.0, чтобы получить строго детерминированные ответы.

5. Промпты решают всё — если ваш код более-менее шаблонный (например, CRUD), можно описать основные паттерны прямо в промпте, и AI будет попадать в точку. Если же код сильно разный — придётся немного поиграть с шаблонами и найти баланс.

6. Будьте конкретны — хотите, чтобы модель отвечала строго по шаблону? Так и пишите: “Отвечай в формате JSON с полями file, line, comment, suggestion” — без "примеров" и "если возможно". LLM любит точные инструкции.

7. Цены на токены — сейчас самый дешёвый провайдер — Gemini, если нужно массовое ревью без нагрузки на бюджет, можно начать с него, а потом перейти на GPT.

Главное — относитесь к AI Review не как к “магическому ревьюеру”, а как к инженерному инструменту, который можно натренировать под ваш проект. Тогда результат действительно будет радовать.

Безопасность и работа с токенами

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

В AI Review вы сами решаете, какие токены использовать и откуда их брать. Инструмент не хранит, не проксирует и не перехватывает ваши данные — всё идёт напрямую от CI/CD к выбранному провайдеру (OpenAI, Claude или Gemini).

Но! Если вы возьмёте свой личный токен (например, от личного OpenAI-аккаунта) и запустите AI Review на корпоративном репозитории, то не стоит удивляться, если через полгода та же модель начнёт “угадывать” названия ваших внутренних сервисов или упоминать приватные конструкции. Это не “слив”, просто вы сами обучили модель на своих данных через публичный ключ.

Поэтому строго рекомендуется:

• использовать только корпоративные токены, выданные специально для работы в CI/CD;

• хранить их в секрет-хранилище (Vault, GitLab Secrets, GitHub Actions Secrets);

• никогда не вставлять токены напрямую в .yaml или .env — даже локально;

• не использовать один и тот же токен для пет-проектов и для корпоративного кода.

Лучше всего, если ваш CI будет подтягивать токен динамически из Vault или Secret Manager — тогда никто случайно не “положит туда чего не стоит”, и ревью останется безопасным на всех уровнях.

А какие есть альтернативы?

Честно говоря, когда я начинал делать AI Review, мне казалось, что таких решений должно быть уже море. Ну правда — 2025 год, LLM повсюду, GitHub Copilot есть у каждого второго. Логично, что кто-то уже сделал “AI, который сам ревьюит код прямо в MR”.

И вот я начал искать… Нашёл десяток SaaS-решений, парочку IDE-плагинов, несколько стартапов и пару корпоративных интеграций. Но вот stack-agnostic, open-source и локального решения, которое можно просто запустить в CI/CD — я так и не нашёл.

Поэтому я решил сделать своё. Но, чтобы быть честным — я собрал таблицу сравнения. Это не “рейтинг” и не попытка сказать, что “все плохие”. Это просто честный обзор рынка, который показывает разные подходы: SaaS против локального, готовые сервисы против кастомных CLI-инструментов.

Если вы знаете похожие решения — обязательно напишите в комментариях! Мне действительно интересно, может быть, я зря изобретал велосипед, и где-то уже лежит простое open-source чудо, которое все юзают.

⚠️ Дисклеймер: таблица носит обзорный характер. Все данные приведены по состоянию на осень 2025 года. Цель — показать подходы, а не “победителей”. AI Review — это клиентский, гибкий и open-source инструмент, тогда как большинство альтернатив — облачные SaaS-решения, у которых тоже есть свои сильные стороны.

Заключение

Когда я начинал делать AI Review, хотелось одного — чтобы инструмент просто работал. Без костылей, без SaaS-зависимостей, без страха “куда улетят мои данные”. Чтобы можно было за 15 минут добавить шаг в CI и получать ревью от ИИ прямо в Merge Request, как от живого коллеги.

Сейчас это реальность. AI Review уже умеет работать в GitLab, GitHub, через Docker, PyPI и просто как CLI — без ограничений по стеку или языку. Вы сами решаете, какой LLM использовать, какие промпты задать, и как строго он должен оценивать код. Хочется “жёсткого ревьюера” — включаете строгие системные промпты. Нужно просто быстрое sanity-check ревью — выбираете summary-режим. Всё полностью на вашей стороне.

Главное — это инструмент, а не сервис. Он не тянет ваши данные в облако, не требует регистрации и не блокирует пайплайн. Запустили — получили результат — пошли дальше.

Полезные ссылки

Чтобы не искать вручную, вот всё, что может пригодиться:

• Репозиторий проекта: github.com/Nikita-Filonov/ai-review

• Документация и конфиги: github.com/Nikita-Filonov/ai-review/tree/main/docs

• Пример ревью на GitHub (inline mode): pull #4

• Пример ревью на GitLab (context mode): merge request #3

• Docker Hub образ: nikitafilonov/ai-review

• PyPI пакет: xai-review

Финальные мысли

Если вы уже пробовали что-то подобное — напишите, какие инструменты использовали. Мне действительно интересно, есть ли на рынке что-то похожее: stack-agnostic, open-source и без SaaS-прокси. А если попробуете AI Review, расскажите, как оно у вас зашло — особенно интересно, какие промпты и режимы вы выбрали.