AICodingLab
Claude Code лайфхаки · Урок 24 из 35

Workflow resume и budget: повторный запуск и лимиты

🎯 Цель урока: Понять, как использовать функцию resume для повторного запуска кэшированных агентов и контролировать бюджет выполнения задач в Claude Code. Освоить advanced техники управления ресурсами и кэшированием.

📖 Теория

В этом уроке мы рассмотрим, как эффективно управлять рабочими процессами в Claude Code с помощью функции resume и budget. Эти инструменты помогут вам оптимизировать время выполнения задач и следить за ресурсами вашего проекта.

Что такое resume и budget?

  • Resume: Позволяет вам перезапустить ранее выполненные процессы с использованием кэшированных данных. Это особенно полезно, когда необходимо повторно запустить задачи, не начиная все с нуля.
  • Budget: Инструмент для контроля затрат, который позволяет установить лимиты на выполнение задач. Это помогает избежать перерасхода ресурсов и позволяет более рационально подходить к планированию.

Архитектура Resume

Resume работает на основе Anthropic Prompt Caching — технологии кэширования промптов, которая сохраняет обработанные части контекста и переиспользует их в последующих запросах.

Первый запуск:
User: "Analyze this 10,000 line file"
Claude: [Processes entire file] → 10,000 tokens input
Cost: $0.30 (10K tokens × $3/MTok)

С Resume (в течение 5 минут):
User: "/resume - now fix the bug on line 5234"
Claude: [Uses cached file analysis] → 100 tokens new input
Cost: $0.01 (100 tokens × $3/MTok + cache hit)
Savings: 97% cheaper!

Как работает кэширование

Anthropic Prompt Caching имеет 5-минутный TTL (Time To Live):

  • 0-5 минут: Кэш активен, resume практически мгновенный
  • 5+ минут: Кэш истёк, нужна полная обработка
  • Размер кэша: До 200K токенов (примерно 150K слов)

Что кэшируется:

  • System prompt (инструкции Claude Code)
  • Содержимое прочитанных файлов
  • Результаты выполненных команд
  • История сообщений (conversation history)

Что НЕ кэшируется:

  • Новые пользовательские сообщения
  • Файлы, измененные после кэширования
  • Real-time данные (WebFetch, API calls)

Budget Management

Budget в Claude Code контролирует три типа ресурсов:

Ресурс Метрика Типичный лимит Применение
Token Budget Токены (input + output) 200K - 2M Ограничение стоимости API calls
Time Budget Время выполнения 30 min - 2 hours Предотвращение бесконечных задач
Tool Call Budget Количество вызовов инструментов 50 - 500 Контроль сложности задач

Стратегии оптимизации

1. Cache-Friendly Workflow:

# Плохо: каждый раз читаем заново
User: "Check file.js"
Claude: [Reads file.js] 1000 tokens
User: "Now fix bug"
Claude: [Reads file.js again] 1000 tokens

# Хорошо: используем кэш
User: "Check file.js and fix bug"
Claude: [Reads file.js once] 1000 tokens
# Все последующие обращения к file.js используют кэш

2. Batch Operations:

# Плохо: множество мелких запросов
"Fix bug in auth.js"
"Fix bug in api.js"
"Fix bug in db.js"

# Хорошо: один запрос с batching
"Fix bugs in: auth.js, api.js, db.js"

3. Resume Checkpoints:

# Создавайте естественные точки resume
"Phase 1: Analyze all files" → /resume
"Phase 2: Generate refactoring plan" → /resume
"Phase 3: Execute refactoring"

🛠 Практика

Базовое использование Resume

Шаг 1. Чтобы запустить ранее сохранённый процесс, используйте команду /resume. Эта команда автоматически восстановит состояние вашего проекта на момент последнего завершения.

/resume

Шаг 2. Resume с продолжением задачи:

# Первая сессия (утро)
User: "Analyze the entire codebase and find performance issues"
Claude: [Анализирует 50K строк кода]
Claude: "Found 12 performance bottlenecks in..."

# Вторая сессия (после обеда, в течение 5 минут)
/resume - now fix the top 3 issues

# Claude использует кэшированный анализ
# Не нужно заново читать 50K строк!

Продвинутое использование Resume

Сценарий 1: Iterative Development

# Итерация 1
User: "Create REST API for user management"
Claude: [Creates 5 files: routes.js, controllers.js, models.js, ...]

# Итерация 2 (в течение 5 минут)
/resume - add authentication middleware

# Итерация 3
/resume - add input validation

# Каждый resume использует кэш предыдущей работы

Сценарий 2: Code Review с Resume

# Первый проход
User: "Review PR #456 for security issues"
Claude: [Reads 20 files, analyzes security]
Claude: "Found 3 security issues..."

# Второй проход (после исправлений)
/resume - re-review only the files that changed

# Claude помнит весь контекст PR из кэша
# Перечитывает только измененные файлы

Сценарий 3: Multi-Step Refactoring

# Step 1: Analysis
User: "Analyze opportunities to extract shared utilities"
Claude: "Found 5 patterns that can be extracted..."

# Step 2: Plan (resume)
/resume - create detailed refactoring plan

# Step 3: Execute (resume)
/resume - execute the plan

# Step 4: Verify (resume)
/resume - run tests and verify nothing broke

Budget Configuration

Создание конфигурации бюджета:

# .claude/budget.json
{
  "version": "1.0",
  "budgets": {
    "default": {
      "tokens": {
        "max_input": 500000,
        "max_output": 100000,
        "max_total": 600000
      },
      "time": {
        "max_duration_seconds": 3600,
        "warn_at_seconds": 2700
      },
      "tools": {
        "max_calls": 200,
        "max_bash_calls": 50,
        "max_edit_calls": 100
      }
    },
    "ci": {
      "tokens": {
        "max_total": 100000
      },
      "time": {
        "max_duration_seconds": 600
      }
    },
    "production": {
      "tokens": {
        "max_total": 2000000
      },
      "time": {
        "max_duration_seconds": 7200
      }
    }
  },
  "alerts": {
    "email": "devops@example.com",
    "slack_webhook": "https://hooks.slack.com/...",
    "warn_at_percent": 80
  }
}

Использование разных бюджетов:

# Использовать default бюджет
claude "your task"

# Использовать CI бюджет
CLAUDE_BUDGET=ci claude "run tests"

# Использовать production бюджет
CLAUDE_BUDGET=production claude "deploy to prod"

Production-Ready Budget Manager

#!/usr/bin/env python3
"""
Budget Manager - управление бюджетами для Claude Code
"""
import json
import time
from pathlib import Path
from dataclasses import dataclass
from typing import Optional, Dict
from datetime import datetime, timedelta

@dataclass
class BudgetUsage:
    """Использование бюджета"""
    input_tokens: int = 0
    output_tokens: int = 0
    tool_calls: int = 0
    bash_calls: int = 0
    edit_calls: int = 0
    start_time: float = None

    def __post_init__(self):
        if self.start_time is None:
            self.start_time = time.time()

    @property
    def total_tokens(self):
        return self.input_tokens + self.output_tokens

    @property
    def elapsed_seconds(self):
        return time.time() - self.start_time

    @property
    def cost_estimate(self):
        """Примерная стоимость в USD"""
        # Claude Sonnet pricing (примерно)
        input_cost = self.input_tokens / 1_000_000 * 3.0
        output_cost = self.output_tokens / 1_000_000 * 15.0
        return input_cost + output_cost

class BudgetManager:
    def __init__(self, config_path: str = ".claude/budget.json"):
        self.config_path = Path(config_path)
        self.usage_path = Path(".claude/budget-usage.json")

        self.config = self._load_config()
        self.usage = self._load_usage()
        self.current_budget_name = "default"

    def _load_config(self) -> Dict:
        """Загрузить конфигурацию бюджетов"""
        if self.config_path.exists():
            with open(self.config_path) as f:
                return json.load(f)
        return self._default_config()

    def _default_config(self) -> Dict:
        """Конфигурация по умолчанию"""
        return {
            "version": "1.0",
            "budgets": {
                "default": {
                    "tokens": {"max_total": 600000},
                    "time": {"max_duration_seconds": 3600},
                    "tools": {"max_calls": 200}
                }
            }
        }

    def _load_usage(self) -> BudgetUsage:
        """Загрузить текущее использование"""
        if self.usage_path.exists():
            with open(self.usage_path) as f:
                data = json.load(f)
                return BudgetUsage(**data)
        return BudgetUsage()

    def _save_usage(self):
        """Сохранить использование"""
        self.usage_path.parent.mkdir(parents=True, exist_ok=True)
        with open(self.usage_path, 'w') as f:
            json.dump({
                'input_tokens': self.usage.input_tokens,
                'output_tokens': self.usage.output_tokens,
                'tool_calls': self.usage.tool_calls,
                'bash_calls': self.usage.bash_calls,
                'edit_calls': self.usage.edit_calls,
                'start_time': self.usage.start_time
            }, f, indent=2)

    def set_budget(self, budget_name: str):
        """Установить активный бюджет"""
        if budget_name not in self.config["budgets"]:
            raise ValueError(f"Budget '{budget_name}' not found")

        self.current_budget_name = budget_name
        self.usage = BudgetUsage()  # Reset usage
        self._save_usage()

    def get_current_budget(self) -> Dict:
        """Получить текущий бюджет"""
        return self.config["budgets"][self.current_budget_name]

    def track_tokens(self, input_tokens: int, output_tokens: int):
        """Отследить использование токенов"""
        self.usage.input_tokens += input_tokens
        self.usage.output_tokens += output_tokens
        self._save_usage()
        self._check_limits()

    def track_tool_call(self, tool_name: str):
        """Отследить вызов инструмента"""
        self.usage.tool_calls += 1

        if tool_name == "Bash":
            self.usage.bash_calls += 1
        elif tool_name in ["Edit", "Write"]:
            self.usage.edit_calls += 1

        self._save_usage()
        self._check_limits()

    def _check_limits(self):
        """Проверить лимиты"""
        budget = self.get_current_budget()

        # Проверка токенов
        if "tokens" in budget:
            max_total = budget["tokens"].get("max_total")
            if max_total and self.usage.total_tokens > max_total:
                raise BudgetExceededError(
                    f"Token budget exceeded: {self.usage.total_tokens} > {max_total}"
                )

        # Проверка времени
        if "time" in budget:
            max_duration = budget["time"].get("max_duration_seconds")
            if max_duration and self.usage.elapsed_seconds > max_duration:
                raise BudgetExceededError(
                    f"Time budget exceeded: {self.usage.elapsed_seconds}s > {max_duration}s"
                )

        # Проверка tool calls
        if "tools" in budget:
            max_calls = budget["tools"].get("max_calls")
            if max_calls and self.usage.tool_calls > max_calls:
                raise BudgetExceededError(
                    f"Tool calls budget exceeded: {self.usage.tool_calls} > {max_calls}"
                )

    def get_status(self) -> Dict:
        """Получить статус бюджета"""
        budget = self.get_current_budget()

        status = {
            "budget_name": self.current_budget_name,
            "usage": {
                "tokens": {
                    "input": self.usage.input_tokens,
                    "output": self.usage.output_tokens,
                    "total": self.usage.total_tokens
                },
                "time": {
                    "elapsed_seconds": int(self.usage.elapsed_seconds),
                    "elapsed_formatted": str(timedelta(seconds=int(self.usage.elapsed_seconds)))
                },
                "tools": {
                    "total_calls": self.usage.tool_calls,
                    "bash_calls": self.usage.bash_calls,
                    "edit_calls": self.usage.edit_calls
                },
                "cost_estimate_usd": round(self.usage.cost_estimate, 2)
            },
            "limits": budget,
            "percentage_used": {}
        }

        # Вычислить проценты использования
        if "tokens" in budget and "max_total" in budget["tokens"]:
            max_tokens = budget["tokens"]["max_total"]
            status["percentage_used"]["tokens"] = round(
                (self.usage.total_tokens / max_tokens) * 100, 1
            )

        if "time" in budget and "max_duration_seconds" in budget["time"]:
            max_time = budget["time"]["max_duration_seconds"]
            status["percentage_used"]["time"] = round(
                (self.usage.elapsed_seconds / max_time) * 100, 1
            )

        if "tools" in budget and "max_calls" in budget["tools"]:
            max_calls = budget["tools"]["max_calls"]
            status["percentage_used"]["tools"] = round(
                (self.usage.tool_calls / max_calls) * 100, 1
            )

        return status

    def reset(self):
        """Сбросить использование"""
        self.usage = BudgetUsage()
        self._save_usage()

    def warn_if_approaching_limit(self, threshold_percent: float = 80.0):
        """Предупредить если приближаемся к лимиту"""
        status = self.get_status()

        for resource, percent in status["percentage_used"].items():
            if percent >= threshold_percent:
                print(f"⚠️  WARNING: {resource} budget at {percent}%")

class BudgetExceededError(Exception):
    """Исключение при превышении бюджета"""
    pass

# Использование
if __name__ == "__main__":
    manager = BudgetManager()

    # Установить бюджет
    manager.set_budget("default")

    # Отследить использование
    manager.track_tokens(input_tokens=1000, output_tokens=500)
    manager.track_tool_call("Bash")
    manager.track_tool_call("Edit")

    # Проверить статус
    status = manager.get_status()
    print(json.dumps(status, indent=2))

    # Предупредить если близко к лимиту
    manager.warn_if_approaching_limit(threshold_percent=80)

Resume + Budget интеграция

#!/bin/bash
# claude-with-budget.sh
# Wrapper для запуска Claude с бюджетным контролем

BUDGET_NAME="${CLAUDE_BUDGET:-default}"
PROJECT_DIR="$(pwd)"
BUDGET_FILE="$PROJECT_DIR/.claude/budget-usage.json"

echo "🎯 Running with budget: $BUDGET_NAME"

# Проверить текущий статус
python3 - <

⚠️ Troubleshooting

Проблема 1: Resume не работает (кэш пропал)

Симптомы: /resume перечитывает все файлы заново.

Решение:

# Проверить время с последнего запроса
# Кэш живёт только 5 минут!

# Если прошло >5 минут - кэш истёк, это нормально
# Используйте resume чаще для максимальной экономии

# Оптимальная стратегия:
# 1. Большая задача (analysis)
# 2. Resume через 2-3 минуты (plan)
# 3. Resume через 2-3 минуты (execute)
# Итого: 3 запроса за 9 минут с 2 cache hits

Проблема 2: Budget exceeded неожиданно

Симптомы: Превышен бюджет хотя задача кажется простой.

Решение:

# Проверить логи
cat .claude/budget-usage.json

# Проверить что не включён debug mode
# Debug может генерировать много токенов

# Уменьшить размер контекста
# Не читайте большие файлы если не нужно

# Используйте более узкие запросы
# Вместо: "analyze entire codebase"
# Делайте: "analyze src/api/ directory"

Проблема 3: Resume возвращает устаревшие данные

Симптомы: Resume использует старую версию файла.

Решение:

# Кэш НЕ обновляется при изменении файлов
# Если файл изменился - нужно перечитать его явно

# Вариант 1: Не использовать resume после изменений
# Вариант 2: Явно указать "re-read modified files"

/resume - re-read files that changed and continue

# Вариант 3: Очистить кэш
# Подождите 5+ минут - кэш истечёт автоматически

Проблема 4: Budget tracking неточный

Симптомы: Показываемые токены не совпадают с реальностью.

Решение:

# Budget Manager использует approximation
# Точные данные доступны только в Anthropic Dashboard

# Для более точного трекинга:
# 1. Интегрируйте с Anthropic API
# 2. Читайте usage из response headers
# 3. Логируйте каждый API call

# Пример интеграции:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(...)
actual_tokens = response.usage.input_tokens + response.usage.output_tokens
manager.track_tokens(response.usage.input_tokens, response.usage.output_tokens)

Проблема 5: Resume работает медленно

Симптомы: Resume не даёт ожидаемого ускорения.

Решение:

# Resume ускоряет только token processing
# Не ускоряет:
# - Tool execution (bash, file I/O)
# - Network requests
# - Claude's thinking time

# Для реального ускорения нужно кэшировать и результаты:
# - Используйте BeforeToolCall hook для кэширования
# - Сохраняйте результаты bash команд
# - Избегайте повторных API calls

Проблема 6: Budget alerts не приходят

Симптомы: Настроены alerts, но уведомления не приходят.

Решение:

# Проверить конфигурацию
cat .claude/budget.json | jq '.alerts'

# Тест отправки в Slack
curl -X POST "$SLACK_WEBHOOK" \
  -H 'Content-Type: application/json' \
  -d '{"text":"Budget alert test"}'

# Добавить logging в BudgetManager
import logging
logging.basicConfig(level=logging.DEBUG)

# Проверить что alerts вызываются
manager.warn_if_approaching_limit(threshold_percent=0)  # Должен всегда предупредить

Проблема 7: Разные сессии конфликтуют по бюджету

Симптомы: Запущено несколько сессий Claude, budget считается некорректно.

Решение:

# Используйте per-session budget files
SESSION_ID=$(uuidgen)
export CLAUDE_BUDGET_FILE=".claude/budget-$SESSION_ID.json"

# Или используйте file locking
import fcntl
with open(budget_file, 'r+') as f:
    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
    # ... update budget ...
    fcntl.flock(f.fileno(), fcntl.LOCK_UN)

# Или используйте shared state (Redis, database)
import redis
r = redis.Redis()
r.incr('claude:tokens:total')

📝 Домашнее задание

  1. Resume workflow: Создайте multi-step задачу (analysis → plan → execute) и используйте /resume между шагами. Измерьте экономию токенов.
  2. Budget configuration: Настройте файл budget.json с тремя профилями: development, ci, production. Каждый с разными лимитами.
  3. Budget tracking: Реализуйте BudgetManager и интегрируйте его в ваш проект. Логируйте все tool calls и считайте стоимость.
  4. Cache optimization: Проанализируйте ваш типичный workflow и определите оптимальные точки для /resume. Создайте cache-friendly checklist.
  5. Alerts system: Добавьте в BudgetManager интеграцию со Slack/Email для alerts при 80% использования бюджета.
  6. Monitoring: Создайте dashboard который показывает real-time budget usage: токены, время, стоимость, tool calls.
  7. Отчёт: Напишите краткий отчет о том, как использование resume и budget повлияло на ваш рабочий процесс. Сколько сэкономили токенов и денег?

🎓 После урока вы умеете

  • Использовать команду /resume для восстановления предыдущих процессов
  • Понимать как работает Anthropic Prompt Caching (5-min TTL, 200K tokens)
  • Создавать cache-friendly workflows для максимальной экономии
  • Настраивать budget в файле budget.json для контроля затрат на задачи
  • Реализовывать production-ready BudgetManager с tracking и alerts
  • Проверять статус бюджета и оптимизировать расходы
  • Интегрировать resume и budget в CI/CD pipeline
  • Диагностировать и решать проблемы с кэшированием и бюджетом
  • Мониторить и анализировать использование ресурсов Claude Code
  • Оптимизировать рабочие процессы, используя кэшированные данные и контроль ресурсов

🔗 Дополнительные ресурсы

Рекомендуемые курсы

Продолжите обучение по смежным темам

ИИ-наставник по этому уроку

Задайте вопрос по теме урока «Workflow resume и budget: повторный запуск и лимиты» — наставник ответит, опираясь на его содержание. Он помогает понять, но не делает домашку за вас.

Привет! Я наставник по этому уроку. Спросите что угодно по теме — объясню простыми словами. 🙂
Ответы генерирует ИИ и может ошибаться — сверяйтесь с уроком.
ИИ-консультант
Помогу выбрать курс