Конспект: Software 3.0 и Вайбкодинг: Как LLM и Трансформеры Меняют Разработку ПО — VibCoderZ - VibeCoderz

Загрузка...

Саммари

🎯 О чём этот конспект: Архитектурный и практический разбор эволюции программирования от Андрея Карпатого (экс-директора по ИИ в Tesla и сооснователя OpenAI). В видео детально рассматривается переход от классического кода (Software 1.0) и обучения нейросетей на датасетах (Software 2.0) к программированию на естественном языке через промпты (Software 3.0), а также глубоко препарируется математика и код архитектуры Transformer на базе nanoGPT.

👤 Кому будет полезно: Вайбкодерам, AI-инженерам, системным разработчикам и фаундерам, создающим продукты на базе LLM-агентов (Cursor, Windsurf, Claude Code, OpenAI API) и желающим понимать фундаментальные механизмы работы современных нейросетей под капотом.

✨ Что получите: Чёткое понимание того, как проектировать приложения в парадигме Software 3.0 (где бэкендом выступает LLM), как выжимать максимальное качество reasoning-моделей правильным дизайном промптов, а также полную ментальную модель архитектуры Transformer (механизм внимания как message passing на графах, каузальные маски и устройство nanoGPT).

1. Парадигма Software 3.0: Английский как самый горячий язык программирования

Контекст: На протяжении последних 70 лет парадигма программирования (Software 1.0) оставалась неизменной: человек пишет явные инструкции компьютеру на C++, Python или ассемблере. Этот подход создал Linux и интернет, но сломался на задачах реального мира — компьютерном зрении, распознавании речи, игре в шахматы и управлении автомобилем. В Software 2.0 программирование сместилось к сбору данных (Data Engine): код компилируется оптимизатором (SGD/Adam) из размеченных датасетов в бинарник из весов нейросети. Сегодня индустрия вошла в эру Software 3.0: фундаментальные большие языковые модели стали вычислительной средой общего назначения (general-purpose runtime), которую программируют инструкциями на естественном языке без написания традиционного императивного кода.

Тайминг: [02:55], [05:10], [20:18]

Выгода: Понимание смены парадигмы позволяет переосмыслить архитектуру IT-продуктов: вместо сотен строк хрупкой бизнес-логики и регулярок задачи оркестрации, классификации и преобразования данных решаются декларативными промптами за считанные минуты.

Как применить:

Шаг 1: Идентификация участков кода для перехода на 3.0 — Проведите аудит проекта и найдите хрупкую императивную логику (парсинг неструктурированных JSON/HTML, извлечение именованных сущностей, эвристики рекомендаций).
Шаг 2: Замена алгоритмического блока на LLM-инструкцию — OpenAI API / Claude API — Сформулируйте спецификацию задачи на естественном языке, явно ограничив входной и выходной формат (structured JSON).
Шаг 3: Настройка системы оценки (Eval-driven development) — Создайте тестовый набор из 50–100 граничных кейсов, чтобы верифицировать поведение промпта так же, как вы прогоняли бы unit-тесты для классического кода.

Результат: Сокращение кодовой базы на 40–80% в задачах обработки неструктурированных данных и запуск фичей без написания сложного парсингового и эвристического кода.

2. Анатомия Reasoning в LLM: Зачем модели «думать вслух»

Контекст: Языковые модели обучаются тривиальной задаче: предсказанию следующего токена на основе интернет-данных. По умолчанию модель имитирует «средний ответ из интернета», что часто приводит к глупым ошибкам на сложных логических или математических задачах. Вычислительный бюджет модели на генерацию одного токена строго фиксирован (один прямой проход через слои трансформера). Если потребовать ответ мгновенно, модели физически не хватает вычислительных шагов, чтобы разрешить глубокие зависимости. Заставляя модель генерировать промежуточные токены рассуждений («думать шаг за шагом»), мы выделяем ей дополнительное процессорное время и пространство в рабочей памяти (контексте).

Тайминг: [08:46], [09:35], [10:45]

Выгода: Рост точности решения нестандартных логических и инженерных задач с 17% до 82% исключительно за счёт модификации формулировки промпта без файнтюнинга и затрат на обучение.

Как применить:

Шаг 1: Внедрение паттерна Chain-of-Thought — Cursor / Claude — Никогда не требуйте от агента сразу финальный код или результат. Сначала заставьте его разложить задачу на шаги.
Шаг 2: Обуславливание на целевой результат (Target-oriented prompting) — Добавьте в промпт указание на верификацию промежуточных выкладок, чтобы сдвинуть вероятностное распределение генерации к правильным ответам.
Шаг 3: Калибровка экспертного профиля — Задайте ролевой срез знаний высокой компетенции («IQ 200 researcher»), чтобы модель не скатывалась к банальным ответам из открытого веба.

# Промпт для решения сложной архитектурной / алгоритмической задачи
 
You are an expert Principal Systems Architect (top 0.1% percentile).
Solve the following task:
[ОПИСАНИЕ ЗАДАЧИ]
 
CRITICAL INSTRUCTIONS:
1. Let's work this out in a rigorous step-by-step way to be absolutely sure we have the correct, optimal answer.
2. Outline each premise, dependency, and edge-case explicitly in your scratchpad before writing any final code.
3. Verify each logical step against performance and concurrency constraints.

Результат: Исключение поверхностных галлюцинаций и получение математически и логически выверенных решений с первого прогона.

3. Симуляция окружения: Эмуляция Linux VM и умного дома внутри LLM

Контекст: Благодаря сжатию колоссальных объемов информации LLM способна работать как симулятор произвольных вычислительных систем. Если правильно обусловить контекст, модель может поддерживать виртуальное состояние файловой системы Linux, исполнять виртуальные Python-скрипты, генерировать сетевые ping-ответы и транслировать команды на естественном языке в структурированные API-вызовы. Например, в кейсе умного дома фраза «Я отправил сына читать на 20 минут, выключи свет, когда пора спать» автоматически преобразуется в валидный JSON-пейлоад с расчетом времени отключения (current_timestamp + 20 min), локацией спальни и типом команды без единой строчки жестко закодированного парсера.

Тайминг: [11:25], [13:20], [14:40]

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

Как применить:

Шаг 1: Создание системного промпта симулятора — Задайте строгие рамки поведения: никакого пояснительного текста, вывод только в заданном формате (code block или JSON).
Шаг 2: Определение контекста и схемы состояния — Передайте метаданные среды (время, локация, доступные девайсы/файлы) прямо в системный промпт.
Шаг 3: Организация двустороннего протокола взаимодействия — Разделите команды пользователя и служебные инструкции симулятора через специальный синтаксис (например, фигурные скобки).

# Промпт: Виртуальный терминал Linux
 
I want you to act as a Linux terminal. 
I will type commands and you will reply with what the terminal should show. 
I want you to only reply with the terminal output inside one unique code block, and nothing else. 
Do not write explanations. 
Do not type commands unless I instruct you to do so. 
When I need to tell you something in English, I will do so by using curly braces {like this}.
 
My first command is: pwd

# Промпт: Бэкенд-контроллер умного дома
 
You are the sentient brain of a Smart Home located in London.
Current timestamp: 2026-03-30T20:00:00Z.
Available devices:
- Living Room: Main Light (id: lr_light), Thermostat (id: lr_therm)
- Kids Bedroom: Bed Light (id: br_light_kids), Ambient Light (id: br_ambient_kids)
 
Rules:
1. Respond ONLY with a valid JSON object matching this schema:
   {"action": "COMMAND"|"QUERY", "target_id": string, "payload": object, "execution_time": ISO_TIMESTAMP}
2. Interpret implicit human time constraints and compute execution_time accordingly.
3. No prose or markdown outside the JSON block.

Результат: Полностью работоспособный декларативный интерпретатор команд, готовый к интеграции с физическими устройствами или внешними API.

4. Паттерн «GPT is all you need for backend»: Zero-code Serverless Архитектура

Контекст: В классической веб-разработке для каждого действия требуется писать маршруты (routes), контроллеры, ORM-модели и логику мутации состояния базы данных. На одном из хакатонов победил проект, продемонстрировавший радикальную концепцию: полный отказ от бэкенд-кода. Вся серверная часть заменяется одним обращением к LLM. Фронтенд отправляет на вход модели текущее состояние приложения в формате JSON и произвольную команду на естественном языке (например, «удали две последние задачи из списка»). Модель самостоятельно вычисляет новое состояние, удаляет нужные узлы из JSON и возвращает обновленный стейт на фронтенд.

Тайминг: [16:24], [17:10]

Выгода: Сокращение времени создания MVP с недель до часов: фронтенд взаимодействует напрямую с LLM-бэкендом без необходимости проектировать базу данных, писать эндпоинты REST/GraphQL и деплоить серверный код.

Как применить:

Шаг 1: Проектирование контракта состояния — Next.js / React — Определите корневой объект состояния (state JSON), хранящийся на клиенте или в легковесном хранилище (KV/localStorage).
Шаг 2: Реализация единого dispatch-метода — Настройте отправку текущего state и произвольного действия action (текстовая строка) в API языковой модели.
Шаг 3: Применение ответа модели — Получайте мутированный JSON и атомарно обновляйте UI-компоненты.

// Пример универсального LLM-бэкенд обработчика
interface AppState {
  todos: { id: string; text: string; completed: boolean }[];
  filter: string;
}
 
async function dispatchLLMAction(currentState: AppState, userIntent: string): Promise<AppState> {
  const response = await fetch("https://api.openai.com/v1/chat/completions", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "gpt-4o-mini",
      response_format: { type: "json_object" },
      messages: [
        {
          role: "system",
          content: "You are the state management engine of an application. You receive the CURRENT_STATE and a USER_INTENT in plain English. You must compute the next state and output ONLY the updated JSON state."
        },
        {
          role: "user",
          content: JSON.stringify({ CURRENT_STATE: currentState, USER_INTENT: userIntent })
        }
      ]
    })
  });
 
  const data = await response.json();
  return JSON.parse(data.choices[0].message.content);
}

Результат: Создание полнофункциональных приложений с произвольными операциями над данными («перенеси все незавершенные задачи на завтра и сгруппируй по приоритету») без единой строчки бэкенд-логики.

5. Преодоление лимита контекста: Архитектура внешнего блокнота (Scratchpad)

Контекст: Контекстное окно любого трансформера ограничено, а удержание всей цепочки мыслей и фактов в скрытых активациях быстро перегружает внимание модели. Человек решает проблему ограниченности рабочей памяти с помощью записной книжки. Аналогично, трансформер можно научить динамически использовать внешнее рабочее пространство (Scratchpad). Модель помечает служебными токенами блоки информации, которые нужно сохранить, после чего внешний рантайм выносит их в персистентное хранилище или векторную память и подгружает обратно по мере необходимости.

Тайминг: [22:26], [23:05]

Выгода: Возможность работы агентов над долгосрочными многоэтапными проектами без деградации рассуждений и потери критически важных инструкций из-за переполнения контекста.

Как применить:

Шаг 1: Внедрение тегов блокнота в промпт — Научите агента выгружать промежуточные факты в блокнот с помощью явных ограничителей.
Шаг 2: Парсинг и сохранение содержимого в рантайме — Python / Node.js — Настройте обработчик стриминга ответа: при обнаружении тега блокнота перехватывайте содержимое и сохраняйте его в локальный файл или key-value базу.
Шаг 3: Автоматическая инъекция блокнота — Перед каждым новым вызовом агента вставляйте актуализированный срез блокнота в начало контекста.

# Системная инструкция для агента с внешним блокнотом
 
Your internal context is finite. You have access to an external SCRATCHPAD.
Whenever you generate a key finding, variable name, API schema, or intermediate plan, emit:
 
<start_scratchpad>
[Data/fact/code to remember for later stages]
<end_scratchpad>
 
Rules:
- The system will save everything inside the scratchpad tags to persistent storage.
- At any subsequent step, this data will be available to you.
- Keep the scratchpad concise and factual.

Результат: Устойчивая работа AI-агента в длинных пайплайнах с сохранением ключевого контекста без перерасхода токенов.

6. Унификация ИИ через Transformer: Конец эпохи зоопарка моделей

Контекст: До 2012 года в машинном обучении каждая область развивалась изолированно: в Computer Vision вручную настраивали дескрипторы признаков (SIFT, HOG, текстилоны, цветовые гистограммы) и поверх обучали SVM; в NLP строили отдельные пайплайны морфологического анализа и синтаксических деревьев. С появлением статьи «Attention Is All You Need» (2017) индустрия сошлась на единой универсальной архитектуре. Трансформер одинаково успешно обрабатывает текст (токены BPE), картинки (ViT: нарезка изображения на квадратные патчи), звук (Whisper: нарезка мел-спектрограммы на слайсы), RL (Decision Transformer: последовательность состояний, действий и наград) и даже биологические структуры (AlphaFold).

Тайминг: [24:45], [25:40], [30:40], [33:35]

Выгода: Единый концептуальный стек: освоив работу с архитектурой Transformer на тексте, разработчик получает готовый инструментарий для работы с любыми модальностями данных.

Как применить:

Шаг 1: Представление любой задачи как последовательности токенов — Любой входной сигнал разбивается на независимые фрагменты фиксированного размера (патчи для изображений, фреймы для аудио, события для логов).
Шаг 2: Проекция в векторное пространство (Linear Projection) — Каждый фрагмент проецируется матрицей в одномерный вектор признаков размерности d_model.
Шаг 3: Добавление позиционного кодирования (Positional Encoding) — Поскольку трансформер оперирует множествами (sets) без встроенного понятия порядка, к векторам признаков прибавляются обучаемые или синусоидальные позиционные векторы.

# Концептуальная нарезка изображения на токены (Vision Transformer паттерн)
import torch
import torch.nn as nn
 
class PatchEmbedding(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768):
        super().__init__()
        self.num_patches = (img_size // patch_size) ** 2
        # Свертка с ядром patch_size и шагом patch_size эквивалентна нарезке на патчи
        self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size)
 
    def forward(self, x):
        # x: [Batch, Channels, Height, Width] -> [Batch, Embed_dim, Num_patches_H, Num_patches_W]
        x = self.proj(x)
        # Flatten в последовательность токенов: [Batch, Embed_dim, Num_patches] -> [Batch, Num_patches, Embed_dim]
        x = x.flatten(2).transpose(1, 2)
        return x

Результат: Возможность мультимодальной интеграции данных любых типов (картинки, телеметрия, текст, аудио) в рамках единой сквозной сети без узкоспециализированных пайплайнов.

7. Внимание как передача сообщений на графах (Message Passing)

Контекст: Классическое математическое описание механизма Self-Attention через матрицы формул часто скрывает базовую интуицию. Карпатый предлагает рассматривать трансформер как процесс передачи сообщений (Message Passing) на ориентированном графе узлов. Каждый токен — это узел графа со своим вектором состояния. Работа слоя внимания делится на два четких этапа:

Communication Phase (Связь): Узлы обмениваются информацией. Узел генерирует Query («что я ищу»). Соседние узлы транслируют свои Key («что у меня есть»). Скалярное произведение Query на Key определяет вес внимания (affinity). По этим весам суммируются Value («содержимое узлов») и обновляют состояние узла.
Compute Phase (Вычисление): Каждый узел независимо прогоняет полученную информацию через локальную двухслойную полносвязную сеть (MLP/FFN), трансформируя свои признаки.

Тайминг: [44:50], [46:15], [48:00]

Выгода: Простая и прозрачная ментальная модель работы нейросети, устраняющая мистику вокруг формулы $Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$.

Как применить:

Шаг 1: Разделение на фазы коммуникации и вычислений — При анализе проблем модели (почему LLM путает контекст или галлюцинирует) проверяйте: проблема в плохом сборе связей (Attention) или в нехватке параметров обработки знаний (MLP).
Шаг 2: Понимание роли множественных голов (Multi-Head) — Каждая «голова» внимания — это независимый граф передачи сообщений со своими весами $W_q, W_k, W_v$. Они выполняются параллельно, позволяя собирать разные типы связей (синтаксические, смысловые, пространственные) одновременно.

# Чистая Python-интуиция одного узла внимания
def node_attention_message_passing(node_query, sender_keys, sender_values):
    """
    node_query: [d_k] — вектор 'что я ищу'
    sender_keys: [N, d_k] — векторы 'что у них есть'
    sender_values: [N, d_v] — векторы 'какую информацию они несут'
    """
    import numpy as np
 
    # 1. Скалярное произведение: вычисляем степень соответствия (affinities)
    scores = np.dot(sender_keys, node_query) / np.sqrt(len(node_query))
 
    # 2. Softmax: нормализуем веса в распределение вероятностей (сумма = 1.0)
    exp_scores = np.exp(scores - np.max(scores))
    weights = exp_scores / exp_scores.sum()
 
    # 3. Взвешенная сумма: собираем значения (Values) от всех отправителей
    updated_node_state = np.sum(sender_values * weights[:, None], axis=0)
    return updated_node_state

Результат: Глубокое понимание того, как трансформер агрегирует контекст, необходимое для отладки архитектур и эффективного составления промптов.

8. Архитектура nanoGPT: Разбор кода авторегрессионного трансформера

Контекст: Андрей Карпатый написал nanoGPT — полную, чистую и минималистичную реализацию трансформера (в стиле GPT-2) объемом около 300 строк на чистом PyTorch, способную воспроизводить обучение модели на открытых данных (OpenWebText / TinyShakespeare). Внутри nanoGPT раскрываются все ключевые элементы современных LLM: Embedding слой, объединенный с Positional Embedding, последовательность блоков TransformerBlock (включающих Causal Self-Attention и MLP с расширением размерности в 4 раза), LayerNorm и финальная линейная проекция (lm_head) в размерность словаря.

Тайминг: [52:18], [55:40], [57:20], [59:20]

Выгода: Полная прозрачность внутреннего устройства любой LLM: никакого «черного ящика», только базовые матричные операции и тензоры PyTorch.

Как применить:

Шаг 1: Настройка батчинга по осям Batch и Time — Поймите, что при обучении на батче $B \times T$ трансформер параллельно учится на всех префиксах последовательности: для токена $t_1$ целью является $t_2$, для последовательности $t_1, t_2]$ целью является $t_3$ и так далее.
Шаг 2: Реализация каузальной маски (Causal Mask) — Чтобы декодер не подглядывал в будущее, перед вычислением Softmax элементы матрицы внимания выше главной диагонали принудительно зануляются значением $-\infty$.
Шаг 3: Авторегрессионная генерация — Генерация текста происходит в цикле: предсказываются логиты для следующего токена, берется выборка (sampling), новый токен конкатенируется с контекстом, а при превышении block_size контекст обрезается слева.

import torch
import torch.nn as nn
from torch.nn import functional as F
 
class CausalSelfAttention(nn.Module):
    def __init__(self, n_embd, n_head, block_size, dropout=0.1):
        super().__init__()
        assert n_embd % n_head == 0
        # Проекции Q, K, V сразу для всех голов в одном тензоре
        self.c_attn = nn.Linear(n_embd, 3 * n_embd, bias=False)
        self.c_proj = nn.Linear(n_embd, n_embd, bias=False)
        self.attn_dropout = nn.Dropout(dropout)
        self.resid_dropout = nn.Dropout(dropout)
        self.n_head = n_head
        self.n_embd = n_embd
        # Нижнетреугольная маска: 1 - смотрим, 0 - маскируем
        self.register_buffer("bias", torch.tril(torch.ones(block_size, block_size))
                                    .view(1, 1, block_size, block_size))
 
    def forward(self, x):
        B, T, C = x.size() # Batch size, Sequence length, Embedding dim
        # Считаем Q, K, V и разбиваем на головы
        q, k, v = self.c_attn(x).split(self.n_embd, dim=2)
        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
 
        # Вычисляем матрицу внимания: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T)
        att = (q @ k.transpose(-2, -1)) * (1.0 / (k.size(-1) ** 0.5))
        # Применяем каузальную маску: будущие токены получают -inf
        att = att.masked_fill(self.bias[:, :, :T, :T] == 0, float('-inf'))
        att = F.softmax(att, dim=-1)
        att = self.attn_dropout(att)
        
        # Собираем значения (Values)
        y = att @ v # (B, nh, T, hs)
        y = y.transpose(1, 2).contiguous().view(B, T, C) # Склеиваем головы обратно
        return self.resid_dropout(self.c_proj(y))

Результат: Готовый, оптимизированный модуль каузального внимания, лежащий в основе всех моделей семейств GPT, Llama и Claude.

FAQ

В: В чем ключевая разница между Software 1.0, 2.0 и 3.0? О: В Software 1.0 человек вручную пишет код алгоритма (C++, Python). В Software 2.0 человек формирует датасет, а алгоритм оптимизации компилирует его в бинарник из весов нейросети. В Software 3.0 фундаментом выступает предобученная LLM, а программой становится промпт на естественном языке, задающий логику работы в рантайме.

В: Почему фраза «Let’s think step by step» так резко увеличивает точность ответов? О: Архитектурно трансформер выполняет строго фиксированное количество матричных умножений на каждый сгенерированный токен. Если модель сразу заставить выдать ответ, ей может не хватить вычислительной глубины для сложного вывода. Промпт заставляет ее генерировать промежуточные токены, тем самым выделяя больше вычислительных шагов на задачу.

В: Почему именно Transformer вытеснил RNN и LSTM? О: Трансформер оптимизирует три свойства: выразительность (expressive), оптимизируемость (благодаря ResNet-соединениям и LayerNorm градиенты текут без затухания) и аппаратную эффективность (efficient). В отличие от рекуррентных сетей, где токены обрабатываются строго последовательно, трансформер представляет собой мелкий и широкий граф, который идеально параллелится на тысячах ядер GPU.

В: Чем отличается Decoder-only архитектура от Encoder-Decoder и Encoder-only? О: В Decoder-only (GPT) используется каузальная маска, запрещающая токенам смотреть в будущее, что делает ее идеальной для генерации текста. В Encoder-only (BERT) все токены свободно общаются между собой в обе стороны, что оптимально для классификации и эмбеддингов. В Encoder-Decoder (T5, классический перевод) энкодер видит весь вход без масок, а декодер авторегрессионно генерирует результат, смотря на выход энкодера через Cross-Attention.

В: Что такое In-Context Learning с точки зрения внутренней математики трансформера? О: Исследования показывают, что когда трансформер читает примеры (Few-shot) в промпте, в его скрытых активациях происходит процесс, математически эквивалентный градиентному спуску (внутреннее мета-обучение). Веса модели при этом не меняются, но состояние активаций адаптируется под паттерн задачи точно так же, как при дообучении (Fine-Tuning).

В: Зачем в трансформере нужен positional encoding? О: Механизм внимания работает над множеством (set) векторов и сам по себе инвариантен к порядку следования элементов: фразы «собака укусила человека» и «человек укусил собаку» без позиционных меток дали бы одинаковое представление. Positional Encoding принудительно внедряет координаты каждого токена в пространстве последовательности.

В: Почему попытка жестко зашить индуктивные смещения (inductive bias) в трансформер часто вредит? О: Как объясняет Карпатый, при масштабировании данных (Scaling Laws) модель самостоятельно находит более оптимальные структуры репрезентации, чем те, что закладывает человек. Ручные эвристики и жесткие ограничения помогают на маленьких датасетах, но становятся бутылочным горлышком при обучении на триллионах токенов.

Ресурсы и ссылки

nanoGPT — Минималистичный и сверхбыстрый репозиторий Андрея Карпатого для обучения и воспроизведения моделей класса GPT-2 на PyTorch — https://github.com/karpathy/nanoGPT
Attention Is All You Need (Vaswani et al., 2017) — Фундаментальная статья, представившая архитектуру Transformer миру — https://arxiv.org/abs/1706.03762
Language Models are Few-Shot Learners (Brown et al., GPT-3 Paper) — Исследование OpenAI, доказавшее способность больших моделей к мета-обучению в контексте — https://arxiv.org/abs/2005.14165
ConvNetJS — Библиотека для обучения нейросетей прямо в браузере на JavaScript, созданная Карпатым — https://cs.stanford.edu/people/karpathy/convnetjs/
The Unreasonable Effectiveness of Recurrent Neural Networks — Легендарное эссе Андрея Карпатого о генеративных возможностях рекуррентных сетей — упомянуто в видео
Building A Virtual Machine inside ChatGPT — Исследование Jonas Degrave по симуляции виртуальной машины Linux внутри контекста LLM — упомянуто в видео
Twitter-аккаунт Райли Гудсайда (Riley Goodside) — Пионер профессии Prompt Engineering (Scale AI) — упомянут в видео

Конспект создан на основе видео «State of GPT / Software 3.0 Keynote» канала Stanford Online / Andrej Karpathy. Все права на оригинальный материал принадлежат авторам. Источник: https://www.youtube.com/watch?v=Rlk0GLRWwTI