Системный подход к вайбкодингу: анализ, дизайн и запуск веб-приложения 26 Sections288 Lessons25 QuizzesСрок службы
- 26 Sections
- 288 Lessons
- Срок службы
Развернуть все разделыСвернуть все разделы
- 0. Прежде чем начать9 Items
- 1.1RT1Y 0.1 Что такое вайбкодинг и откуда взялось слово
- 1.2RT1Y 0.2 Что вы построите к концу курса
- 1.3RT1Y 0.3 Как устроен этот курс и как по нему идти
- 1.4RT1Y 0.4 Что понадобится — программы, доступы и деньги
- 1.5RT1Y 0.5 Сколько времени это займёт
- 1.6RT1Y 0.6 Что обычно идёт не так
- 1.7RT1Y 0.7 Почему системный подход, а не набор промптов
- 1.8RT1Y 0.8 Как работать в петле и вести записи
- 1.9RT1Y 0.9 Кому курс не подойдёт
- 1. Что может пойти не так с вайбкодингом?10 Items
- 2.1RT1Y 1.1 Как проект скатывается в бесконечные правки
- 2.2RT1Y 1.2 Что на самом деле делает ИИ-агент
- 2.3RT1Y 1.3 Почему агент уверенно сообщает неправду
- 2.4RT1Y 1.4 Цена размытой задачи и неясных границ
- 2.5RT1Y 1.5 Петля спека → генерация → проверка → откат
- 2.6RT1Y 1.6 Три роли человека рядом с агентом
- 2.7RT1Y 1.7 Где подход работает, а где нужен разработчик
- 2.8RT1Y 1.8 Выбор своей предметной области для курса
- 2.9RT1Y 1.9 Как описать идею проекта в свободной форме
- 2.10RT1Y 1 Итоговый тест5 Questions
- 2. Из чего состоит приложение: базовая техграмотность15 Items
- 3.1RT1Y 2.1 Что происходит после клика по кнопке
- 3.2RT1Y 2.2 Браузер, клиент и сервер без технического тумана
- 3.3RT1Y 2.3 Почему приложение почти всегда делится надвое
- 3.4RT1Y 2.4 Что делает фронтенд и где кончается его зона
- 3.5RT1Y 2.5 Что делает бэкенд и за что он отвечает
- 3.6RT1Y 2.6 Почему языков программирования так много
- 3.7RT1Y 2.7 Зачем в курсе выбран Python
- 3.8RT1Y 2.8 Библиотека, пакет и зависимость простыми словами
- 3.9RT1Y 2.9 Фреймворк и чем он отличается от библиотеки
- 3.10RT1Y 2.10 Что такое FastAPI и что он берёт на себя
- 3.11RT1Y 2.11 HTTP — запрос, ответ и методы без магии
- 3.12RT1Y 2.12 Что означают коды 200, 404 и 500
- 3.13RT1Y 2.13 API, эндпоинт и JSON на примере записи
- 3.14RT1Y 2.14 Кто первым встречает пользователя у входа
- 3.15RT1Y 2 Итоговый тест5 Questions
- 3. Где живут данные: базы, кэш и файлы14 Items
- 4.1RT1Y 3.1 Зачем приложению база, а не таблица в Excel
- 4.2RT1Y 3.2 Таблицы, строки и связи на понятном примере
- 4.3RT1Y 3.3 SQL как язык вопросов к данным
- 4.4RT1Y 3.4 Почему в курсе используется PostgreSQL
- 4.5RT1Y 3.5 Когда данные не помещаются в строгие таблицы
- 4.6RT1Y 3.6 Документная база — что в ней удобно и что нет
- 4.7RT1Y 3.7 Хранилище ключ-значение и зачем нужен кэш
- 4.8RT1Y 3.8 Когда обычный поиск перестаёт справляться
- 4.9RT1Y 3.9 Где хранить картинки, документы и вложения
- 4.10RT1Y 3.10 Как выбрать базу без лишней драмы
- 4.11RT1Y 3.11 Транзакция — почему операция должна быть целой
- 4.12RT1Y 3.12 Индекс — откуда берётся ускорение и тормоза
- 4.13RT1Y 3.13 Резервные копии как часть устройства системы
- 4.14RT1Y 3 Итоговый тест5 Questions
- 4. Как части приложения общаются: очереди, брокеры и фоновые задачи12 Items
- 5.1RT1Y 4.1 Сразу или потом — два способа делать работу
- 5.2RT1Y 4.2 Какие операции нельзя держать в ожидании экрана
- 5.3RT1Y 4.3 Очередь задач на бытовом примере
- 5.4RT1Y 4.4 Что делает брокер сообщений между частями системы
- 5.5RT1Y 4.5 RabbitMQ — когда нужен простой обмен задачами
- 5.6RT1Y 4.6 Kafka — когда важен поток событий, а не очередь
- 5.7RT1Y 4.7 Фоновая отправка письма и напоминания о записи
- 5.8RT1Y 4.8 Задачи по расписанию и регулярные операции
- 5.9RT1Y 4.9 Вебхук — когда внешний сервис сам приходит к вам
- 5.10RT1Y 4.10 Потерянные и задвоенные сообщения — как это выглядит
- 5.11RT1Y 4.11 Когда брокер только мешает и усложняет проект
- 5.12RT1Y 4 Итоговый тест5 Questions
- 5. Терминал, файлы и умение читать ошибки12 Items
- 6.1RT1Y 5.1 Что такое терминал и зачем он нужен в курсе
- 6.2RT1Y 5.2 Что в терминале делать безопасно, а что нет
- 6.3RT1Y 5.3 Путь, папка и текущий каталог без путаницы
- 6.4RT1Y 5.4 Как перемещаться по папкам и не потеряться
- 6.5RT1Y 5.5 Как читать команду до её запуска
- 6.6RT1Y 5.6 Аргумент и флаг — что меняет поведение команды
- 6.7RT1Y 5.7 Красный текст на экране — как не пугаться
- 6.8RT1Y 5.8 Как найти настоящую причину в сообщении об ошибке
- 6.9RT1Y 5.9 Стектрейс и лог — где искать полезную часть
- 6.10RT1Y 5.10 Что делать, если ничего не происходит
- 6.11RT1Y 5.11 Как искать причину по одному изменению за раз
- 6.12RT1Y 5 Итоговый тест5 Questions
- 6. Docker и запуск проекта на своём компьютере13 Items
- 7.1RT1Y 6.1 Зачем Docker нужен непрограммисту
- 7.2RT1Y 6.2 Почему он снимает проблему ‘у меня работает’
- 7.3RT1Y 6.3 Образ и контейнер на бытовых аналогиях
- 7.4RT1Y 6.4 Слой, том и порт без технической каши
- 7.5RT1Y 6.5 Установка Docker — что проверить после запуска
- 7.6RT1Y 6.6 Откуда брать стартовый репозиторий курса
- 7.7RT1Y 6.7 Dockerfile — из чего собирается приложение
- 7.8RT1Y 6.8 Docker Compose — несколько сервисов одной командой
- 7.9RT1Y 6.9 Файл .env и настройки отдельно от кода
- 7.10RT1Y 6.10 Запуск проекта командой make up
- 7.11RT1Y 6.11 Что делать при проблемах с реестрами из России
- 7.12RT1Y 6.12 Типовые поломки запуска и как их распознать
- 7.13RT1Y 6 Итоговый тест5 Questions
- 7. Git как страховка от необратимого14 Items
- 8.1RT1Y 7.1 Зачем Git тому, кто не пишет код руками
- 8.2RT1Y 7.2 Коммит как точка сохранения проекта
- 8.3RT1Y 7.3 Почему маленький коммит лучше большого
- 8.4RT1Y 7.4 Диф — как увидеть, что именно поменял агент
- 8.5RT1Y 7.5 Ветка под каждую задачу и зачем это вам
- 8.6RT1Y 7.6 Слияние веток без паники
- 8.7RT1Y 7.7 Конфликт при слиянии — как понять, что произошло
- 8.8RT1Y 7.8 Revert — безопасный откат уже внесённых изменений
- 8.9RT1Y 7.9 Reset — чем он отличается и почему опасен
- 8.10RT1Y 7.10 Как вернуть то, что кажется потерянным
- 8.11RT1Y 7.11 Что не должно попадать в репозиторий никогда
- 8.12RT1Y 7.12 Pull request как единица приёмки работы агента
- 8.13RT1Y 7.13 Где хранить репозиторий, работая из России
- 8.14RT1Y 7 Итоговый тест5 Questions
- 8. Анализ: требования и границы системы9 Items
- 9.1RT1Y 8.1 Почему ‘я примерно знаю, что хочу’ не работает
- 9.2RT1Y 8.2 Какие вопросы задать заказчику или самому себе
- 9.3RT1Y 8.3 Как вытащить скрытые умолчания из разговора
- 9.4RT1Y 8.4 Требование и готовое решение — как их не путать
- 9.5RT1Y 8.5 Что входит в границы системы, а что нет
- 9.6RT1Y 8.6 Внешние участники и их интерес к системе
- 9.7RT1Y 8.7 Контекстная диаграмма на одном листе
- 9.8RT1Y 8.8 Как зафиксировать требования в проверяемом виде
- 9.9RT1Y 8 Итоговый тест0 Questions
- 9. Анализ: роли и сценарии9 Items
- 10.1RT1Y 9.1 Кто пользуется системой и чем роли отличаются
- 10.2RT1Y 9.2 Как описать основную цель каждой роли
- 10.3RT1Y 9.3 Основной сценарий — путь от входа до результата
- 10.4RT1Y 9.4 Как расписывать шаги сценария без двусмысленности
- 10.5RT1Y 9.5 Альтернативные потоки — когда пользователь идёт иначе
- 10.6RT1Y 9.6 Ошибки и исключения как часть сценария
- 10.7RT1Y 9.7 Кто что видит и кто что может менять
- 10.8RT1Y 9.8 Как проверить сценарии на полноту до кода
- 10.9RT1Y 9 Итоговый тест5 Questions
- 10. Анализ: домен, данные и состояния11 Items
- 11.1RT1Y 10.1 Глоссарий — одно слово — один смысл
- 11.2RT1Y 10.2 Сущности проекта на примере сервиса записи
- 11.3RT1Y 10.3 Атрибуты — какие данные реально нужны сущности
- 11.4RT1Y 10.4 Связи между сущностями и что они меняют
- 11.5RT1Y 10.5 Один-ко-многим и другие важные отношения
- 11.6RT1Y 10.6 Доменная модель — как собрать картину целиком
- 11.7RT1Y 10.7 Как проверить, что модель не врёт о реальности
- 11.8RT1Y 10.8 Состояния записи — создана, подтверждена, отменена
- 11.9RT1Y 10.9 Запрещённые переходы и почему они важны
- 11.10RT1Y 10.10 Типовые ошибки моделирования и их цена
- 11.11RT1Y 10 Итоговый тест5 Questions
- 11. Анализ: правила, ограничения и критерии приёмки10 Items
- 12.1RT1Y 11.1 Бизнес-правила — что в системе нельзя нарушать
- 12.2RT1Y 11.2 Инварианты — правила, которые должны держаться всегда
- 12.3RT1Y 11.3 Скорость, надёжность и объём без технического тумана
- 12.4RT1Y 11.4 Нефункциональные требования простым языком
- 12.5RT1Y 11.5 Как записать критерий приёмки так, чтобы проверить
- 12.6RT1Y 11.6 Чем ‘работает’ отличается от ‘кажется, работает’
- 12.7RT1Y 11.7 Как найти дыры и противоречия в собственной модели
- 12.8RT1Y 11.8 Что делать с конфликтующими требованиями
- 12.9RT1Y 11.9 Как выглядит готовый пакет аналитики для агента
- 12.10RT1Y 11 Итоговый тест5 Questions
- 12. Системное мышление: видеть приложение целиком12 Items
- 13.1RT1Y 12.1 Что такое система и зачем вам это мышление
- 13.2RT1Y 12.2 Почему целое ведёт себя не как сумма частей
- 13.3RT1Y 12.3 Потоки данных от рождения до удаления
- 13.4RT1Y 12.4 Карта системы — как уместить приложение на листе
- 13.5RT1Y 12.5 Как держать карту системы в актуальном состоянии
- 13.6RT1Y 12.6 Радиус поражения — что сломается от одной правки
- 13.7RT1Y 12.7 Почему одна правка тянет за собой десять
- 13.8RT1Y 12.8 Удобная фича, которая создаёт новую нагрузку
- 13.9RT1Y 12.9 Когда метрика начинает портить продукт
- 13.10RT1Y 12.10 Откуда растёт сложность и как её не плодить
- 13.11RT1Y 12.11 Как временный костыль становится архитектурой
- 13.12RT1Y 12 Итоговый тест5 Questions
- 13. Системный дизайн: части, границы и контракты14 Items
- 14.1RT1Y 13.1 Как перейти от доменной модели к устройству системы
- 14.2RT1Y 13.2 По какому шву делить приложение на части
- 14.3RT1Y 13.3 Почему файл на 3000 строк лишает вас контроля
- 14.4RT1Y 13.4 Что такое контракт между частями приложения
- 14.5RT1Y 13.5 Как понять хороший контракт без программирования
- 14.6RT1Y 13.6 Почему чёткие границы важны для работы с агентом
- 14.7RT1Y 13.7 Простота против гибкости — выбор с последствиями
- 14.8RT1Y 13.8 Скорость против надёжности на реальном примере
- 14.9RT1Y 13.9 Как записывать цену решения вслух и письменно
- 14.10RT1Y 13.10 Зачем нужен журнал решений и отвергнутых вариантов
- 14.11RT1Y 13.11 Оценка размеров системы без точных расчётов
- 14.12RT1Y 13.12 Где решение обратимо, а где ошибаться дорого
- 14.13RT1Y 13.13 Как понять, что систему пора менять
- 14.14RT1Y 13 Итоговый тест5 Questions
- 14. Системный дизайн: время, одновременность и отказы13 Items
- 15.1RT1Y 14.1 Две записи на один слот — где рождается конфликт
- 15.2RT1Y 14.2 Конкуренция за ресурс без сложных терминов
- 15.3RT1Y 14.3 Что делать, если кнопку нажали дважды
- 15.4RT1Y 14.4 Идемпотентность на примере записи и оплаты
- 15.5RT1Y 14.5 Почему операция должна пройти целиком
- 15.6RT1Y 14.6 Время и часовые пояса — тихие и дорогие ошибки
- 15.7RT1Y 14.7 Расписание и календарь — где ломается логика
- 15.8RT1Y 14.8 Внешний сервис недоступен — таймаут и повтор
- 15.9RT1Y 14.9 Деградация вместо полного отказа
- 15.10RT1Y 14.10 Частичный отказ — одна часть сработала, другая нет
- 15.11RT1Y 14.11 Наблюдаемость как часть проекта с самого начала
- 15.12RT1Y 14.12 Что логировать, чтобы потом найти причину
- 15.13RT1Y 14 Итоговый тест5 Questions
- 15. Spec-driven development11 Items
- 16.1RT1Y 15.1 Почему спека важнее устных договорённостей
- 16.2RT1Y 15.2 Спека как исходный код проекта
- 16.3RT1Y 15.3 Продуктовая спека — что строим и для кого
- 16.4RT1Y 15.4 Функциональная спека — как работает отдельная часть
- 16.5RT1Y 15.5 Задача — самый маленький рабочий уровень спеки
- 16.6RT1Y 15.6 Формат спеки, понятный человеку и модели
- 16.7RT1Y 15.7 Как связать требование, задачу, тест и коммит
- 16.8RT1Y 15.8 Почему спека должна жить в репозитории
- 16.9RT1Y 15.9 Что происходит, когда код и спека расходятся
- 16.10RT1Y 15.10 Как из спеки появляется бэклог задач
- 16.11RT1Y 15 Итоговый тест5 Questions
- 16. Архитектура, данные и миграции13 Items
- 17.1RT1Y 16.1 Монолит со слоями — почему это разумный старт
- 17.2RT1Y 16.2 Что лежит в app/domain и зачем это выделять
- 17.3RT1Y 16.3 Что лежит в app/application и чем слой полезен
- 17.4RT1Y 16.4 Что лежит в app/infrastructure и app/interface
- 17.5RT1Y 16.5 Как ориентироваться в структуре репозитория курса
- 17.6RT1Y 16.6 Почему в курсе выбран именно этот стек
- 17.7RT1Y 16.7 Как доменная модель превращается в схему базы
- 17.8RT1Y 16.8 Что такое миграция и почему без неё опасно
- 17.9RT1Y 16.9 Как выполнять миграции командой make migrate
- 17.10RT1Y 16.10 Настройки из окружения и файл .env.example
- 17.11RT1Y 16.11 API-контракт в письменном виде
- 17.12RT1Y 16.12 Архитектура как способ сжать контекст для агента
- 17.13RT1Y 16 Итоговый тест5 Questions
- 17. Проектирование экранов11 Items
- 18.1RT1Y 17.1 Как сценарий превращается в экран
- 18.2RT1Y 17.2 Какие экраны нужны сервису записи на старте
- 18.3RT1Y 17.3 Состояние загрузки — что видит человек в ожидании
- 18.4RT1Y 17.4 Пустой экран, ошибка и успех как отдельные случаи
- 18.5RT1Y 17.5 Формы — как человек вводит данные без боли
- 18.6RT1Y 17.6 Валидация и подсказки до отправки формы
- 18.7RT1Y 17.7 Сообщения об ошибках, которые можно понять
- 18.8RT1Y 17.8 Навигация — как не потерять человека по дороге
- 18.9RT1Y 17.9 Тексты интерфейса как часть требований
- 18.10RT1Y 17.10 Как описать экран так, чтобы агент не гадал
- 18.11RT1Y 17 Итоговый тест5 Questions
- 18. Управление ИИ-агентами14 Items
- 19.1RT1Y 18.1 Как агент видит ваш проект и его файлы
- 19.2RT1Y 18.2 Что такое контекст и почему он ограничен
- 19.3RT1Y 18.3 Файл AGENTS.md — правила проекта для агента
- 19.4RT1Y 18.4 Что класть в правила, а что не засоряет контекст
- 19.5RT1Y 18.5 Скиллы — повторяемые процедуры вместо длинных промптов
- 19.6RT1Y 18.6 Когда длинная сессия начинает портить результат
- 19.7RT1Y 18.7 Как понять, что контекст пора сбросить
- 19.8RT1Y 18.8 За что вы платите — токены, чтение и переписывание
- 19.9RT1Y 18.9 Выдуманные API и несуществующие пакеты
- 19.10RT1Y 18.10 ‘Всё готово’ при недоделанной работе
- 19.11RT1Y 18.11 Самовольный рефакторинг и цикл бесконечных правок
- 19.12RT1Y 18.12 Как распознать, что агент поехал
- 19.13RT1Y 18.13 Когда несколько агентов помогают, а когда мешают
- 19.14RT1Y 18 Итоговый тест5 Questions
- 19. Постановка задач агенту11 Items
- 20.1RT1Y 19.1 Как разложить спеку до задачи в один диф
- 20.2RT1Y 19.2 Признаки слишком крупной задачи для агента
- 20.3RT1Y 19.3 Признаки слишком мелкой задачи и лишней дробности
- 20.4RT1Y 19.4 Когда задача готова к передаче агенту
- 20.5RT1Y 19.5 Definition of Ready простыми словами
- 20.6RT1Y 19.6 Definition of Done — по чему принимать результат
- 20.7RT1Y 19.7 Что обязательно дать агенту вместе с задачей
- 20.8RT1Y 19.8 Зачем нужны примеры, ограничения и антипримеры
- 20.9RT1Y 19.9 Итерация и уточнение вместо переписывания с нуля
- 20.10RT1Y 19.10 Какие задачи агенту отдавать нельзя
- 20.11RT1Y 19 Итоговый тест5 Questions
- 20. Качество: как проверять то, что писал не ты13 Items
- 21.1RT1Y 20.1 Два вопроса качества — работает и удобно ли
- 21.2RT1Y 20.2 Почему регресс нельзя проверять только руками
- 21.3RT1Y 20.3 Что такое тест и как он выглядит глазами новичка
- 21.4RT1Y 20.4 Юнит-тесты для правил предметной области
- 21.5RT1Y 20.5 Интеграционные тесты для базы и внешних связей
- 21.6RT1Y 20.6 Дымовые тесты для главных сценариев
- 21.7RT1Y 20.7 Почему тесты должны расти из спеки
- 21.8RT1Y 20.8 Чем опасны тесты, написанные по готовому коду
- 21.9RT1Y 20.9 Тестовые данные и наполнение базы для проверки
- 21.10RT1Y 20.10 Как читать pull request, не умея писать код
- 21.11RT1Y 20.11 Красные флаги в дифе — лишнее и опасное
- 21.12RT1Y 20.12 Команды make test и make lint в вашей приёмке
- 21.13RT1Y 20 Итоговый тест5 Questions
- 21. Ручное тестирование: то, что не сделает за вас никто14 Items
- 22.1RT1Y 21.1 Почему приёмку результата всегда делает человек
- 22.2RT1Y 21.2 Что агент не видит в принципе
- 22.3RT1Y 21.3 Как проходить сценарий руками системно, а не хаотично
- 22.4RT1Y 21.4 Чек-лист из критериев приёмки
- 22.5RT1Y 21.5 Исследовательское тестирование — как ломать осознанно
- 22.6RT1Y 21.6 Где пользователь запнётся и бросит форму
- 22.7RT1Y 21.7 Тексты и ошибки глазами живого человека
- 22.8RT1Y 21.8 Почему нужен прогон на реальных данных
- 22.9RT1Y 21.9 Проверка на реальных людях, а не на идеальном кейсе
- 22.10RT1Y 21.10 Мобильный экран, медленный интернет и старый браузер
- 22.11RT1Y 21.11 Доступность — если человек видит или управляет иначе
- 22.12RT1Y 21.12 Как фиксировать находки для точечной правки
- 22.13RT1Y 21.13 Когда найденное — баг, а когда дыра в спеке
- 22.14RT1Y 21 Итоговый тест5 Questions
- 22. Выкладка: пайплайн, стенд и продакшен в России14 Items
- 23.1RT1Y 22.1 Что такое пайплайн и зачем он одиночному проекту
- 23.2RT1Y 22.2 Из каких шагов состоит нормальная выкладка
- 23.3RT1Y 22.3 Почему главная ветка должна оставаться зелёной
- 23.4RT1Y 22.4 Как передавать секреты без хранения в репозитории
- 23.5RT1Y 22.5 Как выбрать VPS и хостинг из России
- 23.6RT1Y 22.6 Первый вход на сервер и базовая подготовка
- 23.7RT1Y 22.7 Что такое домен и как он указывает на сервер
- 23.8RT1Y 22.8 DNS — почему адрес начинает работать не сразу
- 23.9RT1Y 22.9 Обратный прокси и зачем нужен замок в браузере
- 23.10RT1Y 22.10 Локально, стенд и прод — три разных окружения
- 23.11RT1Y 22.11 Выкладка первой версии и проверка после релиза
- 23.12RT1Y 22.12 Миграции на проде — самая опасная операция
- 23.13RT1Y 22.13 Бэкап и проверка восстановления, а не только копии
- 23.14RT1Y 22 Итоговый тест5 Questions
- 23. Безопасность и правовые границы13 Items
- 24.1RT1Y 23.1 Как секреты утекают через репозиторий и логи
- 24.2RT1Y 23.2 Почему нельзя класть секреты в промпты
- 24.3RT1Y 23.3 Prompt injection — когда данные управляют агентом
- 24.4RT1Y 23.4 Подменённые пакеты и атаки через зависимости
- 24.5RT1Y 23.5 Как понять, что приехало в ваш проект
- 24.6RT1Y 23.6 Аутентификация — как система узнаёт пользователя
- 24.7RT1Y 23.7 Авторизация по ролям — кто что может делать
- 24.8RT1Y 23.8 Проверка ввода и ограничение частоты запросов
- 24.9RT1Y 23.9 Персональные данные и что меняет 152-ФЗ
- 24.10RT1Y 23.10 Где хранить данные с учётом российского контекста
- 24.11RT1Y 23.11 Лицензии кода и заимствований — бизнес-риски
- 24.12RT1Y 23.12 Чек-лист аудита безопасности перед релизом
- 24.13RT1Y 23 Итоговый тест5 Questions
- 24. Инцидент: когда прод сломался12 Items
- 25.1RT1Y 24.1 Первые действия, когда прод перестал работать
- 25.2RT1Y 24.2 Почему нельзя чинить вслепую и сразу всё менять
- 25.3RT1Y 24.3 Где искать причину в логах и метриках
- 25.4RT1Y 24.4 Как отличить сбой кода от сбоя инфраструктуры
- 25.5RT1Y 24.5 Откат релиза — когда это самый быстрый путь
- 25.6RT1Y 24.6 Откат миграции — почему это отдельная история
- 25.7RT1Y 24.7 Хотфикс — когда можно срезать угол, а когда нельзя
- 25.8RT1Y 24.8 Что сообщать пользователям во время аварии
- 25.9RT1Y 24.9 Постмортем без поиска виноватых
- 25.10RT1Y 24.10 Что менять в правилах агента после инцидента
- 25.11RT1Y 24.11 Что менять в спеке и пайплайне после аварии
- 25.12RT1Y 24 Итоговый тест5 Questions
- 25. Итог: сдача проекта и перенос подхода10 Items
- 26.1RT1Y 25.1 Как сдавать проект по критериям приёмки
- 26.2RT1Y 25.2 Финальная проверка приложения перед показом
- 26.3RT1Y 25.3 Разбор pull request с посеянными дефектами
- 26.4RT1Y 25.4 Как замечать лишние и тихие правки
- 26.5RT1Y 25.5 Карта системы как итоговый документ проекта
- 26.6RT1Y 25.6 Журнал решений как защита от пересмотра хаотично
- 26.7RT1Y 25.7 Как входить с этим подходом в чужой проект
- 26.8RT1Y 25.8 Как перенести метод на свою рабочую задачу
- 26.9RT1Y 25.9 Что учить дальше после первого продакшена
- 26.10RT1Y 25 Итоговый тест5 Questions
This content is protected, please войти and записаться in the course to view this content!
RT1Y 11.8 Что делать с конфликтующими требованиями
Предыдущий
RT1Y 11 Итоговый тест
Следующий