Введение
Go (Golang) уже давно стал стандартом для создания высоконагруженных микросервисов, REST API и консольных утилит. По данным опроса Go Developer Survey 2025, проведённого командой Go, 62% респондентов используют Go для разработки API, а 41% — для CLI-инструментов. Однако даже опытные разработчики тратят до 30% времени на рутинные задачи: генерацию boilerplate, написание тестов и документации. Использование промтов (промптов для AI) позволяет сократить это время в 2–3 раза. Я собрал 8 проверенных промтов, которые сам использую в продакшене. Каждый — с реальным примером и кодом.
1. Генерация структуры микросервиса
Проблема: Создание нового микросервиса каждый раз требует ручной настройки роутера, логгера, конфига и graceful shutdown. Это отнимает 15–20 минут.
Промт: «Сгенерируй Go-микросервис с HTTP-сервером на net/http, graceful shutdown, логгированием через log/slog, чтением конфига из YAML и health check endpoint. Используй go 1.22. Структура папок: cmd/, internal/, pkg/.»
Пример результата:
package main
import (
"context"
"log/slog"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"gopkg.in/yaml.v3"
)
type Config struct {
Server struct {
Port string `yaml:"port"`
} `yaml:"server"`
}
func main() {
cfg := loadConfig("config.yaml")
slog.Info("starting server", "port", cfg.Server.Port)
srv := &http.Server{Addr: ":" + cfg.Server.Port, Handler: routes()}
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
slog.Error("server error", "err", err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.Shutdown(ctx)
}
func routes() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Write([]byte(`{"status":"ok"}`))
})
return mux
}
func loadConfig(path string) Config {
data, _ := os.ReadFile(path)
var cfg Config
yaml.Unmarshal(data, &cfg)
return cfg
}
Результат: За 30 секунд получаете рабочий каркас микросервиса. Остаётся только добавить бизнес-логику.
2. Генерация обработчика REST API с валидацией
Проблема: Написание CRUD-эндпоинтов с валидацией JSON и возвратом ошибок в едином формате — рутина.
Промт: «Напиши Go-обработчик для создания пользователя (POST /users). Принимает JSON: name (string, не пустое), email (string, валидный email), age (int, >= 18). Возвращает 201 с созданным объектом или 400 с описанием ошибки. Используй encoding/json и net/http.»
Пример результата:
func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
var req struct {
Name string `json:"name"`
Email string `json:"email"`
Age int `json:"age"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeError(w, http.StatusBadRequest, "invalid JSON")
return
}
var errors []string
if req.Name == "" {
errors = append(errors, "name is required")
}
if !strings.Contains(req.Email, "@") {
errors = append(errors, "invalid email")
}
if req.Age < 18 {
errors = append(errors, "age must be >= 18")
}
if len(errors) > 0 {
writeError(w, http.StatusBadRequest, strings.Join(errors, "; "))
return
}
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(req)
}
func writeError(w http.ResponseWriter, code int, msg string) {
w.WriteHeader(code)
json.NewEncoder(w).Encode(map[string]string{"error": msg})
}
Результат: Готовый обработчик с валидацией за 10 секунд. Экономия на типовых проверках.
3. Генерация тестов для Go-функций
Проблема: Table-driven тесты требуют шаблонного кода. AI ускоряет их написание в 5 раз.
Промт: «Напиши table-driven тесты для функции Sum(a, b int) int. Проверь: положительные, отрицательные, нулевые значения. Используй testing пакет.»
Пример результата:
func TestSum(t *testing.T) {
tests := []struct {
a, b, expected int
}{
{1, 2, 3},
{-1, 1, 0},
{0, 0, 0},
{-5, -3, -8},
{100, 200, 300},
}
for _, tt := range tests {
result := Sum(tt.a, tt.b)
if result != tt.expected {
t.Errorf("Sum(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
}
}
}
Результат: За 5 секунд получаете полный набор тестов. Остаётся только запустить go test.
4. Генерация CLI-утилиты с флагами
Проблема: Создание консольной утилиты с парсингом флагов и подкомандами — базовая задача, но требует много boilerplate.
Промт: «Создай CLI-утилиту на Go с двумя подкомандами: 'greet' (принимает флаг --name, выводит приветствие) и 'calc' (принимает два числа и операцию --op: add или sub). Используй flag пакет.»
Пример результата:
package main
import (
"flag"
"fmt"
"os"
)
func main() {
if len(os.Args) < 2 {
fmt.Println("Usage: mycli <command> [flags]")
return
}
switch os.Args[1] {
case "greet":
greetCmd := flag.NewFlagSet("greet", flag.ExitOnError)
name := greetCmd.String("name", "World", "name to greet")
greetCmd.Parse(os.Args[2:])
fmt.Printf("Hello, %s!\n", *name)
case "calc":
calcCmd := flag.NewFlagSet("calc", flag.ExitOnError)
a := calcCmd.Int("a", 0, "first number")
b := calcCmd.Int("b", 0, "second number")
op := calcCmd.String("op", "add", "operation: add or sub")
calcCmd.Parse(os.Args[2:])
switch *op {
case "add":
fmt.Printf("Result: %d\n", *a+*b)
case "sub":
fmt.Printf("Result: %d\n", *a-*b)
}
default:
fmt.Println("Unknown command")
}
}
Результат: Рабочая CLI-утилита за 20 секунд. Можно сразу компилировать через go build.
5. Генерация SQL-миграции и её Go-модели
Проблема: Синхронизация схемы БД и Go-структур — частый источник ошибок.
Промт: «Сгенерируй SQL-миграцию для создания таблицы users (id, name, email, created_at) и Go-структуру с тегами json и db. Используй PostgreSQL.»
Пример результата:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
name VARCHAR(255) NOT NULL,
email VARCHAR(255) UNIQUE NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
);
type User struct {
ID int `json:"id" db:"id"`
Name string `json:"name" db:"name"`
Email string `json:"email" db:"email"`
CreatedAt time.Time `json:"created_at" db:"created_at"`
}
Результат: Согласованная схема и код за 10 секунд. Устраняет несоответствие типов.
6. Генерация логирования в middleware
Проблема: Добавление логгирования каждого запроса требует написания middleware.
Промт: «Напиши middleware для net/http, который логирует метод, путь, статус код и длительность запроса. Используй slog.»
Пример результата:
func LoggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
srw := &statusResponseWriter{ResponseWriter: w}
next.ServeHTTP(srw, r)
slog.Info("request",
"method", r.Method,
"path", r.URL.Path,
"status", srw.status,
"duration", time.Since(start).String(),
)
})
}
type statusResponseWriter struct {
http.ResponseWriter
status int
}
func (srw *statusResponseWriter) WriteHeader(code int) {
srw.status = code
srw.ResponseWriter.WriteHeader(code)
}
Результат: Готовый middleware за 15 секунд. Подключается одной строкой.
7. Генерация обработчика ошибок с кастомными типами
Проблема: В Go нет встроенного механизма для иерархии ошибок. Часто пишут if err != nil вручную.
Промт: «Создай кастомный тип ошибки AppError с полями Code (int), Message (string) и Err (error). Реализуй метод Error() и функцию Wrap. Пример использования: вызов функции, которая возвращает AppError.»
Пример результата:
type AppError struct {
Code int
Message string
Err error
}
func (e *AppError) Error() string {
return fmt.Sprintf("code %d: %s: %v", e.Code, e.Message, e.Err)
}
func Wrap(err error, code int, msg string) error {
return &AppError{Code: code, Message: msg, Err: err}
}
func DoSomething() error {
return Wrap(fmt.Errorf("db timeout"), 500, "internal error")
}
Результат: Единый формат ошибок. Упрощает отладку и ответы API.
8. Генерация конфигурационного файла с env-переменными
Проблема: Чтение конфига из env-переменных — частая задача. os.Getenv требует много кода.
Промт: «Напиши Go-функцию, которая читает конфиг из env-переменных: DB_HOST, DB_PORT, DB_USER, DB_PASSWORD. Если переменная не задана — используй дефолтные значения. Верни структуру Config.»
Пример результата:
type Config struct {
DBHost string
DBPort string
DBUser string
DBPassword string
}
func LoadConfig() Config {
return Config{
DBHost: getEnv("DB_HOST", "localhost"),
DBPort: getEnv("DB_PORT", "5432"),
DBUser: getEnv("DB_USER", "postgres"),
DBPassword: getEnv("DB_PASSWORD", ""),
}
}
func getEnv(key, defaultVal string) string {
if val := os.Getenv(key); val != "" {
return val
}
return defaultVal
}
Результат: Конфиг за 5 секунд. Легко расширяется добавлением новых полей.
Заключение
Эти 8 промтов покрывают 80% рутинных задач Go-разработчика: от создания микросервисов до обработки ошибок. По моему опыту, их использование сокращает время на boilerplate-код с 30% рабочего дня до 5%. Начните с первого промта — сгенерируйте каркас микросервиса и постепенно добавляйте остальные. Если у вас есть свои любимые промты для Go — делитесь в комментариях. А для глубокого погружения в архитектуру микросервисов рекомендую официальную документацию Go (go.dev/doc) и книгу «100 Go Mistakes and How to Avoid Them».
Комментарии