Cursor для новичков: лёгкий vibe-coding

Старт: установка Cursor и первый проект

Что такое Cursor и зачем он новичку

Cursor — это редактор кода с встроенным ИИ-помощником. Он помогает:

Создавать код по описанию обычным языком

Объяснять непонятные фрагменты

Быстро исправлять ошибки и улучшать проект

В этом курсе под vibe-coding мы будем понимать подход: не застревать на мелочах, а быстро собирать рабочие маленькие проекты, постепенно прокачивая понимание.

Что нужно перед стартом

Минимальные требования

Компьютер на Windows, macOS или Linux

Доступ в интернет

Пара свободных гигабайт на диске

Аккаунт

Cursor обычно предлагает вход (например, через Google). Это нужно, чтобы ИИ работал стабильно.

Официальный сайт Cursor:

Cursor

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

Cursor Docs

Установка Cursor

Windows

Открой сайт Cursor

Нажми кнопку загрузки для Windows

Запусти установщик и следуй шагам мастера

Открой Cursor из меню Пуск

macOS

Открой сайт Cursor

Скачай версию для macOS

Перетащи Cursor в папку Applications

Запусти Cursor и подтверди запуск приложения

Linux

Открой сайт Cursor

Скачай сборку для Linux (обычно .AppImage или пакет)

Установи/запусти согласно формату файла

Если на Linux возникают вопросы с запуском .AppImage, ориентируйся на общие правила AppImage для твоего дистрибутива.

Первый запуск: базовая настройка

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

Проверь и сделай минимум:

Войти в аккаунт (если предложено)

Выбрать тему (светлую или тёмную)

Разрешить доступ к папкам (если система спросит)

Если Cursor предложит импортировать настройки из другого редактора, можно пропустить. Мы настроим всё по ходу курса.

!Схема, где находятся основные панели Cursor

Разбираемся в интерфейсе (самое нужное)

В Cursor тебе важны 4 вещи:

Проводник (панель файлов): создаёшь и открываешь файлы проекта

Редактор: место, где ты пишешь код

Терминал: встроенная командная строка для запуска команд

AI-чат: место, где ты просишь ИИ объяснить или сгенерировать код

Терминал — это окно, куда вводят команды текстом, например python app.py.

Ставим Python для первого проекта

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

Установи Python с официального сайта:

- Python

После установки открой Cursor

Открой встроенный терминал

Проверка установки (в терминале):

Если команда не сработала, попробуй:

Должна появиться версия, например Python 3.12.x.

Первый проект: "hello-cursor" (папка + один файл)

Создаём папку проекта

Создай на компьютере папку hello-cursor

В Cursor выбери открытие папки проекта

Важно: проект в нашем курсе — это просто папка с файлами. Никакой магии.

Создаём файл app.py

В проводнике Cursor создай файл app.py и вставь код:

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

input(...) показывает вопрос и ждёт ввод

name — переменная, в которой хранится введённый текст

print(...) печатает сообщение

f"...{name}..." подставляет значение переменной внутрь строки

Запускаем проект

Открой терминал в Cursor и выполни команду (из папки проекта):

Если у тебя работает через python3, то так:

Введи имя и убедись, что программа отвечает приветствием.

Подключаем vibe-coding: просим ИИ улучшить проект

Теперь добавим маленькую фишку: сделаем программу дружелюбнее и устойчивее.

Пример запроса в AI-чат

Скопируй запрос и отправь в AI-чат Cursor:

> "Улучши мой app.py: если пользователь ничего не ввёл, попроси ввести имя ещё раз. Добавь приветствие по времени суток: утро/день/вечер. Покажи готовый код целиком."

Когда ИИ предложит код:

Сравни с твоим файлом app.py

Замени содержимое app.py на улучшенную версию

Запусти программу снова

Правило новичка: не принимай изменения вслепую. Минимум — прочитай глазами и запусти.

Типичные проблемы и быстрые решения

В терминале пишет, что python не найден

Возможные причины:

Python не установлен

Python установлен, но не добавлен в PATH

Что делать:

Убедись, что ставил Python с Python

На Windows при установке обычно есть галочка добавления в PATH — если пропустил, переустанови Python

Попробуй команду python3 --version

Программа запускается, но сразу закрывается

Если ты запускал двойным кликом по файлу, окно могло закрыться мгновенно. Запускай из терминала Cursor командой python app.py.

Код работает не так, как ожидалось

Сделай привычку:

Скопируй ошибку из терминала

Вставь её в AI-чат

Попроси: "Объясни простыми словами, что означает ошибка и как исправить"

Итог

Ты сделал базу, которая нужна для всего курса:

Установил Cursor

Открыл папку проекта

Создал и запустил первый файл

Использовал AI-чат, чтобы улучшить программу

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

Интерфейс и ключевые функции: Chat, Edit, Composer

Зачем это новичку и как связано с прошлой статьёй

В прошлой статье ты установил Cursor, создал папку проекта и запустил первый app.py. Теперь важно научиться не просто общаться с ИИ, а понимать, каким инструментом пользоваться в зависимости от задачи.

В Cursor чаще всего ты будешь переключаться между тремя ИИ-функциями:

Chat — когда нужно спросить, понять, разобрать ошибку, получить совет

Edit — когда нужно точечно изменить конкретный кусок кода

Composer — когда нужно собрать фичу или мини-проект, затрагивающий несколько файлов и шагов

Где это находится в интерфейсе

Cursor устроен как современный редактор кода: слева файлы, по центру код, снизу терминал, сбоку или отдельной панелью ИИ-инструменты.

!Схема, чтобы быстро запомнить, где искать основные панели

Чтобы комфортно учиться vibe-coding, держи в голове простую связку:

Файлы ты открываешь в панели проекта

Код правишь в редакторе

Запуск и ошибки смотришь в терминале

Подсказки и генерацию делаешь через Chat / Edit / Composer

Чем отличаются Chat, Edit и Composer

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

| Функция | Когда использовать | Что ты даёшь ИИ | Что получаешь | Главный риск новичка | |---|---|---|---|---| | Chat | Вопросы, объяснения, разбор ошибок, идеи | Вопрос + кусок кода/ошибка | Ответ текстом, рекомендации, примеры | Верить ответу без проверки на запуске | | Edit | Небольшая правка в конкретном месте кода | Выделенный фрагмент + просьба | Изменение в этом фрагменте | Попросить слишком абстрактно и получить лишние правки | | Composer | Новая фича, несколько файлов, план работ | Описание задачи + ограничения + контекст проекта | План + набор изменений по проекту | Получить много изменений сразу и потерять контроль |

Chat

Chat — это твой быстрый способ:

понять, что делает код

расшифровать ошибку из терминала

спросить, как улучшить программу

получить варианты решений и выбрать подходящее

Как задавать вопросы в Chat, чтобы ответы были полезными

Чем точнее входные данные, тем меньше “магии” в ответе.

Рабочий шаблон запроса:

> “У меня проект на Python. Я запускаю командой python app.py. Получаю ошибку: ... Объясни простыми словами, что это значит, и предложи 2 способа исправить. Покажи, какой способ проще для новичка.”

Если Chat предлагает код, проси его вставлять целиком только для конкретного файла:

> “Покажи обновлённый код целиком только для app.py. Другие файлы не меняй.”

Chat для ошибок: золотое правило

Когда что-то сломалось, действуй так:

Скопируй ошибку целиком из терминала

Вставь в Chat

Добавь: в каком файле ты это делал и какой командой запускал

Это сильно повышает шанс, что ответ будет точным.

Edit

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

Типичные задачи для Edit:

переименовать переменную или сделать текст понятнее

добавить проверку на пустой ввод

упростить блок if/else

сделать код аккуратнее, но без изменения логики

Как пользоваться Edit безопасно

Привычка, которая экономит часы:

Выдели фрагмент кода, который хочешь изменить

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

Проверь, что ИИ меняет только выделенное

Запусти программу в терминале

Примеры хороших запросов для Edit:

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

“Отрефактори этот блок: сделай понятные имена переменных и комментарий в одной строке. Логику не меняй.”

Если результат не понравился, почти всегда быстрее:

отменить изменение

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

Composer

Composer — это режим, когда ты хочешь получить мини-фичу или мини-проект целиком, и это обычно:

несколько шагов

несколько файлов

изменения в существующих файлах

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

Как работать с Composer, чтобы не утонуть

Проси Composer работать по плану и маленькими порциями.

Надёжная формулировка:

> “Сначала предложи план из 3–5 шагов. Дождись моего подтверждения. Потом вноси изменения шаг за шагом и каждый раз показывай, какие файлы меняешь и что именно.”

Пример задачи для Composer на базе твоего hello-cursor

Ты уже сделал app.py с приветствием. Теперь можно попросить Composer добавить небольшую фичу, затрагивающую проект:

сохранять последнее введённое имя в файл

при следующем запуске предлагать его как вариант

Запрос, который держит изменения под контролем:

> “У меня проект hello-cursor с файлом app.py. Добавь функцию: сохраняй последнее имя в файл last_name.txt, а при старте, если файл существует, предлагай использовать сохранённое имя. Сначала дай план, потом покажи изменения только для тех файлов, которые реально нужны.”

Как давать контекст ИИ: правило трёх уровней

ИИ почти всегда ошибается не из-за “глупости”, а из-за нехватки контекста. Давай его по слоям.

Цель

Например: “Хочу, чтобы программа приветствовала пользователя и не падала на пустом вводе”.

Ограничения

Например: “Python, один файл app.py, без сторонних библиотек, код должен быть понятен новичку”.

Факты из проекта

Например: “Вот мой текущий код app.py: ...” или “Вот ошибка из терминала: ...”.

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

Безопасный vibe-coding: как принимать изменения от ИИ

Твоя цель — скорость, но без хаоса. Минимальный чеклист:

Прочитай глазами то, что ИИ предлагает изменить

Проверь границы изменений: какие файлы тронуты и зачем

Запусти проект в терминале после правок

Если стало хуже — откати правку и переформулируй запрос

Важная мысль: ИИ ускоряет работу, но ответственность за результат остаётся у тебя.

Как быстро выбрать правильный инструмент

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

Если хочешь понять или спросить — Chat

Если хочешь поправить маленький кусок кода — Edit

Если хочешь сделать фичу, план и несколько файлов — Composer

Итог

Теперь у тебя есть базовая “карта” Cursor:

Chat помогает думать и разбираться

Edit делает точные правки в нужном месте

Composer собирает более крупные изменения по проекту

Дальше в курсе мы будем прокачивать главный навык vibe-coding: формулировать запросы так, чтобы ИИ выдавал управляемый результат, а ты сохранял контроль над кодом и пониманием.

Промптинг для разработчика: задачи, контекст, ограничения

Зачем разработчику вообще “уметь просить”

В прошлых статьях ты:

установил Cursor и запустил первый app.py

узнал, что в Cursor есть Chat, Edit и Composer

Теперь ключевой навык лёгкого vibe-coding — формулировать запросы так, чтобы ИИ давал управляемый результат.

Промптинг в разработке — это не “красивые слова”. Это способ:

быстрее получать нужный результат

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

не терять контроль над проектом

Три компонента сильного промпта

Почти любой удачный запрос к ИИ можно разложить на 3 части:

Задача

Контекст

Ограничения

!Три части промпта: задача, контекст, ограничения

Задача

Задача отвечает на вопрос: что ты хочешь получить в итоге.

Хорошая задача:

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

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

Плохо:

“Сделай красиво”

“Почини код”

Хорошо:

“Добавь повторный ввод имени, если строка пустая”

“Объясни ошибку из терминала простыми словами и предложи 2 варианта исправления”

Контекст

Контекст отвечает на вопрос: где это происходит и что у тебя уже есть.

Что чаще всего является полезным контекстом:

язык и версия (например, Python 3.12)

структура проекта (например, “один файл app.py”)

текущий код (кусок или целиком)

команда запуска (например, python app.py)

текст ошибки из терминала целиком

Главное правило: если ИИ не видит важный факт, он будет его додумывать.

Ограничения

Ограничения отвечают на вопрос: как именно делать и чего избегать.

Ограничения защищают тебя от “магии” и расползания изменений.

Примеры сильных ограничений:

“Не добавляй новые файлы”

“Не используй сторонние библиотеки”

“Код должен быть понятен новичку, добавь короткие комментарии”

“Покажи итоговый код целиком только для app.py”

“Сначала предложи план, дождись подтверждения, потом делай шаг за шагом”

Универсальный шаблон промпта

Если не знаешь, как начать, копируй этот каркас и заполняй по ситуации.

Важная привычка: явно писать, что именно ты хочешь получить в ответ. ИИ может и объяснить, и переписать, и “улучшить архитектуру”. Твоя формулировка решает, насколько это будет уместно.

Как промпт зависит от инструмента: Chat, Edit, Composer

Одна и та же задача по-разному формулируется в зависимости от режима.

| Инструмент | Когда выбирать | Какой промпт работает лучше всего | Что просить в ответ | |---|---|---|---| | Chat | понять, спросить, разобрать ошибку, выбрать вариант | много контекста: команда запуска, ошибка, фрагмент кода | объяснение, варианты решений, короткие примеры | | Edit | точечная правка конкретного места | короткая задача + ограничения “меняй только выделенное” | обновлённый фрагмент без лишних изменений | | Composer | фича на несколько шагов и/или файлов | задача + ограничения по масштабу + просьба действовать по плану | план и последовательные изменения по файлам |

Практика на твоём проекте hello-cursor

Ниже примеры запросов, которые можно прямо использовать.

Пример для Chat: понять ошибку

Ситуация: ты запустил python app.py, и что-то сломалось.

Промпт:

> У меня проект на Python. Запускаю python app.py. Получаю ошибку (вставляю целиком): > > Объясни простыми словами, из-за чего она возникает. Предложи 2 способа исправить. Укажи, какой проще для новичка.

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

есть команда запуска

есть ошибка целиком

ты просишь объяснение и варианты, а не “перепиши всё приложение”

Пример для Edit: маленькая правка без расползания

Ситуация: хочешь поменять только один участок кода, не трогая всё остальное.

Выдели в app.py блок, который отвечает за ввод имени

Открой Edit и дай запрос

Промпт:

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

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

задача узкая

ограничение защищает от лишних правок

Пример для Composer: фича “сохранить имя” с контролем

Ситуация: хочешь добавить поведение, которое затрагивает логику приложения, и удобнее сделать это через план.

Промпт:

> У меня проект hello-cursor на Python с файлом app.py. Хочу фичу: сохранять последнее введённое имя в файл last_name.txt, а при старте, если файл существует, предлагать использовать сохранённое имя. > > Ограничения: > - использовать только стандартную библиотеку Python > - код должен быть понятен новичку > - сначала предложи план из 3–5 шагов и дождись моего подтверждения > - потом вноси изменения шаг за шагом и каждый раз показывай, какие файлы меняешь

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

понятная задача

ограничения по библиотекам и понятности

контроль масштаба через “план → подтверждение → шаги”

Частые ошибки новичков в промптах и быстрые фиксы

Слишком общая просьба

Недостаток контекста

Нет ограничений по масштабу

Смешивание разных целей в одном запросе

Нет указания формата ответа

Как исправлять быстро:

если ответ “не туда” — добавь ограничение: “меняй только app.py”, “не добавляй файлы”, “только стандартная библиотека”

если ИИ угадал неверно — добавь контекст: команда запуска, кусок кода, ошибка целиком

если задача большая — переключись на Composer и требуй план + шаги

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

Я чётко написал задачу (что должно получиться)?

Я дал контекст (что есть сейчас: код, команда запуска, ошибки)?

Я указал ограничения (что нельзя, какие файлы трогать, какой стиль)?

Я попросил формат ответа (объяснение, план, код целиком для файла, изменения только фрагмента)?

Итог

Промптинг для разработчика в Cursor держится на трёх опорах:

Задача — что именно нужно сделать

Контекст — с чем мы работаем прямо сейчас

Ограничения — как делать и чего не делать

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

Vibe-coding практика: от идеи до MVP с итерациями

Зачем эта практика, если Cursor уже “умеет писать код”

Ты уже умеешь:

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

выбирать режимы Chat, Edit, Composer

писать промпты через задачу, контекст, ограничения

Теперь главный навык лёгкого vibe-coding — превращать идею в рабочий MVP и улучшать его итерациями так, чтобы не утонуть в правках.

MVP — это минимально рабочая версия. Не “идеальная”, а “уже полезная и запускается”.

В чём суть итераций

Итерация — короткий цикл:

выбрал одну маленькую цель

сделал изменение

запустил и проверил

зафиксировал результат

Так ты держишь скорость и контроль.

!Диаграмма, показывающая короткий цикл от идеи до MVP и повторных улучшений

Правило одной итерации

Чтобы итерации были быстрыми, держи ограничение:

одна итерация = одна проверяемая фича или одно исправление

Плохая итерация:

“Сделай приложение для заметок с аккаунтами, синхронизацией и дизайном”

Хорошая итерация:

“Добавь команду list, чтобы показать все заметки”

Выбираем учебный мини-проект для практики

Чтобы не упереться в установку библиотек, сделаем консольный MVP на Python в одной папке.

Идея проекта: мини-приложение заметок в терминале.

MVP-цель на сегодня:

добавить заметку

показать список заметок

хранить заметки в файле notes.json

Почему это хороший тренажёр:

понятная логика

есть работа с файлами

легко тестировать через терминал

Справка по формату JSON (если захочешь углубиться): Документация Python: json

Подготовка проекта в Cursor

Создай папку проекта vibe-notes и открой её в Cursor.

Создай файл app.py.

Запускать будем так:

Если у тебя команда другая, используй python3 app.py.

Итерация 0: договоримся о “рамках”

Перед тем как просить ИИ писать код, зафиксируй рамки. Это снижает “магические” решения.

Рамки проекта:

Python, только стандартная библиотека

один файл app.py

данные в notes.json в той же папке

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

Промпт-рамка, которую полезно копировать

Этот шаблон можно вставлять в Chat перед большой работой, чтобы ИИ “держал стиль”.

> Мы делаем учебный проект на Python для новичка. > Ограничения: стандартная библиотека, понятный код, минимум файлов (пока один app.py), запуск python app.py. > Если предлагаешь изменения, показывай код целиком только для app.py.

Итерация 1: делаем MVP-скелет через Composer

Задача итерации: чтобы приложение запускалось и понимало базовые команды.

Когда использовать Composer здесь: он быстро соберёт каркас (парсинг команд, чтение/запись файла), и это удобнее, чем “по кускам”.

Промпт для Composer

Скопируй и вставь в Composer:

> Задача: > - Сделай консольное приложение заметок в app.py. > - Команды: > - add <текст>: добавить заметку > - list: вывести все заметки с номерами > - help: показать подсказку > > Контекст: > - Проект пустой, есть только app.py. > - Запуск: python app.py. > > Ограничения: > - стандартная библиотека Python > - хранить заметки в notes.json рядом с app.py > - если файла нет, создавай пустой список > - код понятный новичку, с короткими комментариями > - покажи итоговый код целиком только для app.py

После ответа Composer: обязательная проверка

Вставь код в app.py.

Запусти:

Если видишь ошибку, копируй её целиком и иди в Chat.

Итерация 2: улучшаем UX точечной правкой через Edit

Типичная проблема MVP: неудобные сообщения или странное поведение на пустом вводе.

Задача итерации: сделать валидацию для add.

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

Как сделать правку

Найди место, где обрабатывается команда add.

Выдели блок обработки add.

Открой Edit и дай промпт:

> Если пользователь вызвал add без текста или с пустой строкой, не сохраняй заметку. Выведи понятное сообщение и покажи пример add Купить молоко. Меняй только выделенный фрагмент.

Запусти снова:

Итерация 3: отлавливаем ошибки хранения через Chat

Иногда MVP “работает”, но ломается, если файл повреждён.

Задача итерации: если notes.json содержит некорректный JSON, приложение не падает, а предлагает восстановление.

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

Промпт для Chat

> У меня консольное приложение заметок на Python, хранит данные в notes.json. > Хочу поведение: если notes.json повреждён (некорректный JSON), приложение не падает. > Предложи 2 варианта: простой для новичка и чуть надёжнее. Для каждого покажи, какой блок кода нужно добавить или изменить (без полного переписывания файла).

Потом выбери вариант и внеси изменения через Edit (выделяя конкретные функции чтения/записи).

Итерация 4: маленькая новая фича через Composer, но под контролем

Добавим одну фичу: del <номер> удаляет заметку.

Здесь снова уместен Composer, потому что фича затрагивает чтение списка, проверку индекса и запись.

Промпт для Composer с контролем масштаба

> Задача: > - Добавь команду del <номер>: удалять заметку по номеру из вывода list. > > Контекст: > - Всё в одном файле app.py, данные в notes.json. > - Уже есть команды add, list, help. > > Ограничения: > - стандартная библиотека > - не меняй формат данных в notes.json > - сначала коротко опиши план из 3 шагов > - затем покажи изменения только для app.py (можно целиком, если так проще)

После внедрения проверь:

Как не потерять контроль: мини-чеклист итерации

| Шаг | Что сделать | Чем помогает | |---|---|---| | Выбрать цель | 1 фича или 1 исправление | меньше хаоса | | Дать контекст | команда запуска, файлы, текущий код/ошибка | меньше “догадок” | | Поставить ограничения | “без новых файлов”, “стандартная библиотека”, “покажи только app.py” | меньше расползания | | Выбрать режим | Chat для понимания, Edit для точечно, Composer для фичи | быстрее попасть в цель | | Запуск | прогнать 2–5 команд в терминале | ловит ошибки сразу |

Типовые “вибе-ошибки” новичка и как чинить

Слишком большая цель за раз

Недостаточно контекста в промпте

Нет ограничений на файлы и масштаб

Принял код и не запустил

Быстрый фикс-паттерн:

откати изменение

уточни промпт: что именно, в каком файле, какой формат ответа

попроси “сначала план, потом изменения”

Итог

Ты прошёл рабочий маршрут vibe-coding:

превратил идею в MVP через маленькие цели

использовал Composer для каркаса и фич

использовал Edit для точечных правок

использовал Chat для выбора решений и разбора проблем

проверял каждую итерацию запуском в терминале

Если хочешь продолжать, лучший следующий шаг — добавить одну “реальную” удобную штуку (например, поиск search <текст>), но так же итеративно: одна цель → один запуск → одна проверка.

Качество и безопасность: тесты, рефакторинг, проверка AI-ответов

Зачем качество и безопасность в vibe-coding

Vibe-coding — это скорость, но скорость без контроля быстро превращается в хаос: “вчера работало, сегодня сломалось, почему — непонятно”. Когда ты используешь Cursor, есть дополнительный риск: ИИ может уверенно предложить решение, которое:

работает не так, как ты хотел

ломает старые сценарии

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

Твоя цель как новичка — не “писать идеально”, а выстроить короткий, повторяемый процесс:

маленькое изменение

быстрая проверка

только потом следующее изменение

!Цикл "попросил → изменил → проверил" помогает не потерять контроль в vibe-coding

Как проверять AI-ответы, чтобы не принимать “магию”

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

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

Совпадает ли результат с задачей

- Если ты просил “добавь команду del”, а тебе переписали половину проекта — это сигнал остановиться.

Какие файлы меняются и зачем

- Проси: “покажи список файлов и что в них меняется”.

Нет ли лишних зависимостей

- Новичку лучше начинать со стандартной библиотеки Python.

Нет ли опасных мест

- Ищи в предложенном коде: eval, exec, os.system, subprocess, неожиданные удаления файлов, запись в странные пути.

Обязательный запуск

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

Что делать, если ответ кажется сомнительным

Используй Chat не только для генерации, но и для аудита.

Пример промпта для проверки кода:

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

Тесты: что это такое и почему они ускоряют

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

Для новичка тесты ценны тем, что:

ловят поломки сразу после правки от ИИ

помогают рефакторить без страха

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

Важно: тесты не обязаны быть “идеальными”. Достаточно 5–10 проверок на ключевые сценарии.

Какие проверки нужны новичку: три уровня

| Уровень | Что проверяем | Как выглядит | Когда достаточно | |---|---|---|---| | Ручная проверка | 2–5 команд в терминале | python app.py add "..." | на раннем MVP | | Дымовой тест | “Запускается и не падает” | запуск help, list | почти всегда после больших правок | | Мини-юнит тесты | отдельные функции | python -m unittest | когда код стал больше и страшно ломать |

Дымовой тест — это простая проверка “не дымит ли”: приложение стартует и выполняет базовые команды.

Мини-тесты на стандартной библиотеке: unittest

В Python есть встроенный модуль unittest — он позволяет писать тесты без сторонних библиотек.

Официальная документация:

unittest — Unit testing framework

Подготовка проекта к тестам: маленький рефакторинг

Проблема консольных приложений (как наш vibe-notes) в том, что логика часто смешана с вводом/выводом. Тестировать проще, если вынести логику в функции.

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

Примеры рефакторинга:

вынести работу с файлом в load_notes() и save_notes()

вынести операции в add_note(notes, text) и delete_note(notes, index)

сделать функцию format_notes(notes) которая возвращает строку

Пример структуры файлов

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

app.py — приложение

test_app.py — тесты

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

Пример: тесты для vibe-notes

Ниже пример того, как ты можешь попросить Cursor помочь, не теряя контроль.

Промпт для Composer: подготовить код к тестам

> Задача: > - Подготовь мой app.py к простым тестам: вынеси логику работы с заметками в функции. > > Контекст: > - Это консольное приложение заметок на Python, хранит список строк в notes.json. > - Команды: add, list, del, help. > > Ограничения: > - Не меняй поведение команд с точки зрения пользователя. > - Стандартная библиотека. > - Покажи изменения только для app.py. > - Сначала коротко перечисли, какие функции добавишь.

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

Пример промпта для Composer: написать test_app.py

> Задача: > - Создай test_app.py для unittest. > - Протестируй функции: добавление заметки, удаление заметки, форматирование списка. > > Контекст: > - Логика вынесена в функции в app.py. > > Ограничения: > - Не тестируй работу с реальным notes.json на диске. > - Тесты должны быть понятны новичку. > - Покажи код целиком только для test_app.py.

Как запускать тесты

В терминале из папки проекта:

Если у тебя Python запускается как python3:

Что означает команда:

python -m unittest — просит Python запустить модуль unittest

unittest сам найдёт файлы вида test*.py и выполнит проверки

Как правильно рефакторить с Cursor, чтобы ничего не сломать

Рефакторинг для новичка должен быть маленьким и проверяемым.

Безопасная схема рефакторинга

Зафиксируй текущее поведение

- Прогони 3–5 команд, которые точно должны работать.

Сделай маленький рефакторинг

- Например, вынеси одну функцию.

Сразу запусти проверку

- Сначала ручные команды, затем тесты.

Только потом следующий шаг

Хорошие запросы для Edit при рефакторинге

“Вынеси этот блок чтения notes.json в функцию load_notes(). Логику не меняй. Меняй только выделенный фрагмент.”

“Переименуй переменные так, чтобы новичку было понятнее. Поведение не меняй. Новые файлы не добавляй.”

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

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

Что чаще всего опасно в коде от ИИ

Выполнение кода из текста

- eval(...), exec(...)

Выполнение команд операционной системы

- os.system(...), subprocess.run(...) без строгих ограничений

Случайное удаление/перезапись файлов

- запись в абсолютные пути - удаление без подтверждения

Работа с пользовательским вводом без проверок

- например, номер для del, который не является числом

Если ты видишь подобное — остановись и попроси альтернативу.

Правила безопасности для vibe-notes

Храни данные только в файле проекта (например, notes.json рядом с app.py)

Не выполняй команды из ввода пользователя

Всегда проверяй ввод

- для del проверять, что индекс — число и в диапазоне

Не добавляй сетевые запросы “просто так”

- если ИИ внезапно добавил работу с интернетом — уточни, зачем

Как просить Cursor так, чтобы он улучшал качество, а не усложнял

Главная ошибка новичка: попросить “сделай профессионально”, и получить лишнюю архитектуру.

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

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

“Не добавляй больше 1 нового файла”

“Не меняй поведение команд”

“Сначала план из 3–5 шагов, затем изменения шаг за шагом”

“Покажи только конкретные изменения / только один файл целиком”

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

Итог

Чтобы vibe-coding оставался лёгким, тебе нужна простая дисциплина:

проверять AI-ответы по чеклисту

рефакторить маленькими шагами

добавить минимальные тесты на unittest

после каждой правки запускать проект и тесты

Так ты сохраняешь скорость Cursor, но перестаёшь зависеть от случайных “магических” изменений.