Продвинутый

Навыки реальных инженеров: .agents-каталог от Matt Pocock

Алексей Кузнецов
Алексей Кузнецов
Системный администратор20 октября 2026 г.12 мин чтения

Разбор навыков, которые действительно важны для инженеров, и как они отражены в открытом каталоге .agents от Matt Pocock. Практические советы без воды.

ai-agents
llm
prompt-engineering
open-source

Навыки реальных инженеров: .agents-каталог от Matt Pocock

Разбор навыков, которые действительно важны для инженеров, и как они отражены в открытом каталоге .agents от Matt Pocock. Практические советы без воды.

Что такое .agents и зачем он нужен

Как возник проект и кто его создаёт

Этот каталог — инициатива одного человека, но с амбициями покрыть реальную боль. Matt Pocock — разработчик TypeScript и React, автор популярных библиотек и обучающих курсов. В 2023 году он задумался: почему при найме инженеров так много шума о дипломах, сертификатах и «правильных» путях, а на деле работает тот, кто умеет решать задачи?

Результат — открытый репозиториторий .agents, где каждый может добавить свою «карточку навыков». Это не HR-портал и не трекер достижений. Это просто список того, что действительно пригодилось в проде.

Пример структуры одной такой карточки:

yaml
# .agents/frontend/react.md
name: React
level: expert
years: 5+
projects:
  - name: "Интерфейс для аналитики"
    description: "SSR + Suspense + кастомные хуки"
    repo: "https://github.com/example/analytics-ui"
skills:
  - "Оптимизация рендеринга (useMemo, useCallback)"
  - "Работа с состоянием (Redux Toolkit, Zustand)"
  - "Тестирование (Jest, React Testing Library)"

Кто добавляет — решает каждый. Но есть модерация: мусье, вроде «знаю CSS», отсекают.

Почему навыки важнее учёждений на практике

Две минуты, и вы поймёте суть. Вместо диплома MIT или сертификата AWS вы видите: «Настроил Kafka-кластер на трёх нодах, обеспечил репликацию и мониторинг через Prometheus». Это конкретика, а не абстракция.

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

«Да, я сталкивался с гонками в БД. Использовал транзакции и уровень изоляции Repeatable Read. Вот конфиг:»

sql
BEGIN ISOLATION LEVEL REPEATABLE READ;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;

Или:

«Да, ловил утечку памяти в Node.js. Было связано с замыыканиями в цикле. Вот как починил:»

js
// Было
for (var i = 0; i < items.length; i++) {
  setTimeout(() => console.log(items[i]), 100);
}

// Стало
for (let i = 0; i < items.length; i++) {
  setTimeout(() => console.log(items[i]), 100);
}

Это и есть суть .agents: не «я умею», а «вот что сделал». Без воды, без шаблонов. Только результат, который можно проверить.

Если мы посмотрим на типичный профиль из каталога, он выглядит так:

yaml
# .agents/devops/kubernetes.md
name: Kubernetes
level: advanced
certifications: []
projects:
  - name: "Миграция микросервисов на k3s"
    description: "Сократил latency на 40%, настроил autoscaling по CPU и очередям"
    repo: "https://github.com/example/k8s-migration"
skills:
  - "Helm-чарты с собственными плагинами"
  - "Настройка RBAC и NetworkPolicy"
  - "Отладка подов через kubectl exec и logs"

Никаких сертификатов. Только опыт, который работает.

Ключевые навыки, которые выделяет каталог

Работа с LLM и агентами: не просто промпты

С практической точки зрения, большинство инженеров, с которыми я работал, подходят к LLM как к «умному поисковику». Вбивают запрос, получают ответ, копируют. Это работает для трёх строк кода, но рушится, как только нужно построить архитектуру.

Настоящий навык — это умение структурировать диалог. Не «напиши API на FastAPI», а:

Контекст: мне нужен REST API на FastAPI с асинхронной PostgreSQL-базой.
Требования:
1. JWT-аутентификация через /auth/login
2. CRUD для сущности "проекты" (Project: id, name, owner_id)
3. Защита эндпоинтов через Depends
4. Alembic миграции
5. Pydantic схемы для валидации
6. Docker Compose для dev-окружения

Выведи структуру проекта и код для app/main.py, app/models/project.py, app/schemas/project.py.

Такой подход даёт предсказуемость. LLM не гадает, а работает с чётким контрактом.

Ещё один признак опытных инженеров — итеративная отладка диалога. Я видел, как коллеги тратят часы, пытаясь «допилить» один промпт, пока LLM не выдаст идеальный код. А опытный инженер сразу разбивает задачу:

  1. Сначала — архитектура и структура проекта.
  2. Потом — модели данных.
  3. Потом — эндпоинты по одному.
  4. В конце — тесты и Docker.

Каждый шаг — отдельный запрос с контекстом предыдущего. Это как писать код по шагам, а не сразу «всё в один файл».

Агенты — это ещё один уровень. Не «пусть сам разбирается», а «агент получает цель, а я контролирую промежуточные состояния». Пример из моей практики:

yaml
# .github/workflows/deploy.yml
name: Deploy via agent
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run deployment agent
        uses: matt-pocock/agents-deploy@v1
        with:
          target: production
          dry-run: false
          notify: slack

Здесь агент не «сам делает всё». Он получает конкретную задачу, а я задаю рамки: куда деплоить, как уведомлять, что логировать.

Системное мышление и отладка в реальном времени

Когда сервер начинает падать в проде, LLM не спасёт. Нужно видеть картину целиком.

Опытные инженеры сначала спрашивают: «Что изменилось?». Потом — «Где именно тормозит?». Потом — «Какие метрики растут?».

Пример из жизни: в одном из кластеров Proxmox нагрузка на одну ноду взлетела до 80+ CPU. Вместо того чтобы сразу рестартовать сервисы, я посмотрел:

bash
# Кто конкретно жрёт CPU
ps aux --sort=-%cpu | head -10

# Анализ вызовов в реальном времени
perf top -p $(pgrep -f 'my-app')

# Сетевые задержки между нодами
ping -c 10 node-2.internal

Оказалось, один контейнер в цикле читал файл с NFS-тома, и из-за бага в ядре каждый read вызывал soft lock на 200 мс. LLM не подскажет это. Только системное мышление + инструменты.

Отладка в реальном времени — это не «поставь breakpoint». Это:

bash
# Следим за логами в реальном времени
journalctl -f -u my-service

# Анализируем трафик на уровне пакетов
tcpdump -i eth0 port 5432 and host db-node-1

# Мониторим изменения файловой системы
inotifywait -m -r -e modify /var/log/myapp/

И ключевой момент: не гасите пожар, а выясняйте почему загорелось. Я когда-то видел, как коллега 20 минут ловил утечку памяти в Go-сервисе, а потом обнаружил, что проблема в json.Unmarshal в цикле без decoder.Reset(). LLM мог бы подсказать про decoder.Reset(), но только если вы знаете, что именно ищете.

Каталог .agents отражает это: не «как написать промпт», а «как построить процесс, где LLM и агенты работают по правилам инженера».

Как использовать .agents на практике

Интеграция с существующими workflow

Когда я впервые увидел каталог .agents от Matt Pocock, подумал: «Ну и ещё один набор скриптов в npm-пакете». Оказалось, что речь о структурированном подходе к описанию агентов — их целей, инструментов и поведения. Именно это нужно, когда агент не просто выполняет задачу, а должен вписываться в ваш пайплайн.

Вот как я подключил .agents к своему текущему стеку: Docker Compose + GitLab CI + Ansible для конфигураций.

Сначала установил пакет:

bash
npm install -D @agents

Затем создал структуру в репозитории:

.agents/
├── agents.yaml
├── tools/
│   └── gitlab-ci.ts
└── prompts/
    └── code-review.md

Файл agents.yaml описывает агента, который будет проводить код-ревью:

yaml
# .agents/agents.yaml
version: "1.0"
agents:
  - name: code-reviewer
    description: "Проверяет PR на соответствие стандартам и безопасности"
    model: gpt-4o
    tools:
      - gitlab-ci
    prompts:
      - path: ./prompts/code-review.md

Инструмент gitlab-ci.ts — это TypeScript-модуль, который интегрируется с GitLab API:

ts
// .agents/tools/gitlab-ci.ts
import { defineTool } from "@agents/core";

export default defineTool({
  name: "gitlab-ci",
  description: "Интеграция с GitLab CI для запуска агентов в пайплайне",
  async run({ context }) {
    const { mergeRequest } = context.gitlab;
    // логика взаимодействия с MR
  }
});

В .gitlab-ci.yml добавил шаг:

yaml
# .gitlab-ci.yml
stages:
  - review

code_review:
  stage: review
  image: node:20
  script:
    - npx @agents run code-reviewer --context=gitlab
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"

Теперь каждый merge request автоматически проходит проверку агентом. Если он находит уязвимость или нарушение стиля — пишет комментарий прямо в MR.

Главное здесь — не «подключить и забыть», а понять, где агент заменяет рутину, а где требует человеческого надзора. У меня .agents работает на уровне CI, но не заменяет финальное одобрение. Это предсказуемо: агенты хороши для масштабирования, но не для принятия решений вместо команды.

Как не потеряться в море агентов и инструментов

Через год после внедрения .agents у меня было уже семь агентов: один для ревью, три для тестирования, два для документирования и один «универсальный». Поначалу казалось, что это удобно. Потом началось — агенты стали конфликтовать друг с другом, писать противоречащие друг другу комментарии, запутывать коллег.

Решение простое, но неочевидное: не все агенты должны быть активными одновременно.

Я ввёл понятие «агент-контекст». Каждый агент работает только в рамках определённой задачи, и его инструменты активируются по необходимости.

Пример конфигурации:

yaml
# .agents/agents.yaml
agents:
  - name: test-runner
    description: "Запускает тесты и анализирует покрытие"
    model: gpt-4o-mini
    tools:
      - docker
      - jest
    triggers:
      - on: push
        branches: [main]
      - on: manual
        label: "run-tests"

Здесь агент test-runner срабатывает либо при пуше в main, либо по ручному триггеру. Никогда не запускается автоматически на merge request — чтобы не дублировать работу code-reviewer.

Также я стал использовать агрегатор агентов — один «кооринатор», который распределяет задачи:

yaml
# .agents/agents.yaml
agents:
  - name: orchestrator
    description: "Распределяет задачи между специализированными агентами"
    model: gpt-4o
    tools:
      - agent-router
    rules:
      - if: task.type == "review"
        then: run code-reviewer
      - if: task.type == "test"
        then: run test-runner

Это как переключатель на мойей лаборатории: один вход — и только нужный сервис включается. Остальные ждут.

И, конечно, логирую всё. Каждый запуск агента записывается в Loki:

yaml
# docker-compose.yml
services:
  loki:
    image: grafana/loki:latest
    volumes:
      - ./loki-data:/loki
    command: -config.file=/etc/loki/local-config.yaml

А в prompts/code-review.md добавил инструкцию:

md
<!-- .agents/prompts/code-review.md -->
Ты — строгий, но справедливый ревьюер. Не пиши водянистых фраз.
Если находишь проблему — сразу указывай строку и предложение исправления.
Если всё чисто — скажи кратко: «Одобрено».

Когда агенты стали понятны по назначению и не пересекались — работа стала предсказуемой. Как в моей сети: каждый кабель на своём месте, и никто не путает eth0 с eth1.

Что не так с традиционными подходами к обучению

Почему курсы не заменят практику с .agents

Скажу прямо: большинство онлайн-курсов по DevOps и инфраструктуре — это как инструкция к IKEA, где все выглядит по-красивому, но в реальности ты сам разбираешься с багами, которые никто не описывал. Я сам проходил курсы по Docker и Kubernetes в 2015-м — теорию усвоил за выходные, а на продакшене сражался с overlay-сетями и DNS-проблемами ещё три месяца.

Вот что обычно предлагают курсы:

bash
# «Курс по Docker» — типичный пример
docker run -d --name webapp nginx

А в реальности вы сталкиваетесь с тем, что:

bash
# Реальная жизнь — ваш контейнер падает через 3 часа
docker inspect webapp
docker logs webapp
# Оказывается, проблема в том, что nginx не может писать в /var/log
# потому что в продакшене volume монтируется с опцией ro

Курсы не покрывают такие сценарии, потому что они не могут учитывать каждую специфику вашей инфраструктуры. Они дают «рабочее» решение, которое ломается в реальном мире.

Каталог .agents подходит иначе. Вместо того чтобы давать готовый рецепт, он показывает, как люди решают реальные проблемы. Например, вместо «как запустить PostgreSQL в Docker», вы видите, как кто-то настраивает репликацию с учётом ограничений своего облака, или как обходит проблему с правами доступа в Kubernetes-подах.

Это как разница между тем, чтобы научить кого-то менять колесо по инструкции, и тем, чтобы показать, как опытный механик диагностирует прокол на ходу — понимаешь не только «что делать», а и «почему так происходит».

Как .agents помогает не просто копировать, а понимать

Когда я впервые увидел .agents, подумал: «Ну ещё один каталог конфигов». Но почитал — и понял, что это не про копирование, а про понимание принципов.

Вот типичный пример из каталога. Вместо того чтобы просто дать docker-compose.yml, автор объясняет, почему выбрал именно такую архитектуру:

yaml
# docker-compose.yml — упрощённый пример из .agents
version: '3.8'
services:
  app:
    image: node:18-alpine
    volumes:
      - ./app:/app
      - /app/node_modules
    environment:
      - NODE_ENV=production
    restart: unless-stopped
    networks:
      - backend
    
  db:
    image: postgres:15-alpine
    volumes:
      - db_data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    environment:
      POSTGRES_DB: ${DB_NAME}
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    restart: unless-stopped
    networks:
      - backend

volumes:
  db_data:

networks:
  backend:
    driver: bridge

Но в комментариях к этому файлу автор пишет, что выбор node:18-alpine связан с размером образа — в продакшене это критично для времени деплоя. А restart: unless-stopped — не просто «чтобы не падало», а стратегия обеспечения доступности при перезагрузке хоста.

Вот это и есть суть .agents. Вы не просто копируете конфиг — вы видите, зачем каждая строка. Это как если бы в учебнике к IKEA не просто давали инструкцию, а объясняли, почему деталь №4 именно в этот уголок, а не в другой.

С практической точки зрения, это меняет подход к обучению. Вместо того чтобы запоминать «как сделать», вы учитесь задавать правильные вопросы: «Почему именно так?», «Что будет, если изменить этот параметр?», «Как это поведёт себя в продакшене?»

Именно поэтому я рекомендую .agents тем, кто хочет не просто «научиться», а научиться правильно.

Часто задаваемые вопросы

Как добавить свою карточку в .agents-каталог?

Склонируйте репозиторий, создайте файл по пути .agents/<stack>/<skill>.md и заполните шаблон YAML, указав название, уровень, годы опыта и список проектов с краткими описаниями и ссылками на репозитории. После этого сделайте pull‑request; модератор проверит, что описание содержит конкретные достижения, а не общие фразы вроде «знаю HTML». Если всё в порядке, PR будет merged и ваша карточка появится в каталоге.

Требуется ли подтверждение навыков от третьих лиц или достаточно самооценки?

В .agents акцент сделан на demonstrable experience, поэтому достаточно собственного описания конкретных задач и результатов, которые вы можете показать в открытых репозиториях или документировать в коммитах. Модерация не требует сертификатов или рекомендаций, но отсекает записи, где нет никаких доказательств (например, только «умею пользоваться Git»). Чем более детально вы опишете, что именно делали и какой эффект получили, тем выше шанс, что карточка пройдёт проверку.

Как работодатели могут использовать .agents при найме?

Работодатель может искать в каталоге нужные технологии и сразу видеть уровень и реальные проекты кандидата, минуя этап анкетирования о дипломах. Это позволяет быстро составить shortlist на основе demonstrable skill set, а затем в интервью сосредоточиться на глубине понимания и подходе к решению задач. Всё это сокращает время на первичный скрининг и повышает шансы найти человека, который уже решал аналогичные проблемы в проде.

Есть ли ограничения по уровням (beginner, intermediate, expert) и как их определять?

Уровни задаются самим автором карточки, но они должны соответствовать фактическому опыту: beginner — до года практической работы с технологией, intermediate — от года до трёх лет с участием в продакшн‑проектах, expert — три и более лет, включая архитектурные решения, оптимизацию и менторство. Если уровень явно завышен без соответствующих проектов в списке, модератор может попросить уточнить или понизить оценку. Цель — сохранить полезность каталога для тех, кто ищет реальную компетенцию.

Поделиться:TelegramX / TwitterVK