Знакома ли вам ситуация? Вы открываете файл контроллера на 2000 строк. Там перемешаны SQL-запросы, HTML-разметка, бизнес-логика и комментарии на ломаном английском. В голове начинает играть тревожная музыка, а внутренний голос шепчет: “Закрой это немедленно, пока оно не сломалось”.

В психологии это называется “когнитивная перегрузка”. Мозг просто отказывается парсить такое количество переменных одновременно. Раньше программистам приходилось часами медитировать над распечатками кода, как сыщикам, пытаясь прокачать навык “Внутренняя империя”.

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

Здесь мы разберем 6 фундаментальных паттернов промптинга, которые вытащат вас из любой ямы:
➪ “Хирург-архитектор” (глубокий рефакторинг, Python)
➪ “Терпеливый ментор” (разбор непонятного кода, TypeScript)
➪ “QA-параноик” (генерация непробиваемых тестов, TypeScript, React)
➪ “Полиглот-транслятор” (миграция кода и переводы, PHP, Python)
➪ “Жестокий ревьюер” (код-ревью и аудит безопасности, Go)
➪ “Говорящий с базами данных” (оптимизация SQL, PostgreSQL)

Кстати, о выборе инструментов для промпт-инжиниринга.

В статье мы разберём 6 паттернов, но на практике важно не только уметь составлять промпты, но и иметь возможность проверять их на разных моделях.

Сервис BotHub собирает ведущие нейросети в одном окне. Вы можете сравнить, как модель от OpenAI справляется с рефакторингом Python, а модель от Anthropic – с написанием тестов на React. Без VPN и возможностью получить 300 000 бесплатных токенов на старте.

По ссылке вы можете получить 300 000 бесплатных токенов и приступить к работе с нейросетями прямо сейчас!

Паттерн 1: “Хирург-архитектор” (глубокий рефакторинг)

Многие часто пишут промпты в духе: “Почини этот код”. Это как прийти к врачу и сказать: “Сделайте мне нормально”. ИИ, как правило, просто поправит синтаксическую ошибку, оставив архитектурный ад нетронутым.

Чтобы получить шедевр, нужно задать роль, ограничения и целевой паттерн.

Промпт:

### Инструкция ###
Ты – Staff Software Engineer уровня FAANG с 15 годами опыта в бэкенде.
Твоя задача – провести безжалостный рефакторинг приведенного ниже Python-кода (написанного на FastAPI).

Проблема: этот код – типичный “all-knowing object” и нарушает принципы SOLID.
Маршрут обрабатывает запросы к БД напрямую через SQLAlchemy, делает бизнес-логику внутри роутера, шлет имейл и возвращает ответ.

Что нужно сделать:
1. Раздели этот код на 3 слоя: router, service (бизнес-логика), repository (доступ к данным).
2. Используй dependency injection (DI).
3. Добавь Pydantic-схемы для входных и выходных данных, чтобы гарантировать типизацию.
4. Обязательно используй асинхронные сессии БД.

В ответе выдай только обновленный код.

### Код для рефакторинга ###
```py
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from models import User, Order
from database import get_db
import smtplib
from email.message import EmailMessage

router = APIRouter()

@router.post("/process_order")
def process_order(user_id: int, item_id: int, quantity: int, price: float, db: Session = Depends(get_db)):
    # 1. Проверяем юзера
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="User not found")

    # 2. Проверяем баланс (бизнес-логика)
    total_cost = quantity * price
    if user.balance < total_cost:
        raise HTTPException(status_code=400, detail="Not enough balance")

    # 3. Снимаем деньги и создаем заказ (Микс бизнес-логики и работы с БД)
    user.balance -= total_cost
    new_order = Order(user_id=user_id, item_id=item_id, quantity=quantity, status="PROCESSING")
    db.add(new_order)
    db.commit()
    db.refresh(new_order)

    # 4. Шлем имейл (внешний сервис, жестко привязанный)
    try:
        msg = EmailMessage()
        msg.set_content(f"Ваш заказ {new_order.id} на сумму {total_cost} в обработке!")
        msg['Subject'] = 'Статус заказа'
        msg['From'] = 'noreply@store.com'
        msg['To'] = user.email
        s = smtplib.SMTP('localhost')
        s.send_message(msg)
        s.quit()
    except Exception as e:
        print(f"Failed to send email: {e}")

    return {"status": "success", "order_id": new_order.id, "remaining_balance": user.balance}
```

Ответ нейронки:

Анализ промпта “Хирург-архитектор”

Зачем мы это сделали? Это классический пример того, как опытные разработчики общаются с ИИ. Ролевой промпт – “ты Senior Staff Engineer” – мгновенно настраивает веса нейросети на генерацию качественного академического кода, отсекая примитивные костыльные решения (так называемые “джуновские” подходы из обучающей выборки).

Мы дали очень четкие ограничения. Если просто сказать “перепиши красиво”, бот может накрутить лишних дизайн-паттернов, которые не к месту в FastAPI. Здесь мы явно прописали целевую архитектуру: router, service, repository (трехслойная архитектура), что сразу дало структуру файлов. Зависимость (dependency injection) заставила бота изолировать работу с БД и электронной почтой, что сделает код тестируемым в будущем.

Также мы затронули больную тему миграции с синхронного на асинхронный код (AsyncSession). Для программиста, особенно того, кто устал переписывать легаси, этот промпт – как глоток свежего воздуха. Вы вставляете спагетти-код, а получаете готовую архитектуру. Теперь вы не просто кодер, который пишет строки, вы Синдзи, который наконец-то полез в чертового робота.

Паттерн 2: “Терпеливый ментор” (разбор непонятного кода)

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

Промпт:

### Роль и задача ###
Ты – ментор, технически подкованный Senior Frontend Developer. Я – Junior-разработчик.
Пожалуйста, объясни мне этот кусок TypeScript-кода так, чтобы я полностью понял, что он делает под капотом.

Требования к ответу:
1. Начни с краткого саммари (в двух предложениях) – какова глобальная цель функции?
2. Сделай пошаговый разбор логики работы функции.
3. Объясни, что произойдет в крайних случаях (edge cases): например, если на вход придет null, пустой массив или объект без нужных ключей.
4. Если код написан плохо, предложи более читаемый современный вариант (например, избегая лишних reduce, если можно использовать map/filter или опциональную цепочку ?.).

### Код для разбора ###
```typescript
type ComplexData = {
  meta?: {
    nodes?: Array<{
      id: string;
      value: number | string;
      metadata?: Record<string, any>;
    }>
  }
};

function extractAndCompute(data: ComplexData | null): number {
  return (data && data.meta && data.meta.nodes)
    ? data.meta.nodes.reduce((acc, curr) => {
        if (curr && typeof curr.value === 'string' && curr.value.match(/^\d+$/)) {
          acc += parseInt(curr.value, 10);
        } else if (curr && typeof curr.value === 'number') {
          acc += curr.value;
        } else if (curr && curr.metadata && curr.metadata['fallbackValue']) {
          acc += Number(curr.metadata['fallbackValue']) || 0;
        }
        return acc;
      }, 0)
    : 0;
}
```

Ответ нейронки:

Анализ промпта “Терпеливый ментор”

Когда видишь data && data.meta && data.meta.nodes, физически ощущаешь запах легаси (и боль тех, кто писал это до эры optional chaining). С этим промптом вы не просите просто “переписать”, вы просите “понять”.

Разбиение на “саммари”, “пошаговый разбор” и “крайние случаи” – ключевой момент. Именно пункт “Крайние случаи” заставляет языковую модель не просто прочитать синтаксис, но и мысленно исполнить его с разными вводными. Модель объясняет, почему стоит регулярка на ^\d+$, чтобы отсеять значения вроде "10px" (а ведь разработчик мог этого сходу не заметить!).

Этот промпт превращает нейросеть для программиста из генератора кода в настоящего ментора. Вы четко видите, где узкие места, и ИИ предлагает вам элегантную, безопасную альтернативу. Это классический пример: нарисуй остаток совы, но перед этим объясни мне, почему предыдущая сова получилась кривой.

Паттерн 3: “QA-параноик” (генерация непробиваемых тестов)

Разработчики не любят писать тесты. Это факт и аксиома. Но чат-бот обожает писать тесты. Главная проблема – если написать “Напиши тесты к этому коду”, вы получите в основном “happy path”-тесты, которые проверяют, что 2+2=4. Нам нужно больше.

Промпт:

### Инструкция ###
Действуй как параноидальный QA Automation Engineer, который обожает находить баги и покрывать код тестами на 100%.
Я использую фреймворк Vitest и библиотеку React Testing Library (@testing-library/react).

Напиши исчерпывающий набор unit-тестов для следующего React-компонента.

Твои тесты должны:
1. Строго следовать паттерну arrange-act-assert (AAA) с комментариями для каждого этапа.
2. Покрывать не только “happy path” (успешные сценарии), но и крайние случаи:
   - Что если API вернет 500-ю ошибку?
   - Что если пользователь быстро кликнет по кнопке дважды?
   - Проверку того, что во время загрузки кнопка переходит в состояние disabled.
3. Замокать глобальный fetch API (встроенными средствами Vitest) и очищать моки после каждого теста (afterEach).

Выдай только код тестов.

### Компонент ###
```tsx
import React, { useState } from 'react';

interface CheckoutProps {
  cartId: string;
  onSuccess: (orderId: string) => void;
  onError: (errorMsg: string) => void;
}

export const CheckoutButton: React.FC<CheckoutProps> = ({ cartId, onSuccess, onError }) => {
  const [isLoading, setIsLoading] = useState(false);

  const handleCheckout = async () => {
    if (isLoading) return;
    setIsLoading(true);

    try {
      const response = await fetch(`/api/checkout/${cartId}`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
      });

      if (!response.ok) {
        throw new Error(`Server responded with status ${response.status}`);
      }

      const data = await response.json();
      onSuccess(data.orderId);
    } catch (error: any) {
      onError(error.message || 'Something went wrong');
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <button
      onClick={handleCheckout}
      disabled={isLoading}
      data-testid="checkout-btn"
    >
      {isLoading ? 'Processing...' : 'Pay Now'}
    </button>
  );
};
```

Ответ нейронки:

Анализ промпта “QA-параноик”

Почему это работает идеально? В данном подходе мы задали нейросети контекст и ограничили свободу там, где она не нужна, но дали простор в поиске уязвимостей. Промпт прямо указывает на фреймворки (Vitest + React Testing Library), что спасает нас от дефолтного мусора на Jest, если проект на Vite.

Паттерн Arrange-Act-Assert (AAA) заставляет ИИ структурировать тесты логично, с комментариями. Вы видите, как бот сначала подготавливает моки (arrange), затем делает fireEvent.click (act) и проверяет результат (assert).

Для разработчика-фронтендера покрытие компонента асинхронными тестами часто вызывает головную боль (возня с waitFor, мокинг fetch). С этим промптом вы получаете готовый тестовый файл, который реально защищает продакшен. Помните: хороший тест – это не тот, который зеленый, а тот, который красный, когда код сломан.

Паттерн 4: “Полиглот-транслятор” (миграция кода и переводы)

Знаете ли вы этот мем про миграцию с PHP на Python? Менеджеры думают, что это просто “CTRL+C → CTRL+V в переводчик”. А на деле мы сталкиваемся с тем, что в языках разные парадигмы, разные стандарты именования и разные стандартные библиотеки.

Промпт:

### Инструкция ###
Твоя задача – перевести (мигрировать) старый PHP-код на современный Python (версия 3.11+).

Правила миграции:
1. Сохрани оригинальную бизнес-логику 1 к 1. Не удаляй функционал!
2. Используй возможности современного Python: типизацию (type hints), `dataclasses` (если нужны классы данных), f-строки.
3. Убери все PHP-специфичные грязные хаки (вроде странных манипуляций с массивами) и используй стандартные питоновские подходы (например, list comprehensions или генераторы словарей).
4. Добавь docstrings Google-формата для всех созданных функций.
5. Напиши краткое объяснение того, какие функции стандартной библиотеки Python заменили встроенные функции PHP (например, как ты обработал работу с датами или массивами).

### Код на PHP ###
```php
<?php
// Скрипт расчета бонусов сотрудников на основе CSV-файла
function calculateEmployeeBonuses($csvFilePath, $bonusPercentage = 10) {
    if (!file_exists($csvFilePath)) {
        throw new Exception("Файл не найден.");
    }

    $file = fopen($csvFilePath, 'r');
    $employees =[];
    $headers = fgetcsv($file); // Пропускаем заголовок

    while (($row = fgetcsv($file)) !== false) {
        $id = $row[0];
        $name = $row[1];
        $baseSalary = floatval($row[2]);
        $joinDate = $row[3]; // Формат YYYY-MM-DD

        // Если человек работает больше 5 лет, бонус удваивается
        $currentDate = new DateTime();
        $joinDt = new DateTime($joinDate);
        $diffYears = $currentDate->diff($joinDt)->y;

        $actualBonusPercent = $diffYears >= 5 ? ($bonusPercentage * 2) : $bonusPercentage;

        $bonusAmount = ($baseSalary * $actualBonusPercent) / 100;

        $employees[] =[
            'id' => $id,
            'name' => $name,
            'salary' => $baseSalary,
            'bonus' => $bonusAmount,
            'total' => $baseSalary + $bonusAmount
        ];
    }
    fclose($file);

    // Сортировка по размеру бонуса по убыванию
    usort($employees, function($a, $b) {
        return $b['bonus'] <=> $a['bonus'];
    });

    return $employees;
}
?>
```

Ответ нейронки:

Анализ промпта “Полиглот-транслятор”

Миграция кода – это трудности перевода. Если не указать версию Python 3.11+, модель может сгенерировать старый код времен Python 2.7 (а в её памяти этого мусора полно).

Промпт решает ключевую боль: когда джуниор переписывает код с другого языка, он тащит за собой привычки этого языка. В итоге мы получаем PHP-код, написанный синтаксисом Python (так называемый пиджин-код). Мы же явно запретили это, указав на: “Убери все PHP-специфичные ‘грязные‘ хаки и используй стандартные питоновские подходы”.

Обратите внимание на вычисление разницы дат (diff_years). ИИ блестяще осознал, что встроенного аналога PHP-шного diff()->y в питоновском datetime нет (в timedelta есть только дни), и написал математически точный расчет с булевым вычитанием. И самое важное – он объяснил это! Это спасает разработчика от скрытых багов.

Паттерн 5: “Жестокий ревьюер” (код-ревью и аудит безопасности)

Вы написали кусок кода. Линтер молчит, тесты зеленые, но вы чувствуете, что где-то здесь кроется проблема производительности или гонка данных. Вы можете попросить коллегу посмотреть – но зачем отвлекать кожаного мешка, если можно запустить “прожарку” нейросетью?

Промпт:

### Инструкция ###
Действуй как безжалостный Staff Security Engineer / Senior Reviewer на языке Go. Твоя задача — провести жесткое код-ревью (Code Review) и аудит безопасности предоставленного сниппета.

Ищи следующие проблемы:
- Состояние гонки данных (race conditions).
- Утечки памяти (goroutine leaks / memory leaks).
- Уязвимости безопасности (path traversal, SQLi и т. д.).
- Плохую обработку ошибок.

Формат ответа:
Выведи Markdown-таблицу со столбцами: Уязвимость/проблема | Степень серьезности | Объяснение.
После таблицы предложи исправленный вариант кода (только исправленный код, без лишней воды).

Будь предельно критичен, не хвали код.

### Код для аудита (уязвимый Go-сервер) ###
```go
package main

import (
            "fmt"
            "io/ioutil"
            "net/http"
            "os"
)

var visitorCount int

func handler(w http.ResponseWriter, r *http.Request) {
            // Увеличиваем счетчик посетителей
            visitorCount++

            // Получаем параметр "file" из query
            fileName := r.URL.Query().Get("file")
            if fileName == "" {
                        fmt.Fprintf(w, "Welcome! You are visitor number %d.", visitorCount)
                        return
            }

            // Читаем запрошенный файл
            basePath := "/var/www/uploads/"
            fullPath := basePath + fileName

            data, err := ioutil.ReadFile(fullPath)
            if err != nil {
                        http.Error(w, "File not found", http.StatusNotFound)
                        return
            }

            w.Write(data)
}

func main() {
            http.HandleFunc("/", handler)
            fmt.Println("Server is running on port 8080...")
            http.ListenAndServe(":8080", nil)
}
```

Ответ нейронки:

Анализ промпта “Жестокий ревьюер”

Что произошло? Мы буквально заставили языковую модель включить режим SAST (static application security testing). Инструкция “Будь предельно критичен, не хвали код” жизненно важна: если её не написать, ИИ в силу своей RLHF-натуры начнет сыпать комплиментами “Отличный код, но вот тут небольшая деталь...”. Нам этого не надо, мы хотим чистую, суровую техническую правду.

Модель обнаружила две критические уязвимости уровня high, которые джуниор 100% бы пропустил. Первая – path traversal, классическая уязвимость чтения произвольных файлов на сервере (запрос вида ../../../../etc/passwd). ИИ не просто увидел её, он предложил элегантное решение с использованием filepath.Clean() и проверкой префикса директории strings.HasPrefix() – это стандарт индустрии в Go для защиты от LFI (local file inclusion).

Вторая – гонка данных. Go запускает каждый HTTP-запрос в отдельной горутине. Изменение глобальной переменной visitorCount++ без лока – это смерть на проде (race condition). Бот предложил оптимальное решение – sync/atomic, что быстрее и правильнее, чем лепить тяжелый sync.Mutex для одного intа.

Паттерн 6: “Говорящий с базами данных” (экстремальная оптимизация SQL)

И наконец, царица всех проблем – тормозящие базы данных. Запросы, которые раньше летали на пустой таблице, через год начинают вешать прод на 15 секунд. Промптить ИИ просто “Оптимизируй SQL” бесполезно, потому что ИИ не видит вашу базу. Вы должны дать ему план запроса.

Промпт:

### Инструкция ###
Ты – Senior Database Administrator (DBA), специализирующийся на PostgreSQL.
Этот SQL-запрос работает катастрофически медленно. Таблица `orders` содержит 10 миллионов строк, `users` – 2 миллиона.

Ниже я привожу:
1. Сам проблемный запрос.
2. План выполнения запроса (EXPLAIN ANALYZE), который выдала база данных.

Твоя задача:
1. Проанализировать вывод EXPLAIN ANALYZE и указать точное узкое горлышко, например seq scan, nested loop или сортировка в памяти.
2. Переписать SQL-запрос для максимальной оптимизации (используй CTE, оконные функции или JOIN’ы, если подзапросы тормозят).
3. Предложить команды `CREATE INDEX`, которые полностью покроют этот запрос (используй композитные или частичные индексы, если необходимо).

### Медленный SQL-запрос ###
```sql
SELECT
    u.id,
    u.username,
    (SELECT SUM(o.total_price) FROM orders o WHERE o.user_id = u.id AND o.status = 'COMPLETED' AND o.created_at >= '2025-01-01') as total_spent
FROM
    users u
WHERE
    u.is_active = true
ORDER BY
    total_spent DESC NULLS LAST
LIMIT 50;
```

### Лог EXPLAIN ANALYZE ###
```
Limit  (cost=1000000.45..1000001.25 rows=50 width=44) (actual time=14523.456..14523.512 rows=50 loops=1)
  ->  Sort  (cost=1000000.45..1005000.45 rows=2000000 width=44) (actual time=14523.444..14523.471 rows=50 loops=1)
        Sort Key: ((SubPlan 1)) DESC NULLS LAST
        Sort Method: external merge  Disk: 45000kB
        ->  Seq Scan on users u  (cost=0.00..55000.00 rows=2000000 width=16) (actual time=0.045..5421.123 rows=1850000 loops=1)
              Filter: is_active
              Rows Removed by Filter: 150000
              SubPlan 1
                ->  Aggregate  (cost=12.45..12.46 rows=1 width=8) (actual time=0.004..0.004 rows=1 loops=1850000)
                      ->  Seq Scan on orders o  (cost=0.00..12.44 rows=1 width=4) (actual time=0.001..0.003 rows=2 loops=1850000)
                            Filter: ((user_id = u.id) AND ((status)::text = 'COMPLETED'::text) AND (created_at >= '2025-01-01'::date))
                            Rows Removed by Filter: 4
Planning Time: 0.123 ms
Execution Time: 14525.888 ms
```

Ответ нейронки:

Анализ промпта “Говорящий с базами данных”

Использование нейросетей для генерации кода часто ограничивается алгоритмами, но работа с БД – это высший пилотаж. Лог EXPLAIN ANALYZE выглядит как матрица с зелёным кодом. Но LLM, обученная на миллионах логов StackOverflow, парсит его мгновенно.

Мы попросили ИИ найти узкое горлышко. Бот увидел страшную цифру loops=1850000 и external merge Disk: 45000kB. Это как если бы вы заставили курьера доставлять 1 миллион посылок по одной, каждый раз возвращаясь на склад (коррелированный подзапрос). Бот переписал это через CTE, что заставляет базу данных вычислить все суммы покупок за один проход (одна агрегация), а затем просто JOIN’ить результаты с юзерами.

Но вишенка на торте – это генерация индексов. Предложенный частичный индекс WHERE is_active = true и композитный индекс с инструкцией INCLUDE (total_price) (так называемый covering index, позволяющий Postgres читать данные только из индекса, вообще не касаясь самой таблицы) – это уровень крутого сеньора. Этот промпт спасает карьеры и бережет нервные клетки DBA.

Сводная таблица: техники промптинга для кодеров

Чтобы закрепить материал, давайте обобщим, какие механики мы использовали в промптах.

Итоги: промпты как новый язык интерфейса

Эра “Напиши мне функцию для сортировки” ушла в прошлое. Использование ChatGPT/Gemini/Grok/Claude/DeepSeek (нужное подчеркнуть) и правильные промпты сегодня снимают колоссальную когнитивную нагрузку.

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

Сохраните эти 6 паттернов к себе в закладки. Замените фрагменты под свои нужды, вставляйте их в бота всякий раз, когда ощущаете препятствие!

Keep coding, keep prompting!