Хабр Курсы для всех
РЕКЛАМА
Большая витрина: от крупнейших школ до частных авторов. Сравнивайте по цене, длительности, формату и выбирайте самый подходящий курс!
Поток AI и ML доступен 24/7 благодаря поддержке друзей Хабра
Комментарии 296
Для агентского режима это очень медленно. Это начинает раздражать. Если взять модель DeepSeek-V4.1-Flash напрямую через API DeepSeek, скорость там достигает 300 токенов в секунду
Для агентского режима с четкой проверкой можно. В остальных случаях - брезгую: столько вранья давно не видел.
А есть какая-то корреляция между измеримой скоростью токенов в секунду и количеством вранья?
Есть реальная польза от агентского режима с многоступенчатой доказательной проверкой, ловится куча багов, пустышек, обещаний и т.д, это работает на любой модели, а разницы из за скорости генерации я не разу не замечал.
Спрошу по-другому - агентский режим на локальной модели с, допустим 12Гб видео и 64Гб оперативки будет работать, пусть и неспеша, но без такого же количества вранья как в упомянутом DeepSeek-V4.1-Flash ?
Скажем так, гарантии я не дам, потому что работаю на своем собственном агенте, а что возьмете вы и как настроите я не знаю, а от агентского контура зависит все.
А на счет DeepSeek-V4.1-Flash, у меня он сейчас как раз подключен, как облачная модель, и вот наблюдение, я ему кинул ссылку на статью, и сказал, хочу то что в статье но с своим блэкджеком, к вечеру полный функционал был готов, в агентском режиме он работает на ура.
Вот кстати если интересно, как работает режим проверки, это дипсик 4.1, режим работы swarm когда есть оркестратор и воркер, и вот как раз воркер закончил работу и прислал отчет оркестратору, а тот не поверил ему, и не зря, нашел косяки и отправил воркера исправлять, без моего вмешательства в работу агента.
Вот кстати если интересно, как работает режим проверки
Расскажите по подробней, где этот режим? Какой-то дополнительный агент?
вы всегда можете в промте задать типа "создай план, делегируй исполнение субагенту, его результат провалидируй(тут тоже опция - через независимого агента-ревьюера)". я такую механику сразу в AGENTS.md зашил, чтобы ни одно решение по проекту не принималось без проверки независимым агентом с моделью другого семейства, чем агент-исполнитель
Вам нужен режим где основной агент делегирует работу суб-агенту, а сам оценивает его работу
12 - мало совсем. Сейчас даже квантованные модели типа квен-кодер не влезают уже в 20ГБ.
Статистическая есть. Логической связи нет
А были ли внешние инструменты - тот же Qdrant+BAAI-m3 эбмеддер, сейчас в облачных сервисах полно этого добра. Делается векторная БД, затем чанкуется любой даташит что под руку попал (включая код с коммент-промпт форматом - не пренебрегайте этим!) и модель всё делает почти так как руками, хоть Алиса хоть Сбер. Мне очень всё это дело помогло сделать микро-проект с PWM/ADC/UART/I2C/SPI с DMA, все адекватные конечные автоматы с фоллбеками и обработчиками ошибок, практически на уровне main(){} с таймерами миниатюрная RTOS, полное понимание проблем RMW с гонкой данных и всё это впихнуть в 64 к флеша и 20к озушки, прочих вкусных протокольных внешних микрух а-ля SPI дисплейчик, мультиплексоры I2C и умные драйверы шаговых. Плюс ещё скиллы соответствующие и промпт-инъекции чтобы направить в нужное русло ну и конечно же md-саммари с хорошей цепочкой и контрольным выводом, плюс питонячьи тесты (уже давно отодвинул Matlab) и тестирующие C-обёртки. Практически можно не использовать stdlib а генерировать printf/scanf по месту и прочие парсеры, умещаясь в килобайты как на каком-нибудь спектруме, самое невероятное - практически отпала необходимость искать чьи-либо библиотеки (!) для периферии, шрифтов, рендеров итд, всё генерируется по месту, остаётся только что-то вроде HAL/SPL на уровне спецификаций регистров управления. Вообщем это добротный джун/миддл с опытом работы 50+ лет в отрасли, начиная от Z80 и до GPU/FPGA.
Кстати интересная идея, подключить тулзу к кодинг агенту которая проиндексирует кодовую базу через ембединг вектора и будет давать возможность искать по смыслу а не только по ключевым словам. Надо попробовать с PI Harness такое проделать.
пробовал AST граф от разных репозиториев, да это немного другое, но суть та же — дать агенту инструмент для поиска по кодовой базе, в итоге работает так себе, современные LLM ужн обучены на некую чуйку лазить по коду как надо а инструмент применяется только по узкой необходимости, когда я прошу это делать (в системном промпте также оформлено как его использовать и тд, не помогает), разве что позволяет мертвый код искать, но как отдельная сессия, а не в процессе решения. Возможно оно нормально будет работать на ООП коде, а не на несколько микросвервисов с разными языками в них, но вот мой опыт ну такое и про индексацию с помощью эмбедингов и векторой базы думаю также будет, работать реально только если много доков и лить top k сразу перед самой таской в промпт тогда может быть
В точку. Нужен самостоятельный AST-инструмент. Настоящий пример который использую прямо сейчас. Лучше потратить пару дней для генерации того что необходимо, тем более модель с этим отлично справляется. Для Питона там куча нативных AST, для C - Clang
Саммари:
AST Python
# PyScanPyAST — Сканер зависимостей Python
## Обзор
Модульный инструмент для статического анализа зависимостей Python-проектов. Сканирует все `.py` файлы, строит направленный граф связей импортов и вызовов, генерирует отчёты о цепочках зависимостей и двусторонней достижимости.
---
## Архитектура
```
scanner.py (CLI точка входа)
└── ini_reader.py (конфигурация)
└── graph_builder.py (сборщик графа)
├── file_scanner.py (поиск файлов)
└── ast_parser.py (парсинг AST)
└── chain_report.py (отчёт цепочек)
└── targeted_deps.py (целевой анализ)
└── runner.py (режимы выполнения)
├── association_engine.py (двусторонний поиск)
└── reporter.py (полный отчёт)
```
---
## Модули
### ini_reader.py — Менеджер конфигурации
- Читает `config.ini` из корня проекта (без дефолтов)
- Парсит `requirements.txt` для извлечения имён venv-пакетов
- Классифицирует узлы графа: Project / System / Venv через O(1) lookup по frozenset
### file_scanner.py — Поиск файлов
- Рекурсивный обход проекта, исключение директорий и расширений по конфигу
- Преобразование путей файлов в точечные имена модулей
- Фильтрация: `.venv`, `__pycache__`, `.pyc`, скрытые файлы
### ast_parser.py — Парсинг AST
- Извлечение рёбер зависимостей через `astroid`: импорты, определения функций, вызовы
- Нормализация импортов: `from X import Y` → `X.Y` каноническое имя
- Разрешение вызовов: вывод astroid → статический фолбэк с трассировкой вложенных атрибутов
- Внешние вызовы сворачиваются к корневому модулю
### graph_builder.py — Сборщик графа
- Построение `networkx.DiGraph` из распаршенных рёбер
- Разделение узлов: пространства имён модулей vs функции/методы (через анализ рёбер `contains`)
- Назначение scope каждому узлу: Project / System / Venv
- Анализ степеней: топ импортируемых модулей, топ вызывающих функций
### association_engine.py — Двусторонний поиск достижимости
- Downstream: BFS вперёд от начального модуля — все зависимые модули и функции
- Upstream: BFS назад от начального модуля — все вызывающие модули и тесты
- Построение кратчайших путей (chain) от корня к каждому достижимому узлу
- Классификация всех достижимых узлов по scope
### chain_report.py — Генератор отчёта цепочек
- BFS-трассировка полной цепочки импортов от целевого файла до листьев
- Группировка импортов по пакету верхнего уровня (напр., `ASTPythonIO/editable_ast`)
- Форматирование: дерево root → leaves + список прямых импортов для каждого файла
### targeted_deps.py — Целевой анализ зависимостей
- Фаза 1: парсинг целевого файла → внешние импорты (stdlib + third-party) + внешние вызовы
- Фаза 2: сканирование всех файлов проекта → поиск вызывающих (кто импортирует цель)
- Вывод: список внешних импортов, внешних вызовов, список модулей-вызывающих
### reporter.py — Генератор полного отчёта
- Сводная статистика: узлы, рёбра, модули, count по типам
- Топ импортируемых модулей (по in-degree) и топ вызывающих функций (по out-degree)
- Деревья зависимостей модулей + деревья вызовов функций
- Полный список всех рёбер (импорт / contains / call)
- Сворачивание внешних узлов: `typing.Any` → `typing`, `tkinter.ttk` сохраняется
### runner.py — Режимы выполнения
- Режим ассоциации: двусторонний поиск от `--init`, upstream/downstream с цепочками
- Режим полного отчёта: полная статистика проекта, деревья, все рёбра
- Форматирование текста с группировкой по scope и rollup внешних узлов
### scanner.py — Точка входа CLI
- Полный скан: `python scanner.py <проект>` → полный отчёт
- Целевой: `python scanner.py <проект> --init <модуль>` → двусторонний отчёт
---
## Внешние пакеты
| Пакет | Назначение |
|-------|-----------|
| `astroid` | Парсинг AST, вывод типов, разрешение импортов |
| `networkx` | Построение и анализ направленного графа зависимостей |
---
## Использование CLI
```bash
# Полный отчёт по проекту
python scanner.py /путь/к/проекту
# Целевой: двусторонний поиск
python scanner.py /путь/к/проекту --init alice_agent_ast.examples.foo
# Цепочка: root → leaves
python chain_report.py /путь/к/проекту alice_agent_ast.examples.foo
# Целевые зависимости: внешние импорты + вызывающие
python targeted_deps.py /путь/к/проекту alice_agent_ast.examples.foo
```
---
## Файлы вывода
| Файл | Содержание |
|------|-----------|
| `dependency_report.txt` | Полный проект: сводка, топ модули, деревья зависимостей, все рёбра |
| `association_report.txt` | Двусторонний: upstream вызывающие, downstream помощники, цепочки |
| `result.txt` | Цепочка: полное дерево цепочки + прямые импорты для каждого файла |
---
## Конфигурация
`config.ini` (обязателен в корне проекта):
```ini
[exclusions]
dirs = .git, venv, .venv, env, __pycache__, build, dist
extensions = .pyc, .pyo
[scopes]
stdlib_prefixes = builtins, abc, importlib, typing, collections, os, sys, ...
[reporting]
top_imported_limit = 15
top_calling_limit = 15
sample_call_trees_limit = 10
```
---
## Ключевые решения
1. **Только config**: нет захардкоженных списков stdlib или правил исключения
2. **Модуль vs функция**: разделение пространств имён модулей и узлов функций через анализ рёбер `contains`
3. **Нормализация импортов**: `from X import Y` → `X.Y` канонические имена, совпадающие с рёбрами импорта
4. **Разрешение вызовов**: вывод astroid → статический фолбэк, внешние вызовы сворачиваются к корневому модулю
5. **Сворачивание внешних узлов**: `typing.Any` → `typing`, `tkinter.ttk` сохраняется как исключение
6. **O(1) классификация**: lookup по frozenset для префиксов stdlib и venv пакетов
Для скана C поиск dead-code
Сканер по С файлам
# CScanFuncsPyClang — Справочник проекта
## Обзор
Python-инструментарий для статического анализа C-проектов на базе **Clang LibIndex**. Сканирует дерево исходников, извлекает AST (абстрактное синтаксическое дерево), строит матрицу вызовов, выявляет мёртвый код, отслеживает макросы и генерирует отчёты.
---
## Архитектура конвейера
```
загрузка конфигурации → парсинг AST → анализ дерева → санитизация → флаги → экспорт
↕
верификатор мёртвого кода
↕
отдельный скрипт верификации
```
```
главный скрипт (оркестратор)
├── Шаг 1: Загрузка конфигурации из INI-файла
├── Шаг 2: Разрешение препроцессорных флагов из CMake/Make
├── Шаг 3: Инициализация движка Clang
├── Шаг 4: Обход дерева файлов проекта
├── Шаг 5: Параллельный парсинг файлов через пул потоков
├── Шаг 6: Агрегация результатов в общие словари
├── Шаг 7: Разрешение целевых функций по вызовам
├── Шаг 8: Санитизация сырых данных
├── Шаг 9: Верификация мёртвого кода
├── Шаг 10: Запись выходных файлов
└── Шаг 11: Печать сводной статистики
```
---
## Модули
### 1. Модуль загрузки конфигурации
**Назначение:** Читает INI-файл конфигурации, разрешает системные пути к заголовочным файлам LLVM, извлекает параметры конвейера и пула потоков.
**Алгоритм:**
- Парсит секции конфигурации: параметры конвейера, компилятора, исключения
- Автопоиск директории ресурсов LLVM по списку стандартных путей
- Парсинг многострочных списков (запятые, переносы строк)
- Возвращает объединённый словарь параметров
---
### 2. Модуль разрешения препроцессорных флагов
**Назначение:** Извлекает определения препроцессора из файлов сборки и подставляет их в аргументы компилятора Clang.
**Алгоритм:**
- Парсит файл CMake для поиска директив определения определений
- Парсит файлы Make для поиска переменных флагов препроцессора
- Объединяет результаты, устраняет дубликаты с сохранением порядка
---
### 3. Модуль парсинга единиц трансляции
**Назначение:** Инициализация движка Clang и парсинг файлов в AST.
**Алгоритм:**
- Создаёт разделяемый индекс Clang для всех потоков
- Формирует аргументы компилятора динамически: базовые флаги, ресурсы, include-пути, флаги из сборки
- Для заголовочных файлов пропускает тела функций для ускорения
- Проверяет файлы на соответствие критериям обработки (расширение, исключения)
- Возвращает единицу трансляции с полным AST
---
### 4. Модуль однопроходного обхода AST
**Назначение:** Один проход по дереву AST извлекает все метаданные без повторных обходов.
**Извлекаемые сущности:**
- Объявления и определения функций с метаданными (имя, строка, тип, статичность, длина тела)
- Определения структур с очисткой анонимных имён
- Явные вызовы функций с дедупликацией по строке и имени
- Косвенные вызовы через указатели (только если целевой узел — функция)
- Определения макросов
- Точки расширения макросов
**Алгоритм:**
- Прямой обход дерева с проверкой принадлежности узла текущему файлу
- O(1) дедупликация через хеш-множества для каждого типа сущности
- Вычисление длины тела функции по диапазону строк
---
### 5. Модуль санитизации данных
**Назначение:** Фильтрация ложных срабатываний, обработка граничных паттернов C-кода.
**Алгоритмы:**
- **Дедупликация заголовков:** при многократном включении одного заголовка из разных файлов сохраняется только первый парсинг
- **Разрешение коллизий имён:** для статических функций формируется составной ключ из пути файла и имени, предотвращающий столкновения
- **Фильтрация мёртвого кода:** проверяет наличие вызовов по составному ключу с fallback на простое имя, исключает заданный список функций
- **Полный пайплайн:** последовательное применение всех трёх шагов
---
### 6. Модуль генерации отчётов
**Назначение:** Буферизованная запись трёх выходных файлов в виде единого блока данных.
**Выходные файлы:**
- Сводка функций: список всех функций по файлам, неиспользуемые, статические с локальным охватом, функции с единственным вызовом
- Сводка структур: список структур с дедупликацией
- Сводка перекрёстных ссылок: определения макросов, точки расширения, неиспользуемые макросы
**Алгоритм:**
- Формирование каждого раздела в памяти через буфер строки
- Однократная запись всего содержимого в файл
---
### 7. Модуль верификации мёртвого кода
**Назначение:** Классификация кандидатов в мёртвый код по агрегированным данным вызовов без повторного парсинга.
**Алгоритм для каждой функции:**
1. Проверка списка исключений → ложноположительный результат
2. Двухключевой поиск в словаре вызовов: составной ключ → простое имя → сырое имя
3. Наличие записей о вызовах → ложноположительный, отсутствие → действительно мёртвый
**Возврат:** Разделённый список на подтверждённо мёртвые и ложноположительные функции.
---
### 8. Отдельный скрипт верификации через чистый AST
**Назначение:** Верификация мёртвого кода исключительно через Clang AST, без regex и grep.
**Алгоритм:**
- Парсит все файлы исходного кода проекта
- Для каждого узла AST проверяет явные вызовы и ссылки на функции
- Пропускает узлы, соответствующие определению самой функции
- Проверяет принадлежность узла текущему файлу (исключает включённые заголовки)
- Строит матрицу: подтверждённо мёртвые / живые с AST-верифицированными точками вызова
---
### 9. Главный скрипт (оркестратор)
**Назначение:** Объединяет все модули в единый конвейер.
**Конвейер:**
1. Загрузка конфигурации
2. Разрешение флагов из файлов сборки
3. Инициализация движка Clang
4. Сбор списка файлов обходом дерева
5. Параллельный парсинг через пул потоков (движок Clang освобождает блокировку интерпретатора)
6. Агрегация результатов в общие словари без копирования данных
7. Разрешение целевых функций по матрице вызовов
8. Санитизация сырых данных
9. Верификация мёртвого кода
10. Запись выходных файлов
11. Печать сводной статистики
---
## Зависимости
```
clang.cindex # Bindings Python для движка Clang LLVM
configparser # Стандартная библиотека — парсинг INI
pathlib # Стандартная библиотека — работа с путями
concurrent.futures # Стандартная библиотека — пул потоков
io.StringIO # Стандартная библиотека — буферизованная запись
```
---
## Запуск
```bash
# Полный конвейер
python checker.py /path/to/c/project
# Только верификация мёртвого кода
python verify_dead.py /path/to/c/project
# По умолчанию (без аргумента) — путь по умолчанию
python verify_dead.py
```
---
## Выходные файлы
| Файл | Путь | Содержимое |
|------|------|-----------|
| Сводка функций | В корне проекта | Функции, неиспользуемые, статические, с единственным вызовом |
| Сводка структур | В корне проекта | Структуры |
| Сводка перекрёстных ссылок | В корне проекта | Макросы, расширения, неиспользуемые макросы |
---
## Ключевые оптимизации
| Оптимизация | Где | Эффект |
|-------------|-----|--------|
| Однопроходный обход AST | Модуль анализа | В 6 раз быстрее (было 6 отдельных обходов) |
| Пул потоков | Главный скрипт | Параллельный парсинг с освобождением блокировки интерпретатора |
| Дедупликация O(1) через хеш-множества | Модуль анализа | Устранение дубликатов вызовов, ссылок, макросов |
| Дедупликация заголовков | Модуль санитизации | Предотвращение дублирования при многократном включении |
| Составные ключи для статических функций | Модуль санитизации | Корректное отслеживание символов с локальной областью |
| Буферизованная запись блоков | Модуль экспорта | Однократная запись в диск вместо тысяч мелких записей |
| Пропуск тел функций в заголовках | Модуль парсинга | Ускорение парсинга заголовочных файлов |
| Верификация мёртвого кода O(1) | Модуль верификации | Без повторного парсинга файлов |
| Автоопределение флагов препроцессора | Модуль флагов сборки | Автоматическое извлечение определений из файлов сборки |
Фактически можно сказать код больше уже и не нужен - достаточно знать его внутреннюю структуру. Это уже новый этап развития языков - по-сути от них ничего не требуется кроме скелета AST, а далее там и рефакторинг и всё что угодно, благо LLM понимает этот формат особенно для Питона, достаточно указать необходимые тулы и можно таргетированно менять всё что угодно без ошибок синтаксиса как таковых, так как операция производится уже внутри языка.
-> также дело не в том что модель может по тексту шагать (это кстати можно сделать в виде скилла - что после нахождения чанков идти по путям к этим txt), а в существенной экономии токенов при множественных запросах по смыслу. То есть в векторной БД уже сразу она может сходу найти ответ на запрос, там сразу видно что то вроде ADC калибровка, PWM тайминги, GPIO назначение входов, ADC режимы семплирования итд. При прямом поиске вероятность глюков без вектора возрастает очень сильно. Тем более эту задачу вполне можно сплавить субагентам, причём самым "туповатым" и использовать только для взаимодействия с этой базой но саммари будет более чем достаточно для принятия решений уже оркестрирующей моделью.
Лисп уже давно создан.
А внутри легендарного Лиспа тот самый AST который суть связка между тумблерами, машинным кодом, ассемблером и языком. Он даже в микро-форме присутствует в прошивке Спектрума. Чтобы не перегружать контекст, желательно использовать гарантированный тул который читает по 100 строк что-то вроде grep с заглушкой по длине, даже специально делаю shell-обёртку чтобы он не промахнулся с этим числом. Мало того, можно даже сделать Питошу который поможет модели посёрфить по ассемблерному коду (вот это уже было бы супер - ждём агентов, которые поддерживают генерацию специализированных тулов налету с прокруткой нагенерённого в отдельном окне вместо one-liner-code мучающий терминал). Скачал тут прошивку для ZX-48k просто для интереса во что там БЭЙСИК превращается
БЭЙСИК превращается, Бэйсик превращается.. в элегантный
# ZX Spectrum 48K ROM — BASIC Interpreter (Часть 1/3)
## 1. Обзор архитектуры
ZX Spectrum BASIC — ROM-интерпретатор Z80 с токенизированным вводом, двумя режимами выполнения (syntax-check / runtime), стековым FP-калькулятором (FORTH-like) и переменной памятью.
**Ключевые концепции:**
- Ввод токенизируется: команды → байты `$80`–`$FF` (1 байт вместо слова)
- Два режима: syntax-check (бит 7 `FLAGS`) и runtime
- Переменные хранятся в области `$5C00`–`5CFF` (64 байта системных переменных)
- Калькулятор — стековый, 5-байт FP числа
- Программа: `[line_num:2][len:2][tokens][end_marker=$80]`
---
## 2. Системные переменные (Memory Map `$5C00`–`$5CFF`)
Доступ через регистр `IY`. Всего 64 байта.
| Смещение | Имя | Размер | Описание |
|----------|-----------|--------|----------|
| `$00` | `ERR_NR` | 1 | Номер ошибки (`$FF` = OK, 0–255 = коды ошибок) |
| `$01` | `FLAGS` | 1 | Битовые флаги: бит 0 — ведущий пробел (print), бит 5 — новая клавиша, бит 6 — тип результата (0=string, 1=numeric), бит 7 — режим синтаксической проверки |
| `$02` | `FLAGS2` | 1 | Расширенные флаги: бит 0 — TV (нижний экран), бит 1–3 — режимы |
| `$07` | `MODE` | 1 | Режим клавиатуры: 0=KLC, 1=E, 2=graphics |
| `$08` | `LASTK` | 1 | Код последней нажатой клавиши |
| `$0B` | `DEFADD` | 5 | Указатель определения пользовательской функции |
| `$10` | `KSTATE` | 16 | Состояние клавиш: `[raw][counter][delay][decoded]` × 4 |
| `$36` | `OSPPC` | 1 | Старый указатель оператора (для CONTINUE) |
| `$38` | `STRLEN` | 1 | Имя переменной из 1 символа (FOR/NEXT) |
| `$3B` | `CHARS` | 2 | Адрес таблицы битовых шрифтов (`$5C36`) |
| `$3D` | `ERR_SP` | 2 | Указатель стека ошибок (база GOSUB) |
| `$42` | `NEWPPC` | 2 | Номер новой строки программы (target) |
| `$45` | `PPC` | 2 | Текущий указатель программы (line number) |
| `$4B` | `VARS` | 2 | Начало области переменных |
| `$51` | `CURCHL` | 2 | Текущий адрес канала (указатель I2C-потока) |
| `$53` | `PROG` | 2 | Начало области BASIC-программы |
| `$55` | `NXTLIN` | 2 | Указатель следующей строки (поиск программы) |
| `$57` | `DATADD` | 2 | Указатель оператора DATA |
| `$59` | `E_LINE` | 2 | Конец текущей строки |
| `$5D` | `CH_ADD` | 2 | Текущий адрес символа (указатель парсера) |
| `$5F` | `X_PTR` | 2 | Указатель ошибки (маркер позиции) |
| `$61` | `WORKSP` | 2 | Начало рабочей области (стек калькулятора) |
| `$63` | `STKBOT` | 2 | Нижняя граница стека калькулятора |
| `$65` | `STKEND` | 2 | Верхняя граница стека (свободная память) |
| `$68` | `MEM` | 2 | Указатель памяти (область переменных/данных) |
| `$74` | `T_ADDR` | 2 | Временный адрес (указатель таблицы синтаксиса) |
| `$76` | `SEED` | 2 | Сид для `RND` |
---
## 3. Токенизация
### 3.1. Формат токенизированного BASIC
| Элемент | Кодировка |
|-----------------|------------------------------------|
| Команды (NEW, RUN, IF…) | байт `$80`–`$FF` (1 байт) |
| Функции (RND, SIN, LEN…) | байт `$80`–`$FF` (1 байт) |
| Операторы сравнения (`<=`, `>=`, `<>`) | байт `$80`–`$FF` |
| Обычные символы | ASCII-код |
### 3.2. Таблица токенов (адрес `$0095`)
Структура: чередование `DEFB` (байт-разделитель с `$80`) и `DEFM` (строка без разделителя). Последний байт токена инвертирован (`$80 | char`) для обозначения конца.
**Функции:**
| Токен | Байт | Расшифровка |
|-------|--------|-------------|
| RND | `$80+'D'` | `"RND"` |
| INKEY$| `$80+'$'` | `"INKEY$"` |
| PI | `$80+'P'` | `"PI"` |
| FN | `$80+'F'` | `"FN"` |
| POINT | `$80+'T'` | `"POINT"` |
| SCREEN$| `$80+'$'`| `"SCREEN$"`|
| ATTR | `$80+'R'` | `"ATTR"` |
| AT | `$80+'A'` | `"AT"` |
| TAB | `$80+'B'` | `"TAB"` |
| VAL$ | `$80+'$'` | `"VAL$"` |
| CODE | `$80+'E'` | `"CODE"` |
| LEN | `$80+'V'` | `"LEN"` |
| SIN | `$80+'N'` | `"SIN"` |
| COS | `$80+'N'` | `"COS"` |
| ASN | `$80+'C'` | `"ASN"` |
| TAN | `$80+'N'` | `"TAN"` |
| SGN | `$80+'B'` | `"SGN"` |
| ABS | `$80+'S'` | `"ABS"` |
| SQR | `$80+'B'` | `"SQR"` |
| INT | `$80+'A'` | `"INT"` |
| PEEK | `$80+'K'` | `"PEEK"` |
| USR | `$80+'I'` | `"USR"` |
| STR$ | `$80+'$'` | `"STR$"` |
| CHR$ | `$80+'$'` | `"CHR$"` |
| NOT | `$80+'T'` | `"NOT"` |
| BIN | `$80+'N'` | `"BIN"` |
**Команды BASIC (`$E6`–`$FF`):**
| Токен | Команда | Описание | Токен | Команда | Описание |
|-------|----------|-----------------------|-------|----------|--------------------|
| `$E6` | NEW | Очистить программу | `$F0` | LLIST | Вывести программу |
| `$E7` | BORDER | Цвет рамки | `$F1` | LET | Присваивание (`=`) |
| `$E8` | CONT | Продолжить | `$F2` | PAUSE | Ожидание |
| `$E9` | DIM | Объявить массив | `$F3` | NEXT | Итерация FOR |
| `$EA` | REM | Комментарий | `$F4` | POKE | Запись в память |
| `$EB` | FOR | Цикл с переменной | `$F5` | PRINT | Вывод |
| `$EC` | GOTO | Переход к строке | `$F6` | PLOT | Точка на экране |
| `$ED` | GOSUB | Подпрограмма | `$F7` | RUN | Запустить |
| `$EE` | INPUT | Ввод с клавиатуры | `$F8` | SAVE | Сохранить на ленту |
| `$EF` | LOAD | Загрузить с ленты | `$F9` | RANDOMIZE| Сид RND |
| | | | `$FA` | IF | Условие |
| | | | `$FB` | CLS | Очистить экран |
| | | | `$FC` | DRAW | Линия/дуга |
| | | | `$FD` | CLEAR | Очистить переменные|
| | | | `$FE` | RETURN | Из подпрограммы |
| | | | `$FF` | COPY | На принтер |
---
## 4. Таблица синтаксиса (Syntax Table, адрес `$1A48`)
### 4.1. Формат записи
```
[ClassByte] [SeparatorByte] [ClassByte] [SeparatorByte] ... [ClassByte] [OFFSET]
```
### 4.2. Коды классов параметров
| Класс | Описание |
|-------|-----------------------------------------------|
| `$00` | Без операндов (конец оператора) |
| `$01` | Переменная требуется (для LET: `VAR = EXPR`) |
| `$02` | Выражение (число или строка) |
| `$03` | Числовое выражение, необязательное (по умолч. 0) |
| `$04` | Односимвольная переменная |
| `$05` | Полный синтаксический контроль (PRINT, INPUT) |
| `$06` | Числовое выражение требуется |
| `$08` | Два числа через запятую |
| `$09` | Два числа + необязательный цвет |
| `$0B` | Команда ленты (SAVE/LOAD/VERIFY/MERGE) |
### 4.3. Классы-рутины (CLASS-TABLE, адрес `$1C01`)
| Класс | Рутин | Адрес | Описание |
|-------|---------|--------|-------------------------------------------|
| `$00` | L1C14 | No operands |
| `$01` | L1C1B | Variable assignment + `=` |
| `$02` | L1C2E | Expression (SCANNING) |
| `$03` | L1C48 | Optional numeric (default 0) |
| `$04` | L1C59 | Single char variable |
| `$05` | L1C6A | Full syntax check |
| `$06` | L1C82 | Numeric expression |
| `$08` | L1E85 | Two comma-separated params |
| `$09` | L21E2 | Colour items + coords |
| `$0B` | L0609 | Tape command dispatch |
### 4.4. Примеры записей
| Команда | Токен | Синтаксис | Описание |
|---------|-------|------------------|-----------------------------------|
| LET | `$E1` | `[$01] [=] [$02]` | `VAR = EXPR` |
| GOTO | `$EC` | `[$06] [$00]` | `GOTO 100` — число, конец |
| IF | `$FA` | `[$06] [THEN] [$05]` | `IF A>5 THEN ...` — условие + оператор |
| FOR | `$EB` | `[$04] [=] [$06] [TO] [$06] [STEP] [$05]` | `FOR I=1 TO 10 STEP 2` |
| PRINT | `$F5` | `[$05]` | Полный синтакс-чек (строки, выражения, TAB) |
| INPUT | `$EE` | `[$05]` | Полный синтакс-чек |
| DIM | `$E9` | `[$05]` | Объявление массивов |
| SAVE | `$F8` | `[$0B]` | Команда ленты |
| RUN | `$F7` | `[$03]` | Необязательное число (строка, по умолч. 0) |
# ZX Spectrum 48K ROM — BASIC Interpreter (Часть 2/3)
## 5. AST-подобная структура данных в памяти
### 5.1. Программа (Program Area)
**Layout (линейная память, отсортирована по номеру строки):**
```
+-------------------+
| Line Number (2B) | $0000–$FFFF, $8000+ = end marker
+-------------------+
| Line Length (2B) | Количество байт токенов
+-------------------+
| Token 1 | $E6 = NEW, $F7 = RUN, ...
+-------------------+
| Token 2..N | Или ASCII для нетокенизированного текста
+-------------------+
| End Marker ($80) | Конец строки
+-------------------+
| ... (следующая) |
+-------------------+
| $80 (global end) | Конец всей программы
+-------------------+
```
**Пример:** `10 PRINT "HELLO"`
```
Line Num: $0010 Length: $000D (13 байт)
Tokens: $F5 $22 "HELLO" $22 $0D
End: $80
```
### 5.2. Переменные (Variables Area)
**Layout (начинается с `VARS`):**
```
+-------------------+
| Name Length (1B) | $01–$7F (бит 7 = инвертирован для последнего символа)
+-------------------+
| Name Chars (N B) | 1–30 символов, регистронезависимо (в нижнем регистре)
+-------------------+
| Data (5B / var) | 5 байт FP-число ИЛИ дескриптор строки
+-------------------+
| Name Length (1B) | Следующая переменная
+-------------------+
| ... |
+-------------------+
| $80 | Конец переменных
+-------------------+
```
**Типы переменных:**
| Тип | Байт 0 | Байты 1+ |
|-------------|------------------|----------------------------|
| Numeric | Знак/экспонента | 5 байт FP-число |
| String | Длина (0–255) | Данные строки |
| Array | `$80 + dim` | Размеры измерений + данные |
**Numeric (5 байт):**
```
Byte 0: Sign (0=+, 1=−) + Exponent high (biased)
Byte 1: Exponent low
Byte 2–3: Mantissa (high)
Byte 4–5: Mantissa (low)
```
Нормализация: мантисса ∈ [0.5, 1.0), экспонента со смещением 128.
Ноль: все байты = `$00`.
### 5.3. Калькулятор (Calculator Stack)
**Layout (растёт вниз от `STKEND`):**
```
High Memory
+-------------------+
| STKEND | ← системная переменная
+-------------------+
| FP Number 5B | ← Operand 3 (самый глубокий)
+-------------------+
| FP Number 5B | ← Operand 2
+-------------------+
| FP Number 5B | ← Operand 1 (top)
+-------------------+
| STKBOT | ← системная переменная
+-------------------+
Low Memory
```
---
## 6. Калькулятор (Floating-Point Stack)
### 6.1. Формат 5-байтного FP-числа
```
Byte 0: [S][EEEEEEE] ← бит 7 = знак, биты 0–6 = экспонента high
Byte 1: [EEEEEEEE] ← экспонента low
Byte 2: [MMMMMMMM] ← мантисса, байт 3 (MSB)
Byte 3: [MMMMMMMM] ← мантисса, байт 2
Byte 4: [MMMMMMMM] ← мантисса, байт 1 (LSB)
```
Нормализация: мантисса ∈ [0.5, 1.0), bias = 128. Ноль: все `$00`.
### 6.2. FP-CALC (Restart `$0028`) — Opcode Table
FORTH-like стековая машина. Однобайтовые операнды:
| Операнд | Мнемоника | Описание |
|---------|--------------|---------------------------------|
| `$01` | EXCHANGE | Swap top 2 |
| `$02` | DELETE | Pop top |
| `$03` | SUBTRACT | `A = B - A` (pop both, push res) |
| `$04` | MULTIPLY | `A = B * A` |
| `$05` | DIVISION | `A = B / A` |
| `$07` | FP-CALC-2 | Рекурсивный вызов |
| `$0F` | ADDITION | `A = B + A` |
| `$10` | NEGATE | `A = -A` |
| `$27` | INT | FP → integer (truncate) |
| `$31` | DUPLICATE | Duplicatetop |
| `$34` | STK-DATA | Push 5B literal из след. байт |
| `$38` | END-CALC | Return, HL = top of stack |
| `$A1` | STK-ONE | Push 1.0 |
| `$C0`–`$C4` | ST-MEM-0..4 | Pop → MEM-N (scratch pad) |
| `$E0`–`$E4` | GET-MEM-0..4| Push MEM-N на стек |
### 6.3. Пример: BEEP dur, pitch
```
Stack before: [duration] [pitch]
$31 DUPLICATE → [dur] [pitch] [pitch]
$27 INT → [dur] [pitch] [int_pitch]
$C0 ST-MEM-0 → [dur] (int_pitch stored)
$03 SUBTRACT → [dur] [frac_pitch]
$34 STK-DATA → [dur] [0.05762265]
$04 MULTIPLY → [dur] [0.0576 × frac]
$A1 STK-ONE → [dur] [0.0576×frac] [1.0]
$0F ADDITION → [dur] [1 + 0.0576×frac]
$38 END-CALC → HL = top of stack
Result: freq = base_freq × (1 + 0.0576 × fractional_pitch)
```
# ZX Spectrum 48K ROM — BASIC Interpreter (Часть 3/3)
## 7. Оценка выражений (Expression Scanning)
### 7.1. SCANNING (адрес `$24FB`) — Главный парсер выражений
Парсит выражение от `CH_ADD` до `)` или конца оператора. Алгоритм: **shunting-yard variant**.
**Алгоритм:**
1. Инициализация: `FLAGS` бит 7 = 1 (syntax-check) или 0 (runtime)
2. `E-LINE-NO` — извлечь необязательный номер строки (для RUN)
3. Цикл по токенам выражения:
- `GET-CHAR` → пропуск пробелов, следующий значимый символ
- Цифра/буква → разбор числа или переменной
- `(` → рекурсивный вызов SCANNING для подвыражения
- Токен функции → push на стек операторов
- Оператор (+, -, *, /, ^…) → обработка приоритета
- `,` → конец выражения (для многопараметрических команд)
**Приоритет операторов:**
| Приоритет | Оператор | FP-CALC Opcode |
|-----------|----------|----------------|
| `$0A` | `^` | `$C6` (to-power) |
| `$08` | `*` | `$C4` (multiply) |
| `$08` | `/` | `$C5` (division) |
| `$06` | `+` | `$CF` (addition) |
| `$06` | `-` | `$C3` (subtract) |
| `$05` | `<=, >=, <>, >, <, =` | `$C9`–`$CE` |
| `$03` | `AND` | `$C8` |
| `$02` | `OR` | `$C7` |
**Правило:** новый оператор с более низким приоритетом → pop и вычислить стек операторов.
### 7.2. Разбор чисел и переменных
**Числа:** `[digits].[digits]E[±digits]` — пример: `123.45E-2 = 1.2345`
1. Пропуск пробелов
2. Чтение цифр в мантиссу (нормализация к 0.5–1.0)
3. Точка → коррекция экспоненты
4. `E` → умножить экспоненту на 10
5. Знак `−` → инвертировать
6. Push 5B FP на стек калькулятора
**LOOK-VARS (адрес `$28B2`) — поиск переменной:**
1. Первый символ из `CH_ADD`
2. Чтение имени (1–30 символов)
3. Поиск в области переменных (от `VARS` до `$80`)
4. Сравнение регистронезависимо
| Carry | C | Результат |
|-------|-------|--------------------|
| 1 | `$00` | Простая numeric |
| 1 | `$40` | Простая string |
| 1 | `$80` | Array |
| 0 | — | Не найдена (создать новую) |
### 7.3. Функции (Functions)
Диспатч при `token - $A5` в таблице `$1A48`:
| Токен | Функция | Описание | Токен | Функция | Описание |
|-------|---------|----------|-------|---------|----------|
| `$A5` | RND | Случайное (LCG) | `$B4` | TAN | Тангенс |
| `$A6` | INKEY$ | Клавиатура (non-blocking) | `$B5` | ASN | Arc sine |
| `$A7` | PI | 3.14159265… | `$B6` | ACS | Arc cosine |
| `$A8` | FN | Пользоват. функция | `$B7` | ATN | Arc tangent |
| `$A9` | POINT | Цвет пикселя | `$B8` | LN | Натуральный лог |
| `$AA` | SCREEN$ | Дамп памяти экрана | `$B9` | EXP | e^x |
| `$AB` | ATTR | Атрибут символа | `$BA` | INT | Целая часть |
| `$AC` | AT | Позиция курсора | `$BB` | SQR | Корень (Newton) |
| `$AD` | TAB | Позиция TAB | `$BC` | SGN | Знак (−1,0,+1) |
| `$AE` | VAL$ | Строка → значение | `$BD` | ABS | Модуль |
| `$AF` | CODE | Код символа | `$BE` | PEEK | Байт памяти |
| `$B0` | VAL | Строка → число | `$BF` | IN | Порт ввода |
| `$B1` | LEN | Длина строки | `$C0` | USR | Машинная функция |
| `$B2` | SIN | Синус (CORDIC) | `$C1` | STR$ | FP → строка |
| `$B3` | COS | Косинус | `$C2` | CHR$ | Код → символ |
---
## 8. Обработка команд (Statement Handlers)
### 8.1. MAIN DISPATCH — STMT-LOOP (адрес `$1B28`)
**Алгоритм:**
1. `NEXT-CHAR` → advance `CH_ADD`
2. `GET-CHAR` → текущий символ
3. `CR` (`$0D`) → `LINE-END`; `:` (`$3A`) → `STMT-LOOP`
4. Push `STMT-RET` (обработчик ошибок)
5. Символ → `C`, `NEXT-CHAR` → past command name
6. Вычесть `$CE` (DEF FN offset) → < 0 → `REPORT-C` (Nonsense)
7. Индекс в таблицу `L1A48` → смещение к syntax entry
8. `HL = syntax entry` → `GET-PARAM`:
- Load param byte из `[HL]`, inc HL → `T_ADDR`
- Push `SCAN-LOOP` return, param → `C`
- Param > `' '` → `SEPARATOR`; иначе → `CLASS-TABLE` dispatch
- Indirect jump к class routine → pop → back to `SCAN-LOOP`
### 8.2. LET (Присваивание, `$E1`)
**Синтаксис:** `VAR = EXPR`
1. Class `$01`: fetch variable name
2. Разделитель `=`
3. Class `$02`: scan expression → результат на стеке (`HL`)
4. `LET` рутинa (`$2AFF`):
- Проверить совпадение типов
- String: копировать данные; Numeric: копировать 5B FP
- Type coercion (int → FP)
### 8.3. IF (Условие, `$FA`)
**Синтаксис:** `IF condition THEN statement [ELSE statement]`
1. Class `$06`: evaluate condition
2. Разделитель `THEN`
3. Class `$05`: full syntax check following statement
4. Runtime: pop condition → 0 (false): искать `ELSE` или конец строки; ≠ 0 (true): выполнить → skip к `ELSE`/конец
### 8.4. FOR (Цикл, `$EB`)
**Синтаксис:** `FOR var = start TO end [STEP step]`
1. Class `$04`: single-char variable
2. Разделитель `=`, Class `$06`: start expr
3. Разделитель `TO`, Class `$06`: end expr
4. Class `$05`: optional STEP (default 1)
5. Runtime:
- Store initial value
- Allocate 13B: current(5B) + limit(5B) + step(5B) + line(2B) + stmt(1B)
- Set bit 7 of variable name (FOR marker)
- Call `NEXT-LOOP` test → continue/skip to matching NEXT
### 8.5. NEXT (Итерация, `$F3`)
**Синтаксис:** `NEXT [var]`
1. Class `$04`: optional variable, Class `$00`: end
2. Runtime:
- Check `FLAGX`, lookup variable
- Not found / not FOR → `REPORT-1`
- Check bit 7 (FOR marker) → not set → `REPORT-I` (NEXT без FOR)
- Increment: `GET-MEM-0` + `GET-MEM-2` → `ADDITION` → `ST-MEM-0`
- `NEXT-LOOP` test: within range → continue; beyond → clear marker, free 13B, set `NEWPPC/NSPPC`
### 8.6. PRINT (Вывод, `$F5`)
**Синтаксис:** `PRINT [items;items;items...]`
Элементы: строки `"text"`, выражения `A,B+C`, `TAB(n)`, `AT row,col`, `;` (без newline), `,` (tab stop 10 cols)
1. Class `$05`: full syntax check
2. Runtime: loop → `SCANNING` → `STK-FETCH` → `PO-ABLE` → `PO-STORE`
3. `;` skip newline, `,` next tab stop, `TAB(n)` abs column, `AT r,c` abs position, CR newline
### 8.7. INPUT (Ввод, `$EE`)
**Синтаксис:** `INPUT ["prompt";] var1 [,var2...]`
1. Class `$05`: full syntax check
2. Runtime: string literal → prompt; set `FLAGX` bit 7; call `EDITOR`
3. `CH_ADD` → input buffer; for each var: `GET-CHAR`, `VAL-FET-2` → parse/store
### 8.8. GOTO (Переход, `$EC`)
**Синтаксис:** `GOTO line_num`
1. Class `$06`: numeric expression → target line number
2. Runtime: set `NEWPPC` to target, `NSPPC` = 0, jump to line
### 8.9. GOSUB / RETURN (Подпрограммы, `$ED` / `$FE`)
**GOSUB:**
1. Class `$06`: target line number
2. Push `NEWPPC/NSPPC` на стек ошибок (`ERR_SP`)
3. Set `NEWPPC` to target
**RETURN:**
1. Pop `NEWPPC/NSPPC` из стека (`ERR_SP`)
2. Resume execution at saved position
### 8.10. RUN / NEW / CLEAR (Управление, `$F7` / `$E6` / `$FD`)
| Команда | Токен | Действие |
|---------|-------|----------|
| RUN | `$F7` | Start program from `PROG`, reset runtime vars |
| NEW | `$E6` | Clear entire program area (`$80` end marker) |
| CLEAR | `$FD` | Clear variables/screen, reset `VARS`, `MEM` |
| CONT | `$E8` | Continue from `OSPPC` (saved line) |
| LOAD | `$EF` | Load from tape → program area |
| SAVE | `$F8` | Save program area to tape |
| LLIST | `$F0` | List program to screen/printer |
| CLS | `$FB` | Clear screen (black) |
| BORDER | `$E7` | Set border colour |
| PAUSE | `$F2` | Wait for interrupt (frame sync) |
| RANDOMIZE | `$F9` | Set `SEED` for RND |
| POKE | `$F4` | Write byte: `POKE addr, value` |
| PLOT | `$F6` | Draw point: `PLOT x,y` |
| DRAW | `$FC` | Draw line/arc: `DRAW dx,dy` |
| COPY | `$FF` | Copy screen to printer |
| DIM | `$E9` | Declare array: `DIM A(10,20)` |
| REM | `$EA` | Comment (skip to end of line) |
| PAUSE | `$F2` | Wait for interrupt |
Вот собственно и есть тот самый AST-мотор под катом, тот же самый ассемблер. Достаточно просто визуализировать его токены на экране, это собственно то что назовём Бэйсиком, а там можно и представить хоть как Go хоть как Python или что ещё, даже индексы менять не нужно, добавить новые для классов, лямбд функций итд. В будущем как раз LLM-ка наверняка научится работать с этим напрямую без потери контекста за счёт hold-тегов.
А ведь мысль то здравая по ast модель не будет у себя в головешке строить модель код а ей уже это дадут. Вопрос в том что была статья на Хабре про использование инструментов что она может написать кучу инструментов классных но пользоваться все равно grep rg и тп. Думаю это вопрос промта и по идее должно сильно улучшить качество на моделях с малым контекстом. Надо эксперимент провести у меня куча кода на go и ts
https://github.com/DeusData/codebase-memory-mcp
Даже визуализация графа строится с фильтрами...
GitNexus например или CodeGraph. Хотя в последнем вроде только BM25.
А что насчёт ведения карты кода как части документации проекта? В виде json: модули с описанием функционала - подсистемы с архитектурой - файлы с ролями и сущностями. В начале новой задачи агент сразу видит всю карту и понимает фронт работы.
интересная идея, подключить тулзу к кодинг агенту которая проиндексирует кодовую базу
Так идея, мягко говоря, не новая. Давно уже пользуюсь.
Если привязать агента к тайпчекеру и прогону юнит-тестов, фантазии отсекаются сами собой. Модель просто делает еще одну итерацию, пока компилятор не заткнется
То есть ситуация такая: даже самые дешевые и самые тупые фронтирные модели стали достаточно умными. Если ты разбираешься в теме, их уровня хватает за глаза.
Если разбираешься в теме то и локальной Qwen 3.8 или ornith-1.5 вполне достаточно, и вуаля, затраты только на электричество 🤣
К сожалению на моей GPU игровой с 16 VRAM сильно медленный инференс для этих моделей. А если контекст растёт, то вообще мрак. А он растёт на громадных кодовых базах где я работаю... А так конечно что то маленькое чуть сложнее hello world проектик или микро сервис - вполне тянет ) тут не спорю )
qwen3.8-27b q3_xxs , KV кэш квантован до q4, контекст ~100k - на 5080 16gb 50-60 tps, prefill - пара секунд для почти забитого контекста. Проект на 180k LOC
У меня RTX 4070 Ti SUPER 16 GB - вообще я надеюсь что они выпустят qwen3.8 30B и что бы MoE архитектура что бы прям летало ) А qwen3.8-27b q3_xxs я запускал тоже )
Если они не выпустят то в течении пары месяцев другие выдадут )
есть неплохой qwen3-coder-30b moe
помойму он старый - сколько ему уже месяцев?
больше года, работает норм, нет рассуждений и вижна, зато инференс ~100 tps
Добавлю ещё Qwen3.6 35B A3B. Тоже MoE, всего 3 миллиарда активных параметров
У Qwen3.8 27B (xhigh) Artificial Analysis Intelligence Index - 34, докупайте еще одну такую же карту (а лучше RTX3090/4090 24Gb) и вперед!
KV кэш квантован до q4
Не надо, K ниже Q8 (или kvarn5) опускать нельзя. Лучше более квантованную модель взять (Q2). Ошибки кэша приводят к очень сильной деградации модели.
С другой стороны, локально обычно только одна видеокарта - и не получится ставить параллельные задачи 3-4 агентам для ускорения общей скорости работы.
У вас молоко прокисает ? или на последнюю электричку опаздываете ?, куда вы все спешите ? 3-4-100 а потом 1000 агентов, вот реально зачем ?
Мама всегда говорила: "Сделал дело - гуляй смело"!
Решил задачи поставленные и свободен) Ведь платят не за то что отсиживаешь 8 часов в день на работе...
А то что это вносит хаос и баги не задумывались ?
Я несколько раз ловил Kimi k3 когда он плодил агентов и они приносили бред, так как даже разведка кучей агентов была не верной из за несогласованности между ними, и итоговый вывод был ошибочный.
Я вообще думал статью написать что щас тестировщики стали важнее программистов. Прекрасно понимаю, что больше кода больше багфиксов и тд это все перепроверять и протестировать. Тут уже не программист узкое горлышко становится а тестировщик.
Ну да понятно, а потом будет статья про кнопку "Сделай красиво БРО" единственный промт на все задачи, и как его правильно писать 🤣
щас тестировщики стали важнее программистов
Как-то по вакансиям и найму этого не видно
Да щас вообще тухляк. Раньше в ИТ искать работу 1-2-3 месяца - щас вообще от 12 месяцев сразу надо закладывать...
Так потому что перед Вами очередь из 100500 вайбкодеров и вайбрезюмеров, которых ещё всех профильтровать надо. Проблема не в том, что кадры не нужны. Проблема в том, что претендентов стало слишком много.
Я так понимаю, что сейчас на всяких Skillbox-ах целенаправленно учат спамить HR-службы нейрослопом. Нагрузка очень высокая на службы сейчас.
Узким горлышком сейчас становится архитектор, который вообще понимает общую картину сервиса. Если фундамент кривой, армия тестировщиков только зафиксирует масштаб катастрофы
Concurrent requests поддерживаются везде, и даже есть GUI‑ручка в LMStudio. Скорость просядет, но не капитально. Фокус в том что одна сессия не использует на полную катушку всю видеокарту, поэтому, если инференс умеет хорошо объединять обработку в батчи, то получится вполне хорошо. Чемпион в этом vLLM, но llama.cpp тоже неплохо справляется. Единственное — понадобится чуть больше видеопамяти.
Почему? У меня vLLM на A100 на Qwen 3.8 27B INT8 W8A16 MTP в один поток выдаёт 24 токена/с, а в восемь потоков — 194 токена/с.
Big pickle неплохо справляется со средней кодовой базой. Но опять же, если в теме шаришь. Ревью за тобой ессно
Советую ещё испытать composer 2.5 в cursor , в подписке за 20$ он почти безлимитный.
Cursor Composer 2.5: занимает третье место в рейтинге Coding Agent Index и стоит примерно в 10-60 раз дешевле, чем конкуренты.
https://artificialanalysis.ai/articles/cursor-composer-2-5-coding-agent-index
мне кажется, Cursor Grok 4.6, в рабочих задачах, работает получше чем composer. А лимит и у него сейчас исчерпать сложно. Но повторюсь, это в рабочих задачах, когда ты понимаешь что и как нужно и ставишь четкие задания в уже сформированной кодовой и архитектурной базе...
composer бывает начинает чудить, особенно при недостаточно сформулированной задаче, ну или в какой нибудь не самой распространенной теме.
Сейчас мне обычно хватает 5.6 sol и grok/composter для закрытия большого числа задач, от написания mvp(несколько микросервисов бек, фронт, postgre... системы аутентификации/авторизации, redis, Kafka и тп) до точечных исправлений в связке разных систем.
Не увидел значительно разницы между режимом Auto, который чаще всего обращается к Composer’у, по сравнению с Cursor Grok 4.6 High. Зато увидел, что за одну неделю смешанного использования этих двух моделей израсходовалось более половины месячного лимита. Вернулся к режиму Auto
Пользуюс гроком, на 60$ тарифе лимиты улетают только так(
я тоже перешел на deepseek harness и модели qwen, deepseek b и меня устраивает. иногда юзаю кодекс сделать ревью
Моего ответа нет: я не фанатик, но программирую не "20+", а "40+", начинал на советских ПМК.
Теперь по теме. Про мой опыт вайбкодинга (с чатомжпт бесплатно) я написал давно. Но мне очень интересно увидеть хоть один пример РЕАЛЬНОЙ ЗАДАЧИ по программированию, которую удалось решить с мощной платной нейронкой без танцев с бубном. Чисто из любознательности! Очень бы хотелось...
Ну я не знаю задачи какого плана вы ожидаете, но вот пример буквально сегодняшний. Юзеры шлют со свой телепонов фоточки, их нужно перекодировать (прочитать всякие heic-и, которые никто кроме ойфонов не понимает, avif-ы там и прочее оно, поправить ориентацию по exif, уменьшить до 1920 по длинной стороне, потом закатать всё в webp с sharp_yuv и наконец сравнить, что наши пляски дали реальный профит и нам не подсунули уже хорошо отшакаленный jpeg или там png, webp для которого оказался больше. Руками я когда-то это делал примерно день, ещё примерно суммарно день ушёл на сбор и исследования различных wtf и особенностей задержек развития головного мозга у различных производителей тупофонов. Астра сегодня выплюнула минут за 15. Танцев с бубном не было, потому что я уже знал про засады с exif, sharp_yuv, необходимости иметь intl и т.д.
взять и скормить это скрипту с ffmpeg кажется проще, чем сливать ИИшке
Я все хочу пример чисто на программирование. :) Насчет обработки фото - а зачем нужно все перечисленное? Точнее, кто и зачем использует полученный от ИИ скрипт? Кстати, на чем Астра его написала и на чем (и какая инстанция) его запускает?
Вопросы могут быть странными, но я далек от подобных задач, команд и т.д. Сижу себе за десктопом и в ВижуалСтудии пишу код, никого не трогаю... Потому и возникают вопросы, ибо просто не сталкивался...
Да блин, есть мобильное приложение с чатиками и фоточками, у него есть бэкенд, какая разница на чём оно написано?) И что здесь нечистого программирования?
Вы не поняли. :) Я говорил о "чистом программировании" именно в плане просто написания программы. "Напиши мне программу, чтобы она делала вот это". Такого типа.
а зачем тогда нужен программист? (~ Oh shi, а что же у нас на рынке труда происходит?)
Вот я и хочу понять: нужны программисты, или уже нет. И читая комментарии, так и не пойму... :)
что то простенькое и не сложное типа автоматизация или программка для чегото конкретного то не нужны - что то большое и громадное и высоконагруженное и промышленное - нужны )
Ну, примерно так я и думал. Для написания простеньких модулей можно применять ИИ, но чтобы из этих модулей собрать серьезную программу - ИИ вряд ли потянет... Не знаю, у меня опыт бесплатного ЖПТ эйфории не вызвал. Но я понимаю, что это не то, с чем все работают...
Скажу больше, не так давно дали код сгнеренный нейронкой и его надо было встроить в инфраструктуру написанную с использованием фреймворка. Проще написать с нуля, чем разобрать то, что ОНО выдало!
Если дать задачу человеку написать код и не предупредить о дальнейшей интеграции в инфраструктуру с фреймворком, будет такая же ситуация. Какое ТЗ, такой и результат. Я делаю так:
Есть агент с ролью архитектор, ему скармливаю вест проект со всеми репозиториями. Есть агент с ролью разработчик. Он получает от архитектора промт с задачей с учётом особенностей проекта. Агент - разработчик отдает результат агенту-review. Внутри codex desktop с передачей задач между чатами все отлично работает.
Вот я и хочу понять: нужны программисты, или уже нет.
Кодеры – в общем-то, не нужны. Нужны люди с навыками проектирования, которые могут правильно поставить задачу и проверить результат. Такие, как я, например 😁 Не программировал уже лет 20+ – а сейчас спокойно могу в одно лицо делать вполне приличный софт. Не поделки класса hello world – вполне себе серьёзные проекты.
Ну так вы проектный менеджер, а не программист или инженер.
Программист, по определению, программирует.
Таким образом, выходит, программисты не нужны. А то кодеры, кодеры, что за ахинея.
Ну так вы проектный менеджер, а не программист или инженер.
Не совсем так. Я менеджер с бэкграундом инженера, программиста и системного архитектора. Навыки написания кода у меня утрачены за давностью лет, но понимать его я не разучился – равно как и не растерял знаний о том, какой должна быть правильная структура кода. И что, может быть, ещё важнее – я знаю, как управлять разработкой таким образом, чтобы код получался качественным. И эти знания очень помогают получать достойный результат от ИИ в качестве программиста.
Ну все верно - сейчас вы менеджер, контроллер качества, но не программист, так как не программируете.
А программистом тут выступает ИИ модель, которой вы делегировали программерские задачи, и таким образом обошлись без «мясного» программиста.
В действительности же - программистов, в части кейсов, ИИ заменяет, без всякой этой ахинеи про «кодеров». Нету никакой четкой границы между «кодером» и «программистом».
Еще вчера, когда бизнес не мог без программистов, совсем, они были «программисты», как только стало возможным заменить их на ИИ, сократив издержки, заместо признания фактов а-ля «ИИ умеет программировать, сорян, пока», решили уничижительно назвать их «кодерами».
Еще вчера, когда бизнес не мог без программистов, совсем, они были «программисты», как только стало возможным заменить их на ИИ, сократив издержки, заместо признания фактов а-ля «ИИ умеет программировать», решили уничижительно назвать их «кодерами».
Тут не соглашусь, я всегда проводил границу между теми, кто способен самостоятельно принимать и реализовывать сложные решения, требующие творческого осмысления (программисты), и теми, кто чисто технически переносит тексты спецификаций в код программы (кодеры).
Вот с последней ролью ИИ нынче неплохо справляется – даже отлично уже, я бы сказал. И должен признать, понемногу начинает забираться и на территорию тех самых программистов. Это прогресс буквально за 2-3 года с момента появления первых моделей, способных хоть как-то программировать – как раз примерно тот срок, за который способный джун становится мидлом. Что будет через 10 лет, можно только предполагать – но очень похоже на то, что писать код руками станет просто незачем.
Если понимать слова не так, как все, то кого угодно можно назвать ненужным. И в вашей терминологии это будет верным.
Но такой подход трудно назвать конструктивным.
Хммм, я тут сейчас тестирую своего агента, и задал ему задачу, прямо как вы описали, "хочу вот это - напиши" Задача получилась не тривиальная, видеоаналитики, то есть агент пишет с нуля, программу с UI на C#, распознавание людей/машин, лиц, привязка человек - его авто, и т.д, контроль с моей стороны требуется только в одном, принятия этапов разработки, когда он просит подтвердить что меня устраивает текущий результат, и можно перейти к следующему этапу.
Вот что он на текущий момент написал, функционал работает, сейчас трудится над нормальным UI, он сам собрал референс из интернета и выбрал тему которая ему показалась актуальной, я только как наблюдатель за ним слежу =)
Задача, конечно, масштабная. Если такое может решить ИИ... Надо менять профессию...
Самое фатальное здесь то, что после того, как ИИ тебе такое написал, уже очень тяжело себя заставить набивать код руками в Visual Studio.
С другой стороны, сами подумайте: Вас сейчас же не смущает сидеть именно в Visual Studio с готовыми библиотеками подо всё на свете и не писать заново драйвера видеокарты, мышки на Borland C++? Да и упёртые фанаты ассемблера тоже повывелись ещё раньше. А почему следующий шаг аналогичной оптимизации производства кода смущает?))
почему следующий шаг аналогичной оптимизации производства кода смущает
В отличие от ассемблера, компилятора и т.п., Ваш «следующий шаг» недетерминирован (см. «температура»).
Лечиться тоже у вайб-хирурга будете?
"Напиши мне программу, чтобы она делала вот это"
Это и есть вайбкодинг. В код даже не смотрят. Иногда даже работает. Но чистым и тем более программированием я бы это не назвал.
Ну, про тех кто не смотрит в код, я вообще не говорю. Я все же о программистах, которые просто используют ИИ. :)
Программист, который использует ИИ, никогда так не напишет. Ну если это Настоящий Программист. Он напишет "напиши мне функцию которая делает то то и то то", или "напиши мне обработку вот этого с логами и ексепшенами". Он даже может попросить инициализацию контроллера, если знает о чем спрашивать. Но "напиши программу чтобы делала вот это и это а потом и вот это, а потом через левую ногу и это, и терминал внутри, и проводник встроенные и еще что-то прикольное" - это яркий пример вайбкодера, и это очень плохой признак. Достаточно знать, что вайбкодер - не программист, совсем. Он - кодер, а кто такой кодер? Тот кто пишет код не особо задумываясь о его работе, чисто по ТЗ. То есть по сути механистически, как мартышка. Вайб - код пишет уже не он, он только рядом постоял по сути.
Почему? Потому что такой вайбкодер даже годный промпт написать не сможет. Либо вечные правки, либо "а и так сойдет", клиповое мышление и тут дает о себе знать. И стандарты индустрии "давай-давай" тоже все усугубляют.
Я точно в другом мире живу. :) Никаких ТЗ отродясь не видел. Как писать код "не задумываясь" - вообще не понимаю. Ко мне приходили ученые и говорили: "надо сделать программу оцифровки изображений с диаграмм". А как? Ну, вот так и так. Я делал, показывал. Они говорили, что нужно еще это и это. А вот это лучше сделать не так. Потом с готовой версией работали неделю - и говорили, что надо вот это сделать, вот это изменить, вот это убрать, Ну и т.д.
И вопрос: как я могу писать код "не задумываясь"? И чем мне тут поможет ИИ, если я сам не очень понимаю, что нужно в итоге? :)
Научное программирование - штука очень специфичная. А другого у меня по работе и не было.
Аналогично когда я пишу программы "для себя" (на другом сайте все выставлены), то опять же: сам себе даю ТЗ, но с первой версии все не придумаешь. У меня вот заменитель блокнота сейчас в 6 версии. Но уже есть список изменений для версии 7. Скоро займусь... И зачем мне тут ИИ? Только для вопросов по языку, библиотекам и т.д., чем самому на форумах копаться...
ИИ здорово избавляет от рутины. Нужно что-то поменять в интерфейсе, CI или еще какой-то типовой ерунде, сгенерировать тесты или раскопать причину ошибки - проще пнуть ИИ и дальше заниматься своей наукой. Хотя и здесь он помогает копаться в источниках и проверять гипотезы.
Вот сейчас "копал" ИИ по медицинским вопросам. Такую ерунду пишет... А по софту - да, я тоже так думаю, что простые рутинные вещи лучше поручать ему. Но вот глобально большую задачу решить...
Вот сейчас "копал" ИИ по медицинским вопросам. Такую ерунду пишет...
Вы в хорошей компании!
@Hemml: Да, всё, в чем ты не разбираешься, нейронка делает хорошо. Но вот то, в чем ты что-нибудь понимаешь, она всегда делает плохо
И я про это тоже писал.
А что такое для вас программирование?
Перекладывание джейсонов перестало им быть? Дак тогда 2/3 разрабов техно гигантов выпадают из программистов.
Я на работе почти перестал решать “программистские” задачи. Больше инженерные и архитектурные.
Как написать код я и так знаю, а вот что написать чтоб оно через год не развалилось - надо подумать.
Короче программирование как тупое набирание буковок на экране уходит в небытие, и это прекрасно.
Ну, я бы не называл это "тупым набиранием буковок", это было когда-то, для профессии "оператор ЭВМ". :) А программист все же не тупо буковки набирает. :)
Насчет того, что уходит в небытие - да, возможно. Но не могу сказать, что это прекрасно. Да и не факт, что навсегда...
Они и не были программистами а были кодерами
Вы реально пишете статью и комментарии на протяжении долгого времени, ориентируясь бесплатный chatGPT заместо того чтобы занести 100 баксов и протестировать фронтирные модели от антропика/опенаи? Где ты буквально можешь написать в окошко "сделай з****сь", и оно сделает это с вероятностью 99.99999%?
Примеры? Пожалуйста - кастомный сетевой стек на богомерзкой жабе 8, с самописным кодгеном, транслятором для определенных задач, отвратительным тулчейном. 0.5Mloc, 15-летнее легаси, две недели моего времени, по большей части будучи meat-proxy, fable 5, результат - код на kotlin. По дороге было найдено десяток древних багов аля "юзер авторизовался с вайфая в аэропорту Хельсинки, а завершил оплату в Торонто с роуминговой симки под прокси", который вылезали раз в полгода у одного такого юзера, и закрывались "Not reproduced", с подтверждениями по тикетам в жире и логам с бэка. Работает, проверено в бою, подтверждено статистикой, количество непонятной хрени уменьшилось заметно.
Сколько бы человеко-лет ушло на это в 2022 я даже знать не хочу, и сколько бы принесло новых багов. Все в агентском режиме, повторяюсь, с новомодными mcp/харнессами для вытягивания логов с елки, тикетов в жире, аналитики, чего еще бы угодно.
Открою Вам секрет, даже на тарифе 20 баксов у OpenAI доступна модель Astra )
а на что тогда ворчать?
вы ещё предложите человеку deepSWE бенч посмотреть.
Ну бенч это бенч, во первых он в хрен пойми каких попугаях, во вторых там на них натаскивают, в третьих там каждый день какая-то "революция". Шума слишком много.
свебенч это просто сборище и оценка конкретных задач в программировании, да поглядите их уже.
А что насчет "во вторых там на них натаскивают"? Сильно глубоко не вникал, но внутренние замеры и независимые - часто сильно разнятся. А когда речь об игроках с миллиардами, отдельное искусство отделить независимые замеры от "независимых".
Быстрый прогресс качества агентов очевиден, но субъективные ощущения от одинаковых по попугаям моделей часто сильно разнятся.
Кстати, отдельно доставляет потребительское качество того же плагина codex. Тормозное и частенько ломающееся окно чата на длинных диалогах, отсутствие нормального поиска по сессиям (особенно бесит) и т.п. Какого фига, у вас же там почти AGI, а речь про один из флагманских продуктов.
ещё разочек, вопрос был про реальные кодерские задачи, или говоря устаревшим языком - "задачи в программировании".
В бенчмарке реальные кодерские задачи, решение которых не утекло в сеть. Т.е. считерить нельзя, можно только придумать новое решение. Но вы же тоже не сходили и не посмотрели про что бенчмарк.
Модель придумывает решение для кодерской задачи, их там много, это решение оценивают, получают баллы в бенчмарке.
Баллы в бенчмарки это воздух. Реальное решение реальной кодерской задачи это суть данного топика.
А кодекс это вайбкодинг на расте, дай бог его пилят 2 человека и 20 агентов. Все что кроме терминальных команд в таких харнессах - в принципе мусор, нужный не разработчику а компании.
Кому и кобыла невеста ©
Скрытый текст
И прочая зоофилия
Тогда плюс llm не в переводе на новый стек lift and shift, что не дало почти никаких преимуществ, он такой же кривой и остался (или вы его попытались улучшить и сломали но ещё не знаете об этом). Плюс LLM в чтении логов и выстраивании (предположений о) модели бага по частичным данным. В это я готов поверить
Да и с бесплатными прекрасно решаются, например переписать кусок кода с одного языка на другой или объяснить как работает
или объяснить как работает
А откуда Вы знаете, как она объяснила: правильно — или всё-таки правдоподобно?
@Hemml : Да, всё, в чем ты не разбираешься, нейронка делает хорошо. Но вот то, в чем ты что-нибудь понимаешь, она всегда делает плохо
Я последний месяц сижу в локальном Qwen 3.8 27b и прогоняю его по своему коду как ревьюера. Thinking - Medium (на High все-таки нужно что-то мощнее одной 3090).
Пара наблюдений:
1) Он достаточно подробно размышляет над ответами, и, если внимательно следить за этими размышлениями, можно получить неплохой профит. То есть кроме того, что ты замечаешь, когда его повело куда-то не туда, он строит какие-то гипотезы, на основе которых можно придумать прикольные архитектурные решения, которые тебе самому в голову не приходили. Я за этот месяц внес как минимум два серьёзных изменения в архитектуру, которые одновременно сделали код чище, красивее и бойчее (раза в 2 по сравнению с моим собственным решением)
2) Он обращет внимание на те аспекты кода, которые ты сам (ввиду недостаточной практики) пропускаешь. Совместными усилиями начинаешь разбираться лучше (во всяком случае сегфоллы и утечки уходят, причем именно в тех местах в которых ожидаешь и после тех изменений, которые кажутся эффективными).
Так что, видимо, ответ на ваш вопрос - откуда я знаю, что объяснение правильное - исключительно из результата. То есть ошибки, которые я где-то насажал, исправляются, и я начинаю видеть их просто глядя в код.
Ну, про то, что из него получается наиотличнейшая резиновая уточка, я уже давно пишу.
Уже больше. И Астра и Фабл печатают код заметно быстрее меня и даже глупых ошибок совершают не больше типичного мидла. Правда время на понять а что делать-то вообще надо никуда не девается. И в отличии от мидла они не способны понять что в задаче чего-то не хватает или просто фигня получается и надо пойти еще подумать еще или спросить у кого-то. Сказали сделать - они сделали. Что вышло то вышло.
печатают код заметно быстрее меня и даже глупых ошибок совершают не больше типичного мидла
, теперь они совершают умные ошибки,
граничащие с саботажем!
Веша, ты открыл для себя каты и теперь считаешь нужным вставлять их в каждый второй комментарий?
Как же убого, что на хабре до сих пор нет возможности скрыть пользователя.
Просто щитпост необремененный никаким интеллектом.
считаешь нужным вставлять их в каждый второй комментарий?
Я считаю нужным прятать картинки под кат. Мне лет так с десяток лет тут объяснили, что приличные люди так делают.
Как же убого, что на хабре до сих пор нет возможности скрыть пользователя.
Так за чем же дело стало: у Вас же ИИшечка — попросите её написать Вам скриптик для Greasemonkey. (С прищуром:) Или слабО?
Просто щитпост необремененный никаким интеллектом.
Beauty is in the eye of the beholder.
Кстати, по поводу Thinking -> Medium: здесь пришли к выводу, что у этой модели есть только 2 уровня рассуждений, low и xhigh. Medium - это фактически low, поэтому для более точной регулировки reasoning effort рекомендуют использовать thinking budget.
Я пробовал все варианты, и мне показалось, что low от medium отличаются. Может быть не результаты (потому что результатом первого запроса у меня практически во всех случаях получается почти работоспособный код с одной галлюцинацией - исправляешь ее и получаешь то, что надо), но вот эти самые рассуждения, которые я читаю, в режиме low ощущались менее ценными. Но может казались (я экспериментировал всего пару раз - скорость на low и medium практически не отличается, так что я вернулся на medium). Зато xhigh способен поразить (если, конечно, дождаться результата).
Я, когда просто тестировал разные модельки, попросил его нарисовать мне иконки. Самый простой и абстрактный промпт - то есть буквально - "Мне нужны иконки для класса, свойства и метода в svg". Пыхтел минут 20, выдал вместе с иконками презентационный сайт для этих иконок, с приличной типографикой и приятными цветами. Сами иконки тоже ничего, но в работу, скорее всего, не пойдут. В отличие от сайта.
А откуда вы знаете что ваш коллега по работе объяснил вам правильно, а не правдоподобно?
Более того, если модель решит что ты её проверять не станешь она начнёт лениться и выдумывать. Был недавно такой случай: план написан неплохо, но дальше на пункты с длинной проверкой (и ей долго проверять и мне) модель просто положила болт и наврала. Я был в шоке
спасибо, что выложили в профиль содержимое CLAUDE.md, я себе скопирую весь текст
Да, с этим согласен. Перевод - это реальная задача, хотя у меня потребности не было, но понять могу. А вот насчет "объяснить как работает"... Разве что надо модифицировать код уволившегося программиста... Но правильно ли объяснит?
Да, если хорошо описать как работает, то много простых скриптов напишет и gemini прямо в браузере google? Он хорошо принимает и выдает длинные листинги по частям. Если будут с ним какие-то тупики, это можно передать второму агенту в другом окне или в бесплатный gpt или в чат поддержки на яндекс облаке, и там ИИ тоже неплохо кодит. в общем перекрестный мозговой штурм между несколькими бесплатными решениями, плюс всегда на яндекс облаке можно и deepseek и qwen3.6-32 мультимодальный, выдает неплохие результаты, которые тоже можно обсудить с другими ИИ.
У нас фронт на мертвом ExtJS где больше 1 млн. строчек кода. Задача создать библиотеку, которая через module federation 2.0 будет мочь встраивать react/vue как view в ExtJS при чем так чтобы микрофронт был изолирован внутри web component. Claude Code с моделью Sonnet 5 выдал готовую библиотеку за 15 минут, потом ещё минут 30 потратил чтобы создать E2E тесты (основную проблему решал с тем, что на современной macOS отсутствует старая Java которая нужна для запуска Sencha Cmd). В итоге встроив либу в наше ExtJS приложение, агент столкнулся с тем, что где-то в этом миллионе строк legacy кода есть обработчик backspace, который блокирует в браузере переход к предыдущей странице, если этот backspace нажали за пределами input/textarea. Так как изолированный микрофронт ExtJS воспринимает как простой div, то там нельзя было стереть текст нажимая backspace. Он нашел участок кода в ExtJS, сделал фикс, открыл MR и описал проблематику в Jira. Если самому повторять этот же путь с самого начала, то ушло бы несколько дней вместо часа работы агентом.
Если самому повторять этот же путь с самого начала, то ушло бы несколько дней вместо часа работы агентом.
..зато у Вас в мозгу было бы понимание, как оно работает — а сейчас его как не было, так и нет.
Перевожу в бытовую плоскость: Представьте себе, что Вы устроились работать библиотекарем в РГБ. В понедельник пришёл читатель и заказал «Сказку о Золотом Петушке» Пушкина. Вы пошли в книгохранилище и, поплутав там часок, принесли ему искомое. Во вторник другой читатель заказал книгу «Мцыри» Лермонтова — Вы уже знаете, в каком крыле искать Лермонтова, потому что вспоминаете, что в поисках Пушкина Вы проходили мимо отдела «Л» — и теперь сразу идёте туда, значительно сократив время поиска. В среду ещё один читатель заказывает ПСС Ленина, все 55 томов — и Вы сначала напрягаетесь, а потом вспоминаете, что во вторник в подсобке между отделами З и К вы видели тележку, на которую все 55 томов отлично поместятся, а Вы кроме того ещё и помните не только где отдел Л, но и примерно в каком месте на стеллаже расположены книги на Ле — вы же во вторник там рылись.
Ну и так далее.
А потом приходит гугол со сканом всех книг мира, и ваши знания про П больше Л резко становятся ненужными на рыночке.
Так в том-то и проблема. Когда приходит LLM, знания не становятся резко не нужными, потому что LLM не может не наврать. Оно просто так математически устроено. Наврёт обязательно, вопрос только: где? Особенно с этой любовью LLM писать код на очень низком уровне абстракций.
И навык надо прокачивать, чтобы понимать, что оно пишет и во-время увидеть, где оно начинает врать.
А вся проблема в том, что при вайбкодинге навыки не прокачиваются. Были уже вон исследования, как это всё влияет на работу мозга
Наврёт конечно. Вот только мясной коллега точно так же и наврёт и наглючит, но железяка хотя бы сделает это быстро при примерно той же вероятности по порядку величины.
С утратой скиллов согласен. Причём непопулярные языки, фреймворки и технологии здесь совсем в пролёте: модели их не знают или очень плохо знают просто из-за малой обучающей выборки. То есть им и так сложно пробиться на рынке, а тут ещё и народ не захочет идти сушить мозги из-за отсутствия поддержки ИИ. Пока всё выглядит так, что вместо сингулярности нас ждёт стагнация.
Наврет там где вы не будете проверять. По закону подлости. И LLM сама тоже понимает где ей сразу влетит, а где может быть пронесёт.
Дело ещё вот в чём: «враньё — в глазах смотрящего проверяющего». Модель просто выдаёт последовательность токенов, и ей глубоко перперндикулярно, что эта последовательность «что‑то означает». А вот тот, кто эту последовательность читает, видит токены «во‑да мок‑ра‑я» и говорит «о, какое ИИ умное», видит токены «Солн‑це зе‑лё‑ное» — и говорит «о, какой бред он несёт».
Пример очень хорош, если нет адресного хранения даже на уровне таблиц xlsx.
Отличный пример абсолютно неликвидного скилла. Завтра так вышло, что конкретно это здание библиотеки отдали под управление купленного на распродаже микроавтобуса индусов, и надо искать работу библиотекарем в другом месте. Да, некое преимущество перед вчерашним выпускником ВУЗа будет из-за раскачанной памяти, прописанном в подсознание распределением, сколько какая буква, а то и биграмма, занимает метров стеллажа. Но, увы, это далеко не то преимущество, за которым будут бегать хедхантеры и умолять возглавить их библиотеку
А Вы реально ожидаете, что вчера устроившийся сотрудник завтра будет всё‑всё знать о проекте?
По моему опыту между состояниями «кто я? где я? что я здесь делаю?» и «в два часа ночи в субботу, вусмерть пьяный пинком ноги открываю нужную дверь и щёлкаю правильным переключателем» проходит с среднем 18 месяцев.
(А я, ежели чо, на своём проекте уже over 12 лет.)
что вчера устроившийся сотрудник завтра будет всё‑всё знать о проекте?
Ну, конечно же, нет! Только, вот, по законам рынка (и законам физики тоже), получать будет больше старичка, который знает почти все. Потому, что старичку платят вилку «удержательную», которая нужна, чтобы преодолевать силу трения скольжения (чтобы продолжал двигаться по своей траектории), а новичку «хайринговую», необходимую для преодоления силы трения покоя (и сорвался с насиженного места).
PS: исключения, подтверждающие правило, бывают. Доля от бизнеса или прибыли для ключевых людей, и все такое
С реальными задачами именно по программированию может быть сложно - зачастую описание задачи неполное и иногда недетерминированное и по сложности не сильно отстаёт от реализации. В этом случае даже топовые ИИ водят кругами, т.к. не понимают всех нюансов задачи, пока их не поймёт и сформулирует сам разработчик.
Но всё меняется, когда нужно делать работающие продукты (как микро-утилиты так и сложные промышленные) как композицию относительно простых задач. Агенты начинают хорошо работать как в продакшен применении, так и в домашнем.
У меня сейчас главные инструменты - это OpenCode с локальным Qwen 3.8 и собственный качественный, как я считаю, опыт разработки руками. За летние месяцы, со всеми их время-затратными развлечениями масштаба частного дома, неполным списком удалось:
подчистить и доработать конфигурации ESPHome десятка домашних устройств - исправить некритичные но неприятные баги, до которых раньше у меня не доходили руки. Внутри конфигураций - и C++ код и конечные автоматы со своим DSL и нативный YAML от ESPHome.
сделать с нуля до post-MVP стадии один коммерческий проект и ТЗ с live demo и детальным коммерческим предложением для другого. Разработку, документирование, финансовое и тестовое сопровождение, ведение репозитория - только силами OpenCode плюс FAR с Colorer для контроля содержимого рабочих файлов.
Проекты логистические, для внутреннего применения с изначально заложенной перспективой продажи SaaS.
Во втором проекте достаточно серьёзная алгоритмическая сложность, но она решается сторонней библиотекой (CP-SAT Solver).аналитика и траблшутинг для другого клиента: агент в workspace для этого клиента интегрирован в readonly со всеми сервисами и инструментами клиента - Basecamp, Slack, Postman, AWS, SendGrid, Twilio. Делает скучные вещи типа сопоставления логов из нескольких мест, моделирование работы скриптов и сервисов и расследование причин проблемы. Пишет красивый и понятный отчёт клиенту.
прямо сегодня нашлось время целиком переработать утилиту, которая разбират фото и видео со всех наших семейных телефонов (5+ штук) и раскладывает в папку нашего фото-архива на файл-сервере.
Утилита делалась года назад на коленке и не имела ни архитектуры, ни надёжности - ломалась на каждом новом для неё формате файлов (HEIC/HEIF, etc.) - теперь это взрослый внутренний продукт со всеми аттрибутами, включая репозиторий и документацию.
Миллион мелких дел и автоматизаций для семьи не упоминаю, но сейчас они делаются, а раньше на них не хватало времени.
Да, впечатляет. Если при этом все полученное надежно и не опасно - то супер. Просто, наверно, у меня очень специфический круг задач бывает, где ИИ откровенно не нужен (ибо объяснить ему какой редактор я хочу написать вместо блокнота - задача нереальная).
Что касается семьи, то и вовсе никому ничего не нужно, каждый сам со своим телефоном разбирается как ему удобно. :) И "умного дома" нет. А вот мелкие бытовые программки "одноразовые" у меня бывают. Я все искал удобный язык для этого вместо VB3, который уже не запускается. Хотел Smallbasic, даже книжку по нему написал и на сайте выставил, но в нем есть минусы. Хочу свою библиотеку написать...
Но опять же - зачем тут ИИ - ума не приложу! Наверно у меня все же осталась досовская психология: "Я - хозяин машины, а не Виндовс, ИИ и прочие посторонние"... :)
Прочитал вашу статью как вы пробовали вайбкодинг, сходил даже на ваш сайт.
Вам нравиться программировать, попробуйте AI использовать в вдругом стиле. Не писать с помощью ИИ, а давать ему код, что вы сами написали и просить сделать ревью вашему коду, найти ошибки и что можно улучшить.
Вы один варитесь в программировании, пишете на бейсике, будет вам как коллега, который будет смотреть ваш код и давать обратную связь.
Да, для меня это изначально было хобби, но стало профессией. Мне нравится, да. :) Насчет идеи проверять код... Ну, не знаю, до сих пор я не видел в этом смысла. А вот для чего я действительно использовал ИИ - это как справочник. Раньше нужно было перерыть кучу ссылок (и не всегда релевантных), теперь спрашиваю "как сделать вот это" и получаю ответ. Это действительно полезно! Хотя как владелец сайтов я против, ибо таким путем на сайты уже никто не заходит, дальше ответа ИИ не идут люди. :)
Мне тоже не зашло писать код с ИИ, зато он хорошо помогает с
рутинными правками: посмотри на изменения в этом файле, найди в проекте все похожие места и сделай там аналогично.
исследованиями: найди все репозитории, зависящие от моей библиотеки, и посчитай, насколько часто в них встречается такой-то паттерн.
отладкой: вот логи, разберись, почему оно падает.
написанием ченджлогов: вот список закрытых тикетов, напиши ченджлог (приходится за ним править, чтобы было кратко и по делу, но это сильно проще, чем самому разбираться, что и зачем там коллеги из соседней команды сделали).
Да щас кодинг ИИ агент это как мидл разработчик за 20 баксов которые не спит не есть работает круглые сутки ) Гонять его за каштанами в огонь одно удовольствие )
Вот тут на 100% согласен! На самом деле изначально т.н. "ИИ" под именем "экспертные системы" еще в СССР предназначался примерно для таких задач. И тут понятно, что чем вручную перебирать, проще с роботом. Но я плохо себе представляю, как можно с помощью ИИ сделать ПРОГРАММУ. Даже типа тех, что делал я (не научные, а утилиты). Главное - как объяснить что нужно? Проще самому написать. :) И интереснее...
теперь спрашиваю "как сделать вот это" и получаю ответ
" объяснить ему какой редактор я хочу написать вместо блокнота - задача нереальная " - гораздо более реальная, чем вы можете себе представить. ИИшки умеют по сумбурному потоку мыслеизвержения каким-то чудом восстановить не только "что хотел сказать автор", но и то, что на самом деле ему надо. У них с пониманием, чего хотят, даже не на десяточку, а на двадцаточку. Просто рассуждаете вслух за клавиатурой о своей программе, и получившуюся простыню, как есть, бросаете в чат. Потом следует сеанс уточнений и вас готовая спецификация.
На платных специализированных ИИ возможно. Но платить им желания не имею, ибо не пишу коммерческий продукт, все мои программы на моем сайте бесплатны. Но Вы меня заинтриговали. Я попробую в бесплатной версии сделать одну штуку, как раз собирался...
P.S. Редактор вместо блокнота у меня давно есть, на сайте выставлен. И уже есть идеи на улучшение до версии 7. Но это я уж сам, без ИИ... :)
Нет. Нет на самом деле. Там модели точно такие же. Ну, может совсем уж фронтиры в открытый доступ не попадают, но совсем фронтиры тут и не нужны. В открытом доступе режется в основном количество запросов, а не интеллект.
Как по этому поводу замечательно сказал сам chatgpt: "модель резко становится умнее, когда пользователь понимает, как с ней общаться". Тут практика нужна. Пальцы надо набить
ИИ - это не про сделай хорошо. Это орган с тысячей клавиш. На нём надо научиться играть
Да, в этом смысле Вы правы. Опыт нужен бесспорно. Посмотрим, проведу еще эксперимент... :)
Периодически провожу, для очевидности — визуально.
ибо объяснить ему какой редактор я хочу написать вместо блокнота - задача нереальная
При условии, что вам нужен именно продукт, а не фан от ручной разработки - очень даже реальная.
Достаточно того, что вы полностью (или в первом приближении) понимаете, чего вы хотите. Этого достаточно для написания наброска спецификации в пару абзацев. После чего агент по вашей просьбе разворачивает его в полноценный документ, дополняя пропущенные моменты и описывая ваши требования более подробно.
Здесь сразу видно, что совпадает с вашим пониманием конечного результата, а что нет. Но теперь менять спецификацию вручную уже нет необходимости - просто указать агенту на спорные места и предложить варианты. И, при желании, спросить дополнительные варианты аналогичные вашему - иногда бывают очень дельные предложения.
Готовая спецификация - это затравочный кристалл проекта. Для дальнейшей разработки ей может пользоваться как LLM, так и любой сторонний разрабочик-человек, причём переключение может происходить на любом этапе. И с этой спецификацией + последующим кодом (и следующими спецификациями) агент уже не потеряет контекст проекта, т.к. они и есть контекст (плюс история изменений в Git).
Но это именно агентская разработка - в режиме чата она принципиально невоспроизводима.
Что касается семьи, то и вовсе никому ничего не нужно, каждый сам со своим телефоном разбирается как ему удобно.
Мои дети, вероятно, помладше и пока ещё не разъехались из дома. Поэтому архив, куда периодически сливаются данные с телефонов (по мере их заполнения) с 300+ тысяч фото и видео - под моим управлением.
Но также есть и всякие школьные мелочи - например подготовить к распечатке три десятка мелких разномастных фото (абсолютно произвольных пропорций), чтобы бóльшая сторорона у всех была одинаковой, а меньшая обрезалась при превышении некоторого размера (чтобы квадрат превратить в прямоугольник). Раньше для этого расчехлялся фото-редактор и требовалось от 30 минут до часа, чтобы это всё подогнать и скомпоновать на несколько листов. Сейчас делается за 5-10 минут с пары попыток и одного уточнения.
Но опять же - зачем тут ИИ - ума не приложу! Наверно у меня все же осталась досовская психология: "Я - хозяин машины, а не Виндовс, ИИ и прочие посторонние"... :)
Абсолютно нормально не использовать ИИ если для него нет задач - есть проекты, где он скорее мешает, чем помогает.
Но ИИ и контроль над своим PC - вещи ортогональные. Скорее с ИИ вы получите больше контроля, т.к. он проверит/настроит/покажет те вещи в вашей системе или проекте, которые вам самим настраивать лень или о которых вы вообще не в курсе.
Но, опять же - всё вышесказанное про мой опыт с локально запущенной LLM, где я могу не бояться утечек данных или комманд из внешней сети исполняющихся на моём компьютере. Облачные LLM использую мало и только в режиме чата.
Локального ИИ у меня нет вообще (сомневаюсь, что ПК потянет), а облачные - да, опасны в некотором смысле. и агентов тоже нет, работал с чатом, но в аккаунте. Кстати, в фотошопе есть автоматическое изменение размера картинок, для своего фотосайта использую.
Дети да, взрослые, но живут с нами. Просто у них на телефоне нет 300+ тысяч фото. :) У них другие увлечения, в соцсетях не сидят. А семейный архив есть, да. Но я его ручками собираю, надежнее. Да и не так он велик, и пополняется очень медленно...
Абсолютно нормально не использовать ИИ если для него нет задач - есть проекты, где он скорее мешает, чем помогает.
В том и дело, что не могу найти задачи, чтобы понадобился серьезный ИИ. Самому интересно, но пока никак...
Всё так. Даже халявный BigPickle в OpenCode начинает работать нормально. Я вот пилю свою игру на локальном Qwen 3.8-27b и бесплатных моделях OpenCode(там иногда попадается вкуснятина). Если задать задачу - "напиши игру такую-то с нуля", то он напишет архитектурный нерасширяемый ужас. Поэтому я сам написал с нуля каркас игры с небольшой помощью ИИ - обычно спрашивал как лучше сделать то или иное архитектурное решение. Описал архитектуру игры в скиллах и как им пользоваться. К тому же qwen-code сам себе написал "шпаргалку" в qwen.md(команда /init). И тут пошло-поехало! Пишу ему добавь такую-то функциональность в игру и он выполняет корректно все что я ему пишу практически без ошибок! Он сам запускает рои агентов, пишет на питоне скрипты, генерирует картинки через MCP Pixellab и даже проверяет результат после выполнения, делая скриншоты игры.
Кажется, вы попали в какой-то пузырь)
Я сам и множество коллег вокруг меня делают и сделали множество реальных серьезных задач в области разработки с ИИшками. Да, в начале агента нужно правильно настроить, особенно с экзотикой типа 1С. Но это делается один раз.
Мой опыт в разработке близок к вашему, студентом даже видел (и использовал!) перфокарты))
О чем вы?
Сейчас ~50% всего кода пишет ИИ.
В ядре линукса ~10% нового кода - это ИИ.
Оно уже тут.
Я 25 лет использую Linux, как основную OS. Никогда не было таких проблем, какие начались с ядра 7.2. Там просто какая-то тупая жесть происходит, обычно связанная с залипанием в чём-нибудь. То клавиатура начинает повторять букву не понятно, по чему. То видеокарта начинает bitblt делать, когда на экране ничего не меняется, и ноутбук превращается в печку, а потом вырубается. При чём, это всё в драйверах, написанных на Rust (самом безопасном языке (tm)!).
Пришлось откатываться на lts.
А куда бежать - не ясно. Потому что, оно же везде скоро так будет.
Перед проблемами с ядром, например, у меня перестало работать выделение текста с ctrl+shift в Thunderbird, перестал рэндомно работать undo и удаление различных объектов, вставленных со внешним форматированием.
Это всё прям тупые детские ошибки, которые программисты веками не допускали, а если и допускали, то быстро отлавливали при тестовых запусках.
А вайбкодеры вот делают. Они сначала токены жгут, чтобы кривой код писать, потом жгут их, чтобы находить баги, а потом, всё равно, критически важные системные компоненты и приложения выходят с критическими багами. А потом OpenAI такая: ой, наши агенты всех взламывают! Всё вышло из-под контроля! Сингулярность! Несите нам бабосики!
Ну так, конечно, блин, если критическая инфраструктура становится нейрослопом, то очень легко потерять контроль.
Жить становится страшновато.
Сочувствую! И Вы правы - будет хуже до тех пор, пока не выкинут ИИ и не вернут грамотных программистов. Проблема в том, что грамотных программистов скоро не останется, ибо откуда им появиться, если все делает ИИ? Как расти и набираться знаний, опыта и т.д.? Реально пахнет катастрофой в отрасли...
Катастрофу в отрасли вылечат грамотные инженеры - как существующие так и свежеобученные или получившиеся из хороших разработчиков. Заодно, возможно, снизится влияние карго-культов связанных с конкретными языками программирования - инженеру это принципиально ровно до той степени, которая определяется потребностями проекта и не более того.
Не рухнула же строительная отрасль, когда пропали чертёжники у кульманов и инженеры стали разрабатывать проекты непосредственно в AutoCAD. А ведь тоже, сколько знаний о заточке грифелей и брендах рейсфедеров пропало из сферы.
Я уже слышал, что джуны заменены ИИ, а без джунов не будет сеньоров. Да и учить кто будет? Старая гвардия вымирает, а новые кто? Так что не знаю...
Какой-то узкий подвид джунов (джуны-кодеры?) становится не нужен. Это те, кто случайно попал в ВУЗ на специальность и всяческие вкатуны за зарплату 200к в наносекунду.
Если человек интересуется своей (или будущей) специальностью, то его экспертность со временем наберётся так или иначе, вместе со смежными областями, которые могут быть просто интересны. Просто акценты в этой экспертности сместятся с вещей ставшими не актуальными на более нужные.
Такого рода экспертность - это то, что сейчас недоступно ИИ и, вероятно, не будет доступно до разработки полноценного AGI.
Да, только таких истинных интересующихся сейчас почти нет нигде. Даже в медицину идут не людей спасать, а бизнес делать...
Если человек интересуется своей (или будущей) специальностью, то его экспертность со временем наберётся так или иначе
Велосипед, конечно, можно изобретать, но зачем? Чтобы топтаться на месте?
Не рухнула же строительная отрасль, когда пропали чертёжники у кульманов и инженеры стали разрабатывать проекты непосредственно в AutoCAD.
AutoCAD не галлюцинировал. Как чертёжник (в то время) я с радостью им пользовался — это была улучшенная линейка, а не недетерминированный молоток.
Есть такое слово — демпинг...
Вот когда нас не останется, и ИИшечки смогут выкатить реальную, а не искусственно заниженную цену...
Про ядро Линукс ничего не скажу, но качество разработки стало падать ещё до вайб-кодинга. Меня в свое время потрясло, когда в эксплорере windows 8 ввели несколько новых горячих клавиш, то они работали только в английской раскладке. Старые комбинации работают в любой, а новые только в английской. Такие баги делали в 90хх, потом вроде научились нормально и вот опять.
У thunderbird, когда пишешь письмо в некоторых случаях пропадет курсор. Это тоже давняя история - никто не чинит, хотя багу довольно много лет. На мой взгляд, совершенно дикий и нелепый баг, но почему-то никак не исправят.
Я другой тренд заметил. Люди вместо того что бы перебирать и покупать себе программы под потребности. Стали тупо просить ИИ написать им программу конкретно под их задачу без лишнего. А то купил софт и пишешь в сапорт мол мне нужна фича и багфикс... И тишина или в лучшем случае обещание что через год исправят.
Реверс инжинеринг считается? Мне Codex (5.6) за сутки полностью отреверсила бинарник от STM32F4 до Си кода (там около 170 DSP функций). С паралельным написанием тестов и сравнением их через QEMU на оригинальном бинарнике. Оно настолько без танцев с бубном было, что в какой-то момент у нее не сходились тесты и оно само стало гонять код через gdb чтобы найти ошибку.
Кстати, интересно. А бинарник был нативный? То есть, ИИ может легко восстановить код на ЯВУ из команд процессора?
Да, но только на достаточно небольших библиотеках. Чем больше либа, тем хуже.
Мне кодекс разобрал старую 32-х битную либу для управления com портами одного древнего промышленного компьютера, добыл оттуда значения регистров потребные, нашёл в оригинальной либе ошибку! а потом по добытой информации накатал уже рабочую либу, какую я благополучно и внедрил в изделие
А вот это да - реально интересно! Но ужас в том, что теперь черта с два скроешь алгоритм, даже в нативном коде... :(
я давал кодексу даташит на микросхему и на микроконтроллер и он с первого раза сделал либу для микрухи. Потом я ему еще давал доступ к дебагу и он сам гонял тесты на микрике и перезаливал прошивку.
Алгоритм скрыть несложно. Есть способы.
А если программа сложная и ответственная то хоть ты 300 раз её декомпилируй а без подтверждения хрен на прод её поставят. Такие тонны тестов нужны, что не захочется. А тесты брать только из следов реальной эксплуатации. Ну то есть если этого нет, то никак
Оно дизассемблировало через objdump и ghidra к которым я дал доступ
И не остановился из за "possible cybersecurity risk"?
я остался в одного на разработке сайта, ИИ помог заменить сначала фронтендера, потом и SEO, копирайтера, devops, QA. конечно, пришлось много времени тратить на настройку проекта, т.к. даже лучшая модель не может выдать на 100% корректный результат единолично, нужна система ревью и приемки, но, все получилось
Как будто у нас задачи не реальные... ну, вот пример.
Семь лет в программе плавал баг с которым никто связываться не хотел. Потому что возникал он где-то внутри сторонней библиотеки когда рак на горе свистнет после дождичка в четверг. Кодекс на это дело посмотрел, сказал "я не знаю, почему падает, но есть пара мест, где вы делаете не по документации". Переделал по документации. Перестало падать.
И такое волшебство у нас каждый день. Оно просто работает...
какая задача? Любая задача.
И идея, что танцев с бубном быть не должно - неправильная. С первого раза программа не пишется. Это нормально. Хотя, с пришествием агентов такое, что работает с первого раза - случается всё чаще
Я попробую объяснить на более понятной теме, на примере с вождением машины. Вот когда водишь давно, то появляется какая то чуйка, что вот если проехать еще чуть быстрее поворот то занесет, или когда паркуешься, то уже без всяких камер и парктроников чувствуешь, когда надо остановится. Вот с нейронками так же! Со временем появлется чувство что может нейронка, а что нет. Только с нейронками поле влияния - это то сообщение которое я отправлю и та модель которую я выбиру. И вот тут начинается целая магия.
Реальные задача. Вот пример: у меня пет проект для туризма, строить маршруты, собирать данные по открытым источникам. Понадобилось мне сделать печать карт. Я попросил сделать это клода и он сделал и результат очень хорош! У меня у самого ушло бы на это ну недели 2 наверно фултайм рабочего времени. А он сделал это за 3 часа. Цель достигнута!
Танцы с бубном говорите."Танцы с бубном" у тех кто не знает как правильно пользоваться этими платными нейронками. А тот кто уже использует только совершенствуется в этом. Придумывает как еще добиться такого же результата, но за меньше время и за меньшую стоимость.
Я тоже как автор использую GPT 5.6 Luna за 20$ от Copilot правда в дефолтном режиме (Medium) - мне хватает. Я точно знаю сколько надо за рас дать ей задачь чтобы она хорошо сделала. Я точно знаю что не надо ей давать и что точно она сделает плохо. Я всегда создаю новый диалог для нового таска, и очень редко шлю второе сообщение в одном и том же диалоге. Это и есть как раз та чуйка о которой я говорил выше.
А бесплатный чатмжпт, это как если дать ребенку сесть за руль выключенного автомобиля. Понажимать педальки, покрутить руль. Водить от этого он не научится. А что можно говорить о чувстве скорости и габаритах машины...
Я бы сказал, что бесплатный ЖПТ это как посадить ребенка за руль детской машинки. Все же чему-то научиться можно. Мне опыт ПМК очень помог с пониманием ассемблера. :)
Но да, наверно, платные модели это другая ступень. Не пробовал...
У меня у самого ушло бы на это ну недели 2 наверно фултайм рабочего времени. А он сделал это за 3 часа. Цель достигнута!
«Опыт — это то, что получаешь, когда не получаешь того, чего хотел получить» ©
У вас была бы карта и опыт. А сейчас у Вас есть карта — но нет опыта.
всё зависит от задачи. я не пользуюсь платными подписками, гоняю немного DeepSeek чат и ChatGPT чат (последний из-за лимитов иногда по несколько часов недоступен в каких-то серьёзных запросах). В целом я полностью с себя снял такую работу как:
оценка алгоритма (самопридуманного) на реальных данных
создание тестовых утилит для проверки гипотез (в основном Си++ MSYS2)
вы не представляете сколько времени освободилось. Плюс еще когда он пишет тест, то ошибок допускает СИЛЬНО меньше чем я сам. Плюс он может в такой утилите добавить исследование таких метрик, о которых я даже не подумал.
Из последнего - прикрутил к своему приложению поддержку QOI и CCITT G4, у меня для второго только на чтение документации ушло бы пара дней, а он мне поддержку прикрутил за пол часа с тестами и бледжеком.
А еще ему можно скормить статью с незнакомой темой и попросить оценить перспективу использования в моём проекте. Уж простите, но насколько человек не был бы умён и образован, но основная масса всё же развивается в глубину, а не в ширину. Ну вот не пользовался я никогда хешами помимо библиотечных HashSet всяких, а когда потребовалось я начал читать статьи, вики, github, а потом такой - а чего это я? Дал свой проект ChatGPT и спросил про хеш, он мне предложил варианты.
Просто это очень хорошая отвёртка, а вот будете вы ей крутить шурупы или колоть орехи - это уже вам решать.
А еще тут баловался с парой алгоритмов и хотел чтобы он сгенерил мне готовые массивы - вжух и у меня на руках .h файлик - пользуйся, даже кодить и собирать не пришлось. А еще мне нравится когда он приободряюще кидается в бой и делает кучу рутины за меня и еще с десяток идей озвучивает, общаешься как с напарником, это создаёт какой-то рабочий настрой, сидеть одному кодить уже тяжело.
Понятно
я имел ввиду что я 20 лет + в ИТ отрасли - мне 47 )))
РЕАЛЬНОЙ ЗАДАЧИ по программированию,
Я работаю в кровавом энтерпрайзе. Тут нет реальных задач по ПРОГРАММИРОВАНИЮ.
Почти каждую задачу решаю с помощью курсора. Подписки 20 баксов с моделью по умолчанию хватает.
А задачи типа: добавь в справочник вот такое поле, прокинь его вот сюда по интеграции. Но далее скучный диалог по конкретным процедурам и таблицам в базе, конкретным сущностям и их инвариантам и т.д. У меня диалог занимает так полчаса-час. Далее она з 5 мин накидывает код, я провожу ревью, иногда прошу переделать. Но обычно все подводные камни выявляю на этапе обсуждения требований. Потом это все накатываю на стенд и проверяю.
Я не знаю, является ли занудное обсуждение задачи "танцами с бубном"?
"без танцев с бубном"
"но чтобы из этих модулей собрать серьезную программу - ИИ вряд ли потянет."
Эмммм. Что?
" Моего ответа нет: я не фанатик, но программирую не "20+", а "40+" "
А я чуть меньше - 35+. Калькулятора не было, а вот на ZX Spectrum уже вовсю писал на бейсике, лазер-бейсике и ассемблере.
" хоть один пример РЕАЛЬНОЙ ЗАДАЧИ "
Ну у меня уже целая эко-система локальных тулзов. Чего только нет (Rust/Python/TypeScript, MongoDB). Например,
- локальная вертикальная панель (task-bar, который прилипает к правому краю первого (левого) монитора), на котором и всякие кнопки (например, переключения между виртуальными десктопами с четкой идентификацией текущего соответствующим изображением), и разные статусы (cam alarm, air alarm), можно даже включить прям там трансляцию с камер в мелком виде.
(Rust)
- вот еще свежачок - свой Harness для Antigravity 2.0, позволяющий выполнять определенные задачи (на hooks), видеть trajectory действий агента, как это удобно сделали в DeepSeek Harness (Rust)
- своя замена для Live Wallpaper (Rus) и целая "тренировочная" система (TypeScript), которая на правом мониторе всегда теперь отображается как wallpaper. точнее, там две. но приведу пример первой. есть 5 кнопок для базовых физических упражнений. отжался ХХ раз - кликнул по кнопке ХХ раз. все пошло в MongoDB. и отображается график активности в виде многоугольника (по всем 5 точкам, нормализованный) за последние 7 дней (точнее, там много разные графики выбирать, я про дефолтный).
- система для камер (переписал на Rust + TensorRT, а до этого юзал свою на python) - тут много детализировать смысла нет. своя зафайнтюненая на своем датасете YOLO model. и клипы сохраняет, и алерты умеет слать, и отдельный UI читает фреймы через shared memory, чтобы лишнюю нагрузку на сеть не делать
- ...
Так, ладно, могу и дальше расписывать, но смысла мало. Я не знаю, что подразумевается под танцами с бубном. Ну мысли LLM-ки читать не умеют. Нужно юзать openspec, составлять четкие инструкции. Дописывать свои skills/rules, давать ей еще тулзы типа gitnexus, дробить все на модули, уменьшая связанность...
Или вот еще пример, который меня самого впечатлял. Забацал я с Antigravity 2.0 Gemini кое-какой сервис (который слушает источники в Telegram и делает LLM анализ новых сообщений), который разделен на несколько отдельных модулей, выполняющих четко каждый свою задачу (на Rust). У каждого своя четкая зона ответственности.
Плюс приложение для Android на Kotlin и сайт на TypeScript (React). Работает все как локально на Windows 10, как и на удаленном VPS. Автоматизм полный - агент сам собрал и docker-контейнер для полных симуляций и прогонов. И docker для сборки под linux. И агент сам умеет любой модуль компилировать и заливать на сервер, перезапускать процессы.
И вишенка на торте. Я ему могу говорить - слушай, там у нас только что false positive произошел. Разберись. Он сам лезет по ssh, берет последние свежие данные в базе (базах) за ХХ минут (сколько я сказал), проводит анализ и описывает причины. Например, в LLM промпте анализатора нет обработки вот такой-то нестандартной ситуации. И он предлагает вариант улучшения промпта. Ну или еще там какие-нибудь правки.
А я могу ответить - не-не-не. Не спеши так делать. Запусти бенчмарк и сделай прогон по нашему референсному датасету, сравнивая текущий промпт и новый промпт. И затем мне дай report. Могу и попросить голосом маянкнуть мне (написал ему скилл, который позволяет боту запускать классный TTS OmniVoice (который крутится у меня в docker). Иногда удобно, когда он почти человеческим голосом тебе репортит, а ты не за компом. :)
Чуть позже заглядываю в анализ, проверяю, нет ли дерградации результатов. И решаю, обновлять ли промпт. Вообще, правильней было бы постоянно shadow test оставлять, но не хочется под гугловский рейт лимитер попадать.
Короче, это офигенное чувство, когда LLM-агенту можно делегировать настолько много.
Нет, ну ведь красота же! Крутилось-крутилось, пофиксило странный баг "egui backend is implemented incorrectly", надеюсь, плюс еще там мелкие правки. Затем само перезапустило через оркестратор (из моей "экосистемы"), проверило логи через duckdb, сделало health-check, обновило спеки, перестроило связи в gitnexus, выполнило commit.
--
Antigravity 2.0 report
#### 2. Implemented Fixes
1. **Migrated to Deferred Viewports:**
- Switched both `alert_overlay_viewport` and `mini_pip_viewport` from `ctx.show_viewport_immediate(...)` to `ctx.show_viewport_deferred(...)`.
- Deferred viewports safely register UI closures with `eframe` without panicking if frames are skipped during window creation or headless passes.
2. **Suppressed Child Viewports When Minimized to Tray:**
- Added `if self.is_minimized_to_tray { return; }` before secondary viewport passes in [`src/ui/app.rs`](file:///c:/abcd/cam/src/ui/app.rs).
3. **Enhanced Mini-PIP Controls & State Synchronization:**
- Introduced `exit_mini_pip: Arc<AtomicBool>` and `mini_pip_opacity_atomic: Arc<AtomicU32>`.
- Added window dragging on click-drag via `ViewportCommand::StartDrag`.
- Added quick return to Dashboard on `Escape` key press or double-clicking the video feed.
- Enabled smooth mouse wheel opacity control (clamped between 20% and 100%) with real-time alpha tinting via `Color32::from_rgba_unmultiplied(255, 255, 255, tint_alpha)`.
---
#### 3. Verification & Autonomous Deployment Protocol
- **Service Verification:**
1. Stopped service: `sm stop abcd-cam`
2. Built release binaries: `cargo build --bin abcd-cam --bin abcd-cam-ui --release` (Clean build, exit code 0).
3. Started service: `sm start abcd-cam`
4. Observed 7-second stabilization delay.
5. Ran health check: `target\release\abcd-cam.exe health` (`status: "healthy"`, all 6 subsystem checks passing, code 0).
6. Queried session telemetry via DuckDB: Verified `err_count: 0` for all errors and reconnect loops.
- **OpenSpec & Git Lifecycle:**
- Synchronized and updated [`openspec/specs/ui-client/spec.md`](file:///c:/abcd/cam/openspec/specs/ui-client/spec.md).
- Archived change to `openspec/changes/archive/2026-09-19-fix-secondary-viewport-panic/`.
- Analyzed graph changes via GitNexus `detect_changes`.
- Committed cleanly to git (`[master fc676fd] fix(ui): eliminate egui immediate viewport callback panic and tray conflicts`).
РЕАЛЬНОЙ ЗАДАЧИ по программированию
Но ведь реальные задачи и задачи по программированию это совершенно разные вещи.
Сделать 3d-площадку для демонстрации решения стереометрических задач координатно-векторным методом – реальная задача? Мне такая была предложена от школьного преподавателя математики когда мы экспериментировали делать всякое через LLM. Простой промпт прямо в браузерной версии Claude Code, доступной через подписку за 20$ (не простой чат на главной, а именно claude.ai/code) сделал рабочий прототип который можно было скачать и запускать в браузере. Ещё много сессий и много запросов и площадка обрасла множество фич, а так же Claude по моей просьбе задеплоил всё в hetzner, потом перевёз в Яндекс Облако (узнав что ip hetzner недоступны из России), настроил oauth-приложения в google и yandex, веб-сервер, миграции, бд.
Получилось https://mathplatform.app
танцев с бубном
На счёт танцев с бубном не знаю, но сам бы я такое не сделал за какие-то обозримые сроки. Фронтенд это даже не моя специализация. Код за агентами не перечитываю (в рамках этого проекта).
Основная проблема это поиск проблем, которые бы эффективно решались с помощью LLM - те, что решаются уже как правило оказываются решенными. Чем дальше, тем будет только сложнее.
Я пытался юзать DeepSeek V4.1 Flash для разработки, но он постоянно входит в цикл, выводя в ризонинг что-то в духе:
Let me output.
OK.
Go.
Writing.
Let me output.
Now.
OK.
И так до бесконечности, пока не остановишь. Даже старый V4 таким не страдал.
провайдер не тот
Использую для разработки напрямую через https://api.deepseek.com, ни разу с циклами не сталкивался.
А вы напрямую у DeepSeek его по API берете?
del
И знаете, какие меня ожидали результаты? У меня перестали кончаться 5-часовые лимиты и недельные лимиты. На тарифе за 20 баксов в месяц, Карл!:)
Тот момент когда пользуешься Claude Opus 5 High / Extra и тоже хватает тарифа за 20€ 🌚 и лимиты 5 часов никак не мешают…
Состояние лимитов в моменте ✅
Мне кажется, вы немного слишком прямо интерпретируете Cost per Task у Artificial Analysis. Это не «стоимость успешно выполненной задачи», а средняя стоимость токенов, потраченных моделью на один элемент их набора бенчмарков. То есть из $0.18 у Luna против $3.26 у Astra напрямую не следует, что Luna делает ту же работу в 18 раз дешевле. При этом нет уверенности, что модель (любая) успешно «решила» этот элемент — она просто потратила токены.
И вы, по‑моему, не смотрите на самое интересное — на профиль результатов по отдельным бенчмаркам. По общему Intelligence Index разница действительно выглядит не такой уж большой: 38 против 53. Но, например, в Terminal‑Bench 4.0, который гораздо ближе к агентской работе программиста, у Luna max около 12%, а у Astra max — около 59%. При этом в SciCode почти паритет: 54% против 56%.
То есть ваш практический результат, на мой взгляд, прямо интересен, но именно «локально»: по сути, вывод не «Luna почти такая же умная и делает ту же работу в 18 раз дешевле», а «для моего класса задач Luna уже пересекла порог достаточности». А после этого скорость, дешёвые итерации и хороший harness (тьфу, а не слово!) действительно могут оказаться полезнее, чем ещё несколько пунктов общего benchmark score.
Ещё один момент: вы смешиваете API economics и лимиты подписки Codex. Cost per Task у Artificial Analysis считается по API‑тарифам, а то, что у вас на Luna перестал быстро заканчиваться лимит подписки за $20, — это уже отдельная политика лимитирования OpenAI. Эти две цифры напрямую друг из друга не следуют.
И с памятью, мне кажется, у вас тоже получилось слишком сильное упрощение. Долгосрочная память не делает контекст бесконечным. Само окно контекста всё равно остаётся конечным — плюс появляются отдельные проблемы с устаревшими фактами, неверным retrieval и compaction.
Но с основной практической мыслью статьи я согласен: после некоторого порога качества модели скорость и стоимость итерации действительно начинают значить намного больше, чем ещё немного «интеллекта» по некоторому агрегированному рейтингу.
MemoryLLM не имеет бесконечного attention-контекста в буквальном смысле.
Но она может бесконечно принимать новые куски текста и обновлять фиксированную внутреннюю latent memory.
Размер этой памяти не растёт вместе с историей.
Старые детали при этом могут постепенно теряться или искажаться.
То есть это скорее бесконечная жизнь с ограниченной памятью, а не бесконечный контекст без потерь.
Сам проект тут:
[2402.04624] MEMORYLLM: Towards Self-Updatable Large Language Models
wangyu-ustc/MemoryLLM: The official implementation of the ICML 2024 paper "MemoryLLM: Towards Self-Updatable Large Language Models" and "M+: Extending MemoryLLM with Scalable Long-Term Memory"
Разница между бенчмарками и реальной разработкой как раз в постановке задачи
В синтетических тестах агент предоставлен сам себе и легко уходит в бесконечный цикл правок
В живом проекте опытный сеньор направляет модель короткими промптами и вовремя бьет по рукам
В отпуске есть время подумать и исследовать.
В отпуске нужно отдыхать, а не работать на работодателя за нулевую ставку.
Ваша модель попроще на сложном участке с плотной логикой либо тихо выпилит часть требований, либо упростит так, что бы только формально было выполнено требование. Так что ваша экономия имеет цену.
2 года на курсоре, MLE. Так и не научился бездумно сжигать лимиты...
Ну вот накидал себе голосового бота для учёта расходов - в итоге 20 центов в месяц на токены.
Вся эта гонка за тем, кто сколько токенов сжёг быстрее всех - это какая то изощрённая форма интеллектуальной маструбации, когда вместо этого можно иметь здоровые отношения (с аишкой)
А deepseek v4.1 flash пробовали, через openrouter?
Возможно автор просто еще не вышел на уровень использования моделей, когда им делегируется максимуму того что они могут осилить. Фантазия того что можно делегировать всегда растет с опытом использования.
Я например буквально на прошлой неделе помню создал сессию, работаю и чувствую, что агент меня бесит и тупит. Запрос был типа - почему при внешне правильных промптах модель в эвале повторяет одни и те же ошибки. Оказалось случайно переключился на сонет с опуса. Переключился на опус и получил привычный конструктив и охват вместо ошибочного цепляния за мелочи. А Sonet все еще очень сильная модель.
А вот разницы межде Fable и Opus я тоже пока не чувствую, потому что еще не вышел на задачи для которых Opus будет мало.
И я тоже программист а не вайбкодер.
Согласен. Точно так же пока не ощутил разницу между астрой и sol. Пока включаю sol xhigh - и полностью ее хватает, больше и не нужно)
Fable сильно меньше страдает от раздувания (как кода, так и коментариев/ документации ) чем opus
Fable почти не гонял, но погонял Astra. в 95% кейсов разницы с Sol или Opus нет, но все-таки есть задачи, где более высокий класс себя проявляет.
Было два опыта использование платных моделей. В первом меня грязно надула фирмочка рекламировавшая свои услуги тут на хабре, продав в качестве платной услуги доступ к бесплатному чату GPT причём не смой последней версии на тот момент.
Второй после выхода GPT-5 подписался на платную версию за 20 баксов. Это было дно!!!
После этого завязал как с GPT так и с платными версиями. Возможно за 2000+ баков в месяц можно что то хорошее найти, но у меня нет задач чтобы это окупить.
Даже локальные модели теперь справляются: Qwen3.8 27b вполне себе решает рабочие задачи, причём на тех же 20-25 токенах в секунду. Справлялась даже с задачами с которыми deepseek v4 flash не смог.
Использовал бы её постоянно, но у провайдера от работы её просто нет.
Про экономию в 20 раз уж больно сладко стелете, это ровно до первого тихого бага в бизнес-логике. Старшие модели держат краевые кейсы на порядок надежнее, когда проект разрастается за пределы пары файлов
Где-то застряла фура с запятыми для комментариев.
На текущий момент китайские модели выигрывают.
GLM 5.3 ужасно тормозная, я сравнивал с claude opus 5. На одном коммите одной репы с одним промтом, получил разницу в 5.3 раза!
кстати они буквально сегодня дропнули GLM 5.3-flashx где фича именно в скорости. Правда я пока не понял насколько она дороже GLM 5.3-flash выходит и наскольтко быстро будет жрать подписку
Ну, согласен.
Сам пользуюсь агрегатором LLM, переключаясь иногда. Результаты плюс-минус одинаковые, а по цене разница может быть в 100 раз.
Поскольку программирую я, по сегодняшним меркам, "низкоуровнево" - мне хватает.
(То есть на прошу ИИ "напиши мне хорошо", а даю задачи по функциям на 20-50 строк, и ими уже дальше оперирую сам).
Хмм сунул задачу в апи дипсика недавно, 5млн токенов и разведение руками - также задача в квен3.8 решилась за 5к токенов
"640 КБ хватит для всех" - когда то говорил один человек
Ну если посмотреть что даёт тот же fable или astra то в 90% в кодинге такой интеллект ненужен, примерно полтора года назад ушел на glm + Kimi + DeepSeek с тех пор ловлю только недоумение когда речь идёт о каких-то лимитах
Ну Kimi k3 сейчас тоже не сахар, я постоянно ловлю на нем лимиты...
Плюсую, перешел с Grok на Luna - небо и земля, главное общается не русскими словами а вполне по-русски, код пишет, супер быстрая - на уровне браузерного Gemini и почти бесплатно.
Рынок не только созрел, но уже предлагает решения агентного SDLC целиком, основанного на графе знаний компании. А не тот "контекст" в виде кучи маркдаун файлов в репе, о чем на Хабре каждый день пишут. Мне подписки норм, можно и тупее и дороже модель выбрать, по необходимости..
Лимиты на размер контекста успешно обхожу документированием знаний в .md и запуском нескольких диалогов. Поэтому основными факторами выступают здравый смысл в ответе и скорость работы модели. Позволить ждать 15 минут на выполнение большого шага, приближающего к цели или полностью решающего задачу, вполне комфортно.
Для обычных (декомпозированных) задач устраивал скоростной Cursor на Composer 2.5. В итоге до самых умных моделей так и не добрался - фактически. Упустил ли я что-то важное таким подходом или просто "опережаю" тренды?
Если я умею хорошо программировать то мне не нужен AI, разве, что для развлечения и баловства! Или может у меня сейчас плохо со здоровьем?! Скрипты по автоматизации действий уже существуют лет как 30!
AI — это Хайп!
В целом и я так думаю. И по идее он должен рухнуть. Главное, чтобы не рухнул на чем-то критическом (типа управления АЭС)...
Если я умею хорошо программировать то мне не нужен AI
Именно. Он нужен тем, у кого с NI проблемы. А также неплохо работает резиновым утёнком.
@Hemml : Да, всё, в чем ты не разбираешься, нейронка делает хорошо. Но вот то, в чем ты что-нибудь понимаешь, она всегда делает плохо
К похожим мыслям автора про «Cost per Task», я сам лично пришел. Но пришлось попотеть чтобы понять, что мне нужно и даже пришлось пакет бенчмарков написать, чтобы понять что выводы правильные. В итоге, выбрал "ChatGPT Sol 5.6 Low", так как "Luna" и даже "Terra" оказались тупыми на некоторых тестах. Но, это мое наблюдение, я все еще в поисках и переплачивать за сомнительную выгоду не охота.
А вот рабочей лошадкой пока выбрал через OpenCode Muse 1.3 (от Мета) - ну эта модель заслуживает отдельной рубрики, очень необычная.. но, без руководства через ChatGPT, я бы ей пользовался осторожно..
Видимо, статью писала и исправляла LLM, а вот вопросы в опросе с ужасной безграмотностью добавил сам человек. И тут прям амба, как разительно отличается!
Я фанатик, программирую с самого детства 20+ лет вся отрасль развивалась на моих глазах
Я вайбкодер, либо только что выпустился с универа и не программист либо вообще левый чувак
Я студент которого учили на программиста и мне сейчас надо будет искать работу
grammarnazi негодует
<grammarnazi_mode_on>
Во фразе "Я фанатик, программирую с самого детства 20+ лет вся отрасль развивалась на моих глазах" нет запятой перед "вся".
Во фразе "Я вайбкодер, либо только что выпустился с универа и не программист либо вообще левый чувак" нет запятой после "программист" и уродский оборот "с универа". Согласно тому, что в русском языке частицы используются парами, а пары составляют частицы "с/на" (c поверхности / на поверхность), "из/в" (из помещения / в помещение), то, надо полгагать, что этому неучу нормально писать, что он учился "НА универе", раз ему комфортно писать мерзость (не имеющую хотя бы малейшего отношения к русскому языку) "С универа".
Во фразе "Я студент которого учили на программиста и мне сейчас надо будет искать работу" нет запятой перед "которого".
Вывод: я понимаю, он от ИИ тупеет, но что заставило его облениться или мешало и пункты опроса проверить с помощью ИИ?
<grammarnazi_mode_off>
Короче коротки чиркну свою историю чтобы понять как и что привело меня к ИИ и вайб кодингу
Я более 18 лет работаю в авиации прошел путь от авиадиспетчера до пилота и прочие позиции
В далеком 2018 заинтересовался программированием, прошел курсы на HTML/CSS и дизайн, даже чуть поработал в перерывах от основных полетов на фрилансе в одной компании и далее жизнь как-то крутило то там то там и не было времени на код и прочие
Но тут пришел 2022 и все поломал.... я был в Европе и понял что надо себя развивать, короче суть в чем.....я начал изучать ИИ и решил что начну пользоваться Claude и Cursor с ИИ внутри
Таким образом я подумал что могу создать хорошего для авиации - и понял систему планирования и учёте полетов и остального с ИИ внутри и отслеживанием полета через GPS
Сел и начал с разработки идеи и структуры через Claude и потом начал писать, точнее он Клод начал писать, а я учиться параллельно учиться что там и как.
В итоге через 5 месяцев и 12 дней готов проект, сейчас он уже в продакшене есть сайт и все там готов и даже уже 4 школы пользуются им.
Вот такая история
Я более 18 лет работаю в авиации прошел путь от авиадиспетчера до пилота и прочие позиции
Ого! До пилота дойти дойти гораздо сложнее, в Европе, чем даже до научного сотрудника. Хотя, с российской лицензией, и, как я понимаю, гражданством именно сейчас путь был бы крайне тяжелый.
Правильно ли я понимаю, что Ваш продукт -- это что-то вроде AMS с интеграцией во что-то вроде SkyDemon?
нет. в Украине я выучился в частной школе за 2 года. получил коммерческую лицензию потом работал инструктором, выучил 9 человек летать. потом летал в частной авиакомпании на джетах
В Европе обучение на пилота стоит не так уж и дорого и по времени тоже около 23-26 месяцев.
Продукт вот он - htttps://flightdeskai.org
В итоге через 5 месяцев и 12 дней готов проект, сейчас он уже в продакшене есть сайт и все там готов и даже уже 4 школы пользуются им.
Главное — чтобы им не пользовались пилоты магистральных рейсов! А этих — не жалко.
А вас допускают писать софт для пилотов, или ток жейсоны разрешают перекладывать?
Ну если вы внимательно читали мой комментарий, который написан простым и понятным языком, то увидели бы что софт для летных школ, кто должен разрешать допускать то? Это софт который используют для планирования а не для выполнения полетов, информационно-визуальное приложение в котором идет только учет и наглядное видение ситуация.
написан простым и понятным языком
Уже одно том, что в нём очевидный избыток многоточий и недостаток запятых, достаточно ясно показывает, что он, может быть, и «простой», но ни разу не «понятный».
Это софт который используют для планирования
А летать потом будут не по плану? Ну ОК.
Отвечаю вам на первое замечание - запятые и прочие знаки препинания это лишь знаки, а суть остается в самом тексте.
Ответ на второе замечание - система планирования и учета работы летной школы. Сам план полета подается через официальные источники подачи планов полета в EUROCONTROL и/или через специальные приложения у Garmin, а моя система не про планирование а про планирование работы летной школы, внимательно ознакомьтесь с данными на сайте проекта.
и не пишите больше такого если не разбираетесь в авиации.
Спасибо
запятые и прочие знаки препинания это лишь знаки, а суть остается в самом тексте.
А, так это всё-таки Вы подошли к калитке с громким лаем?
и не пишите больше такого если не разбираетесь в авиации.
Ну так Вы же не разбираетесь в программировании — а пишете...
Раньше Ламеры у всех ассоциировались с чайником, а теперь Лламер это звучит гордо)
Метрика Cost per Task, отличный отрезвляющий душ для тех, кто до сих пор по привычке скармливает копеечный рефакторинг топовым API
У меня стек небольшой, php + mysql + javascript (натив), просто опыт 15 лет, конечно какую-то работу снял ии, но в целом то он балван, я про дипсик.
Пока первый правильные промп не скормишь ему, диалог вряд ли у вас получиться.
В целом я так считаю, для тех кто в теме 5 10 15 лет, только благо. Правильный вопрос это уже половина решения.
Много воды, ИМХО и личного опыта. Мало фактуры, конкретики, выводов. Мнение валидное, согласен, но какой либо пользы для себя в статье не увидел. Да, в большом старом продукте важна долгосрочная память и выстроенные пути/skills/итдитп. Да, понимание продукта и задач + грамотно построенные запросы больше влияют на результат, чем "мощь" модели. Вроде бы все, кто с этим успел поработать, и так это понимают. Вывод статьи слишком уж размытый. Переходить на бесплатные инструменты и грамотней работать с задачами? Посыл автора где-то потерялся к концу статьи.
Я вообще не программист - я админ с 20-тилетним стажем. Я знаю только bash и не люблю другие языки программирования, хотя погружен в принципы построения программ. Внезапно, я стал программировать вообще не заглядывая в код, но понимая как должна работать программа. Для примера: написал парсер на bash - мне было удобно что я быстро читаю код, а модели я ещё не доверял. Потом написал SQL-запросы - тут тоже пока наглядно и всё понятно. Отчет сделал в "экселе" сделал скриншот, вставил в модель, сначала для генерации html-шаблона - вот тут у меня вообще нет скила, а потом спросил модель как она понимает этот отчет. Оказалось хорошо понимает и бесплатно в виде её пояснений получил контекст для написания логики его заполнения, чтобы не писать самому. Ну и соединить всё - дело техники. Использовал qwen3.6-27B в Q8 кванте локально.
Правда, сейчас хотелось бы скорость получить, через openrouter тоже часто не очень-то быстро модели работают.
Странно, что в статье о, по сути, скорости LLM ни слова о gemini-flash 3.8. Она по скорости в разы обходит даже 5.6 Luna (как и все gemini-flash), при том по интеллекту как бы на уровне frontier моделей (и всё ещё значительно дешевле). Обязательно попробуйте
Тоже пользуюсь таким подходом. Только для больших и сложны фичей использую умные модели для написания спецификации, а дальше реализую уже дешевыми моделями. Помогает сильно экономить. В том же кодексе за 100$ можно считать что luna безлимитная
Зарегистрируйтесь на Хабре, чтобы оставить комментарий
Я перестал пользоваться самыми умными ИИ‑моделями. Программировать стало быстрее и дешевле