3,583 papers
arXiv:2608.02420 74 3 авг. 2026 г. FREE

Chat-Debugging Protocol: как вести LLM через диагностику сложной проблемы, чтобы она не путалась

КЛЮЧЕВАЯ СУТЬ
Студент спросил модель про GP15 — имел в виду пин для светодиода. Модель решила, что речь про питание, и ответила неправильно. Chat-Debugging позволяет вести LLM через сложную диагностику без потери деталей на длинной дистанции. Метод режет контекст на порции, просит сразу несколько гипотез вместо одной и проверяет их по очереди. Фишка — не сваливать всё сразу, а гонять модель через шаги и поправлять, если она сбилась.
Адаптировать под запрос

TL;DR

Chat-Debugging — это протокол общения с LLM при диагностике сложной проблемы с несколькими возможными причинами: контекст даётся порциями, модель просят предложить несколько гипотез причины (не одну), каждая гипотеза проверяется тестом по очереди, а пользователь регулярно напоминает модели забытые детали.

Главная находка исследования: в длинном диалоге модель начинает терять нить — путает, какая деталь к чему относится. В примере из статьи студент спросил "можно использовать GP15?", имея в виду пин для светодиода, а модель решила, что речь про питание, и ответила неправильно. Причина простая — модель держит "в голове" весь предыдущий текст диалога, и чем он длиннее и сложнее, тем легче ей перепутать детали.

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

🔬

Схема метода

ШАГ 1: Опиши систему по частям (не всё сразу) → модель объясняет, как должно работать
ШАГ 2: Попроси тест-план → модель даёт пошаговую проверку
ШАГ 3: Сообщи результат теста → модель предлагает НЕСКОЛЬКО гипотез причины, от вероятной к менее вероятной
ШАГ 4: Проверяй гипотезы по одной, докладывай результат → модель сужает круг или меняет гипотезу
ШАГ 5: Нашли причину → попроси финальный тест, чтобы подтвердить фикс

Все шаги — в одном диалоге, но каждый шаг = отдельное сообщение с новой порцией информации, а не один длинный промпт.


🚀

Пример применения

Задача: Запустили рекламу в Яндекс.Директ неделю назад. Показы и клики есть, заявок — ноль. Непонятно, в чём проблема: реклама, посадочная страница или форма.

Промпт:

У меня проблема: рекламная кампания в Яндекс.Директ работает неделю.
Показов 5000, кликов 120, заявок 0.

Контекст: нишу — [ремонт квартир], посадочная страница — [квиз-лендинг],
бюджет — [15000 руб/неделю], гео — [Москва].

Помоги разобраться:
1. Кратко объясни, что должно происходить на каждом этапе (показ → клик → заявка).
2. Предложи несколько возможных причин, почему заявок нет — от самой
   вероятной к менее вероятной. Для каждой причины дай способ проверки.

Жди мои результаты теста перед следующим шагом, не сваливай всё в один ответ.

Результат: модель распишет путь клиента (показ-клик-заявка), затем даст список гипотез — например, "форма не грузится на мобильных", "нет чёткого призыва к действию", "аудитория не целевая" — с конкретным способом проверить каждую. После того как пользователь протестирует и отпишется по одной гипотезе, модель сузит круг или предложит следующую. Диалог растянется на несколько сообщений, а не решится одним ответом.


🧠

Почему это работает

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

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

Протокол использует эту силу (много гипотез сразу), но компенсирует слабость (забывание контекста) простым правилом — давать информацию порциями и не бояться поправлять модель, когда она путает детали. Это не техническая хитрость, а дисциплина общения.

Рычаги управления: - Число гипотез за раз → попроси "дай 5 вариантов" вместо одного, если хочешь шире охватить проблему - Частота напоминаний контекста → если диалог длинный, раз в 5-7 сообщений скажи "напомню: у нас вот такие условия..." - Порядок гипотез → попроси сортировать "от простого теста к сложному", если хочешь экономить время на проверках


📋

Шаблон промпта

У меня проблема: {краткое описание системы или ситуации}.
Симптом: {что не работает так, как должно}.

Контекст (дам по частям, если сложно):
{деталь 1}
{деталь 2}

Помоги мне разобраться:
1. Кратко объясни, как это должно работать в норме.
2. Предложи тест, чтобы проверить, работает ли как ожидается.

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

Подставляй: {краткое описание системы} — что за процесс/устройство/проект, {симптом} — что конкретно не работает, {деталь} — параметры, которые важны для диагностики (давай их порциями, а не всё сразу).

🚀 Быстрый старт — вставь в чат:

Вот шаблон Chat-Debugging протокола. Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы, чтобы заполнить поля.

[вставить шаблон выше]

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


⚠️

Ограничения

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

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

⚠️ Малая выборка: выводы построены на кейсе одного студента и нескольких его диалогах. Это не статистика, а качественное наблюдение — паттерн вероятный, но не доказанный на широкой аудитории.


🔍

Как исследовали

Исследователи взяли одного студента-электрика четвёртого курса (под псевдонимом Дэниел) и попросили поделиться логами его переписки с GPT-4o во время реальных учебных проектов — три диалога: чисто софтверный баг, связка железа с кодом, и чисто "железный" дебаг светодиодной схемы. Два исследователя независимо разбирали логи и интервью с Дэниелом методом постоянного сравнения (constant comparative analysis) — по сути, искали повторяющиеся темы вручную, без автоматической разметки.

Сравнение трёх диалогов показало разницу: софтверный баг чинился за один обмен сообщениями, а "железный" дебаг требовал многих итераций с гипотезами и тестами. Удивило исследователей то, что даже самые короткие и разговорные промпты типа "мне нужно подключить батарею на 11.1В к светодиоду" модель понимала корректно — кроме одного случая ("test LED"), когда контекста было слишком мало.

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


🔗

Ресурсы

Andrew Ash, John Hu — Oklahoma State University, School of Electrical and Computer Engineering. Исследование поддержано NSF Award EES-2321255.


📋 Дайджест исследования

Ключевая суть

Студент спросил модель про GP15 — имел в виду пин для светодиода. Модель решила, что речь про питание, и ответила неправильно. Chat-Debugging позволяет вести LLM через сложную диагностику без потери деталей на длинной дистанции. Метод режет контекст на порции, просит сразу несколько гипотез вместо одной и проверяет их по очереди. Фишка — не сваливать всё сразу, а гонять модель через шаги и поправлять, если она сбилась.

Принцип работы

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

Почему работает

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

Когда применять

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

Мини-рецепт

1. Опиши систему по частям: не вываливай всё сразу — дели на детали: что за устройство, какой симптом, какие параметры важны.
2. Попроси тест-план: пусть модель сама предложит, как проверить систему шаг за шагом.
3. Дай несколько гипотез: не жди одну причину — проси 3-5 вариантов от самого вероятного к менее вероятному.
4. Проверяй по одной: тестируй гипотезы по очереди, докладывай результат каждой.
5. Напоминай контекст: раз в 5-7 сообщений повторяй ключевые детали — модель забывает.

Примеры

[ПЛОХО] : У меня схема не работает, помоги найти проблему
[ХОРОШО] : Расскажу по частям. У меня Raspberry Pi Zero, светодиод подключен к GP15. Как должно работать питание этого пина? — затем в следующем сообщении: Диод не горит. Дай тест-план проверки — затем: Проверил, напряжение на пине 0V. Какие гипотезы причины?
Источник: WIP: Chat-Debugging: Large Language Model as a Hardware Debugging Assistant
ArXiv ID: 2608.02420 | Сгенерировано: 2026-08-04 06:39

Проблемы LLM

ПроблемаСутьКак обойти
Модель путает детали в длинном диалогеМодель держит весь текст переписки "в голове". Чем длиннее диалог и чем больше в нём разных фактов — тем легче ей перепутать, какая деталь к чему относится. Например, спросил про один параметр — модель привязывает ответ к другому, похожему по смыслу. Это происходит даже когда пользователь ничего не путал сам, просто диалог стал длиннымНе вываливай всю информацию сразу. Подавай контекст порциями, шаг за шагом. Раз в 5-7 сообщений коротко напоминай ключевые условия: "напомню, у нас вот такие параметры...". Если видишь, что модель сбилась — сразу поправь, не жди следующего шага

Методы

МетодСуть
Диагностика по шагам с несколькими гипотезамиВеди диагностику проблемы не одним промптом, а цепочкой сообщений: 1) опиши систему по частям, попроси объяснить как должно работать в норме, 2) попроси план теста, 3) сообщи результат теста, 4) попроси НЕСКОЛЬКО гипотез причины (не одну) — от вероятной к менее вероятной, с способом проверки каждой, 5) проверяй гипотезы по одной, докладывай результат, 6) после нахождения причины — финальный тест для подтверждения. Жди мои результаты теста перед следующим шагом, не сваливай всё в один ответ. Почему работает: модель хорошо умеет одновременно выдать много версий причины — шире, чем это делает человек, который часто застревает на первой идее. Но модель плохо держит длинный контекст без напоминаний. Метод берёт от неё сильную сторону (много гипотез), а слабую (забывание деталей) компенсирует дроблением информации и контролем пользователя на каждом шаге. Когда работает: сложная проблема с несколькими возможными причинами, есть возможность тестировать гипотезы по очереди. Когда не работает: нужен быстрый ответ за один промпт, простая задача с одной очевидной причиной — тогда пошаговость просто замедляет
📖 Простыми словами

WIP: Chat-Debugging:LargeLanguageModelas a Hardware Debugging Assistant

arXiv: 2608.02420

Суть Chat-Debugging в том, что LLM — это не всевидящее око, а скорее очень умный, но дико рассеянный стажер. Если вывалить на него всю проблему разом, он захлебнется в деталях и выдаст первое попавшееся решение, которое, скорее всего, будет пальцем в небо. Метод ломает привычный подход «вопрос-ответ» и превращает диагностику в пошаговый протокол, где модель заставляют не гадать, а системно перебирать варианты, не теряя нить разговора.

Это как если бы ты пришел к врачу с целым мешком анализов и жалоб, а он, вместо того чтобы бегло их просмотреть и выписать подорожник, заставил бы тебя доставать по одной бумажке. Сначала смотрим кровь, потом давление, потом рентген. При этом ты каждые пять минут бьешь его по рукам и напоминаешь: «Док, не забывай, у меня еще аллергия на цитрусовые». Так мозг нейронки не перегревается, и она не улетает в свои фантазии, а держится жесткой логики.

Вместо того чтобы просить «почини мне рекламу», ты скармливаешь данные порциями и требуешь несколько гипотез сразу. Например, модель должна выдать: «Вариант А — кривой лендинг, Вариант Б — не та аудитория, Вариант В — сдохла форма заявки». Дальше вы берете Вариант А и проверяете его до победного, пока гипотеза не подтвердится или не отвалится. Главная фишка здесь — регулярные напоминания: ты буквально впихиваешь в модель забытые детали, чтобы контекст не «поплыл» через десять сообщений.

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

Короче: хватит надеяться, что AI сам во всем разберется, если ты просто скинешь ему лог ошибок. Используй порционную подачу данных и заставляй модель генерировать список гипотез, а не один ответ. Если не будешь постоянно напоминать ей вводные данные, она начнет галлюцинировать и нести чушь. Системный перебор и контроль контекста — это единственный способ заставить LLM реально решать сложные задачи, а не просто красиво о них рассуждать.

Работа с исследованием

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

0 / 2000
~0.5-2 N-токенов ~10-30с
~0.3-1 N-токенов ~5-15с