Kilocode в VS Code (Windows) для C++: настройки, использование и трюки без установки

Обзор Kilocode и подготовка VS Code для работы с C++

В этом курсе мы используем VS Code на Windows как среду разработки для C++ и расширение Kilocode как помощника для работы с кодом (подсказки, генерация фрагментов, объяснения, рефакторинг). Фокус курса — настройки, использование и практические трюки, без установки отдельных “движков”, локальных моделей или дополнительных приложений.

Важно разделять две вещи:

Комфортная работа с C++ в редакторе (подсветка, автодополнение, переход к определению, ошибки в коде) — это настраивается в VS Code.

Сборка и запуск C++ программ требуют компилятора (MSVC/MinGW/Clang). В этом курсе мы можем настроить редактор и Kilocode без установки компилятора, а запуск кода — либо “если компилятор уже есть”, либо через онлайн-инструменты.

!Диаграмма, показывающая роли VS Code, расширения C/C++ и Kilocode, и опциональность компилятора для запуска

Что такое Kilocode в контексте VS Code

Kilocode — это расширение для VS Code, которое помогает работать с кодом и текстом прямо в редакторе. В задачах на C++ оно обычно полезно для:

генерации черновиков функций, классов, тестовых примеров;

объяснения чужого кода и ошибок компиляции (если вы их вставите);

предложений по улучшению читаемости и рефакторингу;

ускорения рутины: комментарии, документация, шаблоны.

При этом качество ответа Kilocode сильно зависит от того, какой контекст вы ему дали: структура проекта, заголовки, соглашения по стилю, ограничения по стандарту C++.

Минимальная подготовка VS Code на Windows

Проверьте версию VS Code

Обновлённый VS Code важен для корректной работы расширений и настроек.

Откройте меню Help → About и убедитесь, что версия не слишком старая.

Документация VS Code: Visual Studio Code Docs

Включите удобный режим настроек: UI и JSON

В VS Code есть два способа менять настройки:

через интерфейс (Settings UI) — удобно для поиска;

через файл settings.json — удобно для точности и переноса настроек.

Официально про настройки: User and Workspace Settings

Практика для курса:

Пользовательские настройки — то, что вам удобно везде (шрифт, темы).

Настройки рабочей папки (workspace) — то, что относится к конкретному проекту C++ (пути к заголовкам, стандарт языка, исключения файлов).

Используйте Profiles, чтобы не “сломать” свою основную среду

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

Сделайте отдельный профиль, например C++ + Kilocode (Course):

отдельный набор расширений;

отдельные настройки;

легко включать/выключать.

Документация: Profiles in Visual Studio Code

Подготовка VS Code именно для C++ (без обязательной установки компилятора)

Поставьте расширение C/C++ от Microsoft

Для C++ в VS Code базовый стандарт де-факто — расширение C/C++.

Страница расширения: C/C++ (ms-vscode.cpptools)

Что оно даёт:

IntelliSense (подсказки, типы, сигнатуры);

диагностику (подчёркивания, предупреждения);

навигацию по коду (Go to Definition, Find References).

Откройте проект правильно: “папка”, а не одиночный файл

Kilocode и C/C++ расширение заметно лучше работают, когда открыт проект как папка.

File → Open Folder...

Почему это важно:

VS Code понимает корень проекта;

настройки проекта можно хранить в .vscode/;

Kilocode проще давать контекст (несколько файлов, структура).

Настройте язык, стандарт и подсказки C++

Если вы создаёте файл .cpp, VS Code обычно сам определяет язык. Если нет:

в правом нижнем углу нажмите на текущий язык (например, Plain Text) → выберите C++.

Для IntelliSense часто достаточно базовой конфигурации. В проектах полезно явно зафиксировать стандарт C++.

Типовой подход:

Создайте/откройте настройки рабочей области .vscode/settings.json.

Добавьте то, что относится именно к проекту.

Пример минимальных настроек проекта:

Пояснения:

files.associations — заставляет VS Code воспринимать расширения файлов как C++.

C_Cpp.default.cppStandard — фиксирует стандарт (например, c++20).

C_Cpp.default.intelliSenseMode — режим подсказок. Даже если компилятора нет, этот режим помогает IntelliSense выбрать “модель” типов/платформы.

Где настраиваются include path и defines

Для проектов на C/C++ расширении часто появляется файл:

.vscode/c_cpp_properties.json

Он используется для:

includePath — где искать заголовочные файлы;

defines — какие макросы считать включёнными;

compilerPath — какой компилятор использовать (если он есть).

Даже если компилятора нет, includePath может быть полезен, чтобы IntelliSense видел ваши #include внутри проекта.

Подготовка Kilocode к работе с C++ проектом

Дайте Kilocode “правильный” контекст

Для задач по C++ Kilocode работает лучше, если:

проект открыт как папка (workspace);

в проекте есть понятная структура (например, src/, include/, tests/);

вы явно указываете ограничения: стандарт C++ (C++17/20), запрет исключений, требования к производительности.

Практический шаблон запроса для C++ (можно копировать и адаптировать):

Ограничьте “лишние” файлы в рабочей папке

Если в проекте есть большие папки (например, build/, out/, .cache/), они мешают поиску и могут ухудшать качество подсказок.

Удобная практика — исключать их из поиска:

Это не “магия Kilocode”, но напрямую улучшает рабочий процесс: меньше шума при поиске и навигации по проекту.

Если компилятора нет: как всё равно проверять идеи

Для курса можно работать с C++ как с кодовой базой (структура, качество, рефакторинг) и проверять компиляцию точечно.

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

использовать онлайн-компилятор для быстрых проверок фрагментов кода: Compiler Explorer

Если же компилятор уже установлен (например, MSVC как часть Visual Studio/Build Tools), позже мы настроим сборку через задачи VS Code и терминал.

Что должно получиться в конце подготовки

К концу этой статьи у вас должно быть:

VS Code, готовый к работе с C++ как редактор;

установленное расширение C/C++;

проект, открытый как папка;

базовые настройки проекта в .vscode/settings.json;

понимание, как давать Kilocode контекст и как “зачищать” лишние папки из поиска.

В следующей статье логично перейти к тому, как именно работать с Kilocode в повседневных сценариях C++: промпты, приёмы уточнения, работа с несколькими файлами и типовые ошибки контекста.

Базовые настройки Kilocode: аккаунт, модель, приватность, контекст

В прошлой статье мы подготовили VS Code для работы с C++ как с проектом (workspace), добавили базовые настройки и убрали «шумные» папки из поиска. Теперь настроим Kilocode так, чтобы он был полезен именно в C++-коде на Windows: подключение аккаунта, выбор модели, приватность и управление контекстом.

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

!Схема, показывающая что именно отправляется в запрос и чем вы управляете

Где находятся настройки Kilocode в VS Code

В VS Code настройки расширений настраиваются так же, как и общие настройки редактора.

Через интерфейс: File → Preferences → Settings, затем в поиске набрать Kilocode.

Через настройки расширения: Extensions → Kilocode → (иконка шестерёнки) → Extension Settings.

Через settings.json, если нужно переносить конфигурацию между проектами.

Полезная база по настройкам VS Code: User and Workspace Settings

User vs Workspace: что куда

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

| Что настраиваем | Где лучше хранить | Почему | |---|---|---| | Вход в аккаунт, ключи, общие предпочтения | User settings | Это относится к вам, а не к конкретному проекту | | Ограничение контекста, исключения папок, «что можно читать» | Workspace settings | В разных проектах разные требования к приватности и структуре | | Системные правила для всей команды | Workspace (в репозитории) | Чтобы у всех были одинаковые ограничения |

Аккаунт и способ подключения

Kilocode в большинстве сценариев работает через облачный сервис (или подключаемого провайдера). Это и есть ключевой момент «без установки»: вы не поднимаете локальные модели и не ставите отдельные движки.

Обычно встречаются два подхода подключения:

Вход через аккаунт в самом расширении.

API-ключ (или токен) провайдера, который вы вставляете в настройки.

Чтобы не «искать по меню», используйте палитру команд:

Откройте Command Palette: Ctrl+Shift+P.

Начните вводить Kilocode.

Выберите команду входа или управления аккаунтом (название зависит от версии расширения).

Практика безопасности для ключей

Храните ключи в User settings, а не в .vscode/settings.json проекта.

Не коммитьте секреты в репозиторий.

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

Выбор модели: качество, скорость и «стоимость ошибки»

В Kilocode, как правило, можно выбрать модель (или «режим») для разных задач. Даже если названия отличаются, логика выбора почти всегда одинаковая.

Как выбрать модель под C++

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

Для анализа архитектуры, сложных шаблонов, UB и тонкостей стандарта лучше более сильная модель.

Удобный принцип:

Чем выше цена ошибки, тем «умнее» модель.

Чем больше контекста (много файлов, сложные зависимости), тем заметнее разница в качестве.

Рекомендация по рабочим режимам

Режим быстро: форматирование комментариев, генерация простых функций, идеи тестов.

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

Если в настройках есть переключатель вроде «использовать модель X для чата» и «модель Y для автодополнения», фиксируйте это явно: так поведение становится стабильнее.

Приватность: что может попасть в запрос и как это контролировать

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

Перед настройкой приватности полезно ответить себе на вопрос:

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

Что потенциально может быть отправлено

В зависимости от режима и возможностей расширения, в запрос могут попасть:

выделенный текст;

активный файл целиком или частично;

другие файлы, которые вы добавили в контекст;

ошибки/диагностика (например, сообщения IntelliSense), если вы их вставили;

структура проекта (список файлов), если расширение умеет искать релевантные фрагменты.

Workspace Trust как «предохранитель»

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

Документация: Workspace Trust

Практика:

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

Для учебных папок можно включить доверие, чтобы Kilocode и C++-инструменты читали файлы без лишних блокировок.

Минимизируем «лишние» данные в проекте

Даже если расширение не отправляет «всё подряд», вам выгодно уменьшить шум, чтобы вы сами случайно не добавили в контекст лишнее.

В настройках workspace используйте исключения для папок сборки и артефактов:

Смысл:

меньше мусора в результатах поиска;

проще выбирать релевантные файлы для контекста;

ниже риск отправить случайные большие логи или бинарные файлы.

Контекст: как «кормить» Kilocode так, чтобы он помогал в C++

Kilocode редко «угадывает» архитектуру C++ проекта без подсказок. Ваша задача — давать контекст дозированно.

Базовая единица контекста

Самый надёжный контекст для задач по C++ — это:

текущий файл .cpp и соответствующий заголовок .h/.hpp;

минимально необходимая часть API (пара классов, сигнатуры, важные #include);

ограничения: стандарт C++ и платформа.

Почему «слишком много контекста» вредно

Модель начинает путаться в версиях одного и того же (несколько реализаций похожих функций).

Растёт шанс, что ответ станет общим и расплывчатым.

Вам сложнее контролировать, что именно было использовано.

Практический алгоритм для C++ задач

Начните с выделения проблемного куска кода.

Добавьте сигнатуры и контракты: что на вход, что на выход, какие инварианты.

Если ответ «не попал», добавьте один связанный файл (например, заголовок).

Только если нужно, добавляйте следующие файлы: реализация, структуры данных, тест.

Шаблон «контекстного» запроса (копируйте)

Смысл каждого пункта:

стандарт и компилятор уменьшают «фантазии» про недоступные возможности;

«без сторонних библиотек» не даст увести решение в Boost или другие зависимости;

«патч» (а не «просто объяснение») дисциплинирует ответ.

Настройки, которые стоит проверить сразу

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

Модель по умолчанию для чата и/или генерации.

Автоматическое добавление контекста: отключите, если работаете с конфиденциальным кодом.

Подтверждение перед отправкой: включите, если хотите видеть «что уйдёт».

Телеметрия: если есть — отключите или настройте по политике компании.

Телеметрия VS Code настраивается отдельно, если вам важно ограничить сбор данных редактором: Visual Studio Code FAQ: Telemetry

Мини-чеклист перед работой в новом C++ проекте

Проект открыт как папка (workspace).

Папки build/out/.cache исключены из поиска.

Вы выбрали модель под задачу (быстро или глубоко).

Вы понимаете, какой контекст будет отправлен (выделение, файл, добавленные файлы).

Workspace Trust выставлен осознанно.

В следующей статье логично перейти к ежедневным сценариям: как просить Kilocode писать безопасные заготовки под C++ (классы, RAII, тестовые примеры), как получать ответы в формате патчей и как избегать типовых ошибок контекста.

Ежедневные сценарии: генерация кода, рефакторинг, объяснение и навигация

В предыдущих статьях мы:

подготовили VS Code на Windows для комфортной работы с C++ как с проектом (workspace);

настроили Kilocode: аккаунт, выбор модели, приватность и управление контекстом.

Теперь соберём это в практику: что именно делать каждый день, чтобы Kilocode ускорял работу с C++ в VS Code без установки дополнительных движков. Фокус — на предсказуемых сценариях, где вы контролируете контекст и получаете результат в удобном для применения виде.

!Цикл ежедневной работы: запрос → патч → проверка → применение

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

Если формулировать запросы абстрактно, вы получите абстрактный ответ. Для повседневной разработки по C++ полезно заранее задавать формат результата.

Самые удобные форматы:

Патч: попросите “покажи итоговые изменения как diff” или “дай изменённые файлы целиком”.

Чёткие ограничения: стандарт C++ (например, C++20), компилятор-совместимость (MSVC), запрет сторонних библиотек.

Минимальный контекст: только нужные файлы/фрагменты, а не весь проект.

Шаблон, который почти всегда работает:

Сценарий: генерация кода под ваш проект

Генерация полезна, когда вам нужен скелет (заготовка), который вы затем доведёте до требований проекта.

Генерация функции по контракту

Вместо “напиши функцию” задайте контракт:

что на вход;

что на выход;

что считать ошибкой;

какие ограничения по стилю и зависимостям.

Пример запроса:

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

std::optional явно задаёт модель ошибки без исключений.

std::string_view снижает лишние копирования.

примеры вызова сразу помогают увидеть спорные случаи.

Генерация пары .hpp + .cpp без “магии”

Если вы просите класс, сразу фиксируйте границы ответственности и структуру файлов.

Пример запроса:

Практический трюк: если у вас в проекте приняты префиксы неймспейсов, стиль именования и формат комментариев, добавьте это одной строкой. Иначе Kilocode выберет “средний по больнице” стиль.

Генерация “безопасных” заготовок для ресурсов

В C++ часто важна корректная работа с ресурсами (файлы, память, блокировки). Это удобно просить как заготовку, но обязательно фиксировать правила.

Требование формулируйте так:

“без сырых new/delete”;

“использовать RAII” (это подход, когда ресурс захватывается в конструкторе и освобождается в деструкторе);

“без глобальных переменных”.

Сценарий: рефакторинг без потери контроля

Рефакторинг — это изменение структуры кода без изменения поведения. Kilocode может ускорить его, но вы должны управлять риском.

Протокол безопасного рефакторинга

Сформулируйте цель (например, “уменьшить дублирование”, “упростить чтение”, “убрать потенциальную ошибку”).

Дайте минимальный контекст:

- текущий .cpp и связанный .hpp; - 1-2 места использования (call sites), если меняется интерфейс.

Попросите план, а затем патч.

Применяйте изменения небольшими порциями.

Пример запроса:

Типовые рефакторинги, которые удобно делегировать

извлечение функции из длинного метода;

переименование переменных и функций под понятные имена;

замена “магических чисел” на constexpr константы;

упрощение вложенных if (ранние возвраты return);

локализация области видимости переменных (объявлять ближе к месту использования).

Трюк: просите минимальный патч

Если вы не хотите, чтобы ответ “переписал всё”, укажите ограничение:

Это резко повышает применимость результата в реальном репозитории.

Сценарий: объяснение кода и поиск причин ошибок

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

Просите объяснение в “правильном виде”

Вместо “объясни код” лучше:

объяснение по шагам;

входы/выходы;

инварианты (что должно быть истинно всегда);

потенциальные ошибки (например, выход за границы, использование неинициализированных значений).

Пример запроса:

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

Разбор ошибки по диагностике из VS Code

Если у вас нет локального компилятора, но есть сообщения от IntelliSense (или вы вставили текст ошибки из CI/коллеги), Kilocode можно использовать как “переводчик” диагностики.

Полезный формат запроса:

Практический трюк: вставляйте ошибку целиком вместе со строкой/файлом, а затем добавляйте 10-30 строк кода вокруг указанного места.

Сценарий: навигация по проекту вместе с VS Code

Важно: навигацию по символам (переход к определению, поиск ссылок) обычно лучше делает сам VS Code с расширением C/C++ от Microsoft, а Kilocode дополняет это “смыслом”: где искать, что важно, какие зависимости подозрительны.

Справочные ссылки по навигации в VS Code:

Навигация по коду в Visual Studio Code

Расширение C/C++ (Microsoft) в Marketplace

Горячие приёмы навигации (без Kilocode)

F12 — перейти к определению.

Shift+F12 — найти все использования.

Ctrl+P — быстрый переход к файлу.

Ctrl+Shift+F — поиск по проекту.

Как подключать Kilocode к навигации

Удобные запросы “поверх” возможностей редактора:

“Подскажи, где в проекте логичнее искать реализацию этой функции, если есть только заголовок”.

“Составь список ключевых мест, которые нужно посмотреть, чтобы понять, откуда приходит это значение”.

“Предложи запросы для поиска по проекту” (по именам, макросам, строкам логов).

Пример:

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

Управление контекстом в ежедневной работе

Качество ответов зависит не от “количества текста”, а от релевантности.

Правило на каждый день:

сначала выделите конкретный фрагмент;

затем добавьте только то, без чего нельзя понять задачу (сигнатуры, структуры данных, 1-2 места использования);

только потом расширяйте контекст.

Если вы заметили, что Kilocode “угадывает” слишком много деталей (например, придумывает отсутствующие типы), возвращайте его в рамки:

Мини-чеклист “перед отправкой запроса”

Указан стандарт C++ и ограничения.

Понятна цель: генерация, рефакторинг, объяснение или поиск.

Контекст минимальный, но достаточный.

Запрошен удобный формат результата: патч/diff или файлы целиком.

Есть ограничение на масштаб изменений, если это важно.

В следующем материале курса обычно логично углубляться в “трюки”: как добиваться стабильных патчей, как просить альтернативы и сравнение решений, и как оформлять запросы так, чтобы Kilocode меньше ошибался на C++-деталях.

Работа с C++-контекстом: CMake, include-пути, стандарты и сборка

В прошлых статьях мы настроили VS Code на Windows для C++ как редактор и научились управлять контекстом Kilocode: что показывать, что скрывать и как просить ответы в формате патча. Теперь добавим недостающий слой, который делает подсказки и анализ кода точными: корректные include-пути, макросы, стандарт C++ и понимание того, как проект реально собирается.

Важно: курс про Kilocode и работу в VS Code без установки дополнительных движков и локальных моделей. Но C++-проект всё равно может использовать систему сборки. Мы разберём настройки так, чтобы:

IntelliSense работал даже если вы не собираете проект локально

при наличии CMake и компилятора вы могли быстро включить сборку и отладку

Kilocode получал правильный контекст и не предлагал несуществующие #include и возможности языка

!Как связаны CMake, compile_commands.json, IntelliSense и Kilocode

Что такое контекст сборки и почему он важен для Kilocode

В C++ один и тот же файл может компилироваться по-разному в зависимости от:

путей поиска заголовков #include

макросов #define и флагов компилятора

выбранного стандарта -std=c++20 или аналога в MSVC

конфигурации сборки: Debug или Release

VS Code с расширением Microsoft C/C++ (IntelliSense) пытается понять это, чтобы:

правильно находить заголовки

корректно подсвечивать ошибки и типы

показывать навигацию по символам

А Kilocode поверх этого выигрывает потому, что вы можете давать ему более точные требования, например:

мы собираем через CMake, C++20, без исключений

у нас есть макрос WIN32_LEAN_AND_MEAN и NOMINMAX

публичные заголовки лежат в include/

Если вы не настроили include-пути и стандарт, Kilocode часто будет вынужден угадывать окружение, а вы будете тратить время на правки.

Термины, которые нужны дальше

Include-путь: список папок, где компилятор и IntelliSense ищут заголовки для #include <...> и #include "...".

Defines (макросы): имена, которые считаются определёнными при компиляции, например UNICODE, NDEBUG.

Стандарт C++: версия языка, например C++17 или C++20, которая влияет на доступные возможности библиотеки и синтаксиса.

CMake: инструмент, который описывает сборку проекта в файле CMakeLists.txt и генерирует проект/команды сборки для выбранного компилятора.

compile_commands.json: файл с точными командами компиляции для каждого .cpp (пути, флаги, defines). Это лучший источник правды для IntelliSense.

Ссылки на основы:

CMake: документация

Расширение Microsoft C/C++ для VS Code

Как IntelliSense в VS Code получает include-пути и defines

Есть три основных подхода. Выбирайте по ситуации.

Подход для небольших проектов: c_cpp_properties.json

Это ручная конфигурация IntelliSense.

Откройте палитру команд Ctrl+Shift+P.

Выполните команду C/C++: Edit Configurations (UI).

Проверьте поля:

Include path

Defines

C++ standard

IntelliSense mode

VS Code сохранит это в .vscode/c_cpp_properties.json.

Пример минимальной конфигурации (адаптируйте пути под ваш проект):

Когда это удобно:

учебные и маленькие проекты

быстрый старт без CMake

код, который собирается простыми командами

Ограничение: если сборка сложная, ручное поддержание includePath и defines становится источником ошибок.

Подход для CMake-проектов: провайдер конфигурации от CMake Tools

Если проект использует CMake, лучше не дублировать настройки вручную, а позволить CMake Tools передавать конфигурацию в C/C++ расширение.

CMake Tools для VS Code

Практический смысл:

CMake Tools знает, какие include-пути и макросы реально используются

IntelliSense становится ближе к реальной компиляции

Kilocode проще просить о правках, не ломая сборку

Подход источник правды: compile_commands.json

Если у вас есть compile_commands.json, IntelliSense обычно работает максимально точно, потому что файл содержит фактические команды компиляции.

В CMake этот файл можно включить настройкой:

Что важно понимать:

этот файл обычно появляется в каталоге сборки (например, build/)

его генерирует CMake после конфигурации проекта

Если вы не хотите собирать проект локально, но хотите точный контекст, вы можете:

получить compile_commands.json из CI

попросить коллегу с настроенной сборкой

сгенерировать его один раз на машине, где CMake уже есть

Настройка стандарта C++ так, чтобы не было сюрпризов

Стандарт C++ влияет на два слоя:

IntelliSense в VS Code (подсказки и диагностика)

реальная сборка (CMake/компилятор)

Чтобы не было расхождений, фиксируйте стандарт в обоих местах.

Стандарт для IntelliSense в settings.json

В workspace-настройках .vscode/settings.json задайте стандарт по умолчанию:

Это помогает даже когда нет настроенного CMake.

Справка по настройкам C/C++ расширения:

Документация расширения C/C++ (Microsoft)

Стандарт в CMakeLists.txt

В CMake стандарт задавайте так, чтобы он применялся к целям:

Расшифровка:

CXX_STANDARD 20 означает C++20

CXX_STANDARD_REQUIRED YES запрещает «тихо» откатиться на более старый стандарт

CXX_EXTENSIONS NO отключает нестандартные расширения компилятора там, где это возможно

Include-пути в CMake: правильный способ для проектов с include/

Частая структура C++ проекта:

include/ для публичных заголовков

src/ для реализации

В CMake не принято добавлять include-пути глобально. Вместо этого добавляйте их целям:

Почему это важно:

меньше случайных зависимостей

проще поддерживать несколько библиотек/исполняемых файлов

IntelliSense через CMake Tools получает те же пути

Сборка в VS Code на Windows: что можно сделать без усложнений

Сборка C++ всё равно требует компилятора. В рамках курса это опционально: Kilocode, контекст и работа с кодом полезны и без сборки. Но если компилятор и CMake уже есть, VS Code можно настроить так, чтобы сборка была в один-два клика.

Вариант для CMake: расширение CMake Tools

Типичный поток работы:

Откройте проект как папку.

Установите CMake Tools.

Выберите kit или компилятор, если расширение спросит.

Выполните конфигурацию.

Соберите цель.

Для справки:

CMake Tools: документация

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

Вариант без CMake: задачи VS Code tasks.json

Если вы собираете проект одной командой, можно добавить задачу. Это не требует CMake, но требует наличия компилятора в системе.

Документация VS Code по задачам:

Tasks в VS Code

Пример каркаса tasks.json (команду компилятора подставьте под своё окружение):

Трюки для Kilocode: как использовать CMake-контекст и не утонуть в файлах

Сборочный контекст полезно явно сообщать Kilocode, иначе он будет предлагать решения, которые конфликтуют с вашим проектом.

Минимальный контекст для задач по сборке и include

Перед тем как просить Kilocode исправить ошибки включения заголовков или “не видит символ”, добавляйте:

содержимое CMakeLists.txt (или relevant-фрагмент)

структуру папок include/ и src/

пример строки #include, которая не находится

выбранный стандарт C++

Пример запроса:

Не давайте в контекст каталоги сборки

Каталоги вроде build/, out/, .cache/ часто содержат тысячи файлов, которые не помогают пониманию исходников.

В workspace-настройках оставляйте исключения, которые мы ввели ранее:

Это упрощает и навигацию, и ручной выбор файлов для контекста.

Просите Kilocode учитывать публичный API

Если у вас есть include/ как публичные заголовки, прямо скажите это в запросе. Тогда Kilocode реже будет предлагать включать приватные заголовки из src/.

Формулировка, которую удобно повторять:

Публичные заголовки доступны только из include/. Заголовки из src/ считать приватными.

Чеклист: правильный C++-контекст в VS Code для точных подсказок

В VS Code задан стандарт C++ в .vscode/settings.json или c_cpp_properties.json.

Include-пути и defines получаются либо из c_cpp_properties.json, либо из CMake Tools, либо из compile_commands.json.

В CMake стандарт и include-директории задаются на уровне целей.

Каталоги сборки исключены из поиска.

В запросах к Kilocode вы явно указываете: стандарт, систему сборки, структуру include/src и просите патч.

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

Промпты и шаблоны: как получать точные ответы для C++

В предыдущих статьях мы настроили VS Code на Windows для C++ (IntelliSense, workspace, исключения папок), подключили и настроили Kilocode (аккаунт, модель, приватность, контекст), а также разобрали, как CMake/include-пути/стандарт языка влияют на точность подсказок. Теперь соберём это в практику: как писать промпты так, чтобы ответы были точными, применимыми и предсказуемыми.

Цель статьи: дать вам набор шаблонов, которые вы сможете копировать в Kilocode, меняя только детали проекта.

!Схема показывает, почему хороший промпт делает ответ применимым (патч, риски, тесты), а не абстрактным.

Принцип точности: не просите ответ, просите результат

Для C++ особенно важно не оставлять Kilocode пространство для догадок: язык строгий, контекст сборки влияет на видимость заголовков и макросов, а ошибки могут быть скрытыми (например, неопределённое поведение).

Рабочая формула точного запроса:

Контекст: что за проект, какие файлы релевантны.

Цель: что именно нужно получить (фикс, рефакторинг, объяснение).

Ограничения: стандарт C++, платформа, компиляторная совместимость, запреты.

Формат вывода: diff/патч, список шагов, список рисков.

Критерии приемки: что считается правильным решением.

Если вы используете этот каркас постоянно, ответы становятся стабильнее даже при смене проекта.

Базовый каркас промпта для C++

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

Пояснения к пунктам:

Роль помогает удерживать стиль ответа: не «эссе», а инженерный результат.

Совместимость: MSVC полезна, потому что некоторые решения зависят от компилятора и платформы.

Не придумывай — это защита от «галлюцинаций», когда помощник создаёт несуществующие сущности.

Как правильно задавать ограничения

Ограничения — это не формальность. В C++ они напрямую определяют корректность решения.

Стандарт языка

Пишите явно: C++17 или C++20. Это влияет на:

наличие std::span, std::format и других возможностей библиотеки;

допустимый синтаксис (например, concepts в C++20);

стиль решений (например, можно ли использовать std::string_view).

Справочник по стандартной библиотеке и типам: cppreference.com.

Исключения, RTTI, зависимости

Если в проекте запрещены исключения или RTTI (это механизм информации о типах во время выполнения), фиксируйте это одной строкой:

исключения: запрещены (тогда просите возвращать std::optional, std::expected или коды ошибок — в зависимости от вашей политики)

RTTI: запрещено

без сторонних библиотек

Производительность и память

Если важно «без лишних аллокаций», пишите критерий приемки:

критерий: не делать динамических выделений памяти в горячем пути

Даже без профилирования это дисциплинирует предлагаемый дизайн.

Формат вывода: требуйте то, что можно применить

Для работы в VS Code самый практичный формат — патч.

Просите diff, если хотите быстро применить изменения вручную.

Просите «полные файлы», если изменения большие, но ограничены 1–2 файлами.

Шаблон фразы:

Почему это важно:

уменьшается вероятность «переписать полпроекта»;

проще ревьюить изменения;

проще откатить.

Трюк против ошибок контекста: сначала вопросы, потом патч

Если задача зависит от скрытого контекста (CMake, макросы, структуры данных), полезно принудить Kilocode спросить недостающее.

Это особенно полезно, когда:

код использует платформенные макросы Windows;

проект собирается разными конфигурациями (Debug/Release);

разные .cpp компилируются с разными defines.

Шаблоны под типовые C++ задачи

Ниже набор практических шаблонов. В каждом шаблоне предусмотрены ограничения и формат результата.

Шаблон для генерации функции по контракту

Трюк: формулировка «список крайних случаев» часто выявляет, где помощник пропустил важные проверки.

Шаблон для рефакторинга без изменения поведения

Трюк: «план → патч» часто даёт более аккуратные изменения, чем просьба «сразу перепиши».

Шаблон для поиска UB и опасных мест

UB (неопределённое поведение) — это ситуация, когда стандарт C++ не гарантирует, что программа будет работать одинаково на разных сборках.

Шаблон для объяснения чужого кода (быстрое погружение)

Шаблон для ошибок include и CMake контекста

Это связывает материал предыдущей статьи про include-пути и CMake.

Документация по CMake: CMake Documentation.

Трюки «точность и контроль» для повседневного использования

Просите альтернативы и сравнение только когда это оправдано

Если попросить «дай 5 вариантов», ответ часто становится расплывчатым. Лучше так:

Дай 2 варианта и сравни: сложность, риск, читабельность.

Привязывайте решения к вашему стилю

Одна строка про стиль обычно достаточно:

Стиль: camelCase для функций, PascalCase для типов, constexpr для констант.

Фиксируйте границы изменений

Это один из самых сильных «трюков» для C++:

Нельзя менять публичные заголовки.

Можно менять только реализацию в этом .cpp.

Нужно сохранить ABI (если вы работаете с библиотекой, но используйте эту фразу только если понимаете, что такое ABI).

Просите добавить проверки

Даже если у вас нет локальной сборки, проверки можно сформулировать как сценарии:

Добавь 6 тест-кейсов в виде main, без фреймворков.

Перечисли 10 входов, которые стоит прогнать (edge cases).

Если Kilocode «уверенно ошибается», возвращайте его к фактам

Готовая фраза:

Мини-чеклист перед отправкой промпта

Указаны платформа и стандарт C++.

Указаны ограничения проекта (зависимости, исключения, стиль).

Даны только релевантные файлы/фрагменты.

Запрошен применимый формат: diff или полные файлы.

Добавлены критерии приемки и границы изменений.

Эти шаблоны завершают практическую часть курса: теперь у вас есть не только настроенный VS Code и корректный C++ контекст, но и язык запросов, который делает Kilocode предсказуемым помощником, а не генератором общих советов.

Трюки продуктивности: хоткеи, команды, сниппеты и мультифайл

В прошлых материалах мы настроили VS Code под C++ (IntelliSense, workspace), включили осознанный контроль контекста для Kilocode (приватность, что отправляется в запрос), разобрали сборочный контекст (CMake, include-пути, стандарт), и научились писать промпты так, чтобы получать применимые ответы (diff, границы изменений, риски). В этой статье соберём практические трюки, которые ускоряют работу каждый день: хоткеи, команды, сниппеты и работа сразу с несколькими файлами.

Ключевая идея: скорость даёт не одна “волшебная” функция, а связка из четырёх привычек:

быстро выделять нужный фрагмент кода

быстро вызывать Kilocode и задавать правильный формат ответа

быстро применять результат (patch/diff) и проверять изменения

быстро переключаться между файлами, не теряя контекст

!Цикл продуктивной работы: от выделения кода до применения патча

Хоткеи VS Code, которые дают максимальный выигрыш в C++

Ниже хоткеи, которые полезны именно в связке C++ + Kilocode: вы быстро находите место, фиксируете контекст, и отправляете запрос.

Справочник по хоткеям и настройке сочетаний клавиш:

Сочетания клавиш VS Code

Навигация и поиск

Ctrl+P открывает быстрый поиск файла по имени

Ctrl+Shift+F поиск по всему проекту

F12 перейти к определению (работает через C/C++ расширение)

Shift+F12 найти все использования

Alt+Left и Alt+Right назад и вперёд по истории переходов

Трюк: когда просите Kilocode разобраться “почему это значение такое”, сначала соберите контекст переходами F12 и Alt+Left, а потом отправляйте запрос уже с правильными фрагментами.

Редактирование и рефакторинг руками, до подключения Kilocode

Ctrl+D выбрать следующее совпадение выделенного слова (ускоряет переименование локально)

Ctrl+Shift+L выбрать все совпадения (опаснее, но очень быстро)

Alt+Up и Alt+Down переместить строку вверх/вниз

Shift+Alt+Down дублировать строку

Ctrl+/ закомментировать строку

Трюк: если вы планируете просить Kilocode о рефакторинге, сначала сделайте механические правки (например, выравнивание, перенос строки, удаление мусорных логов) хоткеями, а затем просите Kilocode только о смысловой части. Так вы снижаете шанс получить “переписанный файл”.

Управление окнами и вкладками

Ctrl+\ разделить редактор на группы

Ctrl+1, Ctrl+2, Ctrl+3 перейти в группу редактора

Ctrl+Tab переключаться между последними файлами

Трюк для мультифайл-работы: слева держите .hpp, справа .cpp. При запросах к Kilocode вы быстрее контролируете, не “ломается” ли интерфейс.

Палитра команд как “панель управления” Kilocode

В VS Code почти всё можно сделать командами, и это важно для Kilocode, потому что названия кнопок и расположение в UI могут меняться.

Ctrl+Shift+P открыть палитру команд

Практика:

Нажмите Ctrl+Shift+P.

Начните вводить Kilocode.

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

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

Документация по палитре команд и интерфейсу редактора:

Пользовательский интерфейс VS Code

Настройка хоткеев под Kilocode через keybindings

Если вы часто делаете один и тот же сценарий (например, “объяснить выделенный код” или “сделать минимальный патч”), имеет смысл повесить это на хоткей.

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

Алгоритм:

Откройте Ctrl+Shift+P и выполните команду Preferences: Open Keyboard Shortcuts.

В строке поиска наберите Kilocode.

Найдите нужную команду и назначьте сочетание.

Документация:

Настройка сочетаний клавиш

Практические варианты хоткеев

хоткей для открытия чата Kilocode

хоткей для действия “по выделению” (объяснить, улучшить, рефакторить)

хоткей для переключения модели (если вы действительно делаете это часто)

Трюк: не пытайтесь повесить всё на хоткеи. Выберите 1–2 действия, которые вы делаете каждый час. Остальное оставьте в Ctrl+Shift+P.

Сниппеты в VS Code: ускоряем C++ и промпты для Kilocode

Сниппет в VS Code — это шаблон текста, который вставляется по короткому триггеру и может содержать курсоры-табуляции для заполнения.

Документация:

Создание сниппетов в VS Code

Сниппет для C++: безопасная заготовка функции

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

Ctrl+Shift+P → Snippets: Configure User Snippets.

Выберите cpp.json.

Добавьте сниппет:

Как использовать:

В .cpp начните печатать cppcontract.

Нажмите Tab.

Заполните поля.

Трюк: после заполнения выделите весь блок и попросите Kilocode: “реализуй функцию по контракту, C++20, MSVC, без сторонних библиотек, дай патч”.

Сниппет для “правильного” запроса к Kilocode (промпт-шаблон)

Вы можете сделать сниппет не только для C++, но и для текста запроса, который вы часто копируете в чат.

Трюк: держите этот шаблон в буфере не “в голове”, а как сниппет. Тогда ваши запросы остаются стабильными, и ответы Kilocode становятся предсказуемее.

Мультифайл: как работать с несколькими файлами так, чтобы Kilocode не путался

Большинство проблем качества у помощников по коду возникает не из-за “модели”, а из-за плохого мультифайл-контекста: вы дали реализацию, но не дали заголовок; дали один .cpp, но не показали место вызова; забыли ограничить масштаб правок.

Базовый мультифайл-протокол для C++

Используйте один и тот же порядок почти всегда:

Откройте .hpp и .cpp рядом через Ctrl+\.

Найдите место изменения в .cpp и соответствующий интерфейс в .hpp.

Подготовьте контекст:

выделение проблемной функции

сигнатуры типов из .hpp

1–2 места использования (call sites), если меняется интерфейс

Сформулируйте границы:

какие файлы можно менять

можно ли менять публичный API

нужен ли минимальный патч

Трюк: если вы хотите, чтобы Kilocode менял только один файл, пишите это явно: Меняй только src/foo.cpp.

Как не “утопить” запрос в проекте

Даже если расширение умеет добавлять контекст автоматически, для точности обычно лучше вручную контролировать объём.

Практические правила:

не добавляйте папки сборки build/, out/

не добавляйте автоматически сгенерированные файлы

если есть несколько похожих реализаций, сообщайте Kilocode, какая из них “истинная”

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

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

В идеале вы просите Kilocode выдавать изменения как unified diff. Дальше ваша задача: быстро просмотреть и применить.

Минимально безопасный поток

Попросите ответ в виде diff и ограничьте список файлов.

Быстро проверьте, что изменения:

не залезли в “запрещённые” файлы

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

соответствуют вашему стандарту C++ (например, C++20)

Примените изменения.

Посмотрите diff в VS Code через Source Control.

Документация по встроенному Git и просмотру изменений:

Источник контроля версий в VS Code

Трюк: даже если вы не используете Git “по-настоящему”, локальный репозиторий сильно помогает безопасно принимать правки: вы видите diff и можете откатить.

Мини-набор привычек на каждый день

вызывать Kilocode через Ctrl+Shift+P, а не искать кнопки

держать .hpp и .cpp рядом в split view

просить ответы в виде unified diff

ограничивать файлы и масштаб изменений одной строкой

использовать 1–2 сниппета: для C++-контракта и для промпта

Следующий логичный шаг после этих трюков: встроить их в вашу “норму” работы, чтобы Kilocode был не отдельным инструментом, а частью привычного цикла правок, проверки и навигации.

Типовые проблемы и отладка: качество ответов, скорость, конфликты расширений

Эта статья завершает практическую часть курса: после настроек VS Code под C++ (IntelliSense, workspace), настройки Kilocode (аккаунт, модель, приватность, контекст), шаблонов промптов и трюков продуктивности неизбежно возникает следующий этап: почему иногда работает хуже, медленнее или странно.

Мы разберём три группы проблем:

Качество ответов: “не тот код”, “галлюцинации”, “слишком общий ответ”, “ломает стиль проекта”.

Скорость: долго отвечает, тормозит VS Code, подвисает IntelliSense.

Конфликты расширений: два помощника одновременно, конкуренция за подсказки/форматирование/команды.

!Диаграмма-памятка: как быстро выбрать правильный путь отладки

Базовая диагностика перед любыми действиями

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

Какой режим ломается: чат, действие по выделению, генерация, автодополнение.

В одном файле или в проекте.

На любом проекте или только в конкретном workspace.

После чего началось: обновление VS Code, обновление расширений, смена профиля, смена сети.

Дальше используйте инструменты VS Code, которые помогают почти всегда.

Где смотреть ошибки расширений

Откройте панель Output: View -> Output.

В выпадающем списке каналов выберите:

1) канал Kilocode (если есть) 2) канал C/C++ (если проблема в IntelliSense/диагностике) 3) канал Log (Extension Host)

Если вы видите явные ошибки (таймаут, отказ в доступе, сетевые проблемы), это уже не “проблема качества ответа”, а техническая причина.

Полезные команды палитры (Ctrl+Shift+P):

Developer: Restart Extension Host (быстро лечит зависшие состояния расширений)

Developer: Show Running Extensions (видно, что грузит Extension Host)

Developer: Open Logs Folder (логи VS Code и расширений)

Документация VS Code по диагностике и производительности:

Visual Studio Code: Performance Issues

Проблемы качества ответов Kilocode в C++

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

открывать проект как папку

давать минимальный, но достаточный контекст

фиксировать стандарт C++ и совместимость (например, MSVC)

просить ответ в формате diff

Ниже — типовые “симптомы” и что делать.

Симптом: Kilocode придумывает несуществующие файлы/типы

Чаще всего причина в том, что запрос сформулирован как “сделай красиво”, но без границ.

Что сделать:

Добавить в запрос жёсткое правило: Не придумывай отсутствующие функции/файлы/типы. Если не хватает контекста — задай вопросы.

Уменьшить контекст: оставьте только текущий файл и связанный заголовок.

Дать “точки истины”:

1) сигнатуры из .hpp 2) 1–2 места вызова 3) фрагмент CMakeLists.txt, если вопрос про #include и зависимости

Шаблон “стоп-строка”, которую полезно вставлять почти всегда:

Симптом: ответ слишком общий, без применимого результата

Причина обычно в отсутствии требований к формату.

Что сделать:

Просить unified diff и ограничить список файлов.

Попросить “минимальный патч” и запретить переформатирование всего файла.

Пример ограничения:

Симптом: код компилируется “в вакууме”, но не подходит проекту

Типичная причина: Kilocode не знает ваш сборочный контекст (стандарт C++, макросы, include-пути, правила исключений/RTTI).

Что сделать:

Явно указать:

- C++17 или C++20 - совместимость MSVC - “без сторонних библиотек” - политику ошибок (исключения разрешены или нет)

Если проект на CMake, добавить в контекст:

- фрагмент CMakeLists.txt для нужной цели - структуру include/ и src/

Если проблема с видимостью заголовков, ориентироваться на реальные настройки IntelliSense:

- c_cpp_properties.json - compile_commands.json (если используется)

Справка по настройке C++ в VS Code:

C++ в Visual Studio Code

Симптом: Kilocode “ломает стиль” проекта

Причина: стиль не задан, а в C++ он особенно разнообразен (имена, отступы, nullptr vs NULL, auto, const-стиль).

Что сделать:

Вставить 1–2 строки про стиль в каждый запрос, где важна согласованность.

Пример:

Симптом: Kilocode исправляет не то (не в том месте)

Чаще всего вы дали мало “границ задачи” или не указали критерий приемки.

Что сделать:

Сформулировать критерий:

- “не менять публичный API” - “не менять поведение” - “исправить только UB/утечку/гонку”

Попросить сначала план из 3–6 шагов, потом патч.

Проблемы скорости: долго отвечает или тормозит VS Code

Здесь важно различать:

медленно отвечает Kilocode (сетевой запрос/модель/таймаут)

тормозит VS Code (Extension Host, поиск по проекту, индексация)

тормозит IntelliSense C/C++ (индексация, include-пути, база символов)

Когда долго отвечает именно Kilocode

Типовые причины:

тяжёлая модель выбрана для простой задачи

слишком большой контекст (много файлов, большие логи)

сеть: VPN, прокси, корпоративная фильтрация

Что сделать:

Переключиться на более быструю модель для повседневных мелких правок.

Уменьшить контекст:

- не добавлять build/, out/, .cache/ - не отправлять целые файлы, если достаточно функции

Проверить, не блокируется ли запрос сетью:

- временно отключить VPN - попробовать другую сеть - посмотреть ошибки в канале Output расширения

Когда тормозит VS Code (даже без запросов)

Что сделать:

Посмотреть “кто грузит редактор”:

- команда Developer: Show Running Extensions

Временно отключить тяжёлые расширения, не относящиеся к C++ и Kilocode.

Уменьшить размер видимого/индексируемого workspace:

- исключить сборочные папки из поиска - не открывать корень диска как workspace

Документация VS Code по исключениям поиска:

Visual Studio Code: Basic Editing и Search

Когда тормозит IntelliSense для C++

Симптомы:

долгие подсказки

неверные “красные подчёркивания”

“не находит заголовки”, хотя сборка в CI проходит

Что сделать:

Убедиться, что IntelliSense получает корректные include-пути и defines:

- через c_cpp_properties.json - через CMake Tools (если проект CMake) - через compile_commands.json (если доступен)

Не путать “сборка” и “IntelliSense”:

- сборка может быть корректной в CI - IntelliSense локально может быть неверен из-за отсутствия контекста

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

Конфликты расширений: как находить и устранять

Под “конфликтом” чаще всего понимаются ситуации:

два расширения одновременно показывают подсказки и мешают друг другу

одно расширение перехватывает хоткеи/команды другого

форматирование “прыгает” (несколько форматтеров)

разные C++ расширения или инструменты сборки дают противоречивый контекст

Быстрый способ изоляции: отдельный профиль

Это самый “безопасный” способ, который не ломает вашу основную среду.

Создайте профиль для курса: только Kilocode и C/C++.

Повторите проблему.

Если в чистом профиле проблема исчезла, значит конфликт был в наборе расширений или настроек.

Документация VS Code по профилям:

Profiles in Visual Studio Code

“Безопасный режим”: запуск VS Code без расширений

На Windows можно запустить VS Code без расширений, чтобы проверить, не расширение ли источник проблемы.

Закройте VS Code.

Запустите из терминала:

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

Extension Bisect: автоматический поиск конфликтующего расширения

VS Code умеет автоматически найти расширение, которое вызывает проблему.

команда: Help: Start Extension Bisect

Документация:

Extension Bisect в VS Code

Типовой конфликт: форматирование C++

Симптом:

вы применили патч, а при сохранении файл внезапно “переформатировался” иначе

Причина:

включены разные форматтеры или правила форматирования для одного языка

Что сделать:

Проверить настройку Format On Save.

Убедиться, что выбран один форматтер по умолчанию для C++.

Если используете clang-format, зафиксировать правила в .clang-format и не смешивать форматирование между инструментами.

Документация VS Code по форматированию:

Formatting в Visual Studio Code

Типовой конфликт: несколько AI-ассистентов

Симптом:

два разных инструмента предлагают подсказки, дублируют панели, мешают хоткеям

Что сделать:

временно отключить остальные AI-расширения и оставить только Kilocode на время настройки рабочего процесса

либо разнести их по разным профилям (для разных задач)

Стабильный “протокол восстановления” для любых странностей

Если вы не уверены, что именно сломалось, используйте универсальную последовательность. Она минимально инвазивна и почти всегда приводит к результату.

Перезапустить Extension Host: Developer: Restart Extension Host.

Повторить проблему на минимальном примере:

- один файл .cpp - короткий запрос - минимальный контекст

Изолировать расширения:

- перейти в чистый профиль - или запустить code --disable-extensions

Проверить логи в Output:

- канал Kilocode - Log (Extension Host)

Если это C++ контекст, проверить источник правды IntelliSense:

- c_cpp_properties.json или CMake Tools/compile_commands.json

Главная идея: сначала возвращаем управляемость (минимальный пример и чистая среда), и только потом усложняем.

Что считать “готовым состоянием” после отладки

У вас должно получиться:

в отдельном профиле C++ + Kilocode воспроизводимо работает базовый сценарий: выделение функции → запрос → diff

вы знаете, где смотреть ошибки: Output и логи

вы умеете быстро изолировать конфликт: отключение расширений или Extension Bisect

вы умеете отделять “проблему Kilocode” от “проблемы контекста C++/IntelliSense”

Это делает работу с Kilocode в VS Code предсказуемой: вы тратите время на код, а не на догадки, почему инструмент сегодня “не в форме”.