Claude, ChatGPT, Codex, DeepSeek, Алиса AI: пошаговая инструкция для тех, кто разрабатывает приложения с помощью искусственного интеллекта.

Представьте ситуацию: вы несколько недель разрабатывали собственное приложение (например, браузерную игру для Яндекс Игр) вместе с нейросетью Claude. Обсуждали устройство программы, писали код, исправляли ошибки, добавляли новые функции. Постепенно проект стал достаточно большим, а переписка с ИИ — очень длинной.
И вот вы решили продолжить работу в новой сессии. Или вообще перейти на ChatGPT, DeepSeek либо Алису AI от Яндекса.
Возникает вопрос: как передать новому ИИ всё, что было сделано раньше? Нужно ли копировать всю переписку? Как сохранить код, настройки и технические решения?
На самом деле всё проще, чем кажется. Главное — правильно организовать хранение проекта.
В этой статье разберём, как подготовить приложение к переносу, зачем нужен Git, какие документы следует сохранить и как передать работу другой нейросети, чтобы она смогла продолжить разработку практически с того же места.
1. Почему новая сессия не знает, что происходило раньше?
Начнём с простого примера.
Вы работали с Claude и в течение нескольких дней обсуждали создание приложения. Нейросеть уже знает, какие технологии используются, какие функции реализованы, какие ошибки исправлены и что ещё предстоит сделать.
Но вы открываете совершенно новый чат.
Новая сессия не обязательно имеет доступ к предыдущей переписке. Даже если используется та же нейросеть, не следует рассчитывать, что она автоматически вспомнит все подробности разработки.
У ChatGPT, Claude и других сервисов есть собственные механизмы сохранения истории, проектов и дополнительного контекста. Однако они не заменяют полноценную документацию самого приложения.
Здесь важно понимать одну вещь:
История переписки с нейросетью и файлы вашего приложения — это не одно и то же.
В переписке находятся обсуждения и предложения, а в папке проекта — реальный исходный код.
Например, вы могли обсуждать создание системы регистрации пользователей, но это ещё не означает, что она действительно реализована в программе.
Поэтому перед переходом в новую сессию необходимо сохранить не всю историю разговоров, а самое важное — актуальное состояние проекта.
2. Что необходимо сохранить перед переносом проекта?
Чтобы другой ИИ смог продолжить разработку, ему понадобятся несколько вещей.
В первую очередь — сам проект.
Это папка со всеми необходимыми файлами приложения:
- Исходный код.
- Структура папок.
- Настройки.
- Компоненты интерфейса.
- Файлы базы данных или миграции.
- Необходимые конфигурации.
- Тесты.
Не нужно переносить временные файлы, скачанные библиотеки и результаты сборки, если они могут быть восстановлены стандартными командами установки и сборки.
Например, в проекте на Node.js обычно не требуется переносить папку node_modules. Достаточно сохранить файлы зависимостей и инструкцию по установке.
Во-вторых — описание проекта.
Новому ИИ необходимо объяснить, что это за приложение, как оно устроено и на каком этапе находится разработка.
В-третьих — список текущих задач.
Нужно зафиксировать, что уже работает, что ещё не закончено и с чего следует продолжить.
Для удобства всё это можно хранить в нескольких обычных текстовых документах.
3. Создаём документы, которые помогут любой нейросети понять проект
Не стоит усложнять задачу и создавать множество файлов. Для начала достаточно трёх основных документов.
PROJECT_CONTEXT.md — главное описание проекта
Это самый важный документ для передачи работы другой нейросети.
В нём необходимо описать:
- Назначение приложения.
- Какие функции уже реализованы.
- Какие функции находятся в разработке.
- Какие технологии используются.
- Как устроена архитектура.
- Какие важные технические решения приняты.
- Какие проблемы пока не решены.
- На каком этапе остановилась разработка.
- Что необходимо сделать следующим шагом.
Особое внимание уделите последнему пункту.
Например:
«На данный момент реализована регистрация пользователей и авторизация. Личный кабинет работает, но система восстановления пароля ещё не закончена. Следующий этап — завершить восстановление пароля и проверить безопасность авторизации».
Такое описание гораздо полезнее, чем несколько десятков страниц старой переписки.
README.md — инструкция по запуску приложения
В этом документе объясняется, как запустить проект.
Желательно указать:
- Какие программы необходимо установить.
- Какие технологии используются.
- Как установить зависимости.
- Как запустить приложение.
- Как запустить тесты.
- Какие настройки необходимы.
Например, если проект создан на React и Node.js, можно указать команды установки и запуска.
TASKS.md — список выполненных и предстоящих задач
Здесь удобно вести простой список:
- Создана структура приложения.
- Разработана главная страница.
- Реализована регистрация.
- Добавлено восстановление пароля.
- Завершена интеграция платёжной системы.
- Проведено тестирование.
Это позволяет новому ИИ быстро понять, что уже сделано, а что ещё предстоит.
Дополнительные документы
Когда проект становится сложнее, можно добавить:
ARCHITECTURE.md— подробное описание архитектуры.DECISIONS.md— важные технические решения и причины их принятия.AGENTS.md— общие инструкции для программных ИИ-агентов.CLAUDE.md— инструкции для Claude Code.
Необязательно создавать всё сразу. Начните с трёх основных документов и постепенно дополняйте их.
4. Что такое Git и зачем он нужен при работе с нейросетями?
Теперь перейдём к одному из самых полезных инструментов при разработке приложений — Git.
Если объяснять совсем просто, Git — это система, которая позволяет сохранять историю изменений вашего проекта.
Представим, что сегодня приложение работает правильно. Вы попросили нейросеть добавить новую функцию, но после внесения изменений программа перестала запускаться.
Как вернуть предыдущую рабочую версию?
Именно для этого и нужен Git.
С его помощью можно:
- Сохранять рабочие версии проекта.
- Просматривать, какие файлы изменились.
- Сравнивать старую и новую версии кода.
- Возвращаться к предыдущим изменениям.
- Работать с разными вариантами разработки.
- Передавать проект другим разработчикам и ИИ-инструментам.
Особенно полезен Git, когда над одним проектом работают разные нейросети.
Например, Claude создал систему авторизации, ChatGPT добавил личный кабинет, а Codex помог исправить ошибки.
Git позволяет контролировать изменения независимо от того, кто именно написал код.
Как начать пользоваться Git?
Сначала установите Git с официального сайта
Затем откройте терминал в папке своего проекта.
Если Git ещё не использовался, выполните:
git init
Эта команда создаст локальный репозиторий — место, где Git будет хранить историю изменений.
Теперь добавим файлы проекта:
git add .
Сохраним первую версию:
git commit -m "Первая сохранённая версия проекта"
Готово! Теперь у вас есть первая сохранённая версия.
Как сохранять изменения в дальнейшем?
После того как нейросеть внесла изменения и вы проверили результат, выполните:
git status
Команда покажет, какие файлы изменились.
Чтобы посмотреть сами изменения:
git diff
Если всё в порядке, сохраните новую версию:
git add .
git commit -m "Добавлена система авторизации"
Теперь Git будет знать, какие изменения были сделаны и в какой момент они сохранены.
Важный совет: сохраняйте изменения после завершения каждой крупной задачи. Не нужно создавать отдельную версию после каждого исправления одной строки, но основные этапы разработки лучше фиксировать.
Если Git уже используется в проекте, не выполняйте повторно git init без необходимости. Сначала проверьте существующий репозиторий.
Нужно ли использовать GitHub?
Git хранит историю изменений на вашем компьютере. Но если компьютер выйдет из строя, локальная копия может быть потеряна.
Поэтому желательно дополнительно разместить проект в удалённом репозитории.
Для этого можно использовать GitHub или GitLab.
Например, GitHub позволяет хранить исходный код в удалённом репозитории и получать к нему доступ с разных компьютеров.
Главное преимущество: вы сможете продолжить разработку даже на другом устройстве.
Для частных проектов можно использовать приватный репозиторий, доступ к которому ограничен.
При этом не забывайте: нельзя размещать в репозитории пароли, API-ключи и другие секретные данные.
Файл .env с реальными ключами следует исключить из Git с помощью .gitignore. При необходимости можно сохранить безопасный пример настроек .env.example без настоящих секретов.
5. Как правильно подготовить проект к переносу?
Теперь объединим всё, что мы рассмотрели.
Допустим, вы работали с Claude и решили перейти на ChatGPT.
Перед переносом выполните несколько простых действий.
Шаг 1. Сохраните текущую версию приложения.
Убедитесь, что исходный код находится в папке проекта. Проверьте, что важные изменения не остались только в переписке.
Шаг 2. Проверьте Git.
Выполните:
git status
Если есть незавершённые изменения, сохраните их или отдельно зафиксируйте, что они ещё не проверены.
Не сохраняйте в Git секреты и временные файлы.
Шаг 3. Подготовьте описание проекта.
Попросите старую нейросеть создать или обновить PROJECT_CONTEXT.md.
Проверьте, чтобы в документе были отражены реальные результаты разработки, а не только планы.
Шаг 4. Обновите README.md и TASKS.md.
Добавьте актуальные инструкции по запуску и список следующих задач.
Шаг 5. Сохраните историю важных решений.
Если во время разработки вы долго обсуждали сложную ошибку или выбирали между несколькими вариантами архитектуры, желательно сохранить итоговое решение и его обоснование.
Всю переписку переносить не обязательно.
Шаг 6. Сделайте резервную копию.
Сохраните проект на другом носителе или в удалённом репозитории.
Теперь проект готов к передаче.
6. Как попросить старую нейросеть подготовить проект к переносу?
Необязательно самостоятельно писать всю документацию.
Можно поручить эту работу самой нейросети, с которой вы разрабатывали приложение.
Например, отправьте ей следующий запрос.
Готовый запрос для Claude, ChatGPT и других ИИ
Я планирую продолжить разработку приложения в новой сессии или с помощью другой нейросети.
Подготовь документацию, которая позволит новому ИИ разобраться в проекте и продолжить работу.
Создай или обнови следующие документы:
1. PROJECT_CONTEXT.md — подробное описание текущего состояния проекта.
2. README.md — инструкции по установке, настройке и запуску.
3. TASKS.md — выполненные, незавершённые и предстоящие задачи.
4. DECISIONS.md — важные технические решения и причины их принятия.
Обязательно опиши:
- Назначение приложения.
- Используемые языки программирования, библиотеки и фреймворки.
- Структуру папок и файлов.
- Реализованные функции.
- Функции, которые ещё не закончены.
- Известные ошибки и ограничения.
- Важные архитектурные решения.
- Последние изменения в коде.
- Текущий этап разработки.
- Конкретные следующие шаги.
Проверь фактическое состояние файлов проекта, если у тебя есть к ним доступ.
Не выдавай обсуждавшиеся, но не реализованные функции за готовые.
Не придумывай отсутствующие сведения. Если информация неизвестна, так и напиши.
В конце подготовь отдельную инструкцию для нового ИИ, чтобы он сначала изучил проект, проверил его состояние и только после этого приступал к дальнейшей разработке.
Сохрани документы непосредственно в папке проекта.
После выполнения проверьте созданные файлы. Нейросеть может ошибиться или описать то, что планировалось сделать, как уже реализованную функцию.
7. Как передать проект другой нейросети?
Теперь самое интересное. У вас есть исходный код и документация. Осталось передать их новому помощнику.
Рассмотрим несколько популярных вариантов.
Claude
У Claude есть несколько способов работы с проектами.
Если вы используете обычный чат, можно передать необходимые документы и доступные для загрузки файлы.
Если используете Claude Code, ситуация удобнее: он работает непосредственно с папкой проекта и может читать файлы, изменять код и выполнять команды.
Для Claude Code предусмотрен специальный файл CLAUDE.md. В нём можно хранить инструкции по работе с проектом. Claude Code умеет автоматически читать такой файл при начале работы в соответствующей папке.
ChatGPT и Codex
В ChatGPT можно создавать проекты (Projects), в которых удобно хранить файлы, инструкции и материалы, связанные с одной задачей. Это помогает сохранять контекст работы между отдельными диалогами.
Однако важно различать обычные проекты ChatGPT и локальные проекты в десктопном приложении.
- Обычные проекты ChatGPT позволяют работать с загруженными файлами и инструкциями, но не получают прямого доступа к папкам на вашем компьютере.
- Локальные проекты в десктопном приложении ChatGPT позволяют подключать папки с исходным кодом. В зависимости от предоставленных разрешений ИИ может читать и изменять файлы непосредственно в этой папке.
Codex также предназначен для работы с программным кодом и может использовать инструкции из файла AGENTS.md. В нём можно описать правила проекта: структуру файлов, используемые технологии, требования к оформлению кода и порядок выполнения задач.
Полезные материалы:
DeepSeek
DeepSeek можно использовать для анализа исходного кода, поиска ошибок, объяснения программных решений и продолжения разработки.
Для работы с файлами через API у DeepSeek предусмотрен Files API. Он позволяет передавать поддерживаемые форматы файлов, в том числе текстовые документы и исходный код. Для документов PDF, Word и PowerPoint предусмотрены механизмы распознавания и извлечения содержимого.
Важно не путать возможности API с возможностями обычного чата на сайте: доступность прикрепления файлов и поддерживаемые форматы в пользовательском интерфейсе могут отличаться.
Документация: DeepSeek Files API
Алиса AI и YandexGPT
Алису и модели YandexGPT также можно использовать для анализа текстов, объяснения кода и работы с документацией проекта.
В чате с Алисой поддерживается прикрепление документов. Согласно справке сервиса, можно прикладывать файлы DOC, DOCX, PDF и TXT. Возможности могут зависеть от версии сервиса и используемого интерфейса.
Документация:
Главное правило: не рассчитывайте, что любая нейросеть автоматически сможет открыть всю папку проекта. Иногда потребуется загрузить документы, иногда — подключить репозиторий, а иногда — использовать специальный программный инструмент.
8. Что написать новой нейросети после передачи проекта?
Допустим, вы передали ChatGPT исходный код и документацию, которые подготовил Claude. Не спешите сразу просить новую нейросеть добавлять функции. Перед началом работы попросите новый ИИ изучить основные файлы проекта:
PROJECT_CONTEXT.md— описание проекта и его текущего состояния;README.md— общая информация, установка и запуск;TASKS.md— текущие и запланированные задачи;DECISIONS.md(если документ существует) — принятые технические решения;AGENTS.mdилиCLAUDE.md— инструкции для ИИ, если они используются в проекте.
После изучения файлов попросите ИИ кратко пересказать, как он понял устройство проекта, какие задачи уже выполнены и что осталось сделать. Только после этого переходите к изменению кода.
Вот готовый запрос:
Я продолжаю разработку существующего приложения. Предыдущий этап выполнялся с помощью другой нейросети.
Я передал тебе исходный код и документацию проекта.
Сначала изучи:
- PROJECT_CONTEXT.md;
- README.md;
- TASKS.md;
- DECISIONS.md;
- AGENTS.md или CLAUDE.md.
Твоя задача:
1. Разобраться, для чего предназначено приложение.
2. Определить используемые технологии.
3. Изучить архитектуру.
4. Проверить, какие функции действительно реализованы.
5. Сравнить документацию с фактическим состоянием кода.
6. Определить текущие проблемы.
7. Выяснить, на каком этапе остановилась разработка.
8. Предложить следующий логический шаг.
Пока ничего не изменяй в исходном коде.
Сначала представь краткое резюме проекта и подтверди, что правильно понял его текущее состояние.
Если обнаружишь расхождения между документацией и кодом, обязательно сообщи о них.
Почему это важно?
Потому что новая нейросеть может неправильно понять старые решения или предложить изменить уже работающие механизмы.
Сначала проверка, потом программирование — это гораздо надёжнее.
9. Как организовать работу, чтобы больше не зависеть от одной нейросети?
Если вы планируете долго разрабатывать приложение, рекомендую выработать простое правило.
После каждой крупной задачи нейросеть должна не только написать код, но и обновить документацию.
Например:
- Вы попросили Claude создать новую функцию.
- Claude написал код.
- Вы проверили работу приложения.
- Изменения сохранены в Git.
- Обновлены PROJECT_CONTEXT.md и TASKS.md.
- В DECISIONS.md записано важное техническое решение, если оно появилось.
Всё! Можно спокойно завершать сессию.

В следующий раз вы можете открыть новую переписку с Claude, перейти на ChatGPT, использовать Codex или попробовать DeepSeek.
Главное — чтобы актуальный код и документация находились у вас, а не только внутри старого чата.
Рекомендуемая структура папки проекта
Для наглядности приведём пример организации папки приложения:
MY_APPLICATION/
│
├── src/
│ └── исходный код приложения
│
├── tests/
│ └── тесты приложения
│
├── docs/
│ └── дополнительная документация
│
├── PROJECT_CONTEXT.md
├── README.md
├── TASKS.md
│
├── DECISIONS.md
│
├── AGENTS.md
├── CLAUDE.md
│
├── .gitignore
├── .env.example
└── .env
Это пример, а не обязательное требование. Структура зависит от конкретного приложения, используемого языка программирования и технологий.
Необязательно создавать все перечисленные файлы, если они пока не нужны. Начните с минимального варианта и расширяйте структуру по мере развития приложения.
Для начала достаточно трёх основных документов:
PROJECT_CONTEXT.md— что представляет собой приложение и на каком этапе находится разработка.README.md— как установить и запустить приложение.TASKS.md— что уже сделано и что предстоит сделать.
По мере развития проекта можно добавить DECISIONS.md, в котором будут записываться важные технические решения и причины их принятия.
Файлы AGENTS.md и CLAUDE.md предназначены для дополнительных инструкций конкретным ИИ-инструментам. Создавать оба файла необязательно.
Отдельно обратите внимание на следующие файлы:
.gitignore— указывает Git, какие файлы и папки не нужно добавлять в репозиторий..env.example— пример файла с настройками без настоящих секретных ключей..env— файл с реальными настройками, паролями и секретами, если они используются приложением.
Важное правило: не сохраняйте секреты в Git
В файле .env обычно хранятся пароли, API-ключи, токены доступа и другие конфиденциальные данные.
Такой файл нельзя добавлять ни в публичный, ни в приватный Git-репозиторий. Даже если репозиторий доступен только вам или вашей команде, хранить реальные секреты в нём небезопасно.
Чтобы случайно не отправить файл .env в Git, добавьте его в .gitignore:
.env
.env.*
!.env.example
Вместо настоящего .env можно создать файл .env.example. В нём указывают названия необходимых переменных, но не настоящие пароли и ключи.
Например:
API_KEY=your_api_key_here
DATABASE_URL=your_database_url_here
Если вы уже отправили настоящий API-ключ или пароль в Git, простого удаления файла недостаточно. Секрет необходимо отозвать или заменить. При необходимости также нужно очистить историю репозитория.
10. Нужно ли сохранять всю переписку с нейросетью?
Итак, вернёмся к первоначальному вопросу.
Нужно ли сохранять историю первого этапа разработки?
Мой совет: сохранять полезную историю стоит, но переносить её целиком в новую сессию обычно не требуется.
Разделим информацию на три группы.
Что обязательно сохранить:
- Исходный код приложения — актуальная версия всех необходимых файлов.
- Основная документация —
PROJECT_CONTEXT.md,README.mdиTASKS.md. - Важные технические решения — причины выбора технологий, архитектурные особенности и известные ограничения.
- Текущее состояние разработки — незавершённые изменения, найденные ошибки и ближайшие задачи.
Не забывайте сохранять изменения в Git. Это позволит вернуться к предыдущей рабочей версии, если при дальнейшей разработке что-то пойдёт не так.
Что желательно сохранить в архиве:
- Важные обсуждения архитектуры.
- Причины отказа от отдельных решений.
- Сложные случаи исправления ошибок.
- Полезные фрагменты переписки.
Что можно не переносить:
- Повторяющиеся вопросы.
- Неиспользованные варианты кода.
- Устаревшие предложения.
- Уже исправленные ошибки.
- Длинные обсуждения, которые никак не повлияли на приложение.
История переписки может пригодиться в будущем, но она не должна быть единственным источником информации о проекте.
Заключение
Работа с нейросетями в программировании открывает большие возможности. Сегодня вы можете создавать приложения вместе с Claude, завтра продолжить разработку в ChatGPT, а затем использовать DeepSeek или инструменты Яндекса.
Не нужно привязывать весь проект к одной нейросети.
Для этого достаточно соблюдать несколько простых правил:
- Всегда храните исходный код у себя.
- Используйте Git для сохранения истории изменений.
- Поддерживайте актуальную документацию.
- После крупных задач обновляйте описание проекта.
- Перед переходом в новую сессию сохраняйте текущий этап разработки.
- Новому ИИ сначала поручайте изучить проект, а уже потом изменять код.
- Не передавайте пароли и секретные ключи вместе с исходным кодом.
Соблюдение этих простых шагов избавит вас от привязки к одному сервису. Чем лучше подготовлена документация, тем проще продолжить разработку с любого ИИ — Claude, ChatGPT, Codex, DeepSeek или YandexGPT.
Главное — помнить, что история переписки может потеряться, а файлы проекта, документация и сохранённые технические решения останутся с вами.





Будьте первыми - оставьте свой комментарий!