# Perf Reviewer

> Review code for performance issues and run benchmarks. Use when user asks to analyze performance, compare AILANG vs Python vs Go, run benchmarks, or review code for optimization opportunities. Use when this capability is needed.

- Skill: `tomevault-io/perf-reviewer` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add tomevault-io/perf-reviewer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/perf-reviewer/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tomevault-io (https://skillmd.com/u/tomevault-io)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tomevault-io/perf-reviewer

---


# Performance Reviewer

Review code for performance issues and run cross-language benchmarks.

## Quick Start

**Run benchmarks comparing AILANG vs Python vs compiled Go:**
```bash
# Run all standard benchmarks
.claude/skills/perf-reviewer/scripts/benchmark.sh

# Run specific benchmark
.claude/skills/perf-reviewer/scripts/benchmark.sh fibonacci

# Review code for performance issues
# Just ask: "review this code for performance"
```

## When to Use This Skill

Invoke this skill when:
- User asks to "benchmark" or "compare performance"
- User wants to compare AILANG vs Python vs Go
- User asks to "review for performance" or "optimize"
- User mentions "slow", "performance", "bottleneck"
- After implementing compute-intensive code
- Before releases to verify no performance regressions

## Available Scripts

### `scripts/benchmark.sh [benchmark_name]`
Run cross-language benchmarks comparing AILANG interpreted, Python, and AILANG compiled to Go.

**Available benchmarks:** `fibonacci`, `sort`, `transform`, `all`

**Output:** Timing comparisons, speedup ratios, and recommendations.

### `scripts/profile_ailang.sh <file.ail>`
Profile an AILANG file with timing breakdown by compilation phase.

## Workflow

### 1. Performance Review (Code Analysis)

When reviewing code, check against these principles (see [resources/principles.md](resources/principles.md)):

**Critical checks:**
1. **Algorithmic complexity** - Is there an O(n log n) solution for O(n²) code?
2. **Batch operations** - Can multiple operations be combined?
3. **Memory allocation** - Are allocations inside hot loops?
4. **Data layout** - Are frequently-accessed fields colocated?

**Quick checklist:**
```
[ ] No O(n²) where O(n log n) exists
[ ] Batch APIs for repeated operations
[ ] Allocations hoisted outside loops
[ ] Hot paths optimized, edge cases separate
[ ] No unnecessary string formatting in loops
```

### 2. Benchmarking (Cross-Language Comparison)

**Run benchmarks:**
```bash
# Full benchmark suite
.claude/skills/perf-reviewer/scripts/benchmark.sh all

# Single benchmark
.claude/skills/perf-reviewer/scripts/benchmark.sh fibonacci
```

**Interpret results:**
| Ratio | Interpretation |
|-------|----------------|
| Go/AILANG < 0.1x | Compiled Go is 10x+ faster (expected) |
| Python/AILANG ~ 1x | Similar interpreted performance |
| AILANG/Go > 10x | Consider compilation for this workload |

### 3. Profiling (Phase Breakdown)

```bash
.claude/skills/perf-reviewer/scripts/profile_ailang.sh examples/compute_heavy.ail
```

**Phase timing helps identify:**
- Slow parsing -> complex syntax
- Slow type checking -> deep type inference
- Slow evaluation -> algorithmic issues

## Performance Principles Summary

From [resources/principles.md](resources/principles.md):

| Principle | Action |
|-----------|--------|
| Profile First | Measure before optimizing |
| Algorithms > Micro-opts | O(n) beats optimized O(n^2) |
| Batch Operations | Amortize overhead |
| Memory Layout | Cache-friendly structures |
| Fast Path | Optimize common case |
| Defer Work | Lazy evaluation |
| Right-size Data | Appropriate containers |

## Resources

- [resources/principles.md](resources/principles.md) - Full performance principles (Abseil-inspired)
- [resources/go_patterns.md](resources/go_patterns.md) - Go-specific optimization patterns

## Notes

- Compiled AILANG (Go) should be 10-100x faster than interpreted
- Python comparison provides baseline for interpreted languages
- Always profile real workloads, not just microbenchmarks

---
> Converted and distributed by [TomeVault](https://tomevault.io/claim/sunholo-data) — claim your Tome and manage your conversions.
<!-- tomevault:4.0:skill_md:2026-04-11 -->