diff --git a/advisor.go b/advisor.go
index f7712891..581e897f 100644
--- a/advisor.go
+++ b/advisor.go
@@ -576,8 +576,8 @@ func (ca *CompressionAdvisor) FormatAdvice() string {
 	var sb strings.Builder
 	sb.WriteString("Compression Advisor:\n")
 	sb.WriteString(strings.Repeat("─", 35) + "\n")
-	sb.WriteString(fmt.Sprintf("Your sessions use avg %sK tokens/session.\n", formatK(avgPerSession)))
-	sb.WriteString(fmt.Sprintf("With optimal compression: ~%sK tokens (%.0f%% savings)\n", formatK(optimalPerSession), savingsPercent))
+	fmt.Fprintf(&sb, "Your sessions use avg %sK tokens/session.\n", formatK(avgPerSession))
+	fmt.Fprintf(&sb, "With optimal compression: ~%sK tokens (%.0f%% savings)\n", formatK(optimalPerSession), savingsPercent)
 	sb.WriteString("\n")
 	sb.WriteString("By content type:\n")
 
@@ -599,9 +599,9 @@ func (ca *CompressionAdvisor) FormatAdvice() string {
 	for _, ts := range typeOrder {
 		if _, present := typeStats[ts.ct]; present {
 			if ts.note != "" {
-				sb.WriteString(fmt.Sprintf("  %-16s %s (%s)\n", ts.label+":", ts.mode, ts.note))
+				fmt.Fprintf(&sb, "  %-16s %s (%s)\n", ts.label+":", ts.mode, ts.note)
 			} else {
-				sb.WriteString(fmt.Sprintf("  %-16s %s (avg %.0f%% savings)\n", ts.label+":", ts.mode, ts.savings*100))
+				fmt.Fprintf(&sb, "  %-16s %s (avg %.0f%% savings)\n", ts.label+":", ts.mode, ts.savings*100)
 			}
 		}
 	}
@@ -614,7 +614,7 @@ func (ca *CompressionAdvisor) FormatAdvice() string {
 		if i >= 3 {
 			break
 		}
-		sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, rec))
+		fmt.Fprintf(&sb, "%d. %s\n", i+1, rec)
 	}
 
 	return sb.String()
diff --git a/format.go b/format.go
index 07f3928b..6dd10240 100644
--- a/format.go
+++ b/format.go
@@ -35,17 +35,17 @@ func formatNumber(n int) string {
 func FormatStats(stats Stats) string {
 	var b strings.Builder
 
-	b.WriteString(fmt.Sprintf("Tokens: %s → %s (%.1f%% reduction)\n",
+	fmt.Fprintf(&b, "Tokens: %s → %s (%.1f%% reduction)\n",
 		formatNumber(stats.OriginalTokens),
 		formatNumber(stats.FinalTokens),
-		stats.ReductionPercent))
+		stats.ReductionPercent)
 
-	b.WriteString(fmt.Sprintf("Saved: %s tokens", formatNumber(stats.TokensSaved)))
+	fmt.Fprintf(&b, "Saved: %s tokens", formatNumber(stats.TokensSaved))
 
 	if stats.Model != "" {
 		costStr := FormatCostSavings(stats, stats.Model)
 		if costStr != "" {
-			b.WriteString(fmt.Sprintf(" | %s", costStr))
+			fmt.Fprintf(&b, " | %s", costStr)
 		}
 	}
 
diff --git a/internal/filter/cache_breakpoint.go b/internal/filter/cache_breakpoint.go
index 1d54019d..6a3b0820 100644
--- a/internal/filter/cache_breakpoint.go
+++ b/internal/filter/cache_breakpoint.go
@@ -52,7 +52,7 @@ func (f *CacheBreakpointFilter) Filter(input string) string {
 		}
 
 		if score >= 0.7 && nextScore < 0.5 {
-			result.WriteString(fmt.Sprintf("\n%s\n", CacheBreakMarker))
+			fmt.Fprintf(&result, "\n%s\n", CacheBreakMarker)
 			breakpoints++
 			lastBreakAt = tokenEstimate
 		}
diff --git a/internal/filter/compaction.go b/internal/filter/compaction.go
index 9ae9b7a3..8473d72f 100644
--- a/internal/filter/compaction.go
+++ b/internal/filter/compaction.go
@@ -563,7 +563,7 @@ func (c *CompactionLayer) buildCompactionPrompt(snapshot *StateSnapshot, turns [
 		if len(content) > 200 {
 			content = content[:200] + "..."
 		}
-		sb.WriteString(fmt.Sprintf("[%s]: %s\n", turn.Role, content))
+		fmt.Fprintf(&sb, "[%s]: %s\n", turn.Role, content)
 	}
 
 	return sb.String()
diff --git a/internal/filter/crunch_bench.go b/internal/filter/crunch_bench.go
index b3227b12..2247a01b 100644
--- a/internal/filter/crunch_bench.go
+++ b/internal/filter/crunch_bench.go
@@ -275,15 +275,15 @@ func (cb *CrunchBench) FormatReport(report *BenchmarkReport) string {
 	sb.WriteString("╔══════════════════════════════════════════════════════════════════╗\n")
 	sb.WriteString("║              CrunchBench - Compression Benchmark Report          ║\n")
 	sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
-	sb.WriteString(fmt.Sprintf("║ Timestamp: %s\n", report.Timestamp.Format("2006-01-02 15:04:05")))
-	sb.WriteString(fmt.Sprintf("║ Tests: %d passed, %d failed, %d total\n", report.Passed, report.Failed, report.TotalTests))
+	fmt.Fprintf(&sb, "║ Timestamp: %s\n", report.Timestamp.Format("2006-01-02 15:04:05"))
+	fmt.Fprintf(&sb, "║ Tests: %d passed, %d failed, %d total\n", report.Passed, report.Failed, report.TotalTests)
 	sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
 	sb.WriteString("║ Aggregate Statistics:\n")
-	sb.WriteString(fmt.Sprintf("║   Avg Compression: %.2f%% (std: %.2f%%)\n", report.OverallStats.AvgCompression, report.OverallStats.StdDevCompression))
-	sb.WriteString(fmt.Sprintf("║   Range: %.2f%% - %.2f%%\n", report.OverallStats.MinCompression, report.OverallStats.MaxCompression))
-	sb.WriteString(fmt.Sprintf("║   Avg Latency: %.2f μs/token\n", report.OverallStats.AvgLatency))
-	sb.WriteString(fmt.Sprintf("║   Avg Quality: %.2f\n", report.OverallStats.AvgQuality))
-	sb.WriteString(fmt.Sprintf("║   Total Time: %v\n", report.OverallStats.TotalTime))
+	fmt.Fprintf(&sb, "║   Avg Compression: %.2f%% (std: %.2f%%)\n", report.OverallStats.AvgCompression, report.OverallStats.StdDevCompression)
+	fmt.Fprintf(&sb, "║   Range: %.2f%% - %.2f%%\n", report.OverallStats.MinCompression, report.OverallStats.MaxCompression)
+	fmt.Fprintf(&sb, "║   Avg Latency: %.2f μs/token\n", report.OverallStats.AvgLatency)
+	fmt.Fprintf(&sb, "║   Avg Quality: %.2f\n", report.OverallStats.AvgQuality)
+	fmt.Fprintf(&sb, "║   Total Time: %v\n", report.OverallStats.TotalTime)
 	sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
 	sb.WriteString("║ Per-Test Results:\n")
 
@@ -292,15 +292,15 @@ func (cb *CrunchBench) FormatReport(report *BenchmarkReport) string {
 		if r.QualityScore < 0.7 {
 			status = "⚠"
 		}
-		sb.WriteString(fmt.Sprintf("║ %s %-20s (%s): %.1f%% in %v [Q:%.2f]\n",
-			status, r.TestName, r.ContentType, r.ReductionPct, r.CompressionTime, r.QualityScore))
+		fmt.Fprintf(&sb, "║ %s %-20s (%s): %.1f%% in %v [Q:%.2f]\n",
+			status, r.TestName, r.ContentType, r.ReductionPct, r.CompressionTime, r.QualityScore)
 	}
 
 	if len(report.Recommendations) > 0 {
 		sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
 		sb.WriteString("║ Recommendations:\n")
 		for _, rec := range report.Recommendations {
-			sb.WriteString(fmt.Sprintf("║   • %s\n", rec))
+			fmt.Fprintf(&sb, "║   • %s\n", rec)
 		}
 	}
 
diff --git a/internal/filter/enhancements.go b/internal/filter/enhancements.go
index e2d34053..df0b1302 100644
--- a/internal/filter/enhancements.go
+++ b/internal/filter/enhancements.go
@@ -101,7 +101,7 @@ func (hg *HeatmapGenerator) Output() string {
 	var sb strings.Builder
 	sb.WriteString("Compression Heatmap:\n")
 	for pos, ratio := range hg.data {
-		sb.WriteString(fmt.Sprintf("  pos %d: %.2f\n", pos, ratio))
+		fmt.Fprintf(&sb, "  pos %d: %.2f\n", pos, ratio)
 	}
 	return sb.String()
 }
diff --git a/internal/filter/file_read_modes.go b/internal/filter/file_read_modes.go
index 6640166d..4ab3619a 100644
--- a/internal/filter/file_read_modes.go
+++ b/internal/filter/file_read_modes.go
@@ -190,12 +190,12 @@ func ComputeDelta(old, new string) IncrementalDelta {
 // FormatDelta returns a human-readable delta string.
 func FormatDelta(delta IncrementalDelta) string {
 	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("Delta: +%d -%d (unchanged: %d)\n", len(delta.Added), len(delta.Removed), delta.Unchanged))
+	fmt.Fprintf(&sb, "Delta: +%d -%d (unchanged: %d)\n", len(delta.Added), len(delta.Removed), delta.Unchanged)
 	for _, line := range delta.Added {
-		sb.WriteString(fmt.Sprintf("+ %s\n", line))
+		fmt.Fprintf(&sb, "+ %s\n", line)
 	}
 	for _, line := range delta.Removed {
-		sb.WriteString(fmt.Sprintf("- %s\n", line))
+		fmt.Fprintf(&sb, "- %s\n", line)
 	}
 	return sb.String()
 }
diff --git a/internal/filter/pipeline_stats.go b/internal/filter/pipeline_stats.go
index db264481..7017d9ec 100644
--- a/internal/filter/pipeline_stats.go
+++ b/internal/filter/pipeline_stats.go
@@ -12,9 +12,9 @@ func (s *PipelineStats) String() string {
 	sb.WriteString("╔════════════════════════════════════════════════════╗\n")
 	sb.WriteString("║         Tok 20-Layer Compression Stats          ║\n")
 	sb.WriteString("╠════════════════════════════════════════════════════╣\n")
-	sb.WriteString(fmt.Sprintf("║ Original:  %6d tokens                         ║\n", s.OriginalTokens))
-	sb.WriteString(fmt.Sprintf("║ Final:     %6d tokens                         ║\n", s.FinalTokens))
-	sb.WriteString(fmt.Sprintf("║ Saved:     %6d tokens (%.1f%%)                 ║\n", s.TotalSaved, s.ReductionPercent))
+	fmt.Fprintf(&sb, "║ Original:  %6d tokens                         ║\n", s.OriginalTokens)
+	fmt.Fprintf(&sb, "║ Final:     %6d tokens                         ║\n", s.FinalTokens)
+	fmt.Fprintf(&sb, "║ Saved:     %6d tokens (%.1f%%)                 ║\n", s.TotalSaved, s.ReductionPercent)
 	sb.WriteString("╠════════════════════════════════════════════════════╣\n")
 	sb.WriteString("║ Layer Breakdown:                                   ║\n")
 
@@ -28,7 +28,7 @@ func (s *PipelineStats) String() string {
 
 	for _, layer := range layerOrder {
 		if stat, ok := s.LayerStats[layer]; ok && stat.TokensSaved > 0 {
-			sb.WriteString(fmt.Sprintf("║   %-20s: %6d tokens saved     ║\n", layer, stat.TokensSaved))
+			fmt.Fprintf(&sb, "║   %-20s: %6d tokens saved     ║\n", layer, stat.TokensSaved)
 		}
 	}
 
diff --git a/internal/filter/sketch_store.go b/internal/filter/sketch_store.go
index 0643b2e7..a7c0d0d8 100644
--- a/internal/filter/sketch_store.go
+++ b/internal/filter/sketch_store.go
@@ -410,13 +410,11 @@ func (f *SketchStoreFilter) ExportSketches() ([]byte, error) {
 	var buf strings.Builder
 
 	for hash, sketch := range f.sketchCache.TokenSketches {
-		buf.WriteString(fmt.Sprintf(
-			"%s:%s:%d:%.2f\n",
+		fmt.Fprintf(&buf, "%s:%s:%d:%.2f\n",
 			hash,
 			sketch.ContentType,
 			sketch.TokenCount,
-			sketch.Importance,
-		))
+			sketch.Importance)
 	}
 
 	return []byte(buf.String()), nil
diff --git a/internal/filter/toml_filter.go b/internal/filter/toml_filter.go
index fce91471..39bd74aa 100644
--- a/internal/filter/toml_filter.go
+++ b/internal/filter/toml_filter.go
@@ -397,7 +397,7 @@ func applyMaxLines(s string, maxLines int) string {
 		b.WriteString(lines[i])
 		b.WriteByte('\n')
 	}
-	b.WriteString(fmt.Sprintf("// ... (%d lines omitted) ...", dropped))
+	fmt.Fprintf(&b, "// ... (%d lines omitted) ...", dropped)
 	b.WriteByte('\n')
 	for i := len(lines) - half; i < len(lines); i++ {
 		b.WriteString(lines[i])
diff --git a/optimizer.go b/optimizer.go
index a90accf4..e4fede8a 100644
--- a/optimizer.go
+++ b/optimizer.go
@@ -395,14 +395,14 @@ func FormatResult(result *OptimizationResult) string {
 
 	var sb strings.Builder
 	sb.WriteString("Context Optimization:\n")
-	sb.WriteString(fmt.Sprintf("Budget: %s tokens\n", formatNumber(budget)))
+	fmt.Fprintf(&sb, "Budget: %s tokens\n", formatNumber(budget))
 	sb.WriteString("─────────────────────────\n")
 
 	keptTokens := 0
 	for _, b := range result.Kept {
 		keptTokens += b.Tokens
 	}
-	sb.WriteString(fmt.Sprintf("Kept (%d blocks):      %s tokens\n", len(result.Kept), formatNumber(keptTokens)))
+	fmt.Fprintf(&sb, "Kept (%d blocks):      %s tokens\n", len(result.Kept), formatNumber(keptTokens))
 
 	compressedTokens := 0
 	savedFromCompression := 0
@@ -413,18 +413,18 @@ func FormatResult(result *OptimizationResult) string {
 	if savedFromCompression < 0 {
 		savedFromCompression = 0
 	}
-	sb.WriteString(fmt.Sprintf("Compressed (%d blocks): %s tokens (saved %s)\n",
-		len(result.Compressed), formatNumber(compressedTokens), formatNumber(savedFromCompression)))
+	fmt.Fprintf(&sb, "Compressed (%d blocks): %s tokens (saved %s)\n",
+		len(result.Compressed), formatNumber(compressedTokens), formatNumber(savedFromCompression))
 
 	droppedTok := droppedTokens(result)
-	sb.WriteString(fmt.Sprintf("Dropped (%d blocks):    -%s tokens\n", len(result.Dropped), formatNumber(droppedTok)))
+	fmt.Fprintf(&sb, "Dropped (%d blocks):    -%s tokens\n", len(result.Dropped), formatNumber(droppedTok))
 
 	sb.WriteString("─────────────────────────\n")
 
 	pct := result.BudgetUsed * 100
-	sb.WriteString(fmt.Sprintf("Total: %s/%s (%.1f%% utilized)\n",
-		formatNumber(result.TotalTokens), formatNumber(budget), pct))
-	sb.WriteString(fmt.Sprintf("Savings: %s tokens from compression + drops\n", formatNumber(result.Savings)))
+	fmt.Fprintf(&sb, "Total: %s/%s (%.1f%% utilized)\n",
+		formatNumber(result.TotalTokens), formatNumber(budget), pct)
+	fmt.Fprintf(&sb, "Savings: %s tokens from compression + drops\n", formatNumber(result.Savings))
 
 	return sb.String()
 }
diff --git a/ratelimit.go b/ratelimit.go
index 1770301a..db9c3e0c 100644
--- a/ratelimit.go
+++ b/ratelimit.go
@@ -353,26 +353,26 @@ func (u *UsageTracker) FormatSummary() string {
 
 	var sb strings.Builder
 	sb.WriteString("Token Usage:\n")
-	sb.WriteString(fmt.Sprintf("  Hourly:  %s / %s (%d%%) %s\n",
+	fmt.Fprintf(&sb, "  Hourly:  %s / %s (%d%%) %s\n",
 		formatNumber(summary.HourlyTokens),
 		formatNumber(u.HourlyLimit),
 		int(summary.HourlyPct),
-		FormatUsageBar(summary.HourlyPct, barWidth)))
-	sb.WriteString(fmt.Sprintf("  Daily:  %s / %s (%d%%) %s\n",
+		FormatUsageBar(summary.HourlyPct, barWidth))
+	fmt.Fprintf(&sb, "  Daily:  %s / %s (%d%%) %s\n",
 		formatNumber(summary.DailyTokens),
 		formatNumber(u.DailyLimit),
 		int(summary.DailyPct),
-		FormatUsageBar(summary.DailyPct, barWidth)))
-	sb.WriteString(fmt.Sprintf("  Session: %s / %s (%d%%) %s\n",
+		FormatUsageBar(summary.DailyPct, barWidth))
+	fmt.Fprintf(&sb, "  Session: %s / %s (%d%%) %s\n",
 		formatNumber(summary.SessionTokens),
 		formatNumber(u.SessionLimit),
 		int(sessionPct),
-		FormatUsageBar(sessionPct, barWidth)))
-	sb.WriteString(fmt.Sprintf("  Cost:   $%.2f / $%.2f (%d%%) %s",
+		FormatUsageBar(sessionPct, barWidth))
+	fmt.Fprintf(&sb, "  Cost:   $%.2f / $%.2f (%d%%) %s",
 		summary.DailyCostUSD,
 		u.CostLimitUSD,
 		int(costPct),
-		FormatUsageBar(costPct, barWidth)))
+		FormatUsageBar(costPct, barWidth))
 
 	return sb.String()
 }