Проектирование API и интерфейсов

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

РазработкаПак: Agent Skills (Addy Osmani)369 строкapi-and-interface-design
Автор
Источник
addyosmani/agent-skills/skills/api-and-interface-design @ 8c99fa3
Лицензия
MIT · Copyright (c) 2025 Addy Osmani

Об этом скилле

Что делает

Скилл ведёт агента через проектирование интерфейса до того, как за ним появится код: REST- или GraphQL-API, граница модуля, контракт типов между фронтендом и бэкендом, пропсы компонента. Отправная точка — закон Хайрама: всё наблюдаемое поведение, включая текст ошибок и порядок элементов, становится тем, на что опираются клиенты. Вторая — правило одной версии: интерфейс расширяют, а не держат две версии параллельно.

Дальше правила: сначала контракт в виде типизированного интерфейса; одна форма ошибки и закреплённый смысл каждого кода ответа; проверка данных на границах системы, в том числе ответов сторонних API, а внутреннему коду после этого можно доверять; новые поля — необязательные, старые не трогать; пагинация у каждого списка; PATCH для частичного обновления; размеченные объединения, раздельные типы входа и выхода и «брендированные» ID в TypeScript.

Самый длинный раздел — о том, как честно обработать Idempotency-Key: ключ выводится из намерения, а не из попытки; занимается вставкой под уникальным ограничением, а не по схеме «проверил, потом сделал»; повтор ключа с другим телом запроса отклоняется; что получит дубль, пока первый запрос ещё идёт, решают осознанно (409, ожидание с лимитом или 202); ключи живут дольше самого длинного пути повтора, включая переигровку очереди недоставленных сообщений.

В папке только SKILL.md и лицензия.

Когда включать и когда не надо

Для новых эндпоинтов, контрактов между модулями или командами и любой правки интерфейса, который уже кто-то вызывает. Больше всего пользы на эндпоинтах, меняющих состояние, которые клиенты повторяют, — например, платёжных.

Тестов и документации API скилл не пишет. Все примеры — TypeScript и REST; GraphQL упомянут, но своих примеров не получил.

Как поставить и вызвать

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

  • Claude Code: /api-and-interface-design или попросить скилл по имени.
  • Codex: $api-and-interface-design.
  • Cursor: наберите / в чате Agent и выберите api-and-interface-design.

Пример: /api-and-interface-design Спроектируй эндпоинты возвратов; клиенты повторяют запрос по таймауту.

Чтобы убрать то, на что опираются клиенты, скилл отсылает к Выводу из эксплуатации и миграциям — поставьте его рядом.

Чем отличается от похожих

Контрактные тесты API из нашего каталога закрепляют обещание уже существующего HTTP API; этот скилл формулирует такое обещание до того, как написан код. Документация HTTP API описывает обработчики такими, какие они есть. Проектирование глубоких модулей Мэтта Покока тоже про интерфейсы, но в терминах глубины и швов, без соглашений HTTP; этот скилл прикладной, вплоть до кодов ответа и ключей идемпотентности. Скилл Паттерны композиции в React углубляется в один вид интерфейса — пропсы React-компонентов: составные компоненты и явные варианты вместо булевых флагов. Создание MCP-сервера применяет похожие правила — единые имена, пагинацию, ошибки с подсказкой, что делать дальше, — к инструментам, которые вызывает агент, и собирает сервер целиком.

Установка

Выполните одну команду — она сохранит SKILL.md и файлы, которые он использует, в папку скиллов агента. Claude Code и Codex подхватывают новый скилл без перезапуска; если скилл не появился, перезапустите агента.

Скилл написан на английском — агент поймёт его и ответит вам по-русски.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/api-and-interface-design/SKILL.md https://anymodel.org/en/skills/addy-osmani/api-and-interface-design/SKILL.md -o ~/.claude/skills/api-and-interface-design/LICENSE https://anymodel.org/en/skills/addy-osmani/api-and-interface-design/LICENSE
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/api-and-interface-design/SKILL.md https://anymodel.org/en/skills/addy-osmani/api-and-interface-design/SKILL.md -o ~/.agents/skills/api-and-interface-design/LICENSE https://anymodel.org/en/skills/addy-osmani/api-and-interface-design/LICENSE
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE') { $p = Join-Path "$HOME\.claude\skills\api-and-interface-design" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/addy-osmani/api-and-interface-design/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE') { $p = Join-Path "$HOME\.agents\skills\api-and-interface-design" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/addy-osmani/api-and-interface-design/$f" -UseBasicParsing -OutFile $p }

Другой агент: сохраните файл в его папку скиллов или дайте ему ссылку на файл: https://anymodel.org/en/skills/addy-osmani/api-and-interface-design/SKILL.md

SKILL.md

Исходник

API and Interface Design

Overview

Design stable, well-documented interfaces that are hard to misuse. Good interfaces make the right thing easy and the wrong thing hard. This applies to REST APIs, GraphQL schemas, module boundaries, component props, and any surface where one piece of code talks to another.

When to Use

  • Designing new API endpoints
  • Defining module boundaries or contracts between teams
  • Creating component prop interfaces
  • Establishing database schema that informs API shape
  • Changing existing public interfaces

Core Principles

Hyrum's Law

With a sufficient number of users of an API, all observable behaviors of your system will be depended on by somebody, regardless of what you promise in the contract.

This means: every public behavior — including undocumented quirks, error message text, timing, and ordering — becomes a de facto contract once users depend on it. Design implications:

  • Be intentional about what you expose. Every observable behavior is a potential commitment.
  • Don't leak implementation details. If users can observe it, they will depend on it.
  • Plan for deprecation at design time. See deprecation-and-migration for how to safely remove things users depend on.
  • Tests are not enough. Even with perfect contract tests, Hyrum's Law means "safe" changes can break real users who depend on undocumented behavior.

The One-Version Rule

Avoid forcing consumers to choose between multiple versions of the same dependency or API. Diamond dependency problems arise when different consumers need different versions of the same thing. Design for a world where only one version exists at a time — extend rather than fork.

1. Contract First

Define the interface before implementing it. The contract is the spec — implementation follows.

// Define the contract first
interface TaskAPI {
  // Creates a task and returns the created task with server-generated fields
  createTask(input: CreateTaskInput): Promise<Task>;

  // Returns paginated tasks matching filters
  listTasks(params: ListTasksParams): Promise<PaginatedResult<Task>>;

  // Returns a single task or throws NotFoundError
  getTask(id: string): Promise<Task>;

  // Partial update — only provided fields change
  updateTask(id: string, input: UpdateTaskInput): Promise<Task>;

  // Idempotent delete — succeeds even if already deleted
  deleteTask(id: string): Promise<void>;
}

2. Consistent Error Semantics

Pick one error strategy and use it everywhere:

// REST: HTTP status codes + structured error body
// Every error response follows the same shape
interface APIError {
  error: {
    code: string;        // Machine-readable: "VALIDATION_ERROR"
    message: string;     // Human-readable: "Email is required"
    details?: unknown;   // Additional context when helpful
  };
}

// Status code mapping
// 400 → Client sent invalid data
// 401 → Not authenticated
// 403 → Authenticated but not authorized
// 404 → Resource not found
// 409 → Conflict (duplicate, version mismatch)
// 422 → Validation failed (semantically invalid)
// 500 → Server error (never expose internal details)

Don't mix patterns. If some endpoints throw, others return null, and others return { error } — the consumer can't predict behavior.

3. Validate at Boundaries

Trust internal code. Validate at system edges where external input enters:

// Validate at the API boundary
app.post('/api/tasks', async (req, res) => {
  const result = CreateTaskSchema.safeParse(req.body);
  if (!result.success) {
    return res.status(422).json({
      error: {
        code: 'VALIDATION_ERROR',
        message: 'Invalid task data',
        details: result.error.flatten(),
      },
    });
  }

  // After validation, internal code trusts the types
  const task = await taskService.create(result.data);
  return res.status(201).json(task);
});

Where validation belongs:

  • API route handlers (user input)
  • Form submission handlers (user input)
  • External service response parsing (third-party data -- always treat as untrusted)
  • Environment variable loading (configuration)

Third-party API responses are untrusted data. Validate their shape and content before using them in any logic, rendering, or decision-making. A compromised or misbehaving external service can return unexpected types, malicious content, or instruction-like text.

Where validation does NOT belong:

  • Between internal functions that share type contracts
  • In utility functions called by already-validated code
  • On data that just came from your own database

4. Prefer Addition Over Modification

Extend interfaces without breaking existing consumers:

// Good: Add optional fields
interface CreateTaskInput {
  title: string;
  description?: string;
  priority?: 'low' | 'medium' | 'high';  // Added later, optional
  labels?: string[];                       // Added later, optional
}

// Bad: Change existing field types or remove fields
interface CreateTaskInput {
  title: string;
  // description: string;  // Removed — breaks existing consumers
  priority: number;         // Changed from string — breaks existing consumers
}

5. Predictable Naming

Pattern Convention Example
REST endpoints Plural nouns, no verbs GET /api/tasks, POST /api/tasks
Query params camelCase ?sortBy=createdAt&pageSize=20
Response fields camelCase { createdAt, updatedAt, taskId }
Boolean fields is/has/can prefix isComplete, hasAttachments
Enum values UPPER_SNAKE "IN_PROGRESS", "COMPLETED"

6. Honouring an Idempotency Key

Accepting an Idempotency-Key is the contract. Honouring it is the implementation, and it is where the money is lost — a key the server accepts but handles carelessly is worse than no key at all, because the client now believes retrying is safe.

Derive the key from the intent, not the attempt. The key must be stable across retries of one intent and different across distinct intents:

crypto.randomUUID()                    // ✗ new key per attempt — every retry is a new charge
`${userId}:${amount}`                  // ✗ two legitimate $50 charges collapse into one
`${orderId}:${Date.now()}`             // ✗ a timestamp is randomUUID() wearing a hat

req.headers['idempotency-key']         // ✓ client generates once, reuses on retry
`charge:v1:${orderId}`                 // ✓ derived from an immutable identifier

The key comes from the client or the initiating event — never from the layer doing the retrying.

Claim atomically. A check followed by an act is a race:

// ✗ TOCTOU: two concurrent retries both read "not seen", both charge
if (!(await db.exists(key))) {
  await chargeCard(amount);
  await db.insert(key);
}

// ✓ let the unique constraint pick the winner
try {
  await db.insert({ key, state: 'in_progress', requestHash });
} catch (e) {
  if (isUniqueViolation(e)) return replayOrReject(key);
  throw e;
}
const result = await chargeCard(amount);
await db.update({ key, state: 'succeeded', response: result });

The unique constraint is the mechanism. A store that cannot enforce uniqueness in one operation cannot back this.

Guard the payload. Same key with a different body is a client bug, and must fail loudly rather than serving the first response to a second request:

if (existing.requestHash !== hash(req.body)) {
  return res.status(422).json({
    error: { code: 'IDEMPOTENCY_KEY_REUSED', message: 'Idempotency key reused with a different payload' },
  });
}

Decide what an in-flight duplicate gets. The first request is still running when the second arrives — the common case under retry storms:

Strategy Response Use when
Reject 409 Conflict Client can retry later; simplest and safest
Wait Block for the result, bounded Caller needs it synchronously
Return pending 202 + status URL Long-running effects

Never let the second caller through because the first "seems stuck". A stalled attempt whose fate is unknown is exactly when duplicating costs most.

Every call has three outcomes, not two: success, failure, and unknown. A timeout tells you nothing about whether the effect applied. Record the intent before calling out, so a crash between the call and the response leaves evidence something must resolve later — rather than a silently retried charge.

Set retention from the longest retry chain, not from disk cost. Keys must outlive every path that can re-deliver the same intent, including a dead-letter queue replayed a week later and any provider dispute window. A 24-hour key TTL behind a 7-day DLQ is a duplicate waiting to happen.

REST API Patterns

Resource Design

GET    /api/tasks              → List tasks (with query params for filtering)
POST   /api/tasks              → Create a task
GET    /api/tasks/:id          → Get a single task
PATCH  /api/tasks/:id          → Update a task (partial)
DELETE /api/tasks/:id          → Delete a task

GET    /api/tasks/:id/comments → List comments for a task (sub-resource)
POST   /api/tasks/:id/comments → Add a comment to a task

Pagination

Paginate list endpoints:

// Request
GET /api/tasks?page=1&pageSize=20&sortBy=createdAt&sortOrder=desc

// Response
{
  "data": [...],
  "pagination": {
    "page": 1,
    "pageSize": 20,
    "totalItems": 142,
    "totalPages": 8
  }
}

Filtering

Use query parameters for filters:

GET /api/tasks?status=in_progress&assignee=user123&createdAfter=2025-01-01

Partial Updates (PATCH)

Accept partial objects — only update what's provided:

// Only title changes, everything else preserved
PATCH /api/tasks/123
{ "title": "Updated title" }

TypeScript Interface Patterns

Use Discriminated Unions for Variants

// Good: Each variant is explicit
type TaskStatus =
  | { type: 'pending' }
  | { type: 'in_progress'; assignee: string; startedAt: Date }
  | { type: 'completed'; completedAt: Date; completedBy: string }
  | { type: 'cancelled'; reason: string; cancelledAt: Date };

// Consumer gets type narrowing
function getStatusLabel(status: TaskStatus): string {
  switch (status.type) {
    case 'pending': return 'Pending';
    case 'in_progress': return `In progress (${status.assignee})`;
    case 'completed': return `Done on ${status.completedAt}`;
    case 'cancelled': return `Cancelled: ${status.reason}`;
  }
}

Input/Output Separation

// Input: what the caller provides
interface CreateTaskInput {
  title: string;
  description?: string;
}

// Output: what the system returns (includes server-generated fields)
interface Task {
  id: string;
  title: string;
  description: string | null;
  createdAt: Date;
  updatedAt: Date;
  createdBy: string;
}

Use Branded Types for IDs

type TaskId = string & { readonly __brand: 'TaskId' };
type UserId = string & { readonly __brand: 'UserId' };

// Prevents accidentally passing a UserId where a TaskId is expected
function getTask(id: TaskId): Promise<Task> { ... }

Common Rationalizations

Rationalization Reality
"We'll document the API later" The types ARE the documentation. Define them first.
"We don't need pagination for now" You will the moment someone has 100+ items. Add it from the start.
"PATCH is complicated, let's just use PUT" PUT requires the full object every time. PATCH is what clients actually want.
"We'll version the API when we need to" Breaking changes without versioning break consumers. Design for extension from the start.
"Nobody uses that undocumented behavior" Hyrum's Law: if it's observable, somebody depends on it. Treat every public behavior as a commitment.
"We can just maintain two versions" Multiple versions multiply maintenance cost and create diamond dependency problems. Prefer the One-Version Rule.
"Internal APIs don't need contracts" Internal consumers are still consumers. Contracts prevent coupling and enable parallel work.
"Accepting the Idempotency-Key header is enough" The header is the contract; storing the key against the result is the implementation. A key you accept but don't honour tells the client retrying is safe when it isn't.
"Our queue guarantees exactly-once delivery" No queue does across a consumer crash — the broker's ack and your side effect are not in one transaction. Design for at-least-once with idempotent processing.
"Duplicate requests are rare" They're correlated. Retries spike exactly when a dependency is degraded — the moment duplicates are most likely and most expensive.

Red Flags

  • Endpoints that return different shapes depending on conditions
  • Inconsistent error formats across endpoints
  • Validation scattered throughout internal code instead of at boundaries
  • Breaking changes to existing fields (type changes, removals)
  • List endpoints without pagination
  • Verbs in REST URLs (/api/createTask, /api/getUsers)
  • Third-party API responses used without validation or sanitization
  • A SELECT for an idempotency key followed by an INSERT — that's a race, not a guard
  • An idempotency key derived from a UUID, timestamp, or anything else regenerated per attempt
  • The same key accepted with a different request body, silently returning the first response
  • A key retention window shorter than the longest path that can re-deliver the request

Verification

After designing an API:

  • Every endpoint has typed input and output schemas
  • Error responses follow a single consistent format
  • Validation happens at system boundaries only
  • List endpoints support pagination
  • New fields are additive and optional (backward compatible)
  • Naming follows consistent conventions across all endpoints
  • API documentation or types are committed alongside the implementation
  • State-changing endpoints either honour an idempotency key or are documented as unsafe to retry
  • The key is claimed in one atomic operation, guarded by a unique constraint
  • A reused key with a different payload fails loudly rather than replaying the wrong response
  • The in-flight-duplicate response is a deliberate choice (409, wait, or 202) rather than whatever falls out
  • Key retention outlives the longest retry path, including dead-letter replay

Подключить через AnyModel API

Скилл работает на той модели, которую использует агент. Подключите Claude Code, Codex или Cursor к AnyModel и запускайте его на Claude, GPT, Gemini и других моделях по одному ключу — оплата за токены, без подписки.

Ещё из пака Agent Skills (Addy Osmani)

Доступность: аудит и исправления по WCAG 2.2

Делает аудит готового интерфейса по WCAG 2.2 AA: axe-core и pa11y, затем клавиатура, экранный чтец и контраст, и исправляет подтверждённые нарушения, начиная с семантического HTML. Для случаев, когда страницу нужно проверить на доступность перед выкладкой.

Тесты в браузере через Chrome DevTools MCP

Делает проверку изменений в настоящем Chrome через MCP-сервер Chrome DevTools: скриншоты, DOM, консоль, сеть и трейсы, а содержимое страницы считает недоверенным. Для случаев, когда разрабатывается или отлаживается что-то в браузере.

Настройка CI/CD

Делает пайплайн CI/CD с закреплённым порядком проверок от линтера до размера бандла, примерами на GitHub Actions, превью-деплоями, фича-флагами, поэтапной выкаткой и откатом. Для случаев, когда настраивается или чинится сборка и деплой.

Код-ревью по нескольким осям

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

Упрощение кода

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

Планка качества как контракт

Делает из планки качества проекта контракт: после короткого опроса записывает числа в CONSTRAINTS.md, привязывает их к инструментам и ловит в диффе пропущенные тесты и ослабленные пороги. Для случаев, когда планка нигде не записана.

Настройка контекста агента

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

Отладка и восстановление после ошибок

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

Вывод из эксплуатации и миграции

Выводит из эксплуатации старые системы, API и фичи: решает, стоит ли, проверяет замену, переводит потребителей по одному, удаляет код при нулевом использовании, схему меняет через expand/contract. Для случаев, когда старое заменяют или переименовывают колонку.

Документация и ADR

Записывает решения в ADR по формату проекта, документирует API, README и changelog с упором на «почему», по истории git проверяет, не устарел ли документ. Для случаев, когда принято дорогое решение, меняется публичный API или документы разошлись с кодом.

Разработка через сомнение

Отдаёт нетривиальные решения субагенту со свежим контекстом, чтобы тот искал ошибки, сортирует находки, ограничивает цикл тремя кругами и предлагает мнение другой модели. Для случаев, когда ставки высоки: авторизация, миграции, необратимые операции.

Фронтенд-интерфейсы для продакшена

Строит компоненты и страницы на дизайн-системе проекта: композиция, простое состояние, WCAG 2.1 AA, mobile-first, состояния загрузки, пустого списка и ошибки, без ИИ-эстетики. Для случаев, когда создают или меняют пользовательский интерфейс.

Git-процесс и версионирование

Ведёт работу в git атомарными коммитами в коротких ветках: сообщения с типом, проверка секретов и тестов перед коммитом, worktree для параллельных агентов, semver, теги и changelog. Для случаев, когда коммитят, ветвятся, открывают PR или выпускают релиз.

Доработка сырой идеи

Доводит сырую идею за три фазы: уточняющие вопросы и пять-восемь вариантов, два-три направления с проверкой ценности, реализуемости и допущений, затем одностраничник с MVP и списком «Чего не делаем». Для случаев, когда идея расплывчата или план надо проверить.

Реализация тонкими срезами

Строит изменения тонкими срезами — вертикально, от контракта или от риска, — тестируя и коммитя каждый перед следующим, в рамках задачи, с feature-флагами и откатываемыми шагами. Для случаев, когда правка затрагивает несколько файлов или задача велика.

Интервью о задаче

Расспрашивает по одному вопросу с догадкой об ответе и оценкой уверенности, пока агент не сможет предсказать ответы, и до спецификации и кода получает подтверждённое намерение. Для случаев, когда в запросе неясно, для кого, зачем и что считать успехом.

Наблюдаемость: логи, метрики, трейсы

Встраивает в фичу JSON-логи с ID запроса, метрики RED и USE с ограниченными метками, трейсы OpenTelemetry и алерты по симптомам с ранбуками, а затем проверяет саму телеметрию. Для случаев, когда фича, фоновая задача или интеграция идёт в прод.

Оптимизация производительности

Ускоряет приложение по замерам: снимает базу, исправляет одно доказанное узкое место, перемеряет с учётом разброса и откатывает нейтральные правки; есть примеры для N+1, индексов, кэша и бандла. Для случаев, когда что-то тормозит или не влезает в бюджет.

Разбивка работы на задачи

Разбивает спецификацию на небольшие вертикальные задачи с критериями приёмки, проверками, размером, порядком и контрольными точками — в tasks/todo.md или в трекер. Для случаев, когда спецификация готова, а работа слишком велика для одного захода.

Защита кода от уязвимостей

Защищает код: модель угроз, правила «всегда», «сначала спросить», «никогда» и паттерны против инъекций, XSS, обхода доступа, SSRF, утечки секретов и опасных зависимостей. Для случаев, когда код принимает ввод, ведёт вход, хранит личные данные или зовёт LLM.

Подготовка к запуску в прод

Готовит запуск в прод: чек-лист перед выкаткой, фича-флаг с этапами от 5% до 100%, пороги для продолжения или отката, бюджет ошибок, письменный план отката и проверки в первый час. Для случаев, когда фича или крупное изменение вот-вот уйдёт в прод.

Код по официальной документации

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

Спецификация и PRD до начала работы

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

TDD: красный, зелёный, рефакторинг

Ведёт изменения по циклу «красный, зелёный, рефакторинг»: находит команды тестов проекта, пишет падающий тест первым, воспроизводит каждый баг тестом до исправления и задаёт правила для моков и имён. Для случаев, когда добавляется логика или чинится баг.