Недавно выпустили Context — нативное приложение для macOS, которое помогает отлаживать MCP-серверы. Задача была сделать удобный инструмент для разработчиков, который органично вписывается в экосистему Apple и построен на SwiftUI.
Почти весь код для Context сгенерировал Claude Code. Всего в проекте около 20 000 строк. Из них руками написано меньше тысячи.
Дальше — история, как всё получилось. Автор статьи рассказал, какие инструменты использовал, в чём плюсы и минусы, и как выжать максимум из генерации кода, если вы делаете нативное приложение.
Статья является переводом зарубежного автора. Оригинал доступен по ссылке. Переводом статьи занималась редакция figure.media.
От Copilot до Claude Code
Первые ИИ для кода появились внутри привычных редакторов. GitHub Copilot, встроенный в VS Code, стал первой массовой попыткой заменить автодополнение чем-то умным. Он не просто подсказывал имена функций, а мог дописывать целые части кода по контексту. Это давало ощутимый прирост скорости, но основная работа по-прежнему оставалась на разработчике.
Дальше началось движение в сторону «агентного» подхода. Появились Cursor, Windsurf и другие решения, которые отказались от идеи одиночных подсказок. Вместо этого — замкнутый цикл: ИИ получает задачу, ищет информацию по коду, изучает документацию, компилирует, запускает тесты, устраняет ошибки и пробует снова. Уже не подсказка, а полноценный участник процесса.
К началу 2025 года на рынок вышел Claude Code. В отличие от других, это отдельная среда. Полноценная IDE, работающая из терминала. Без визуального интерфейса, без вкладок и панели инструментов, только текстовое поле и логика, построенная вокруг агента.
Claude не дополняет IDE — он ею становится. Работа строится через диалог с моделью. Такой подход радикально отличается от привычного, но именно это делает его интересным: не конкурирует с редакторами, а меняет представление о процессе.
Почему появляются проекты, но не появляются релизы
У разработчиков с плотной загрузкой на основной работе часто скапливаются десятки недоделанных пет-проектов. Прототипы запускаются, идеи проверяются, но до выпуска дело не доходит. Чаще всего стопор случается в последней четверти пути. Финальные 20% — самые дорогие по времени и усилиям. Из-за этого многие не доводят проекты до релиза годами.
Ситуация начала меняться с появлением Claude Code, особенно с его поддержкой MCP-серверов. MCP (Model Context Protocol) — это открытый стандарт от Anthropic, он даёт агентам доступ к инструментам и контексту, необходимому для выполнения задач. Sentry через MCP-сервер позволяет ИИ находить ошибки, анализировать стек-трейсы и даже использовать встроенного агента для устранения.
У MCP есть нюанс: его не запустишь одной командой в терминале. Серверы общаются с клиентами либо через стандартные потоки ввода-вывода, либо по HTTP с использованием Server-Sent Events. Это не curl и не API-запрос в два клика. Существуют утилиты вроде MCP Inspector, которые помогают тестировать такие сервера, но они далеки от удобства.
Это и подтолкнуло к решению: сделать нативное macOS-приложение, которое упростит работу с MCP. С одной стороны — закрыть конкретную задачу. С другой — проверить, на что способен Claude Code в реальном проекте. В идеале — получить и опыт, и готовый продукт.
Claude Code пишет код, и делает это лучше среднего разработчика
Claude Code (на базе свежих моделей Sonnet 4 и Opus 4) показывает стабильный, уверенный результат в генерации кода. Это не уровень топ-1% инженеров, но по качеству и точности выше среднего. Особенно в задачах, где чётко сформулировано, что нужно сделать. Claude умеет:
- находить и читать релевантные участки кода в проекте;
- улавливать стиль, паттерны и архитектурные принципы;
- читать спецификации и документацию;
- генерировать фичу по описанию;
- писать автотесты под неё;
- собирать проект, запускать тесты;
- исправлять ошибки сборки и тестирования до зелёного билда;
- анализировать скриншоты или логи и чинить баги на их основе.
Всё это за время, которое человеку нужно было бы только на погружение в контекст
Впечатляет точность и скорость. Представьте: берёте нового сотрудника без опыта в вашем коде и он выпускает рабочую функцию за несколько минут. Claude делает примерно это, и при правильной постановке задачи не спотыкается.
Насколько хорошо Claude Code справляется с Swift и SwiftUI
В качестве основы для приложения выбран стек последних технологий Apple: Swift 6.1 и SwiftUI под macOS 15.5. Интерес представляло, как Claude справится с языком, который гораздо реже встречается в обучающих выборках, чем Python или JavaScript.
В Swift 5.5 Claude показывает уверенные навыки, большинство синтаксических конструкций он использует корректно. Однако с Swift Concurrency — новой системой асинхронного программирования, появившейся в 5.5 — возникают сложности. Это не удивительно: даже опытные разработчики не всегда используют её без ошибок.
Claude путается в выборе между современными и устаревшими фреймворками. В ряде случаев вместо SwiftUI он использует AppKit или даже Objective-C API, несмотря на наличие современных аналогов. С SwiftUI ситуация лучше. Claude генерирует рабочие интерфейсы, пусть и не всегда эстетичные. При доработке они превращаются в полноценные, нативные маковские экраны.
При генерации UI-кода Swift нередко выдаёт ошибку: The compiler is unable to type-check this expression in reasonable time. Это происходит, когда выражения слишком сложны для проверки типов. Claude автоматически разбивает крупные конструкции на мелкие и при этом не нарушает логику. Иногда даже без наставлений пользователя, ориентируясь по сообщениям компилятора.
Чтобы избежать типичных ошибок, добавьте в проект файл CLAUDE.md — с правилами работы. Вот выдержка из такого файла:
- Использовать SwiftUI, если только нужная функция не требует AppKit.
- Проектировать UI по гайдлайнам Apple для macOS.
- Использовать SF Symbols для иконок.
- Опираться на самые современные API — проект не требует обратной совместимости.
- Применять актуальные возможности Swift 6, включая concurrency и макросы.
Даже простой набор правил даёт стабильный результат, а при желании можно идти глубже — использовать готовые шаблоны из репозитория agent-rules от Питера Штайнбергера, где собраны рекомендации для генерации качественного Swift-кода.
Качество можно оценить на практике, в исходниках проекта доступны примеры:
- OAuthClient.swift — реализация OAuth 2.1.
- JSONOutlineView.swift — дерево JSON с поддержкой сворачивания узлов на SwiftUI.
Как улучшить интерфейс с помощью пары слов
Один из неожиданных плюсов работы с Claude Code — умение на лету улучшать дизайн интерфейса. Если сгенерированный UI выглядит грубовато, достаточно просто написать: «Сделай красивее» или «Сделай интерфейс элегантнее и удобнее». Claude воспринимает такие запросы буквально и вносит улучшения, причём с минимальным участием разработчика.
Более методичный подход — сначала запросить список идей: «Предложи, как можно улучшить этот интерфейс». Claude выдаёт перечень точечных изменений, от визуальных до UX-решений. Дальше можно выбрать нужное и применить.
Для визуальной обратной связи работает простой приём: если в UI что-то сломалось или хочется подправить конкретный элемент, достаточно сделать скриншот и вставить его в Claude (через drag’n’drop или ⌘+V). Claude проанализирует изображение и предложит решение.
Пока это не автоматизировано полностью, но при этом универсально. Метод работает независимо от того, на чём собирается фронт: SwiftUI, Web, Android и т.д.
Контекст важнее промптов
Когда генеративный ИИ стал массовым, появился и термин prompt engineering. Считалось, что от формулировки запроса зависит всё: как сформулируешь, такой результат и получишь. С развитием моделей концепция потеряла актуальность.
Современные ИИ, включая Claude с моделями Sonnet 4 и Opus 4, хорошо справляются даже с неточным вводом. Больше не нужны идеальные фразы: модели понимают намерение, даже если текст небрежный, с ошибками или неполный. Всё благодаря тому, что они умеют «рассуждать» пошагово через встроенный chain-of-thought (CoT).
Настоящее ограничение теперь не в запросах, а в контексте
У новых моделей Anthropic контекстное окно на 200 тысяч токенов. В это окно входят ваши запросы, все предыдущие ответы Claude. Чем больше переписка, тем ближе к пределу, и чем ближе к этому пределу, тем хуже становится качество отклика.
В Claude Code есть индикатор, показывающий, сколько контекста осталось. Когда он заполняется, запускается compaction: модель сжимает предыдущую переписку в краткое резюме и начинает работу с новым окном. У этого есть побочные эффекты: важные детали могут потеряться, особенно если в исходной беседе были ошибки — они могут остаться в «сжатой» версии и повлиять на результат.
Поэтому ключевая задача — контекстная инженерия, не просто правильно задать вопрос, а управлять тем, что модель «помнит» и как она строит логику. Это и есть новая грамотность: выжимать максимум из ограниченного окна, не теряя суть и детали.
Как дать ИИ максимум контекста до начала задачи
Один из приёмов, который позволяет значительно повысить качество работы Claude Code, так называемый прогрев агента — вместо того чтобы сразу давать задачу, сначала подгружается дополнительный контекст. Это увеличивает шансы получить точный и логичный результат с первого раза.
По умолчанию Claude читает два файла — CLAUDE.md в рамках проекта и CLAUDE.md в профиле пользователя. Но в задачу можно вручную добавить дополнительную документацию или исходный код — как локально, так и с внешних источников.
Пример запроса на прогрев:
Прочитай файлы DXTTransport.swift, DXTManifest.swift, DXTManifestView.swift, DXTConfigurationView.swift, DXTUserConfiguration.swift, AddServerFeature.swift и AddServerView.swift, чтобы понять, как реализовано добавление серверов из DXT-пакетов.
Затем прочитай документацию по формату manifest.json: https://raw.githubusercontent.com/anthropics/dxt/refs/heads/main/MANIFEST.md
После этого — сделай краткое резюме по прочитанному.Claude использует встроенные инструменты Search и Read, чтобы найти и просканировать указанные файлы. Внешние источники подтягиваются через Fetch. Запрос на резюме заставляет модель обобщить информацию, и это повышает качество всех следующих шагов.
Этот подход полезен, если проект использует сторонние библиотеки или API, которые появились уже после даты среза знаний модели. Чтобы ускорить прогрев, можно использовать утилиты вроде Context7 и llm.codes — они переводят документацию в формат, который модель читает без потерь.
ИИ не читает мысли — ему нужны ТЗ
Чтобы Claude Code справился с задачей, одной общей формулировки недостаточно. Никакая модель не построит полноценную фичу «по вдохновению». Без подробного ТЗ результат будет либо примитивным, либо мимо задачи.
В демо-роликах часто показывают, как по одному предложению создаются «целые приложения», но это работает только для эффектного старта или прототипов. Если нужна реальная функция, с логикой, архитектурой и тестами — нужно описание. Пусть даже неформальное.
Спецификация не обязана быть идеально написанной, её можно набросать голосом, телеграфным стилем или в заметках. Главное, чтобы в ней было:
- Что должно происходить пошагово.
- Как это должно выглядеть.
- Какие ограничения и зависимости есть.
- Какие сценарии нужно поддерживать.
На первый взгляд, объёмный промт, но составить такой текст быстрее, чем писать код руками
ИИ способен многое, но только если понимает, что от него хотят. Поэтому чёткое ТЗ — это не «лишняя формальность», а основа нормальной работы.
Прежде чем писать код, заставьте Claude думать
Одна из типичных проблем при работе с Claude Code — модель слишком быстро переходит к реализации без подготовки и плана. Это снижает качество результата: появляются ошибки, пропускаются важные детали. Решить можно активацией режима углублённого мышления. Это встроенная функция, Claude реагирует на ключевые слова:
- think — обычное размышление,
- think hard — на шаг глубже,
- think harder — ещё более подробный анализ,
- ultrathink — максимальная проработка.
Сигналы заставляют модель разложить задачу на шаги, учесть контекст и только потом предлагать решение. В режиме ultrathink Claude тратит больше токенов, но и результат получается на порядок лучше.
Чтобы повысить точность ещё больше, в промпт добавьте: «не переходи к реализации, пока я не одобрю план». Это позволяет сначала обсудить логику, уточнить детали, и только потом запускать кодогенерацию.
Если нужен системный подход, стоит прочитать статью Claude Code: Best practices for agentic coding от Anthropic. В ней подробно разобраны все техники, включая те, что описаны выше. Это must-read для тех, кто работает с Claude или другими агентами.
Как выстроить обратную связь, чтобы Claude учился на своих ошибках
Claude становится по-настоящему полезным, когда умеет сам проходить цикл: внести изменение, протестировать, понять, что пошло не так, и повторить попытку. Чтобы это работало, важно выстроить обратную связь.
Модель умеет собирать проекты через swift build — это работает стабильно, но с Xcode-сборками возникают сложности: правильную команду xcodebuild Claude подбирает не всегда. Помогает сторонний инструмент XcodeBuildMCP — он даёт модели упрощённый интерфейс для сборки и запуска.
С тестами ситуация похожая. Для Swift-пакетов swift test работает из коробки. А вот с UI-тестами и приложениями точной информации пока нет — вероятно, тут тоже нужен XcodeBuildMCP.
Claude умеет отлаживать через логи: добавляет отладочные сообщения, анализирует ошибки, предлагает правки. Но не может самостоятельно кликать по интерфейсу и доводить приложение до нужного состояния — это должен делать человек. После этого можно вставить логи вручную, и модель разберётся, что не так. Это рабочий способ, но до полной автономности далеко. Если заранее написать юнит-тесты, это частично решает проблему. В вебе для этого уже есть решения вроде playwright-mcp. Для нативной разработки — пока нет.
С визуальной отладкой всё чуть проще. Скриншоты Claude обрабатывает хорошо, и может итеративно улучшать UI. В теории можно подключить автоматизацию съёмки через Peekaboo. Но и здесь не обойтись без ручного взаимодействия: приложение сначала нужно довести до нужного состояния, чтобы сделать корректный снимок.
Обратная связь — это не дополнительный этап, а основа работы. Без неё Claude будет каждый раз начинать с нуля. С ней он учится на ошибках и становится полезным инструментом.
Claude Code — не только про код
Хотя Claude Code создавался как инструмент для генерации кода, он работает на базе универсальной языковой модели. Это значит, что его можно подключать и к смежным задачам, не только к программированию. Он помогает с редактированием текстов, генерацией вариантов, планированием новых фич и разбором продуктовых решений.
Один из простых, но полезных приёмов — генерация мок-данных. Особенно на раннем этапе, когда настоящие данные недоступны, а интерфейс хочется показать. Пока шла работа над клиентской библиотекой MCP на Swift, возникла задача: быстро собрать интерфейс и оценить UX.
Настраивать руками реалистичный тестовый JSON слишком долго, а Claude справился за секунды. Сгенерированные данные выглядели достаточно правдоподобно, чтобы протестировать отображение, провести итерации по дизайну и сделать первые скриншоты.
Claude оказался полезен там, где обычно всё упирается во время и лень
Особенно это помогло в случае с MCP, где на тот момент большинство серверов реализовывали только базовые инструменты, а расширенные функции из спецификации — почти никто не использовал. Без моков UI остался бы без проверки.
Автоматизация, которая раньше стоила времени, теперь почти бесплатна
Как и говорили выше, самая трудная часть выпуска приложения — последние 20%, автоматизация релиза. Особенно на macOS, где нужно пройти через цепочку подписей, нотификаций и упаковки. Раньше на этом этапе приходилось вручную настраивать Fastlane, писать скрипты на Python, всё это отлаживать и часто бросать на полпути.
За пару часов итераций Claude собрал полноценный скрипт релиза, который:
- проверяет окружение и наличие нужных инструментов,
- собирает лог изменений: вытягивает коммиты из git, комбинирует с ручными правками, оформляет как HTML-описание релиза,
- собирает приложение, подписывает, отправляет на нотификацию и упаковывает в DMG,
- создаёт Sparkle-совместимый appcast для автообновлений,
- тегирует релиз и публикует его на GitHub,
- загружает отладочную информацию в Sentry для расшифровки крашей.
После того как скрипт заработал, потребовался всего один запрос, и Claude оформил красивый вывод в консоли.
В итоге получился инструмент, которым приятно пользоваться
Это более 2000 строк кода, которые вручную просто не стали бы писать. Максимум автоматизировали бы 1–2 критичных шага. А тут — полный цикл, с понятным интерфейсом и без рутины. Затраты — пара абзацев описания и немного отладки по ходу выполнения, экономия — десятки минут на каждом релизе.
IDE будущего будут совсем другими
Во время работы над проектом неожиданно выяснилось, что практически всё можно было сделать с помощью двух инструментов — Claude Code и GitHub Desktop (для просмотра diff). Файловый менеджер, редактор исходников, плагины, предпросмотр — всё это почти не понадобилось. Xcode запускался пару раз для правок, но даже тогда не использовались его фишки вроде SwiftUI Preview или отладчика интерфейса.
Если учесть, что нынешние агентные ИИ — это самый «сырой» этап их развития, становится очевидно: традиционные IDE себя изживают. VS Code, Cursor, Copilot — они идут от классического редактора, которому 20+ лет. Даже самые продвинутые IDE по структуре всё ещё напоминают JetBrains в начале 2000-х.
Есть попытки переосмыслить интерфейс разработки. Например, Warp, который движется от терминала к агентной среде. Но даже терминал — не предел мечтаний. Будущее не за интерфейсом, а за процессом. В новых IDE главным станет не редактирование кода, а управление контекстом и обратной связью для агента. То, что сегодня выглядит невообразимо, через время станет стандартом.
Главное — снова можно выпускать проекты
Но важнее всего не технологии, а то, что они вернули возможность запускать побочные проекта без выгорания и без застревания на последнем этапе.
Сейчас это ощущается, как будто в сутках появилось плюс пять часов. А стоило это — 200 долларов в месяц. Самый разумный апгрейд продуктивности за последние годы.
