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

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

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

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

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

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

А потом был день, о котором я, собственно, и рассказываю.

За три месяца до этого

Небольшое отступление, чтобы было понятно, с каким настроением я в тот день садился за очередную попытку.

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

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

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

Так что в тот день я не ждал ничего особенного. Просто решил ещё раз попробовать — на задаче, до которой всё равно ни у кого не доходили руки. В целом настроение можно описать как недоверие.

Что я поставил на вход

Сел за VS Code, подключил Claude Code. Дальше:

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

Всё. Никаких памяток на десять страниц, никаких описаний метаданных, никаких инструкций «какие процедуры общих модулей правильно использовать». После нескольких месяцев написания таких памяток я на них, честно говоря, подзабил.

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

Дальше я просто оставил нейронку работать и занялся другими делами.

Через полтора часа я вернулся в окно редактора

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

Первая строка: задача выполнена, сделано следующее. И дальше списком:

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

И финальная фраза: заходите, проверяйте, всё ли правильно.

Сказать, что я афигел, когда всё это прочитал, — это ничего не сказать. Я ждал план на бумаге, а получил сделанную работу с отчётом о самопроверке.

Дальше была проверка руками. Я открыл расширение, прочитал код, посмотрел формы, прогнал несколько сценариев сам. Почти идеально. Нашлись пара мест, где я, опираясь на двадцать пять лет разработки, сделал бы проще — но это именно «сделал бы проще», а не «сделал бы правильно».

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

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

«Нас теперь всех уволят?»

Я показал результат в нашем рабочем чате.

Дальше происходило интересное. Сверху в статусной строке загорелось: печатает один разработчик. Погасло. Загорелось снова — печатает второй. Погасло. Потом печатали двое сразу, потом трое. И всё молча, ни одного сообщения. Люди набирали текст, читали, что получилось, и стирали.

Так продолжалось минуты полторы. Наконец кто-то дожал и отправил. Первое сообщение, которое вышло в чат в тот день, было такое:

— Нас теперь всех уволят?

Это было очень смешно :)) Конечно, никого не уволили. Но команда после этого стала относиться к нейронкам совсем иначе. И — что оказалось для меня самым неожиданным — писать в личку начали именно самые недоверчивые. Как настроить, с чего начать, как вообще с этим работать.

А расширение, с которого всё началось, до сих пор стоит в нашей рабочей бухгалтерии и успешно работает без сбоев. В неизменном виде. Ни одной правки за всё время.

Теперь главное: почему это сработало

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

Итак. Несколько месяцев до этого у меня не получалось то, чего я хотел. В тот день получилось с первого захода. Что изменилось?

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

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

Условие первое: было что читать

Исходники личного кабинета лежали у меня на диске. Я не рассказывал, как устроен биллинг, — я показал папку. А конфигурация бухгалтерии лежала рядом выгрузкой в файлы, и по ней был поиск.

Разница тут принципиальная. Когда несколькими месяцами раньше я просил доработать проведение документа, я фактически говорил: «догадайся, что у меня в конфигурации, и напиши код». Догадаться о таком нельзя, а спросить было не у кого — и модель заполняла пробел сама. То есть выдумывала. Причём выдумывала убедительно: имена правильные, параметры логичные, только процедуры такой в конфигурации нет.

Здесь догадываться было не о чем. Есть файлы — читай, сколько нужно, столько и читай. Не «вспомни, как устроены такие системы вообще», а «посмотри, как устроена вот эта».

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

Условие второе: было где проверить

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

А дело тут вот в чём. Главная беда, из-за которой раньше и не получалось, — не в том, что модель чего-то не знает. С «не знаю» жить можно. Плохо то, что она не отличает «я знаю» от «я не знаю» и выдаёт второе с той же уверенностью, что и первое. Выдумка выглядит ровно как знание, и заметна она только тогда, когда вы полезли проверять.

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

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

Условие третье: было чем перевести задачу на язык модели

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

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

• поиск смыслом, а не по имени файла: спросить «где считается себестоимость» и получить нужные модули, даже если слова «себестоимость» в них нет;
• граф связей конфигурации: что откуда вызывается, кто на что ссылается, что сломается, если тронуть вот это;
• справка по платформе под рукой у модели — чтобы синтаксис и параметры она брала из справки, а не из памяти;
• проверка кода сразу после написания, до того как код попадает мне на глаза.

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

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

Формула, которую я оттуда унёс

Если совсем коротко:

Нейросеть сильна там, где может читать и проверять. Слаба там, где должна помнить.

Все мои неудачные попытки укладываются в эту фразу без остатка. Просил помнить конфигурацию — получал выдумку. Дал прочитать и прогнать — получил работающий код.

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

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

Что из этого можно взять себе

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

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

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

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

А чтобы проходил не человек, нужны инструменты, которые сами добывают для нейронки нужное: сведения о конфигурации и её объектах, тексты процедур, связи между ними. Причём в нужный момент и в нужном месте работы — не всё сразу и заранее, а ровно то, что требуется на текущем шаге.

Чем такое делают

Тут стоит сказать, чем именно я это делал. Единого инструмента, который «делает вот так», не существует, и выбор зависит от того, что у вас за задача и что за база. Варианты сейчас такие.

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

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

Пока ещё бесплатный официальный инструмент платформы. 1С:Напарник. С типовыми задачами и небольшими обработками справляется хорошо, работает в 1C:EDT из коробки, и для многих это лучший первый шаг: не надо ничего собирать самому.

Платные инструменты, наборы MCP-серверов. MCP (Model Context Protocol) — общий способ подключать к нейросети внешние источники данных и инструменты; набор таких служб и есть то, чем модель дотягивается до вашей базы. Наборов несколько, различаются они тем, что именно умеют видеть в вашей конфигурации. Общее у них одно: смотреть надо не на список возможностей, а на то, отвечают ли они на вопросы именно по вашей конфигурации — той, что с доработками трёх предыдущих команд.

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

Сколько это заняло

Полтора часа работы нейронки — это то, что я видел по часам.

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

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

Чего я не измерял

Это один случай, а не эксперимент. Я не повторял ту же задачу несколько раз, не сравнивал разные модели между собой, не пробовал, что будет, если убрать одно из трёх условий и оставить два. Всё, что написано выше про три условия, — разбор задним числом, а не проверенная гипотеза. Возможно, там сыграло что-то ещё, чего я не заметил.

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

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

И самое важное. Я тогда решил, что нашёл рецепт: даёшь что читать, даёшь где проверить, даёшь чем дотянуться до конфигурации — получаешь результат. Рецепт я понёс команде.

Что было дальше

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

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

Но об этом — в следующем рассказе.

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

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