Промпт-инжиниринг AI: основные команды и приёмы для разработчиков

Промпт-инжиниринг стал одним из самых критических навыков для разработчиков, использующих AI-инструменты. Используете ли вы ChatGPT, Claude, GitHub Copilot или Cursor, качество промпта напрямую определяет качество вывода AI. Хорошо составленный промпт может превратить расплывчатый, бесполезный ответ в точный, готовый к production код. Это всестороннее руководство охватывает всё: от базовых приёмов промптов до продвинутых стратегий, специфических для каждого инструмента советов и готовых шаблонов, которые помогут получить максимальную ценность от каждого взаимодействия с AI.

Что такое промпт-инжиниринг?

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

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

Небольшие изменения в формулировке промпта дают огромную разницу. Сравните "исправь ошибку" с "исправь исключение нулевой ссылки в методе UserService.authenticate, когда параметр email равен undefined. Метод находится в src/services/UserService.ts и использует bcrypt для сравнения паролей". Первый промпт почти не даёт AI полезной информации. Второй предоставляет чёткое описание проблемы, местоположение и контекст — позволяя AI произвести точное, корректное исправление с первой попытки.

Базовые приёмы промптов

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

Zero-shot промптинг

Zero-shot промптинг — самая простая форма промпта: вы даёте AI прямую инструкцию без каких-либо примеров. AI полностью полагается на свои обучающие данные и информацию в промпте для генерации ответа. Эта техника подходит для простых задач, где желаемый формат вывода очевиден, или когда AI видел много похожих примеров в обучении.

Write a Python function that validates an email address using regex.
The function should return True for valid emails and False for invalid ones.

Zero-shot промптинг эффективен для распространённых, хорошо определённых задач. Однако когда нужен специфический формат вывода, стиль или подход, few-shot промптинг более надёжен.

Few-shot промптинг

Few-shot промптинг включает предоставление одного или нескольких примеров желаемого паттерна ввода-вывода перед постановкой фактической задачи. Эта техника очень мощна, потому что точно демонстрирует, что вы хотите, уменьшая неоднозначность и направляя AI к правильному формату и стилю. AI изучает паттерн из ваших примеров и применяет его к новому вводу.

Convert these database column names to camelCase JavaScript variable names:

user_first_name -> userFirstName
created_at_timestamp -> createdAtTimestamp
is_email_verified -> isEmailVerified
total_order_count ->

Now convert: product_category_id

Few-shot промптинг особенно ценен, когда нужен последовательный формат, специфические соглашения кодирования или когда AI может делать предположения, не соответствующие стилю проекта. Обычно двух-трёх примеров достаточно для установления чёткого паттерна.

Chain-of-thought промптинг

Chain-of-thought промптинг просит AI рассуждать о проблеме пошагово перед выдачей окончательного ответа. Эта техника значительно улучшает точность на сложных задачах, заставляя AI обрабатывать промежуточные шаги, а не перескакивать к потенциально неверным выводам. Исследования показывают, что добавление "think step by step" в промпт может повысить точность на 30-50% в задачах рассуждения.

Analyze this React component for performance issues. Think step by step:

1. First, identify all state variables and their update patterns
2. Then, check for unnecessary re-renders
3. Next, look for missing memoization opportunities
4. Finally, suggest specific optimizations with code examples

Here's the component:
[component code]

Chain-of-thought промптинг необходим для отладки, архитектурных решений и любых задач, требующих логического рассуждения. Требуя от AI показать процесс рассуждения, вы также получаете возможность проверить его логику и обнаружить ошибки в промежуточных шагах.

Ролевой промптинг

Ролевой промптинг назначает AI определённую роль или уровень экспертизы, что влияет на глубину, стиль и фокус ответа. Когда вы говорите AI "действуй как старший DevOps-инженер", он меняет перспективу, предоставляя более ориентированные на эксплуатацию, готовые к production советы, а не общие фрагменты кода. Эта техника использует обучение AI на предметно-специфическом контенте для получения более экспертного вывода.

Act as a senior security engineer with 15 years of experience in web application security. Review this authentication implementation and identify any vulnerabilities, ranking them by severity. For each vulnerability, explain the attack vector and provide a secure code fix.

Ключ к эффективному ролевому промптингу — конкретность. "Действуй как Python-разработчик" слишком расплывчато. "Действуй как Python-разработчик, специализирующийся на создании высокопроизводительных пайплайнов данных с использованием Apache Airflow и pandas" даёт AI гораздо более чёткую систему отсчёта.

Системные и пользовательские промпты

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

CLAUDE.md действует как постоянный системный промпт. В ChatGPT можно установить пользовательские инструкции как системные промпты для всех разговоров.

# System prompt example
You are a TypeScript expert working on a Next.js 14 project using:
- App Router (not Pages Router)
- Server Components by default
- Prisma for database access
- Tailwind CSS for styling
- Zod for validation

Always use strict TypeScript. Prefer server actions over API routes.
Never use 'any' type. Use 'unknown' and narrow with type guards.

# User prompt example
Add a user profile page that shows the current user's name, email,
avatar, and last 10 activity records. Include loading states and
error handling.

Основные AI-команды для разработчиков

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

"Act as..." / "You are a..." — назначение роли

Назначение роли — одна из самых мощных команд в промпт-инжиниринге. Указывая роль, вы активируете предметно-специфические знания и устанавливаете ожидания относительно глубины и стиля ответа. Чем конкретнее роль, тем лучше вывод.

You are a senior backend engineer at a fintech company who specializes
in building secure, high-throughput payment processing systems.
You have deep expertise in PostgreSQL, Redis, and distributed systems.
You always consider edge cases, race conditions, and failure modes.

Design a payment processing API that handles:
- Credit card payments via Stripe
- Bank transfers via Plaid
- Retry logic with exponential backoff
- Idempotency keys to prevent duplicate charges

"Step by step" — цепочка рассуждений

Добавление "step by step" или "let's think step by step" в промпт запускает AI на разложение процесса рассуждения. Это особенно эффективно для отладки, проектирования алгоритмов и архитектурных решений. Пошаговый подход не только даёт лучшие результаты, но и делает рассуждения AI прозрачными, позволяя выявлять логические ошибки.

Debug this SQL query that's causing a timeout. Think step by step:

1. First, analyze the query structure and joins
2. Identify potential performance bottlenecks
3. Check for missing indexes
4. Suggest an optimized version with EXPLAIN analysis

SELECT u.name, COUNT(o.id), SUM(o.amount)
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
LEFT JOIN order_items oi ON o.id = oi.order_id
WHERE o.created_at > '2026-01-01'
GROUP BY u.name
HAVING COUNT(o.id) > 10
ORDER BY SUM(o.amount) DESC;

"Think aloud" — прозрачность рассуждений

"Think aloud" похоже на "step by step", но больше фокусируется на процессе принятия решений AI. Оно просит AI рассказать о своих рассуждениях, включая рассмотренные альтернативы и почему был выбран конкретный подход. Это ценно, когда нужно понять компромиссы в дизайнерских решениях или оценить, обоснованы ли рассуждения AI.

I need to choose between WebSocket and Server-Sent Events for a
real-time notification system. Think aloud about the trade-offs,
considering: browser support, bidirectional communication needs,
server resource usage, and scalability. Then recommend one with
justification.

"Explain like I'm 5" — упрощённое объяснение

При изучении новых концепций или попытке понять сложный код "explain like I'm 5" (ELI5) убирает жаргон и предоставляет интуитивные объяснения на основе аналогий. Это особенно полезно при входе в новые проекты, понимании незнакомых кодовых баз или объяснении технических концепций нетехническим заинтересованным сторонам.

Explain like I'm 5: What is a monad in functional programming,
and why do Haskell developers keep talking about them?
Use a real-world analogy, not code.

"Review and critique" — код-ревью

Использование "review and critique" сигнализирует AI занять критическую позицию, а не просто принимать код. Это даёт более тщательный анализ, включая потенциальные ошибки, проблемы безопасности, проблемы производительности и нарушения стиля. Это как получить код-ревью от старшего инженера по требованию.

Review and critique this Express.js middleware. Focus on:
- Security vulnerabilities
- Error handling gaps
- Performance concerns
- Best practice violations
- Suggest improvements with code examples

[paste your middleware code]

"Write tests for" — генерация тестов

Генерация тестов — одно из самых ценных применений AI-инструментов. Указав "write tests for" вместе с фреймворком тестирования и ожиданиями по покрытию, можно быстро сгенерировать всесторонние наборы тестов. Ключ в указании граничных случаев и приоритетов тестирования.

Write tests for the UserService.register method using Jest.
Cover these scenarios:
- Happy path with valid input
- Duplicate email registration
- Invalid email format
- Password too short
- Missing required fields
- Database connection failure
- Concurrent registration attempts

Use describe/it blocks. Include setup and teardown.
Mock the database layer.

"Refactor using..." — рефакторинг на основе паттернов

Указание паттерна проектирования или принципа в промпте рефакторинга даёт AI чёткую целевую архитектуру. Вместо расплывчатого запроса "отрефактори это", именование паттерна даёт сфокусированный, последовательный рефакторинг, следующий установленным принципам программной инженерии.

Refactor this notification system using the Strategy pattern.
Currently, all notification types (email, SMS, push) are handled
in a single class with if-else chains. Create separate strategy
classes for each notification type, a context class that delegates
to the active strategy, and a factory for creating strategies.

[paste your current code]

"Find bugs in" — отладка

Команда "Find bugs in" активирует аналитический режим AI, побуждая искать проблемы, а не генерировать код. Работает лучше всего, когда предоставляется код, описывается ожидаемое поведение и упоминаются наблюдаемые симптомы.

Find bugs in this async Node.js function. It's supposed to process
a batch of orders and update their status, but sometimes orders
get processed twice and the status updates are inconsistent under
high load.

[paste your function code]

"Add error handling" — повышение надёжности

Многие фрагменты кода, сгенерированные AI, работают на нормальном пути, но не имеют правильной обработки ошибок. Команда "Add error handling" специально нацелена на этот пробел, прося AI рассмотреть режимы сбоев, граничные случаи и стратегии восстановления.

Add error handling to this file upload function. Consider:
- File size limits
- Invalid file types
- Network interruptions during upload
- Disk space errors
- Concurrent upload conflicts
- Partial upload cleanup

Use try-catch with specific error types. Add retry logic for
transient failures. Return meaningful error messages to the client.

Паттерны промптов для генерации кода

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

Промпт реализации функции

При реализации новых функций наиболее эффективные промпты следуют структуре, похожей на спецификацию: описание функции, указание технологического стека, определение критериев приёмки и упоминание любых ограничений. Это даёт AI полную картину того, что нужно построить.

Implement a user avatar upload feature for a Next.js 14 application.

Tech stack: Next.js App Router, TypeScript, Prisma, PostgreSQL, AWS S3

Requirements:
- Accept JPEG, PNG, WebP (max 5MB)
- Resize to 200x200 and 400x400 thumbnails using Sharp
- Upload originals to S3 with unique keys
- Store S3 URLs in the User model
- Delete old avatar when uploading a new one
- Return presigned URLs for frontend display

Acceptance criteria:
- Invalid file types return 400 with error message
- Files over 5MB return 413
- Successful upload returns 200 with avatar URLs
- Old avatars are cleaned up from S3

Create: API route, service layer, Prisma schema update, and types.

Промпт дизайна API

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

Design a RESTful API for a project management application.

Architecture: Express.js with TypeScript, following clean architecture
Auth: JWT with refresh token rotation
Versioning: URL-based (/api/v1/)
Response format: { success: boolean, data?: T, error?: { code, message } }

Endpoints needed:
- Projects CRUD with team membership
- Tasks CRUD with assignee, priority, status
- Comments on tasks with mentions
- Activity feed (recent actions across projects)

Include:
- Request/response TypeScript interfaces
- Zod validation schemas
- Error handling middleware
- Pagination for list endpoints (cursor-based)

Промпт схемы базы данных

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

Design a Prisma schema for an e-commerce platform with these entities:

- Users (authentication, profile, addresses)
- Products (variants, categories, inventory)
- Orders (line items, status history, payments)
- Reviews (ratings, images, helpful votes)
- Cart (items, applied coupons)

Requirements:
- Use PostgreSQL with UUID primary keys
- Soft deletes with deletedAt timestamps
- Proper indexes for common query patterns
- Enums for order status, payment status
- Decimal fields for prices (not float)
- Full-text search on product name and description
- Include a migration file

Промпт UI-компонента

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

Create a reusable DataTable component in React with TypeScript.

Styling: Tailwind CSS + shadcn/ui conventions
Features:
- Column definitions with sort, filter, and custom renderers
- Server-side pagination with page size selector
- Row selection (single and multi) with checkboxes
- Loading skeleton state
- Empty state with custom message
- Responsive: card layout on mobile, table on desktop

Accessibility:
- Keyboard navigation (arrow keys, Enter, Escape)
- Screen reader announcements for sort and filter changes
- ARIA labels on all interactive elements

Props interface:
- data, columns, isLoading, pagination, onSort, onFilter, onSelect

Include a usage example with a user list table.

Промпт конфигурации и DevOps

Промпты DevOps и конфигурации должны указывать целевую среду, требования безопасности и любые организационные стандарты. Это предотвращает генерацию AI общих конфигураций, не соответствующих инфраструктуре.

Create a Docker Compose setup for a development environment with:
- Next.js app (hot reload enabled)
- PostgreSQL 16 with persistent volume
- Redis for session storage
- MinIO (S3-compatible) for local file storage

Requirements:
- All services on a shared network
- Environment variables from .env file
- Health checks for all services
- Volumes for node_modules (avoid bind mount issues)
- PostgreSQL initialized with seed data
- Non-root containers where possible

Also create:
- Dockerfile for the Next.js app (multi-stage build)
- .env.example with all required variables
- Makefile with common commands (up, down, logs, reset-db)

Продвинутые стратегии промптов

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

Цепочка промптов

Цепочка промптов разбивает сложные задачи на серию более мелких, сфокусированных промптов, каждый из которых строится на выводе предыдущего. Эта стратегия даёт лучшие результаты, чем попытка сделать всё в одном массивном промпте, потому что каждый шаг получает полное внимание и контекст AI.

# Step 1: Design the architecture
"Design the architecture for a real-time chat application.
List the components, their responsibilities, and how they
communicate. Use a diagram-like text format."

# Step 2: Define the data model
"Based on the architecture above, design the database schema
for the chat application. Include users, conversations,
messages, and read receipts. Use Prisma schema format."

# Step 3: Implement the API
"Implement the REST API for the chat application based on
the architecture and schema we designed. Start with the
message endpoints: send, list, delete."

# Step 4: Add WebSocket support
"Now add WebSocket support for real-time message delivery.
Use Socket.io. Integrate with the existing message API."

# Step 5: Write tests
"Write integration tests for the chat API and WebSocket
events using Jest and Supertest."

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

Заполнение контекста

Заполнение контекста включает предоставление AI всего соответствующего кода, документации и контекста перед заданием вопроса. Хотя это кажется очевидным, многие разработчики пропускают этот шаг и удивляются, почему AI делает неправильные предположения. Чем больше релевантного контекста предоставлено, тем точнее и конкретнее будет ответ AI.

 {
    await this.db.query('UPDATE users SET email = $1 WHERE id = $2', [email, id]);
    await this.cache.del(`user:${id}`);
  }
}
```

Here is the User type:
```typescript
interface User {
  id: string;
  email: string;
  name: string;
  role: 'admin' | 'user';
  createdAt: Date;
}
```

Now, add an updateProfile method that allows updating name and email,
with validation that the email is not already taken by another user.

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

Спецификация ограничений

Установка явных ограничений предотвращает нежелательные предположения AI. Ограничения определяют, что AI не должен делать, что часто так же важно, как и то, что он должен делать. Распространённые ограничения включают версии технологий, требования производительности, правила безопасности и стандарты кодирования.

Build a URL shortener API with these constraints:

MUST:
- Use Node.js 20+ with native fetch (no axios)
- Use PostgreSQL via pg driver (no ORM)
- Generate short codes of exactly 7 characters
- Support custom aliases (max 20 chars)
- Return 301 for existing short URLs
- Rate limit to 100 creates per hour per IP

MUST NOT:
- Use any ORM or query builder
- Store full URLs without normalization
- Allow short codes that conflict with existing routes
- Return database errors to the client

PERFORMANCE:
- Handle 10,000 requests per second
- Cache hot URLs in Redis with 5-minute TTL
- P99 latency under 50ms for redirects

Контроль формата вывода

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

Analyze this codebase and provide the output in this exact format:

## Architecture Overview
[2-3 paragraph summary]

## Component Diagram
```mermaid
graph TD
    [components and relationships]
```

## API Endpoints
| Method | Path | Description | Auth |
|--------|------|-------------|------|

## Database Tables
| Table | Columns | Indexes | Relations |
|-------|---------|---------|-----------|

## Recommendations
1. [Priority] [Description] - [Estimated effort]
2. ...

## Technical Debt
- [ ] [Description] - [Impact: High/Medium/Low]

Итеративное уточнение

Итеративное уточнение — это практика постепенного улучшения вывода AI через последующие промпты. Первый ответ редко идеален, но он предоставляет отправную точку для уточнения. Каждая итерация приближает к желаемому результату эффективнее, чем попытка достичь совершенства в одном промпте.

# Iteration 1: Get a starting point
"Write a rate limiter middleware for Express.js"

# Iteration 2: Add specificity
"Good start. Now modify it to use Redis for distributed
rate limiting across multiple server instances. Use sliding
window instead of fixed window."

# Iteration 3: Add edge cases
"Add handling for: Redis connection failures (fall back to
in-memory), custom rate limits per route, burst allowance
for legitimate traffic spikes, and proper headers
(X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset)."

# Iteration 4: Add tests
"Write comprehensive tests for all the scenarios we've
covered, including Redis failures and burst handling."

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

Специфические приёмы для разных инструментов

Хотя вышеуказанные техники применимы ко всем AI-инструментам, каждая платформа имеет уникальные сильные стороны и особенности. Адаптация стиля промптов к характеристикам каждого инструмента может значительно улучшить результаты.

ChatGPT / GPT-4

ChatGPT и GPT-4 превосходны в диалоговом взаимодействии и выигрывают от структурированных, хорошо организованных промптов. Они хорошо обрабатывают длинный контекст и особенно хороши в объяснении концепций и генерации документации.

• Используйте пользовательские инструкции: установите технологический стек и предпочтения в пользовательских инструкциях ChatGPT, чтобы не повторять в каждом разговоре.
• Используйте Code Interpreter: для задач анализа данных просите ChatGPT использовать Code Interpreter для запуска Python-кода и генерации визуализаций.
• Используйте формат Markdown в промптах: GPT-4 хорошо реагирует на структурированные промпты с заголовками, маркированными списками и блоками кода.
• Указывайте длину ответа: GPT-4 склонен к многословию. Когда нужна краткость, добавляйте "be concise" или "in under 200 words".
• Используйте системные сообщения: в API используйте системные сообщения для установки постоянных инструкций, таких как стандарты кодирования и контекст проекта.

# Effective GPT-4 prompt structure
**Role:** Senior TypeScript developer
**Task:** Implement a JWT authentication middleware
**Context:** Express.js API, PostgreSQL, existing User model
**Constraints:** No external auth libraries, use crypto module
**Output:** Complete, production-ready code with types
**Format:** Single file with inline comments for complex logic

Claude / Claude Code

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

• Используйте CLAUDE.md: это самое эффективное, что можно сделать. Поместите контекст проекта, соглашения и предпочтения в CLAUDE.md.
• Явно указывайте расположение файлов: Claude Code работает лучше всего, когда указаны файлы для чтения и изменения.
• Позволяйте запускать команды: Claude Code может выполнять тесты и команды сборки. Просите его проверять работу, запуская тесты.
• Используйте /compact в длинных сессиях: когда контекст становится длинным, используйте /compact для сжатия диалога с сохранением важной информации.
• Используйте XML-теги: Claude хорошо реагирует на части промпта, размеченные XML, для чёткого разделения разных частей запроса.

# Effective Claude Code prompt
Read the following files to understand the current architecture:
- src/routes/userRoutes.ts
- src/middleware/authMiddleware.ts
- src/models/User.ts

Then refactor the authentication flow to support:
1. JWT access tokens (15 min expiry) + refresh tokens (7 day expiry)
2. Token rotation on refresh (invalidate old refresh token)
3. Rate limiting on the refresh endpoint (5 per minute per user)

Update all related files and run the test suite when done.

GitHub Copilot

GitHub Copilot работает иначе, чем инструменты на основе чата — он предоставляет встроенные предложения по мере ввода. Эффективное использование Copilot зависит от написания кода, который чётко передаёт намерение через комментарии, сигнатуры типов и окружающий контекст.

• Пишите описательные комментарии: добавляйте комментарии перед функциями, такие как // Validate email format and check for duplicates, чтобы дать Copilot чёткое намерение.
• Используйте типы TypeScript: хорошо определённые типы и интерфейсы направляют Copilot к правильной реализации.
• Предоставляйте примеры в комментариях: показывайте ожидаемый ввод/вывод в комментариях, чтобы помочь Copilot соответствовать желаемому формату.
• Принимайте частичные предложения: иногда Copilot правильно угадывает структуру, но ошибается в деталях. Примите предложение, затем отредактируйте детали.
• Используйте Copilot Chat для сложных задач: для многофайловых изменений или архитектурных решений используйте Copilot Chat вместо встроенных предложений.

> {
  // Copilot will generate the implementation based on these types

Cursor

Cursor сочетает интеграцию IDE с возможностями AI-чата, предлагая как встроенные дополнения, так и интерфейс чата, понимающий кодовую базу. Его сила в глубокой осведомлённости о проекте и способности ссылаться на конкретные файлы и символы.

• Используйте ссылки @file: ссылайтесь на конкретные файлы с @filename, чтобы дать Cursor точный контекст.
• Используйте @codebase для широкого контекста: когда нужно, чтобы Cursor искал по всему проекту, используйте @codebase.
• Используйте @docs для документации библиотек: Cursor может ссылаться на документацию сторонних библиотек с @docs.
• Используйте Cmd+K для встроенного редактирования: выберите код и используйте Cmd+K для описания изменений на естественном языке.
• Установите правила проекта: используйте файл .cursorrules (аналогично CLAUDE.md) для установки постоянных инструкций проекта.

# Effective Cursor prompt
@src/services/paymentService.ts @src/types/payment.ts

Refactor the processPayment function to use the Strategy pattern.
Create separate strategy classes for each payment provider
(Stripe, PayPal, BankTransfer). The function should accept a
payment method and delegate to the appropriate strategy.

Keep the same public API so existing callers don't break.

Codex CLI

Codex CLI — это терминальный агент программирования от OpenAI, концептуально похожий на Claude Code. Он превосходен в выполнении многошаговых задач разработки из командной строки.

• Предоставляйте чёткие цели: Codex CLI работает лучше всего с чёткими высокоуровневыми целями, а не пошаговыми инструкциями.
• Указывайте рабочую директорию: убедитесь, что запускаете Codex CLI из правильного корня проекта.
• Сначала используйте режим предложений: перед тем как позволить Codex вносить изменения, используйте режим предложений для проверки плана.
• Осторожно настраивайте разрешения песочницы: контролируйте, что Codex может выполнять, через конфигурацию разрешений песочницы.
• Итеративно улучшайте вывод: как и с другими инструментами, первая попытка может потребовать уточнения через последующие промпты.

Распространённые ошибки и как их избежать

Даже опытные разработчики совершают эти распространённые ошибки промптов. Распознавание и избегание их немедленно улучшит взаимодействие с AI.

Расплывчатые инструкции

Самая распространённая ошибка — предоставление расплывчатых, недостаточно конкретных инструкций. Промпты вроде "исправь это", "сделай лучше" или "добавь функциональность" почти не дают AI полезной информации. AI делает предположения, и эти предположения обычно не соответствуют вашим намерениям.

# Bad
"Fix the login bug"

# Good
"Fix the bug where users with uppercase emails cannot log in.
The issue is in src/auth/login.ts - the email comparison is
case-sensitive but emails are stored in lowercase in the database.
The fix should normalize the email to lowercase before comparison."

Недостаток контекста

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

# Bad
"Write a function to send emails"

# Good
"Write an email sending function for our NestJS application.
We use:
- @nestjs/mailer with Handlebars templates
- SMTP via AWS SES
- Templates stored in src/templates/emails/
- Existing MailService class in src/mail/mail.service.ts

The function should accept a template name, recipient, and
template variables. Include error handling for SES throttling
and bounce notifications."

Перегрузка промпта

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

# Bad - Too many tasks in one prompt
"Build a complete user management system with authentication,
profile management, email verification, password reset,
role-based access control, and an admin dashboard"

# Good - Break it into focused prompts
Prompt 1: "Design the database schema for a user management system..."
Prompt 2: "Implement the authentication endpoints..."
Prompt 3: "Add email verification flow..."
Prompt 4: "Implement role-based access control middleware..."

Игнорирование формата вывода

Когда нужен определённый формат вывода — JSON, Markdown, конкретная структура файла — неуказание этого приводит к непредсказуемому форматированию. AI может вернуть прозу, когда нужен JSON, или один файл, когда нужно несколько. Всегда явно указывайте желаемый формат вывода.

# Bad
"List all the API endpoints"

# Good
"List all API endpoints in a markdown table with these columns:
| Method | Path | Description | Auth Required | Request Body | Response |"

Отказ от итераций

Принятие первого ответа AI без уточнения — упущенная возможность. Первый ответ предоставляет основу, которую можно улучшить через последующие промпты. Итерация — это то, где проявляется истинная сила AI-ассистированной разработки — каждый цикл производит лучший, более отточенный вывод.

# Instead of accepting the first response, iterate:
"Good start. Now add input validation using Zod schemas."
"Now add proper error handling with custom error classes."
"Now add logging for all operations."
"Now write tests for all the edge cases we've discussed."

Библиотека шаблонов промптов

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

Шаблон 1: Реализация функции

You are a senior {language} developer specializing in {framework}.

Implement {feature_description} for our {project_type} application.

Tech stack:
- {language} {version} with {framework} {version}
- {database} for data storage
- {orm} for database access
- {testing_framework} for tests

Requirements:
- {requirement_1}
- {requirement_2}
- {requirement_3}

Constraints:
- Must follow existing patterns in the codebase
- Must include input validation
- Must handle errors gracefully
- Must be backward compatible

Output:
1. Implementation code with inline comments for complex logic
2. Unit tests covering happy path and edge cases
3. Brief explanation of design decisions

Шаблон 2: Расследование ошибки

You are a debugging specialist with expertise in {language}/{framework}.

Investigate and fix this bug:

**Symptom:** {describe_the_observed_behavior}
**Expected:** {describe_the_expected_behavior}
**Frequency:** {always/sometimes/under_specific_conditions}
**Environment:** {production/staging/development}

Relevant code:
```
{paste_relevant_code}
```

Error output / stack trace:
```
{paste_error_output}
```

Think step by step:
1. Identify the root cause
2. Explain why this bug occurs
3. Provide the fix with code
4. Suggest how to prevent similar bugs
5. Write a regression test

Шаблон 3: Код-ревью

You are a senior code reviewer at a {company_type} company.

Review this {language} code for:

1. **Correctness:** Logic errors, off-by-one errors, null handling
2. **Security:** Injection, XSS, auth bypasses, data exposure
3. **Performance:** N+1 queries, unnecessary allocations, missing caches
4. **Maintainability:** Code smells, naming, complexity
5. **Testing:** Missing test cases, brittle tests

Code to review:
```
{paste_code}
```

For each issue found, provide:
- Severity: 🔴 Critical / 🟡 Warning / 🔵 Info
- Category: Which of the 5 areas above
- Description: What's wrong and why
- Suggestion: How to fix it, with code example

End with an overall assessment and top 3 priorities.

Шаблон 4: Дизайн конечной точки API

Design a {http_method} {endpoint_path} endpoint for {resource_description}.

Framework: {framework}
Auth: {auth_method}
Database: {database}

The endpoint should:
- {functionality_1}
- {functionality_2}
- {functionality_3}

Provide:
1. Route definition with middleware chain
2. Request validation schema ({validation_library})
3. Controller/handler function
4. Service layer function
5. Database query/function
6. Response types (success and error)
7. Example curl request and response

Шаблон 5: Миграция базы данных

Create a database migration for {change_description}.

Current schema:
```
{current_schema}
```

Desired changes:
- {change_1}
- {change_2}

ORM: {orm_name}
Database: {database_type}

Requirements:
- Migration must be reversible (include down migration)
- Preserve existing data (write data migration SQL if needed)
- Add appropriate indexes for new columns
- Consider performance impact on large tables
- Include rollback safety checks

Шаблон 6: Генерация набора тестов

Write a comprehensive test suite for {function_or_class_name}.

Testing framework: {framework}
Mocking library: {library}

Code under test:
```
{paste_code}
```

Test categories to cover:
- ✅ Happy path: All valid inputs produce correct outputs
- 🔄 Edge cases: Empty inputs, boundary values, null/undefined
- ❌ Error cases: Invalid inputs, permission denied, network failures
- 🏎️ Performance: Response time expectations for critical paths
- 🔒 Security: Auth checks, input sanitization

For each test:
- Use descriptive test names that read like documentation
- Follow Arrange-Act-Assert pattern
- Include setup/teardown for shared state
- Mock external dependencies

Шаблон 7: План рефакторинга

You are a software architect specializing in {language} refactoring.

Current code:
```
{paste_current_code}
```

Problems with current code:
- {problem_1}
- {problem_2}

Refactor using {pattern_or_principle}.

Provide:
1. **Analysis:** What's wrong and why the current approach doesn't scale
2. **Target Architecture:** How the refactored code should be structured
3. **Step-by-step Plan:** Ordered refactoring steps (safe, incremental)
4. **Refactored Code:** Complete implementation
5. **Migration Guide:** How to transition from old to new without breaking changes
6. **Risk Assessment:** What could go wrong and how to mitigate

Шаблон 8: Генерация документации

Generate documentation for this {language} code:

```
{paste_code}
```

Documentation type: {JSDoc/TSDoc/Python docstrings/README section}

Requirements:
- Document all public functions/classes/methods
- Include parameter descriptions with types
- Include return type descriptions
- Add usage examples for non-obvious APIs
- Note any side effects or important caveats
- Use {style_guide} conventions

For README documentation, include:
- Overview (1-2 paragraphs)
- Installation instructions
- Quick start example
- API reference table
- Configuration options

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

You are a performance engineering specialist.

Analyze and optimize this code for performance:

```
{paste_code}
```

Current performance:
- {metric}: {current_value}
- Target: {target_value}
- Bottleneck suspected at: {location}

Optimization constraints:
- Must not change the public API
- Must maintain all existing test passes
- Must not sacrifice readability for micro-optimizations
- {additional_constraint}

Provide:
1. **Profiling Analysis:** Where time/memory is being spent
2. **Optimization Strategies:** Ranked by expected impact
3. **Optimized Code:** With comments explaining each change
4. **Benchmark Comparison:** Before vs after expected metrics
5. **Trade-offs:** Any readability or complexity costs

Шаблон 10: Аудит безопасности

You are a security engineer specializing in {language}/{framework} security.

Perform a security audit on this code:

```
{paste_code}
```

Check for:
- Injection attacks (SQL, NoSQL, command, LDAP)
- Authentication and authorization bypasses
- Cross-site scripting (XSS) vulnerabilities
- Cross-site request forgery (CSRF) exposure
- Insecure direct object references (IDOR)
- Sensitive data exposure (logging, error messages)
- Insecure cryptography or key management
- Race conditions in concurrent operations
- Denial of service vulnerabilities

For each finding:
- Severity: Critical / High / Medium / Low
- OWASP Category: Which Top 10 category
- Description: Clear explanation of the vulnerability
- Attack Scenario: How an attacker would exploit it
- Remediation: Specific code fix
- Verification: How to confirm the fix works