Глава 3. Озарение в 3 часа ночи: когда я понял, что всё изменилось

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

🌱 История: Момент, когда я понял

3 часа ночи. Весна 2023 года.

Я сижу перед экраном. Передо мной — Midjourney.

Я пишу промпт:

"A garden growing inside a computer, digital plants made of code, warm lighting, peaceful atmosphere"

Жду 30 секунд.

И вижу.

Сад внутри компьютера. Растения из кода. Тёплый свет. Красиво. Органично.

Но меня поразило не что я увидел.

А как это произошло.

Я не нарисовал это

Я не взял кисть. Не открыл Photoshop. Не потратил 3 часа на рисование.

Я описал желаемое.

И AI вырастил изображение из этого описания.

Не построил. Не сконструировал.

Вырастил.

И тогда меня осенило

Вот оно.

То, о чём я думал с 1992 года, когда писал интерпретатор Пролога.

То, что казалось фантастикой.

Самообучающиеся системы, которые создают новое.

Не просто категоризируют (как мой ML-классификатор глаз в 2021).

А создают.

Из вычислительной мощности и описания.

Из токенов и намерений.

Выращивают.

Я сидел до 5 утра.

Генерировал изображения. Экспериментировал с промптами.

И понимал: разработка программ больше никогда не будет прежней.

💡 Осознание: От строительства к выращиванию

Знаешь, почему строительство — плохая метафора для программирования?

Потому что здание статично.

Ты построил дом — он стоит. Не растёт. Не адаптируется. Не учится.

Программа — живая.

Она меняется. Эволюционирует. Баги появляются и исчезают. Новые фичи вырастают.

Но раньше мы притворялись, что строим здание:

• Чертежи (архитектура) ✓
• Фундамент (базовые модули) ✓
• Стены (основной код) ✓
• Крыша (UI) ✓

Всё контролируемо. Всё детерминировано.

А потом приходил реальный мир:

• Требования изменились (стены не там!)
• Баг в фундаменте (всё переделывать!)
• Новая фича (пристройка?)

И мы латали здание. Делали костыли. Рефакторили.

Метафора не работала.

А теперь — новая метафора

Программа — это сад.

Ты:

• Сажаешь семена (начальный код, идеи)
• Поливаешь (добавляешь фичи)
• Ухаживаешь (рефакторинг, чистка)
• Обрезаешь (удаляешь dead code)
• Наблюдаешь, как растёт (частично непредсказуемо)

И с приходом AI — это стало буквально правдой.

📚 Контекст: Четыре фундаментальных изменения

Изменение 0: Недетерминированность (конец эпохи предсказуемости)

Это самое важное изменение. Все остальные — следствия этого.

Что изменилось в самой природе программ

70 лет программирования (1950-2020):

Программа = детерминированная система

• Одинаковый вход → одинаковый выход
• functionName(input) → всегда тот же output
• 100% предсказуемость
• 100% воспроизводимость

Примеры:

// Детерминированная функция
function add(a, b) {
  return a + b;
}

add(2, 3); // → 5 (всегда)
add(2, 3); // → 5 (всегда)
add(2, 3); // → 5 (всегда)

-- Детерминированный запрос
SELECT * FROM users WHERE id = 5;
-- → Всегда один и тот же пользователь

На этом строилось ВСЁ:

• Тестирование (assert output === expected)
• Отладка (воспроизвести баг)
• Оптимизация (кэширование результатов)
• Надёжность (детерминированность = предсказуемость)

Новая реальность: Недетерминированные программы

С 2023 года (эра LLM):

Программа = недетерминированная, вероятностная система

• Одинаковый вход → разные выходы
• llm.generate(prompt) → каждый раз другой результат
• Вероятностная природа
• Невоспроизводимость — это норма

Примеры:

// Недетерминированная функция
async function generateCode(prompt) {
  return await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }]
  });
}

await generateCode("Напиши функцию сортировки");
// Вариант 1: quicksort
// Вариант 2: mergesort
// Вариант 3: встроенный Array.sort()
// Все три раза — разные реализации!

Практический пример:

Вы создаёте AI-ассистента для поддержки клиентов.

Детерминированный подход (старый):

function getResponse(question) {
  const responses = {
    "Как оформить возврат?": "Перейдите в раздел 'Мои заказы'...",
    "Где моя посылка?": "Введите трек-номер на странице..."
  };
  return responses[question] || "Извините, не понял вопрос";
}

getResponse("Как оформить возврат?");
// → Всегда одинаковый заранее написанный ответ

Недетерминированный подход (новый):

async function getResponse(question, context) {
  return await llm.generate({
    systemPrompt: "Ты вежливый ассистент службы поддержки",
    userMessage: question,
    context: context
  });
}

await getResponse("Как оформить возврат?", userHistory);
// Ответ 1: "Конечно помогу! Для возврата товара вам нужно..."
// Ответ 2: "Понимаю ваше желание вернуть товар. Процесс такой..."
// Ответ 3: "Давайте разберёмся с возвратом. Сначала..."
// Каждый раз — разная формулировка, но смысл одинаковый

Что меняется:

Почему это фундаментально меняет всё

1. Тестирование перестало быть точным

Раньше:

test('add function', () => {
  expect(add(2, 3)).toBe(5); // ✅ Точное совпадение
});

Теперь:

test('AI summary', async () => {
  const summary = await ai.summarize(article);

  // ❌ Не работает: каждый раз разный текст
  expect(summary).toBe("Статья про AI...");

  // ✅ Работает: проверяем смысл
  expect(summary).toContainKeyPoints(['AI', 'программирование', 'будущее']);
  expect(summary.length).toBeLessThan(200);
  expect(semanticSimilarity(summary, expectedMeaning)).toBeGreaterThan(0.8);
});

2. Отладка стала вероятностной

Раньше:

• Баг воспроизводится 100% времени
• Фиксим → баг исчезает навсегда

Теперь:

• AI галлюцинирует в 5% случаев
• Невозможно точно воспроизвести
• Фиксим промпт → вероятность снижается до 1%, но не исчезает полностью

3. Появились новые метрики качества

Вместо "правильно/неправильно" → оцениваем:

• Релевантность (насколько ответ подходит к вопросу)
• Полезность (помог ли ответ пользователю)
• Безопасность (нет ли токсичного контента)
• Вероятность галлюцинаций (как часто AI выдумывает факты)

4. Программы стали "живыми"

Детерминированная программа = механизм

• Работает по заданному алгоритму
• Предсказуемо
• Как часы

Недетерминированная программа = организм

• Адаптируется к контексту
• Вероятностно
• Как растение

Практические последствия

Для разработчиков:

✅ Новые навыки:

• Prompt engineering (как направлять вероятность)
• Semantic testing (как тестировать смысл, а не текст)
• Probabilistic debugging (как находить вероятностные баги)

✅ Новые инструменты:

• LLM observability (OpenTelemetry для AI)
• Semantic similarity metrics (cosine similarity, embeddings)
• A/B testing для промптов

❌ Старые подходы не работают:

• Unit тесты с точным совпадением
• Полностью детерминированная отладка
• Кэширование по точному входу

Для пользователей:

✅ Преимущества:

• Программы адаптируются к контексту
• Ответы более человечные
• Разнообразие вариантов

❌ Недостатки:

• Иногда непредсказуемое поведение
• Нужно учиться работать с вероятностными системами

Изменение 1: Скорость (от часов к секундам)

Плохо: Как было раньше

Пятница, 17:00. Задача: добавить аутентификацию.

Твой план:

1. Спроектировать схему БД (users, sessions, tokens) — 30 минут
2. Выбрать библиотеки (JWT? Passport.js? bcrypt?) — 15 минут гугления
3. Написать модель User — 20 минут
4. Написать endpoints (/register, /login, /logout) — 1 час
5. Написать middleware для проверки токенов — 30 минут
6. Написать тесты — 1 час
7. Отладка (забыл захешировать пароль! XSS уязвимость! Баг в refresh token!) — 2 часа

Итого: 5.5 часов.

Результат: В пятницу в 22:30 ты всё ещё дебажишь. Выходные испорчены.

Хорошо: Как стало с AI

Пятница, 17:00. Та же задача.

Твой диалог с AI:

Ты: Создай систему аутентификации пользователей с JWT токенами
    на Express.js и PostgreSQL. Включи проверку силы пароля,
    rate limiting, и тесты.

AI: [через 30 секунд]
    ✓ Модель User с хешированием паролей (bcrypt)
    ✓ Endpoints: /register, /login, /logout, /refresh
    ✓ Middleware для JWT
    ✓ Rate limiting (express-rate-limit)
    ✓ Проверка силы пароля (zxcvbn)
    ✓ 15 unit тестов

Ты: Добавь двухфакторную аутентификацию через TOTP.

AI: [через 20 секунд]
    ✓ Интеграция с speakeasy для TOTP
    ✓ Endpoints: /2fa/setup, /2fa/verify
    ✓ QR код для Google Authenticator
    ✓ 5 дополнительных тестов

Время на генерацию: 1 минута. Время на проверку и правки: 30 минут.

Итого: 31 минута.

Результат: В пятницу в 17:31 ты уже тестируешь работающую систему. Выходные свободны.

Ускорение: в 10 раз.

Изменение 2: Барьер входа (от месяцев к дню)

Плохо: Новичок в 2020

Саша хочет стать разработчиком.

Его путь:

1. Учит синтаксис JavaScript — 1 месяц
2. Учит HTML/CSS — 2 недели
3. Учит Node.js — 1 месяц
4. Учит Express — 2 недели
5. Учит React — 2 месяца
6. Учит базы данных — 1 месяц

Через 5 месяцев: Саша может создать простое todo-приложение.

Продуктивность в первый день: 0%.

Хорошо: Новичок в 2025

Маша хочет стать разработчиком.

Её путь:

День 1:

Маша → AI: Создай todo-приложение с React и Node.js

AI: [создаёт проект]

Маша: Что делает этот код? [указывает на useState]

AI: useState — это React Hook для хранения состояния...
     Вот пример попроще... [объясняет]

Маша: Добавь возможность редактировать задачи

AI: [добавляет функцию]

Через 1 день: Маша создала работающее приложение.

Через 1 неделю: Маша понимает основы React (учась на реальных примерах).

Продуктивность в первый день: 60%.

Снижение барьера входа: в 100 раз.

Изменение 3: Роль разработчика (от писателя к выращивателю)

Раньше: Писатель кода

Ты писал каждую строку.

Каждую функцию. Каждый компонент. Каждый тест.

Полный контроль = полная ответственность.

Твоя ценность = скорость печатания + знание синтаксиса.

Сейчас: Выращиватель программ

Ты:

• Архитектор — проектируешь систему

  • "Мне нужна микросервисная архитектура с 3 сервисами..."

• Выращиватель — направляешь рост

  • "Этот компонент слишком разросся, разделим его"
  • "Здесь нужна обрезка — удали неиспользуемый код"

• Ревьюер — проверяешь качество

  • "AI, этот код уязвим к SQL injection. Исправь."
  • "Покрытие тестами только 60%. Добавь edge cases."

• Воспитатель — обучаешь AI

  • "В нашей команде мы используем этот паттерн... [даёшь пример]"
  • "Вот наш style guide. Используй его."

Твоя ценность = стратегическое мышление + экспертиза + способность направлять AI.

🛠️ Практика: Метафора в действии

Сравнение подходов

Конкретный пример: Создание API

Задача: CRUD API для блога (посты, комментарии, пользователи)

Подход "строительство":

// Ты пишешь ВСЁ вручную:

// models/User.js (20 строк)
const mongoose = require('mongoose');
const userSchema = new mongoose.Schema({
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  // ... ещё 15 строк
});

// models/Post.js (25 строк)
// models/Comment.js (20 строк)

// routes/users.js (80 строк)
router.post('/register', async (req, res) => {
  try {
    const { email, password } = req.body;
    // валидация, хеширование, сохранение...
    // ... ещё 10 строк
  } catch (error) {
    // обработка ошибок
  }
});
// ... ещё 70 строк

// routes/posts.js (100 строк)
// routes/comments.js (80 строк)

// middleware/auth.js (30 строк)

// tests/users.test.js (50 строк)
// tests/posts.test.js (60 строк)
// tests/comments.test.js (50 строк)

// Итого: ~600 строк кода
// Время: 2 дня

Подход "выращивание":

Ты → AI:
Создай REST API для блога на Express.js с MongoDB:
- Модели: User, Post, Comment
- User: email, password (хешированный), createdAt
- Post: title, content, author (ref User), comments (ref Comment[])
- Comment: text, author (ref User), post (ref Post)
- CRUD endpoints для всех моделей
- JWT аутентификация
- Валидация (express-validator)
- Обработка ошибок
- Unit тесты (Jest)
- Покрытие 80%+

AI: [через 1 минуту]
✓ Созданы 3 модели
✓ Созданы 12 endpoints
✓ Добавлена JWT аутентификация
✓ Добавлена валидация всех полей
✓ Добавлена обработка ошибок
✓ Написаны 24 теста
✓ Покрытие: 87%

Вот структура проекта:
models/
  User.js (35 строк)
  Post.js (40 строк)
  Comment.js (30 строк)
routes/
  users.js (120 строк)
  posts.js (140 строк)
  comments.js (100 строк)
middleware/
  auth.js (40 строк)
  errorHandler.js (20 строк)
tests/
  users.test.js (80 строк)
  posts.test.js (90 строк)
  comments.test.js (70 строк)

Итого: ~765 строк кода (БОЛЬШЕ, чем вручную!)
Время: 5 минут генерация + 30 минут проверка = 35 минут

Результат:

• AI написал больше кода (лучше покрыт тестами)
• AI написал качественнее (обработка edge cases, которые ты бы забыл)
• В 80 раз быстрее (2 дня vs 35 минут)

💰 Экономика AI-разработки: Токены → Код → Способности

Что изменилось в экономике

Раньше программирование стоило:

• Время программиста (самый дорогой ресурс)

Сейчас программирование стоит:

• Токены (вычислительная мощность)
• Время программиста (но гораздо меньше!)

Что такое токены?

Токен — это единица текста для LLM.

Примерно:

• 1 токен ≈ 4 символа (в английском)
• 1 токен ≈ 1-2 символа (в русском, сложнее)

Цена (GPT-4, пример):

• Input: $0.03 за 1000 токенов
• Output: $0.06 за 1000 токенов

Пример:

Сгенерировать функцию из 100 строк кода:

• Промпт: ~200 токенов ($0.006)
• Ответ: ~1000 токенов ($0.06)
• Итого: $0.066 (6.6 центов)

Время: 10-30 секунд.

Альтернатива (написать вручную):

• Время: 30 минут
• Стоимость программиста ($50/час): $25

Экономия: в 400 раз!

Токены как инвестиция

Мы делаем вычислительные операции, тратим энергию, тратим деньги.

Мы платим токенами, и эти токены мы превращаем в программный код, добывая его из компьютера.

Это как майнинг:

• Майнинг биткоинов: электричество → биткоины
• Майнинг кода: токены → программный код

Мы инвестируем в код:

• Покупаем токены
• AI генерирует код
• Код становится частью продукта
• Продукт приносит ценность

Наращивание способностей

Мы воспитываем программный продукт:

1. Предоставляем знания:

• Загружаем документацию в базу знаний
• RAG (Retrieval-Augmented Generation)
• AI использует эти знания при генерации

2. Расширяем функциональные возможности:

• Добавляем новые промпты → новые функции
• Добавляем инструменты → новые способности агента

3. Развиваем базу данных:

• Анализируем информацию
• Трансформируем её
• AI обогащает данные

Так мы выращиваем новые способности для наших программных продуктов.

👤 Агенты как личности

Photo by Luan Fonseca on Unsplash

Ева — наш корпоративный агент

Сейчас мы создаём AI-агентов.

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

• С именем и фамилией
• Наделять их хорошими чертами характера

Пример: Ева

Ева — наш интеллектуальный корпоративный агент.

Роль:

• Менеджер
• Руководитель
• Ассистент

Черты характера:

• Внимательная к деталям
• Проактивная
• Всегда проверяет факты перед ответом
• Вежливая и профессиональная

Способности:

• Доступ к корпоративной базе знаний
• Может создавать задачи в Jira
• Может отправлять уведомления в Slack
• Может генерировать отчёты

Почему имена и личность важны

1. Психологически легче взаимодействовать:

Сравните:

"AI система 3.7, выполни анализ продаж"
vs
"Ева, можешь проанализировать наши продажи за последний месяц?"

Второе звучит естественнее.

2. Команда агентов:

Когда у вас несколько агентов:

• Ева — менеджер проекта
• Алекс — разработчик
• Софья — тестировщик

Легче распределять задачи:

• "Ева, создай план спринта"
• "Алекс, реализуй эту функцию"
• "Софья, протестируй результат"

3. Эволюция и рост:

Когда агент имеет личность, легче говорить о его развитии:

"Мы будем добавлять новые способности для Евы"

Это звучит как:

• Обучение сотрудника
• Развитие члена команды

А не как:

• Апдейт системы

Программа как живой организм

С агентами, имеющими личность, программа начинает ощущаться как живая:

• Она учится (RAG, fine-tuning)
• Она развивается (новые способности)
• Она адаптируется (контекст, память)
• Она взаимодействует (общение с пользователями)

Это не просто код. Это развивающаяся сущность.

🎯 Чек-лист: Признаки фундаментального сдвига

Ты понял, что мир изменился, если:

В работе:

• Ты описываешь задачу вместо того, чтобы писать код
• Ты проверяешь сгенерированный код, а не пишешь каждую строку
• Ты делаешь за 1 час то, на что раньше уходил день
• Ты направляешь AI промптами, как выращиватель направляет рост растения

В мышлении:

• Ты думаешь "как это вырастить", а не "как это построить"
• Ты видишь программу как живой организм, а не мёртвую конструкцию
• Ты воспринимаешь токены как инвестицию в код
• Ты спрашиваешь "какие способности нужны этой программе", а не "какие функции написать"

В результатах:

• Твоя продуктивность выросла в 10+ раз
• Ты создаёшь проекты, которые раньше казались слишком большими
• Ты проверяешь код на безопасность, а не тратишь время на boilerplate
• Ты учишь AI писать код в стиле твоей команды

Три вопроса, чтобы понять масштаб изменений:

1. Сколько времени ты тратишь на написание кода vs проверку кода?

   • 2020: 90% написание, 10% проверка
   • 2025: 20% написание (или описание задачи), 80% проверка

2. Кто пишет больше строк кода за день — ты или AI?

   • 2020: Ты (100% кода)
   • 2025: AI (80% кода), ты доделываешь 20%

3. Сколько проектов ты можешь вести одновременно?

   • 2020: 1-2 проекта (время ограничено)
   • 2025: 5-10 проектов (AI даёт масштаб)

🌟 Почему это не хайп, а реальность

Я видел 9 технологических волн за 40 лет.

Я знаю, как отличить хайп от фундаментального сдвига.

Хайп выглядит так:

• 3D TV (2010): "Все будут смотреть TV в 3D!"

  • Результат: Умерло через 5 лет.

• Google Glass (2013): "Будущее AR!"

  • Результат: Никто не носит.

• Blockchain everything (2017): "Блокчейн решит все проблемы!"

  • Результат: Нишевое применение.

Признаки хайпа:

1. Решение ищет проблему
2. Технология не дозрела
3. Экономика не сходится
4. Только ранние адопторы используют

Фундаментальный сдвиг выглядит так:

• Интернет (1995): Изменил всё. Навсегда.
• Мобильные приложения (2008): Изменили всё. Навсегда.
• AI (2023-2025): Меняет всё. Навсегда.

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

1. Решение закрывает реальные проблемы
2. Технология работает прямо сейчас
3. Экономика выгодна (дешевле старого способа)
4. Массовое принятие (миллионы пользователей)

Почему AI — это фундаментальный сдвиг:

✅ Работает прямо сейчас

• GitHub Copilot: 20M+ пользователей, 1.3M платных подписчиков (2025)
• ChatGPT: 800M+ активных пользователей в неделю (2025)
• 95% разработчиков используют AI-инструменты (Stack Overflow Survey 2025)

✅ Экономически выгодно

• $0.06 за 1000 токенов vs $25/час разработчика
• ROI = 400x

✅ Решает реальные проблемы

• Boilerplate код → AI генерирует
• Низкий барьер входа → новички продуктивны с первого дня
• Дефицит разработчиков → AI увеличивает продуктивность в 10x

✅ Технология дозрела

• Качество кода: senior уровень
• Понимание контекста: да
• Рассуждение: да (Chain of Thought)

Это не хайп. Это новая реальность.

Финальная мысль: Мы в начале

Знаешь, что самое удивительное?

Мы только в начале.

GPT-4 (2023) vs GPT-5 (скоро) — качество будет ещё лучше.

Агенты становятся автономнее.

Инструменты становятся умнее.

И метафора выращивания станет ещё точнее.

Программы будут учиться на своих ошибках.

Адаптироваться к пользователям.

Эволюционировать без программиста.

Мы растим не просто код.

Мы растим будущее.

Следующая часть: Фундамент мастерства — без него ты не сможешь управлять AI. Даже самый лучший выращиватель должен понимать биологию растений.

Ключевые мысли главы

Озарение приходит в 3 часа ночи:

• Midjourney вырастил изображение из промпта
• Не построил. Вырастил.
• То, о чём я думал с 1992 — стало реальностью

Четыре фундаментальных изменения: 0. Недетерминированность: Детерминированные программы → Вероятностные системы

1. Скорость: 5 часов → 30 минут (10x)
2. Барьер входа: 5 месяцев → 1 день (100x)
3. Роль: Писатель → Архитектор + Выращиватель

Метафора имеет значение:

• Строительство = статично, детерминировано
• Выращивание = органично, адаптивно
• Программа = живой организм

Экономика токенов:

• Токены → код (инвестиция)
• $0.066 за функцию vs $25 вручную
• Экономия в 400 раз

Агенты как личности:

• Ева, Алекс, Софья — члены команды
• Легче взаимодействовать и развивать
• Программа становится живой сущностью

Это не хайп:

• 92% разработчиков используют AI (2024)
• ROI = 400x (экономика сходится)
• Технология работает прямо сейчас
• Массовое принятие

Мы в начале:

• Модели становятся лучше
• Агенты — автономнее
• Программы будут эволюционировать сами
• Мы растим будущее