Scripted Formatting Delegation

Deterministic Formatting Delegation Protocol (Prettier & Ruff CLI)

Overview

When asked to fix styling, adjust indentation from 4 spaces to 2 spaces, or format messy JSON/code files, naive agents rewrite the entire file from scratch using LLM code generation turns.

Re-formatting code through an LLM is a major anti-pattern:

1. Severe Token Waste: Reformatting a 600-line file consumes 3,500+ expensive output tokens for zero semantic or algorithmic changes.
2. Streaming Latency: Takes 15 to 25 seconds of streaming wait time.
3. Hallucination Risk: Models frequently introduce subtle syntax errors (e.g., dropped commas, altered regex escapes) while attempting to re-indent code.

The Deterministic Formatting Delegation Protocol offloads 100% of formatting, indentation, and wrapping to local high-speed CLI formatters (ruff format, prettier --write, biome format, gofmt), completing repository-wide formatting in sub-20 milliseconds at $0.00 cost.

LLM Code Re-Streaming vs. Local Formatter Execution

┌─────────────────────────────────────────────────────────────┐
│                 Formatting Mechanism Comparison             │
│                                                             │
│  LLM Token Re-Streaming (600 Lines / 3,800 Tokens):         │
│  • Agent regenerates all 600 lines to fix indentation       │
│  • 3,800 output tokens billed ($0.057)                      │
│  • 18.5 seconds streaming latency                           │
│  • Risk of dropped comments or subtle syntax drift          │
│                                                             │
│  Local Formatter Delegation (`ruff format` / `prettier`):   │
│  • Agent executes: `ruff format src/` via CLI               │
│  ↳ 600 lines formatted in 8 milliseconds on local CPU       │
│  ↳ 0 Tokens Billed ($0.00), 2,300x Faster Execution!        │
└─────────────────────────────────────────────────────────────┘

The High-Speed Formatter Toolkit

Execute these CLI formatters via run_command:

The 2-Step Agent Formatting Workflow

┌───────────────────────────────────────────────────────────────────────────┐
│ STEP 1: APPLY ATOMIC LOGIC PATCH                                          │
│ Agent modifies target business logic using `replace_file_content`         │
│                                                                           │
│ STEP 2: RUN FORMATTER SWEEP LOCALLY                                       │
│ Agent runs `npx prettier --write <file>` or `ruff format <file>` via CLI │
│ ↳ Auto-formats whitespace, line wraps, and trailing commas instantly      │
└───────────────────────────────────────────────────────────────────────────┘

Benchmark Comparison

Formatting 20 messy source files across a full-stack codebase:

Agent Operational Directive

MANDATORY: Agents must NEVER generate token streams to reformat code, adjust indentation, or fix trailing commas. Always run a local CLI formatter (ruff format, prettier --write, gofmt) via terminal execution.