Путь iOS‑разработчика
от Trainee до Staff

• Сложность алгоритмов в нотации Big-O — пригодится буквально каждый день.
• Система типов: что такое ссылка, что такое значение, в чём разница.
• Стек vs куча — где живут данные, как двигаются между потоками.
• Бинарное представление чисел (чтобы не было сюрпризов с Int, UInt8, Float).

• Конкретные алгоритмы сортировки (сортировки за вас написали в стандартной библиотеке).
• Глубокая теория компиляторов и автоматов — понадобится только в очень специфичных задачах.
• Доказательство NP-полноты — придёт само, если выберете путь System Design.

Big-O

Оценка асимптотики: как растёт время/память при росте входа. O(1) — константа, O(log n) — бинарный поиск, O(n) — линейный, O(n log n) — сортировки, O(n²) — наивные двойные циклы.

Stack vs Heap

Стек быстрый, ограниченный, авто-очистка. Куча — динамическая, медленнее, очищается ARC/GC. Value-типы Swift живут на стеке (если не захвачены замыканием), reference — на куче.

Value vs Reference type

Value (struct, enum) — копируется при передаче. Reference (class) — передаётся по ссылке. Это влияет на производительность и многопоточность.

Copy-on-Write

Оптимизация для коллекций: копия делается только при записи. Array, Dictionary, Set, String — все CoW.

Парадигмы

OOP (наследование, полиморфизм), FP (чистые функции, иммутабельность), POP (компоновка через протоколы) — Swift поддерживает все три.

1. Big-O для своего кода. Откройте проект и найдите 5 функций. Для каждой определите сложность по времени и памяти. Где O(n²)? Можно ли свести к O(n log n)? Подсказка: вложенный for — это часто O(n²). Используйте Set/Dictionary для O(1) поиска.
   Habr: Big-O на пальцах
2. Stack vs Heap. Создайте struct с массивом и class с массивом. Запустите Time Profiler и сравните аллокации при создании 1 млн копий. Перед запуском включите Allocations Instrument. Обратите внимание на колонку Persistent.
   Performance · Apple
3. Copy-on-Write. Реализуйте свою CoW-структуру с isKnownUniquelyReferenced. Покажите, что копия не происходит при чтении. Внутри храните class-обёртку. На запись — проверка уникальности и только тогда копия.
   isKnownUniquelyReferenced
4. Структуры данных вручную. Реализуйте односвязный список, hash table, мин-кучу — без стандартной библиотеки. Это лучше любого учебника. Hash table — самое полезное. В iOS-собесах его просят чаще, чем кажется.
5. Парадигмы на одном примере. Возьмите сценарий «список задач» и решите его 3 способа: классический OOP, чистый FP, POP-стиль. Сравните читаемость.
6. Бинарное представление. Что выведет Int8(127) &+ 1? А UInt8.max + 1? Запустите в playground и объясните результат через двоичную запись. Это про переполнение и дополнительный код (two's complement).
7. Big-O для коллекций Swift. Найдите в документации сложности операций для Array, Set, Dictionary. Какая сложность у contains на массиве из 100k элементов?
8. Ленивая оценка. Сравните arr.map(...).filter(...) и arr.lazy.map(...).filter(...) на массиве из 1 млн элементов. Где разница? Lazy не материализует промежуточные коллекции — экономит память.

• HTTP/1.1 vs HTTP/2 vs HTTP/3 — что меняется на практике (multiplexing, TLS 1.3, QUIC).
• TLS-handshake и сертификаты — без этого ATS-ошибки будут «магией».
• Процессы vs потоки vs очереди — это база Concurrency.
• Sandbox iOS-приложения, файловая система, App Group.

• Глубокая реализация TCP/IP (control flags, congestion windows) — нужно, только если строите VPN/SDK.
• Линуксовые системные вызовы — пригодятся точечно.
• Подробности SSL/TLS-хендшейка вручную — поймите концептуально.

RunLoop

Цикл обработки событий, привязанный к потоку. main RunLoop отвечает за UI-события, таймеры, источники.

Sandbox

Изолированная среда: приложение видит только свои контейнеры (~/Library, Documents, tmp). Доступ к чужим — через intent/share extensions.

App Transport Security (ATS)

iOS требует HTTPS с TLS 1.2+. Disable можно только через Info.plist и не для прода.

HTTP/2

Мультиплексирование, бинарный формат, server push. URLSession поддерживает «из коробки».

HTTP/3 (QUIC)

Поверх UDP, быстрее устанавливает соединение. Включается в URLSession через assumesHTTP3Capable.

1. Пощупать sandbox. Попробуйте записать файл в /private/tmp из приложения и в FileManager.default.url(for: .documentDirectory). Сравните результат.
   FileManager · Apple
2. Анализ TLS. Откройте nscurl --ats-diagnostics https://example.com. Какие версии TLS поддерживаются? Что блокирует ATS?
3. Charles/Proxyman. Перехватите трафик симулятора. Найдите запросы, которые шлёт SwiftUI Preview. Установите root-сертификат Proxyman в симулятор и trust его в Settings.
4. HTTP/2 → HTTP/3. Включите config.assumesHTTP3Capable = true и сравните latency на 100 запросах.
5. WebSocket с нуля. Используйте URLSessionWebSocketTask и подключитесь к публичному echo-серверу. Реализуйте reconnect с экспоненциальной задержкой.
   URLSessionWebSocketTask
6. RunLoop в действии. Запустите Timer.scheduledTimer с задержкой 1с в фоновом потоке без явного RunLoop. Почему он не сработает?
7. Background modes. Включите Background Fetch и реализуйте обновление данных через BGAppRefreshTask. Замерьте, сколько раз iOS его реально вызвал за сутки.
   BackgroundTasks

• Атомарные коммиты, осмысленные сообщения (Conventional Commits — но без догматизма).
• rebase vs merge: когда что использовать.
• Разрешение конфликтов осознанно, не через «принять свои».
• Этикет код-ревью: как давать и получать обратную связь.

• Внутренности git (objects, packfiles) — нужно при написании tooling.
• Submodules — лучше избегайте; используйте SPM/Tuist.
• Subtrees — экзотика.

1. Interactive rebase. Сделайте 5 коммитов, переименуйте 2-й, объедините 3-й и 4-й, удалите 5-й. git rebase -i HEAD~5 — затем reword, squash, drop.
2. Cherry-pick. Перенесите конкретный коммит из feature-ветки в hotfix.
3. Bisect. Найдите коммит, в котором сломался тест — без чтения diff'ов, только через git bisect.
4. Merge vs Rebase. Сделайте PR с merge, затем PR с rebase. Сравните историю в git log --graph.
5. Conflict осознанно. Создайте конфликт, разберите его в Xcode'овском merge view. Убедитесь, что код всё ещё компилируется.
6. Reflog. «Случайно» сделайте reset --hard. Восстановите коммит через git reflog.
7. Hooks. Напишите pre-commit, который запускает SwiftLint. Сделайте коммит с warning — он должен упасть.
8. Code review навык. Найдите свой PR полугодовой давности и напишите ревью на самого себя.

• Trunk-based vs GitFlow. Понимать, какая стратегия подходит вашей команде. Не навязывайте GitFlow стартапу из 4 человек.
• Code review как наставничество. Хорошее ревью — это не «верните пробел», а «вот почему этот подход создаст проблему через год».
• Релизные процессы. Связка git-flow + ветки релизов + теги версий + автогенерация changelog.
• Контракты команды. Договариваетесь, как именно вы коммитите, мерджите и ревьюите. Документируйте в README.

• zsh + Oh My Zsh / starship — приятный prompt и плагины.
• Homebrew, brew bundle, Brewfile — воспроизводимое окружение.
• jq, fzf, ripgrep, bat, tldr — обязательные.
• xcrun, simctl, xcodebuild — Xcode без UI.

• Глубокий awk/sed — обычно достаточно jq и Python-скриптов.
• Vim/Emacs holy wars — выберите редактор и идите дальше.

1. Brewfile. Соберите все ваши пакеты в Brewfile: brew bundle dump. Сохраните в dotfiles-репо.
2. simctl. Запустите симулятор iPhone 15 Pro из терминала, установите .app, снимите скриншот. xcrun simctl boot "iPhone 15 Pro", simctl install, simctl io ... screenshot.
3. jq для App Store Connect API. Распарсите ответ /v1/builds и достаньте номер последней сборки одной строкой.
4. fzf. Настройте поиск по последним веткам: git checkout $(git branch | fzf).
5. Алиасы. Создайте gco, gst, gp, xcb. Каждый сэкономит ~50 нажатий в день.
6. tldr. Замените 80% вызовов man на tldr. Убедитесь, что это быстрее.
7. xcodebuild без Xcode. Соберите проект, прогоните тесты, поднимите архив — целиком из терминала.

• Optional и его обработка: if let, guard let, ??, optional chaining.
• Замыкания: capture lists, escaping vs non-escaping, trailing syntax.
• Расширения и условные расширения для дженерик-типов.
• Уровни доступа: open, public, internal, fileprivate, private.
• Property wrappers и result builders на пользовательском уровне.

• Дотошное знание всех глобальных функций Stdlib — учим по мере встречи.
• @dynamicMemberLookup, @dynamicCallable — экзотика.
• Swift macros на уровне написания — пользоваться чужими достаточно для джуна-мидла.

Optional

Перечисление с двумя кейсами: .some(Wrapped) и .none. Все «крестики» (?, !) — это сахар над ним.

Capture list

Список захватываемых переменных в начале замыкания: { [weak self] in ... }. Без него — захват по сильной ссылке, с риском retain cycle.

@escaping

Замыкание, которое переживёт текущий scope (например, callback в URLSession). Требует явного захвата self.

guard

Ранний выход из функции. Делает «happy path» плоским.

Result builder

Декларативный синтаксис «как в SwiftUI». Используется через @resultBuilder аннотацию.

1. Optional pyramid → guard. Возьмите код с 4 вложенными if let и переписали через guard let. Какой вариант читать легче?
2. Capture list. Создайте retain cycle с замыканием в UIViewController. Поймайте его через Memory Graph. Исправьте через [weak self].
3. Trailing closure. Перепишите UIView.animate(withDuration: 0.3, animations: {}, completion: {}) в trailing-стиле с двумя замыканиями.
4. Property wrapper. Напишите @Clamped(0...100), который ограничивает значение Int.
   Swift Book · Properties
5. Result builder. Реализуйте свой @AttributedStringBuilder, который собирает NSAttributedString декларативно.
6. Уровни доступа. Создайте модуль через SPM. Сделайте API так, чтобы внешний код видел только то, что нужно.
7. Equatable + Hashable. Объявите struct с 3 свойствами и реализуйте Hashable вручную (без autosynthesis).
8. Расширения протоколов. Напишите дефолтную реализацию description через Mirror для всех типов, реализующих Reflectable.
9. Result type. Перепишите callback с (Data?, Error?) на Result<Data, Error>. Сравните читаемость.
10. String — это коллекция. Сравните str.count и str.utf8.count для строки "👨‍👩‍👧‍👦". Объясните разницу. Это про grapheme clusters vs code units.

• PAT — protocol with associated types — почему нельзя использовать как тип напрямую.
• some (opaque) vs any (existential): когда что выбирать.
• Type erasure (AnyPublisher, AnySequence): зачем и как сделать свой.
• Дженерик-ограничения: where, == , :, several constraints.
• Phantom types для compile-time контроля состояния.

• Variadic generics (each T) — недавно появились, узкий круг задач.
• Метатипы и Self-семантика на углублённом уровне — пригодится точечно.

1. PAT. Объявите protocol Container { associatedtype Item; ... }. Попробуйте использовать Container как тип переменной — поймайте ошибку компиляции, исправьте через any.
2. some vs any. Напишите функцию makeAdder() -> some Numeric. Затем перепишите как any Numeric. Сравните бенчмарк через XCTMetric.
3. Type erasure. Сделайте свой AnyView с двумя реализациями SomeView и OtherView. Измерьте размер на runtime через MemoryLayout.
4. Phantom types. Реализуйте API Money<USD> и Money<EUR>. Компилятор должен запретить складывать их.
5. Дженерик-ограничения. Реализуйте extension Array where Element: Numeric { var average: Element }.
6. Sequence/Collection. Сделайте свой FibonacciSequence, реализующий Sequence. Используйте через for-in.
7. Result builder. Реализуйте HTMLBuilder, чтобы собирать html-строку декларативно.
8. Conditional conformance. Сделайте extension Array: Equatable where Element: Equatable. Проверьте, что [Any] не равно само себе.

• Дизайн API. На senior уже не «как написать код», а «как другие будут им пользоваться». Читайте API Design Guidelines, смотрите эволюцию Stdlib.
• Источник истины — SE-предложения. swift-evolution. Понимать, куда движется язык, и принимать архитектурные решения с заделом.
• Балансы. Не упарываться в дженерики там, где protocol достаточно. Сложность — это техдолг.
• Менторство. Объяснить protocol with associated types джуну так, чтобы он понял с первого раза — самостоятельный навык.

• Retain cycles в замыканиях, делегатах, NotificationCenter, Combine, Task.
• weak vs unowned vs unowned(unsafe): когда какое использовать и какова цена.
• Side tables — что хранится отдельно от объекта (strong / unowned / weak counters).
• autoreleasepool в горячих циклах с Objective-C объектами.
• Memory Graph и Allocations Instrument: ловить утечки и фантомные объекты.
• MemoryLayout: size, stride, alignment.
• Value type vs Reference type: где живёт, как копируется.

• Внутренности HeapObject и weak references на C++ уровне — крутой контент, но не для джуниора.
• Подробности swift_release/swift_retain и оптимизаций компилятора — пригодится при оптимизации горячих участков.
• Memory Integrity Enforcement (Swift 6.x) — концептуально достаточно понимать.

graph LR
  HO[HeapObject] -->|inline| HD[Header
strong + unowned]
  HO --> SP[side-table-ptr]
  SP --> ST[Side Table]
  ST --> SC[strong count]
  ST --> UC[unowned count]
  ST --> WC[weak count]
  W1[weak ref #1] --> ST
  W2[weak ref #2] --> ST
                

При первом обращении weak-ссылки создаётся side table с тремя счётчиками. Сама weak-ссылка указывает не на объект, а на side table — поэтому когда объект уничтожается, она «обнуляется» автоматически.

graph LR
  P[ViewController] -->|strong| C[Closure]
  C -->|capture self strong| P
  P -.->|или| D[Delegate]
  D -.->|strong
ОШИБКА| P
  P2[ParentVC] -->|strong child| Ch[ChildVC]
  Ch -.->|strong parent
ОШИБКА| P2
  N[NotificationCenter] -.- O[Observer]
  T[Timer] -->|strong target| P
                

Замыкание → [weak self]. Делегат → weak var delegate. Child → Parent → weak. Timer → invalidate() в deinit родителя или используйте API с blocks. NotificationCenter с iOS 9+ держит наблюдателей слабо.

ARC

Automatic Reference Counting. Компилятор автоматически вставляет retain/release при создании/выходе из области видимости ссылочных типов.

Strong

Дефолтный режим. Удерживает объект; при refCount == 0 объект уничтожается.

Weak

Не удерживает объект, всегда Optional. Автоматически становится nil при уничтожении объекта (через side table).

Unowned

Не удерживает объект, не Optional. При обращении к уничтоженному — крах. Дешевле weak.

Side table

Дополнительная структура, где живут strong/unowned/weak счётчики и список weak-ссылок. Создаётся лениво при первой weak-ссылке.

Heap object header

16 байт: указатель на metadata + inline-счётчики strong и unowned. Если есть weak — добавляется указатель на side table.

Capture list

{ [weak self, unowned vc] in ... } — явное указание, как захватить self/другие переменные в замыкание.

Retain cycle

Два или больше объектов держат друг друга через strong, ARC не может их освободить.

Abandoned memory

Не утечка, но память «забыта»: на неё ещё есть ссылки, но в логике приложения она не используется.

Autoreleasepool

Скоп, в конце которого освобождаются объекты, отмеченные autorelease (актуально для Foundation/Objective-C — UIImage, NSString, файлы).

MemoryLayout

size — реальный размер, stride — шаг в массиве (с padding), alignment — требуемое выравнивание.

Copy-on-Write

Коллекции (Array, Dictionary, Set, String) создают копию буфера только при записи и только если !isKnownUniquelyReferenced.

EXC_BAD_ACCESS

Обращение к освобождённой/невалидной памяти. Часто — следствие unowned на уже мёртвый объект или ручной C-pointer.

1. Таймер-утечка. Создайте UIViewController с Timer.scheduledTimer(target: self, ...). Откройте Memory Graph — увидите утечку. Исправьте через weak target или новый block-API Timer(timeInterval:repeats:block:).
2. weak vs unowned. Реализуйте обе версии замыкания и убедитесь, что unowned крашится при доступе к освобождённому объекту. Замерьте разницу в скорости через XCTMetric.
3. NotificationCenter в iOS 9+. Подпишитесь без сохранения токена, отпустите ViewController. Объясните, почему утечки нет. NC хранит наблюдателей через weak с iOS 9+, но если используете addObserver(forName:queue:using:) с замыканием — нужен токен.
4. autoreleasepool. Загрузите 1000 UIImage(contentsOfFile:) в цикле. Сравните рост памяти с autoreleasepool и без — разница может быть в 50-100×.
5. Closure capture list. Передайте self в Task { ... }. Поймайте retain cycle в Memory Graph. Исправьте через [weak self].
6. Side tables. Объясните, почему weak var чуть медленнее, чем strong. Посмотрите доклад «Understanding Swift Performance» (WWDC 2016, session 416).
7. Combine cycle. $publisher.sink { value in self.use(value) }. Поймайте утечку и исправьте через [weak self] или store(in: &cancellables).
8. UIView retain cycle. Замените все strong ссылки между parent и child view на weak. Объясните, что сломается, что нет.
9. Memory Graph CLI. Запустите приложение, снимите .memgraph через leaks PID -outputGraph file.memgraph, откройте в Xcode.
10. MemoryLayout. Сравните size, stride, alignment для Bool, UInt8, кастомного struct Pair.
11. Copy-on-Write вручную. Реализуйте свою CoW-структуру через isKnownUniquelyReferenced. Убедитесь, что копия не происходит при чтении.
12. weak self в Task. Внутри actor или async-функции захватите self через [weak self]. Поймёте, почему семантика отличается от GCD.

• Memory budget команды. Договоритесь о пиковом и среднем footprint. Включите измерение в CI через UI-тест с XCTMemoryMetric.
• Plan для extensions. Виджеты/share-extensions имеют жёсткие лимиты памяти (30-50 MB) — нужна стратегия preview, обработки изображений, кэша.
• Code review-чек-лист. 1) self в замыканиях — capture list. 2) Делегаты — weak. 3) Combine — store(in:). 4) Timer/DisplayLink — invalidate в deinit. 5) NotificationCenter — токены.
• Менторство. Объяснить «почему 2 МБ картинка ест 80 МБ» и научить искать abandoned memory — отдельный навык.

• async/await, Task, TaskGroup — основа.
• actor, @MainActor, isolation domains.
• Sendable, data races на компиляции.
• Structured vs unstructured concurrency.
• Cancellation: Task.checkCancellation, withTaskCancellationHandler.
• Bridge от GCD/callback API через withCheckedContinuation.

• Custom Executor — экзотика, нужна в системных задачах.
• distributed actor — пока редко используется.
• Глубокая интеграция с Combine, если у вас новый проект.

1. Bridge. Перепишите URLSession.dataTask(with:completion:) на async через withCheckedContinuation.
2. TaskGroup. Скачайте 10 картинок параллельно через withTaskGroup. Сохраните порядок.
3. Actor. Реализуйте actor BankAccount с deposit/withdraw. Запустите 100 параллельных депозитов — всё должно сходиться.
4. Race condition. Создайте class с мутабельным массивом. Запустите 1000 паралл. append. Поймайте data race в Thread Sanitizer.
5. @MainActor. Найдите в проекте 3 места, где обновление UI делается без @MainActor. Добавьте аннотацию.
6. Sendable. Объявите struct User и попробуйте передать в Task. Если выдаст warning — исправьте через Sendable.
7. Cancellation. Реализуйте загрузку, которая корректно отменяется при Task.cancel().
8. AsyncSequence. Сделайте свою AsyncSequence, которая выдаёт значения каждые 1с.
9. Reentrancy. Внутри actor вызовите await ещё одного actor. Объясните, почему второй вызов может «переплестись».
10. Migrate to Swift 6. Включите SWIFT_STRICT_CONCURRENCY=complete. Исправьте все warning.

• План миграции. На больших проектах нельзя «просто включить» strict concurrency. Нужен план: модули, прогрессия, временные @preconcurrency.
• Архитектурные паттерны. Использовать ли @MainActor-only архитектуру? Когда выделять Domain-actor? Это решения, которые влияют на 5+ лет проекта.
• Обучение команды. Доклады, code review с акцентом, internal RFC. Senior — это не «я знаю», а «команда знает».

• App lifecycle: application(_:didFinishLaunching), UIScene, состояния foreground/background.
• Время и даты: Date, Calendar, DateFormatter, FormatStyle.
• FileManager — где что лежит (Documents, Caches, tmp, App Group).
• Codable: encoder/decoder, custom keys, версионирование DTO.
• NotificationCenter, KVO — современные альтернативы (Combine/AsyncSequence).

• NSCoder/NSKeyedArchiver вручную — Codable покрывает 95% задач.
• Глубокая работа с NSPredicate вне CoreData.
• NSRegularExpression — есть нативный Regex с iOS 16.

1. Lifecycle логирование. Залогируйте все 6 переходов состояний приложения (active/inactive/background/...). Проверьте: что происходит при свайпе домой?
2. Scene-based миграция. Перенесите старое UIKit-приложение с Scene Delegate. Сравните, что изменилось.
   UISceneDelegate
3. Codable с миграцией. Версионируйте DTO: добавьте новое поле, обработайте отсутствие у старых клиентов.
4. FormatStyle. Отформатируйте сумму 1234.5 как «1 234,50 ₽» через .formatted(.currency(code: "RUB")).
5. Date arithmetic. Подсчитайте, сколько дней осталось до конца месяца (учтите часовой пояс).
6. FileManager. Сохраните файл в Caches. Что произойдёт, если устройство близко к заполнению?
7. App Group. Поделитесь данными между приложением и виджетом через App Group container.
8. Notification → AsyncSequence. Подпишитесь на UIApplication.didBecomeActiveNotification через NotificationCenter.default.notifications(named:).

• UIView vs UIViewController vs UIWindow lifecycle (viewDidLoad, viewWillAppear, viewIsAppearing).
• Responder chain, hit-testing — без этого жесты «магия».
• Layer vs View, setNeedsLayout vs layoutIfNeeded.
• Адаптивность: trait collections, dynamic type, dark mode.

• Storyboards и XIB — на новых проектах их почти не делают, но читать уметь надо.
• Tab bar customisation на низком уровне (когда хватает UITabBarController).

Responder chain

Цепочка ответственных за события объектов: View → SuperView → ViewController → Window → App. Понимание её решает 80% багов с жестами.

Hit-testing

Алгоритм поиска view, по которому ткнули. Переопределение hitTest(_:with:) позволяет делать «прозрачные» области.

setNeedsLayout

Помечает view, что layout устарел. Реальный layoutSubviews запустится в следующем цикле.

Trait collection

Контекст: размер класс, dynamic type, accessibility, dark mode. Меняется без перезапуска.

1. Lifecycle лог. Залогируйте все методы жизненного цикла VC при presentation/dismissal/push/pop.
2. iOS 13+ viewIsAppearing. Используйте новый метод и сравните с viewWillAppear. Когда какой?
3. Hit-test puzzle. Сделайте кнопку, которая ловит тапы на 50px вокруг себя. Реализуйте через переопределение point(inside:with:).
4. Custom transition. Реализуйте своё UIViewControllerAnimatedTransitioning с zoom-эффектом.
5. Gestures. Создайте конфликтующие UIPanGestureRecognizer на ScrollView и кастомной view. Разрешите конфликт через UIGestureRecognizerDelegate.
6. Trait collection. Реализуйте view, реагирующую на изменение dark mode и accessibility размера.
7. Embedded VC. Сделайте контейнер, который встраивает 2 child VC и переключает между ними анимированно.
8. UIScrollView с Auto Layout. Зацепите content size автоматически через констрейнты.
9. Diffable + UICollectionView. Реализуйте список с NSDiffableDataSourceSnapshot. Анимируйте удаление.
10. Programmatic only. Сделайте экран без сториборда и xib, целиком кодом. Используйте UICollectionViewCompositionalLayout.

• State management: @State, @Binding, @Observable, @Environment.
• View identity и структурная идентичность — почему view иногда «теряет» state.
• NavigationStack, NavigationPath, deep links.
• Перформанс: разделение view, EquatableView, профилирование _printChanges().
• Интеграция с UIKit через UIViewRepresentable.

• Старый NavigationView — устарел, забываем.
• ObservableObject/@Published на новых проектах — переходим на @Observable.
• Ручной GeometryReader везде — есть onGeometryChange и containerRelativeFrame.

1. @Observable. Перепишите модель с ObservableObject + @Published на новый макрос. Сравните количество перерисовок.
2. NavigationStack. Сделайте stack с deep linking: app://users/42 открывает экран пользователя.
3. Identity. Реализуйте список, в котором при reorder теряется state дочерней view. Исправьте через .id(...).
4. Performance. Сделайте экран с 1000 элементами. Используйте LazyVStack, выделите тяжёлые subviews в отдельные.
5. UIKit bridge. Встройте MKMapView через UIViewRepresentable. Реализуйте обновление через updateUIView.
6. Custom layout. Реализуйте FlowLayout через Layout protocol.
7. Анимация. Сделайте matched geometry effect между двумя экранами.
8. Environment. Создайте свой EnvironmentValue для темы. Передайте его через все экраны.
9. Snapshot тестирование. Используйте swift-snapshot-testing для всех state-вариантов экрана.
10. Профилирование. Включите let _ = Self._printChanges() и найдите лишние перерисовки.

• Решение «UIKit или SwiftUI». Senior определяет миграционную стратегию: где UIKit обоснован, где SwiftUI экономит время.
• Дизайн-система. Свой layer над SwiftUI с компонентами, токенами цвета, типографикой. Позволяет команде делать UI быстрее и единообразно.
• Performance budget. Договариваетесь с командой: сколько перерисовок допустимо на экран, какие FPS-минимумы. Меряете в Instruments.

• NSLayoutConstraint и Anchor API — кодовые констрейнты быстрее любого Interface Builder.
• Content hugging vs compression resistance — без этого не сделать ни одной хорошей формы.
• UIStackView — ¾ задач решает он, не плодите констрейнты руками.
• Safe area, layout margins, readable content guide.

• Глубокие нюансы Visual Format Language — устарел.
• Storyboards-only подход.

1. Anchor API. Расположите 4 кнопки в форме сетки 2x2 без UIStackView, используя только anchors.
2. UIStackView. Перепишите экран с 8 констрейнтами в 2 вложенных стека.
3. Hugging/Compression. Сделайте лейбл с длинным текстом, который сжимается, а не растягивает кнопку рядом.
4. Safe area. Сделайте экран, который правильно работает на iPhone SE и iPhone 16 Pro Max.
5. Compositional Layout. Реализуйте экран App Store: горизонтальный список с большими карточками, ниже — горизонтальная сетка.
6. Self-sizing cells. Сделайте таблицу, где высота ячейки зависит от длины текста.
7. Layout debugging. Поймайте «conflicting constraints» в консоли и научитесь читать сообщение.
8. UIKit + SwiftUI. Встройте UIHostingController с динамическим content size.

• NSDiffableDataSourceSnapshot, секции, supplementary views.
• UICollectionViewCompositionalLayout с группами и orthogonal scrolling.
• Pre-fetching, recycle ячеек, конфигурация через UICollectionView.CellRegistration.
• Производительность: image decoding, drawing async.

• UICollectionViewFlowLayout — устарел для новых проектов.
• Ручная отрисовка через drawRect на ячейках без необходимости.

1. App Store-like экран. 3 секции: hero-карточка, horizontal carousel, grid.
2. Diffable + анимация. Реализуйте drag-and-drop с анимацией.
3. Pre-fetching. Реализуйте UICollectionViewDataSourcePrefetching для подгрузки изображений.
4. Self-sizing. Ячейки с динамической высотой через Compositional Layout.
5. Sticky headers. Реализуйте «прилипающие» заголовки секций.
6. Lists API. Используйте UICollectionLayoutListConfiguration для table-like UI с swipe-actions.
7. Custom decoration. Добавьте подложку под секцию через NSCollectionLayoutDecorationItem.
8. Производительность. Сделайте лист с 10 000 элементов и сложными ячейками — 60fps без даунгрейдов.

• UIView.animate с spring — для большинства задач достаточно.
• CABasicAnimation, CAKeyframe — когда нужна тонкая настройка.
• Interactive transitions с UIPercentDrivenInteractiveTransition.
• SwiftUI: matchedGeometryEffect, custom Animation, PhaseAnimator.

• Lottie — мощно, но добавляет вес. Используйте, если есть готовая анимация от дизайнеров.
• Hero и подобные библиотеки — на новых проектах достаточно нативных API.

1. UIViewPropertyAnimator. Сделайте паузируемую анимацию.
2. Spring. Подберите параметры spring для естественного движения карточки.
3. Interactive dismiss. Свайп вниз — закрывает экран с интерактивной отменой.
4. matchedGeometryEffect. Реализуйте hero-переход в SwiftUI.
5. Lock Screen анимация. Повторите анимацию iOS 16 (см. мою статью).
6. CAEmitterLayer. Сделайте конфетти при успешном действии.
7. PhaseAnimator (iOS 17+). Анимация в несколько фаз без таймеров.

• SwiftUI .colorEffect, .layerEffect — самый простой путь к шейдерам с iOS 17+.
• Core Image для фильтров, Vision для распознавания.
• CALayer и его подклассы для тонкой работы с UI.

• Глубокая работа с Metal-командами — нужно для игр и пост-эффектов.
• Compute shaders — узкая ниша.

1. SwiftUI Shader. Сделайте кнопку с эффектом «жидкого стекла» через .layerEffect.
2. CIFilter. Примените blur и vignette к фото.
3. CAGradientLayer. Сделайте анимированный gradient-background.
4. CADisplayLink. Реализуйте плавную анимацию, синхронизированную с обновлением экрана.
5. Vision. Распознайте текст с фото через VNRecognizeTextRequest.
6. MetalKit. Нарисуйте треугольник через MTKView и собственный shader.

• MVVM с binding'ами — самый ходовой паттерн на Junior/Middle.
• Clean Architecture: разделение domain / data / presentation.
• SOLID на практике, не в теории.
• Dependency Injection без фреймворков — composition root.
• The Composable Architecture — современный кандидат для SwiftUI-проектов.

• VIPER ради VIPER — много boilerplate'а, оправдан только в больших командах.
• «Идеальная» архитектура — её не существует.

1. MVVM. Реализуйте экран профиля с биндингами через @Observable.
2. Clean. Разнесите код на 3 модуля: domain (use cases), data (repositories), presentation. Compile-time-проверка зависимостей.
3. VIPER. Один экран на VIPER. Подсчитайте количество файлов — это даст почувствовать стоимость.
4. TCA. Реализуйте feature через Reducer/State/Action. Напишите unit-тесты на reducer.
5. DI без фреймворка. Composition root в AppDelegate, протоколы вместо классов в инициализаторах.
6. Coordinator. Уберите весь navigation код из ViewController в Coordinator.
7. Тестируемость. Покройте unit-тестами use case без UI-симуляторов.
8. Миграция. Возьмите legacy-MVC экран и поэтапно мигрируйте на MVVM (без переписывания всего).

• Архитектурный RFC. На крупных проектах изменение архитектуры — это документ с обсуждением, тренадеоффами и планом миграции.
• Не «лучшая», а «уместная». Маленький стартап — простая MVVM. Холдинг с 50 разработчиками — модульная Clean. Не путайте.
• Контекст команды. Учитывайте: уровень разработчиков, время на onboarding, поддержку.
• Технический долг. Senior умеет принимать «уродливое сейчас, рефакторинг по плану». Перфекционизм убивает проекты.

• Coordinator/Router паттерн в UIKit.
• NavigationStack + NavigationPath в SwiftUI.
• Universal Links / Deep Links / Apple Push.
• Flow Coordinators для онбординга, чекаута, подписок.

• NavigationView (старый) — устарел.
• Готовые навигационные SDK типа RxFlow — без них в большинстве случаев лучше.

1. Coordinator UIKit. Перенесите push/present/dismiss в координаторы.
2. NavigationStack. Сделайте экран со state-driven навигацией: path.append(.profile(id)).
3. Deep Link. Откройте конкретный экран по app://users/42.
4. Universal Link. Настройте apple-app-site-association и обработку.
5. Flow. Реализуйте онбординг как Coordinator с возможностью «вернуть пользователя на предыдущий шаг».
6. Modal vs Push. Сделайте экран, который в зависимости от контекста открывается то модально, то push.
7. Tab + Modal + Push. Реализуйте логику «при тапе на push открываем модально, но в табе сохранится текущий стек».

• Swift Package Manager — стартовая точка для любой модуляризации.
• Tuist для генерации проектов из Project.swift — устраняет merge conflicts в pbxproj.
• Структура слоёв: Feature / Domain / Data / DesignSystem / CoreUtils.
• Public/Internal API — сознательное решение, что выставлять наружу.

• CocoaPods на новых проектах — SPM достаточно.
• Carthage — почти не используется.

1. SPM локальный. Вынесите фичу в local SPM-package. Сравните время сборки.
2. Tuist старт. Сгенерируйте проект из Project.swift.
3. Feature module. Разбейте экран профиля: ProfileFeature, ProfileUI, ProfileDomain.
4. Public API. Намеренно скройте внутренности через internal. Используйте Sample app для тестирования.
5. Module Graph. Постройте граф зависимостей через tuist graph.
6. Кэширование. Включите tuist cache и сравните время первой и последующих сборок.
7. Resource bundle. Передайте лок-строки в SPM-модуль через Bundle.module.

• Стандарт команды. Договоритесь, как именно делятся модули, как именуются. Документируйте в CONTRIBUTING.md.
• Время сборки как метрика. Меряйте, сколько собирается incremental и clean. Цель — не дать им расти быстрее, чем растёт продукт.
• Sample apps. Каждая фича собирается отдельным mini-app — ускоряет dev-итерации в 10x.

• Frame: контекст → ограничения → сценарии → API → данные → клиентская архитектура → углы.
• Кэширование (см. отдельный раздел) и offline-first.
• Pagination, real-time обновления (WS, push).
• Тулинг: feature flags, AB-тесты, аналитика.
• Безопасность ключей (Keychain, secure enclave).

• Глубоко в backend — knowing-your-place полезно.
• Распределённые системы — клиенту достаточно концепций.

1. Дизайн ленты. Спроектируйте Twitter-like ленту: пагинация, кэш, real-time.
2. Чат. Спроектируйте Telegram-like чат: оффлайн отправка, синхронизация, push.
3. Загрузчик. Сервис загрузки файлов с приостановкой/возобновлением.
4. Аналитика. Унифицируйте отправку событий, добавьте батчинг и retry.
5. Платежи. Платёжный флоу с 3DS и idempotency keys.
6. Виджет. Спроектируйте виджет с App Group + Background tasks обновлением.

• Технологическое влияние. На Staff/Principal вы — тот, кто делает технологические выборы (нативно vs кросс, новый стек, миграции). Эти решения отражаются на 100+ инженерах годами.
• Документация и RFC. Большие изменения должны жить как живой документ с argued trade-offs, не как «обсудили в slack».
• Обучение через примеры. Любой сложный системный выбор должен быть сопровождён demo-приложением и open-source примером для команды.

• URLSession (configuration, delegate, async API).
• Retry, exponential backoff, идемпотентность запросов.
• Codable + DTO + версионирование контрактов.
• WebSocket через URLSessionWebSocketTask.
• Логирование запросов и трекинг через interceptor-ы.

• Alamofire/Moya на новых проектах — нативного API хватает.
• Глубокий gRPC — нужен на специфичных проектах.
• Подробности TLS handshake — концептуально достаточно.

1. Network layer. Спроектируйте protocol APIClient с типизированными request/response.
2. Retry с backoff. Реализуйте retry: 3 попытки, задержки 1s, 2s, 4s.
3. Idempotency. Добавьте header Idempotency-Key к POST-запросам.
4. Multipart upload. Загрузите файл с прогрессом через uploadTask.
5. WebSocket reconnect. Реализуйте автоматический reconnect при потере соединения.
6. Логи запросов. Перехватите все запросы через URLProtocol и сохраните в файл.
7. Mock server. Поднимите локальный mock через swifter или swift-nio, прогоните UI-тесты.
8. Cache headers. Используйте ETag/If-None-Match для кэширования на клиенте.

• Когда что: UserDefaults (настройки), Keychain (секреты), File (бинарь), SQL (списки), CoreData/SwiftData (графы объектов).
• SwiftData — современный путь для новых проектов.
• Миграции схем (lightweight, ручные).
• Шифрование на уровне файла или базы.

• Realm/MagicalRecord на новых проектах — нативные альтернативы зрелее.
• Глубокая работа с FetchedResultsController — SwiftData упрощает.

1. SwiftData CRUD. Создайте модель @Model class Note. Сделайте список с фильтром.
2. Миграция. Добавьте новое поле в модель. Реализуйте lightweight migration.
3. Keychain wrapper. Напишите свой protocol SecureStorage поверх Security framework.
4. Бэкапы. Включите/выключите isExcludedFromBackup для папки кэшей.
5. FileCoordinator. Напишите безопасное чтение/запись файла из нескольких процессов.
6. GRDB. Сделайте таблицу с FTS5 (full-text search) и реализуйте поиск.
7. App Group + UserDefaults. Поделитесь настройками между приложением и виджетом.
8. Шифрование. Сохраните JSON в файл, зашифрованный AES (CommonCrypto).

• Стратегии: cache-aside, write-through, write-behind, refresh-ahead.
• HTTP caching: ETag, Cache-Control, max-age.
• Offline-first: локальная база как single source of truth.
• Конфликты данных: last-write-wins, CRDT.

• Полноценная синхронизация типа CouchDB — экзотика для большинства приложений.

1. Repository pattern. Реализуйте UserRepository, который сначала отдаёт из cache, потом обновляет из сети.
2. NSCache. Сделайте image cache с лимитом 50 MB.
3. Disk cache. Сохраните JPEG на диск с TTL 24 часа.
4. HTTP cache. Настройте URLCache с правильными заголовками.
5. Offline сценарий. Поставьте режим «без интернета». Приложение должно отображать данные из кэша и помечать «outdated».
6. Optimistic UI. При лайке мгновенно обновите UI, отправьте запрос в фоне, при ошибке откатите.

• Swift Testing (новый фреймворк) и XCTest.
• Mock vs Stub vs Spy vs Fake — понимать разницу.
• Snapshot-тесты для UI (swift-snapshot-testing).
• Test Plans для разных конфигураций.
• Покрытие как индикатор, не как KPI.

• BDD-фреймворки (Quick/Nimble) — на новых проектах SwiftTesting + Test Plans достаточно.
• Стопроцентное покрытие — миф, ведущий к плохим тестам.

1. Swift Testing старт. Перепишите 5 XCTestCase в новый @Test синтаксис.
2. Mock сети. Подменяйте URLProtocol в тестах для контролируемых ответов.
3. Snapshot. Зафиксируйте 3 состояния экрана профиля.
4. UI test. Напишите end-to-end сценарий «логин → главная → выход».
5. Тест async. Тестируйте actor с разными порядками операций.
6. Параметризованные тесты. 10 кейсов через arguments:.
7. Тестирование времени. Подменяйте Date через DI.
8. CI metric. Добавьте отчёт о покрытии в PR.

• LLDB: po, p, v, thread backtrace, breakpoint actions.
• Memory Graph и Allocations Instrument.
• Time Profiler, Hangs, Hitches.
• Network Instrument, Animation Hitches.
• Сanonical breakpoints (UIViewAlertForUnsatisfiableConstraints, -_NSAutoreleaseNoPool).

• Скриптование LLDB на Python — узкая ниша.
• Hopper/IDA — нужно при reverse engineering.

1. Conditional breakpoint. Поставьте остановку, срабатывающую только когда userId == 42.
2. Sound на breakpoint. Используйте action «Play sound» вместо print.
3. Memory Graph. Найдите «фантомный» UIViewController.
4. Time Profiler. Профилируйте старт приложения. Найдите 3 узких места.
5. Hitches. Запустите Animation Hitches и поймайте дёрганый scroll.
6. os_log. Перейдите с print на Logger. Просмотрите в Console.app.
7. LLDB chisel. Установите Facebook Chisel и используйте vs (view dump).

• Метрики из MetricKit и App Store Connect (Hangs, Hitches, Disk writes).
• Cold start: что выполнять до first frame, что отложить.
• Image decoding на background.
• Бюджет аллокаций в горячих циклах.
• Бенчмарки через XCTMetric и OSSignpost.

• Микрооптимизации без замеров — корень всех зол.

1. App launch <400ms. Замерьте через OSSignpostInterval. Найдите 3 источника задержки.
2. Hangs. Поймайте main thread block в Instruments.
3. Image decoding. Перенесите decode в background thread. Сравните FPS на скролле.
4. Memory footprint. Снизьте пиковую память на 30%.
5. SwiftUI body diff. Найдите тяжёлый body, разделите на subviews.
6. Networking burst. Пакетируйте запросы при онбординге.
7. MetricKit. Соберите real-world метрики и отправьте в свою аналитику.

• Performance budget. Договоритесь с командой о метриках (cold start, scroll FPS, memory). Включите в CI.
• Real user monitoring. Не только лабораторно, но и в проде — через MetricKit, Sentry, Firebase Performance.
• Перформанс как продукт. Уметь продать улучшения бизнесу через метрики (retention, conversion, ratings).

• Keychain: kSecAttrAccessible, sharing groups.
• ATS, certificate pinning, public key pinning.
• Code Signing: provisioning profiles, entitlements, App ID.
• OWASP Mobile Top 10.

• Глубокая обфускация Swift — почти невозможна без сторонних инструментов.
• White-box cryptography — узкая ниша.

1. Keychain wrapper. Сохраните токен с kSecAttrAccessibleAfterFirstUnlock.
2. Cert pinning. Настройте pinning на public key через URLSessionDelegate.
3. Биометрия. Используйте LAContext для подтверждения операции.
4. Jailbreak detection. Проверьте 5 признаков (без ложных срабатываний).
5. Secure enclave. Сгенерируйте ключ в Secure Enclave и подпишите данные.
6. App attest. Реализуйте проверку integrity приложения.

• VoiceOver labels, hints, traits.
• Dynamic Type на всех экранах.
• Локализация через String Catalog (.xcstrings).
• Множественное число и плюрализация.
• RTL-языки (арабский, иврит).

• Поддержка всех локалей сразу — лучше start small.

1. VoiceOver сессия. Включите VoiceOver и пройдите 3 экрана своего приложения.
2. Dynamic Type. Прогоните UI на самом большом размере шрифта (AX5).
3. String Catalog. Перенесите .strings файлы в .xcstrings.
4. Pluralization. Реализуйте «1 сообщение / 2 сообщения / 5 сообщений».
5. Accessibility Inspector. Прогоните audit и исправьте все warnings.
6. RTL test. Включите Hebrew и проверьте все экраны.

• Fastlane: match, gym, pilot, deliver.
• Xcode Cloud — самый простой CI без серверов.
• GitHub Actions для запуска тестов.
• Кэширование: derived data, SPM, Tuist cache.
• Версионирование (semver, build number).

• Свои Mac-раннеры — дорогая инфраструктура, начните с облачных.

1. Fastlane match. Настройте управление сертификатами через приватный git-репо.
2. Beta lane. Сделайте fastlane beta для отправки в TestFlight.
3. GitHub Actions. Запускайте тесты на каждый PR.
4. Кэш SPM. Уменьшите время сборки в 2 раза за счёт кэша.
5. Build number автоинкремент. Из тегов git.
6. Slack уведомление. После успешного билда отправьте в канал.
7. Xcode Cloud. Поднимите минимальную конфигурацию: тест + архив.

• App Store Connect API.
• TestFlight группы и phased release.
• App Review Guidelines (особенно секции о приватности).
• Privacy nutrition labels, App Tracking Transparency.
• Подготовка скриншотов (см. мою статью про status bar 9:41).

• Apple Search Ads — нужно при росте маркетинга.

1. API. Получите список билдов через App Store Connect API.
2. TestFlight ad-hoc. Раздайте билд внешним тестерам.
3. Phased release. Включите 7-дневный rollout.
4. Privacy labels. Заполните корректно для своего приложения.
5. Скриншоты. Сгенерируйте через fastlane snapshot.

• Crashlytics / Sentry / Bugsnag — выбор и интеграция.
• Symbolication, dSYM upload в CI.
• Custom keys и breadcrumbs.
• Дашборды: crash-free %, ANR, slow frames.
• Аналитика событий (Amplitude, Mixpanel, Firebase).

• Свой crash-reporter — нет смысла, всё уже сделано.

1. Sentry SDK. Установите, отправьте искусственный краш.
2. dSYM upload. Автоматизируйте через CI.
3. Breadcrumbs. Логируйте 10 ключевых событий до краша.
4. MetricKit. Подключите hangs и hitches к мониторингу.
5. Аналитика. Спроектируйте универсальный EventTracker с батчингом.

• Two pointers / sliding window.
• Hash map / set для O(1) поиска.
• BFS / DFS на графе и матрице.
• Бинарный поиск (включая по ответу).
• Dynamic programming (на 1D, 2D).
• Backtracking.
• Heap / priority queue.
• Union-Find (DSU).

• Сегментные деревья, fenwick — олимпиадная экзотика.
• Сложные жадные на 7+ строк — редко спрашивают.

1. Two Sum. O(n) через hash map.
2. Longest substring without repeating. Sliding window.
3. Number of Islands. BFS/DFS на матрице.
4. Search in Rotated Sorted Array. Бинпоиск с условием.
5. House Robber. Базовое DP.
6. Coin Change. DP с возвратами.
7. Word Break. DP + строки.
8. Top K Frequent Elements. Heap.
9. Friend Circles. Union-Find.
10. Generate Parentheses. Backtracking.

• Делегирование, target-action, ответственная цепочка.
• Observer (NotificationCenter, KVO, Combine, AsyncSequence).
• Builder, Factory Method, Abstract Factory.
• Strategy и Decorator.
• iOS: Coordinator, Repository, Use Case.

• Visitor, Memento, Mediator — редко в чистом виде.

1. Builder для NSAttributedString. Сделайте текучий API.
2. Strategy. Разные алгоритмы сортировки списка как стратегии.
3. Decorator. Логирование запросов через декоратор API-клиента.
4. Observer. Сравните NotificationCenter, Combine, AsyncSequence на одной задаче.
5. Singleton. Покажите, почему он мешает тестам, и замените на DI.

• Claude Code (CLI) и его hooks/slash-команды.
• CLAUDE.md как «контракт проекта» с агентом.
• MCP-серверы (Model Context Protocol) для интеграций.
• Cursor: rules, settings, agent mode.
• GitHub Copilot для inline-completions.
• Промпт-инженерия (см. следующий раздел).

• Тренировка собственных моделей — узкая ниша.
• Прыжки между 5 ассистентами — выберите 1-2 главных.

1. CLAUDE.md. Опишите проект в 200 строк: архитектура, тесты, стиль кода, запрещённые операции.
2. Slash-команда. Создайте /review, который проводит ревью текущего PR по чек-листу.
3. Hook на Stop. При завершении агента запустите swiftlint.
4. MCP simulator. Подключите MCP, через который Claude Code запускает приложение в симуляторе.
5. Cursor rules. Настройте .cursor/rules с правилами для iOS-проекта.
6. Сравнение. Сделайте одну фичу через Claude Code и через Cursor agent. Сравните скорость и качество.
7. Subagent. Создайте subagent @code-reviewer с узкой задачей.
8. Pre-commit AI hook. AI проверяет изменения перед коммитом и предлагает улучшения.

• Команда + AI. Договоритесь о правилах: что отдаём AI, что нет (security-критичный код, бизнес-логика).
• Свои MCP-серверы. Если в команде уникальные инструменты — заверните в MCP, чтобы AI работал с ними напрямую.
• AI-onboarding. Новички осваивают кодбазу через диалог с агентом, который знает ваш CLAUDE.md.
• AI-driven docs. Документация автогенерируется из кода и проверяется на актуальность через AI.

Skills (Anthropic Claude Skills) — переиспользуемые наборы инструкций + кода, которые делают AI-агента «специалистом» по конкретной задаче. Аналог macOS Shortcuts, но для агента: набор файлов SKILL.md + опциональные скрипты, которые агент подгружает по требованию.

• Назначение: упаковать «как мы это делаем» — стиль кода, шаблоны PR, проверка лицензий — чтобы агент применял рутинные операции одинаково.
• Состав: SKILL.md с описанием + scripts/ + templates/. Загружается лениво, не съедает контекст до момента вызова.
• Примеры: swift-test-author (генерация тестов в стиле проекта), pr-reviewer (ревью по чек-листу команды), arch-rfc-writer (черновик RFC по шаблону).
• Где хранить: локально в репозитории .claude/skills/ или в Anthropic Console для всех агентов.

MCP — открытый стандарт для подключения внешних источников данных и инструментов к AI-ассистентам (как USB для AI). Сервер MCP предоставляет агенту: resources (читаемый контекст), tools (вызываемые действия), prompts (готовые шаблоны).

iOS-полезные MCP-серверы:

• modelcontextprotocol/servers — официальная коллекция MCP-серверов (filesystem, github, postgres, slack, sqlite, time).
• ios-simulator-mcp — MCP для управления симулятором iOS (boot/shutdown/screenshot/install).
• XcodeBuildMCP — управление Xcode-сборкой, тестами, симуляторами.
• xcode-mcp-server — пакетные операции с Xcode-проектом.
• github/github-mcp-server — официальный сервер для работы с GitHub PR/issues/CI.
• AppStoreConnectMCP — App Store Connect API через MCP.
• mcp-package-version — следит за версиями SPM-пакетов.
• awesome-mcp-servers — каталог 500+ серверов.

Как подключить в Claude Code:

claude mcp add-json xcode-simulator '{
  "command": "npx",
  "args": ["-y", "ios-simulator-mcp"]
}'

AI-агенты и ассистенты

• anthropics/claude-code — официальный CLI Claude Code.
• anthropic-quickstarts — стартовые проекты, в т.ч. computer-use agent.
• getcursor/cursor — Cursor IDE.
• sourcegraph/cody — open-source ассистент с Code Search.
• Open Interpreter — локальный agent с code execution.
• OpenHands (ex OpenDevin) — open-source автономный software engineer.
• aider — CLI-ассистент с Git-flow.
• Cline — VS Code agent с auto-approve.
• Roo Code — fork Cline с расширенной кастомизацией.
• continue.dev — open-source Copilot для VS Code/JetBrains.

iOS / Swift × AI

• apple/swift-mcp-sdk — официальный SDK Apple для MCP на Swift.
• MacPaw/OpenAI — клиент OpenAI API на Swift.
• SwiftAnthropic — Swift SDK для Anthropic API.
• exyte/AIChat — UI-компоненты чата для AI-приложений.
• huggingface/swift-transformers — запуск трансформеров на iOS.
• WhisperKit — on-device транскрипция через Whisper + Core ML.
• mlx-swift — Apple ML-фреймворк, родственник PyTorch для M-серии.
• awesome-apple — каталог Apple/Swift инструментов.

Awesome-списки

• awesome-mcp-servers — 500+ MCP-серверов.
• awesome-mcp-clients — клиенты MCP.
• Awesome-LLM — общая база по LLM.
• awesome-chatgpt — инструменты вокруг ChatGPT.
• Awesome-CoreML-Models — готовые модели для iOS.
• awesome-production-ml — деплой ML в проде.

Статьи · английский

• Anthropic · Claude Code best practices
• Anthropic · Building effective agents
• Anthropic · How we build Claude Skills
• MCP · Introduction (официальная)
• Cursor · Agent mode documentation
• GitHub blog · Copilot tag
• Simon Willison · LLM blog (must-read)
• Every · Chain of Thought (Dan Shipper)
• LogRocket · Integrating MCP into an iOS app
• NSHipster · Foundation Models

Статьи · русский (Habr и др.)

• Яндекс · Промпт-инжиниринг для разработчиков
• WB · Как мы внедряем AI в рабочие процессы
• Сбер · Архитектура AI-ассистента
• Habr · MCP — стандарт для интеграции LLM
• МТС · Code Llama и autocomplete в IDE
• Habr · Cursor vs Copilot vs Claude Code
• Habr · Foundation Models для iOS-разработчика

• Контекстные подсказки: roles, examples, constraints.
• Поэтапная декомпозиция (chain-of-thought).
• Передача файлов и схем через @-меньки/attachments.
• Iterative refinement — лучше 5 итераций короткими промптами.
• Знать слабые места моделей (галлюцинации API, устаревшие фреймворки).

• «Магические» формулировки — большинство трюков уже не нужны на современных моделях.

1. One-shot bad → good. Возьмите свой реальный плохой промпт и перепишите его в 3 итерации.
2. Шаблон рефакторинга. «Возьми этот код, [роль reviewer], сохраняя API, …». Сравните результаты.
3. Декомпозиция. Большая задача → 5 промптов вместо одного.
4. Examples-based. Дайте 2 примера правильных тестов и попросите написать аналогичный.
5. Verification. Заставьте AI самого проверить результат на чек-листе.
6. System prompt в CLAUDE.md. Ограничьте поведение агента: «не используй force unwrap», «всегда добавляй mock».

• Foundation Models framework — генерация текста на устройстве.
• Core ML: интеграция готовых моделей (.mlmodel/.mlpackage).
• Vision: распознавание объектов, текста, лиц.
• Natural Language: язык, тональность, лемматизация.
• Create ML для дообучения на своих данных.

• Тренировка с нуля больших моделей — узкая ниша.
• Custom Metal-kernels для CoreML — нужно при оптимизации.

1. Foundation Models. Сгенерируйте summary текста через SystemLanguageModel.
2. Vision OCR. Распознайте текст с фото через VNRecognizeTextRequest.
3. Sentiment. Определите тональность отзыва через NLTagger.
4. Image classification. Классифицируйте картинки готовой моделью с CoreML.
5. Create ML. Обучите классификатор «кошки/собаки» на своих фото.
6. Стриминг. Streaming-ответ от Foundation Models с обновлением UI токен за токеном.

• Письменная коммуникация: PR-описания, RFC, постмортемы.
• Конструктивный код-ревью: hard on idea, soft on author.
• Эстимейты: декомпозиция, риски, буферы.
• Менторство джуниоров.
• Принятие feedback без обиды.

• Курсы публичных выступлений на 100 человек — нужно ситуативно.

• Влияние без власти. На Lead/Staff вы влияете, не приказывая. Это про argued posts, demo, RFC.
• Сеть. Конференции, твиттер, опен-сорс — возможности приходят через людей.
• Менторство как мультипликатор. 5 учеников = 5 параллельных «вы».
• Энергия и приоритеты. Senior умеет говорить «нет» и не сгорать.

• Trainee → Junior: от «помоги, сломалось» к «сделал сам, спросил review».
• Junior → Middle: от «сделал фичу» к «спроектировал модуль и закрыл углы».
• Middle → Senior: от «решил задачу» к «выбираю, какие задачи делать и почему».
• Senior → Lead: от «себя» к «команде»: процессы, найм, грейды.
• Lead → Staff/Principal: от «одной команды» к «организации»: стандарты, тренды, технологический PR.

• Алгоритмы: 80-100 задач из 8 паттернов (см. раздел 31).
• iOS: Concurrency, ARC, UIKit/SwiftUI, архитектура.
• System Design: разделы 19, 20, 22.
• Поведенческие: STAR-формат, заранее подготовленные истории.
• Вопросы к ним: 3 серьёзных вопроса в каждом раунде.