Building a C++ engine with an AI agent harness

Building a low-level C++ voxel-planet engine (see PlanetExplorer) solo means being the researcher, the implementer, and the reviewer at once. Rather than treat an LLM as an autocomplete, I built a small agent harness around the project — specialized, mostly read-only agents plus workflow skills — so AI accelerates the hard parts while the architecture and testing gates stay firmly in control. The goal is leverage without vibe-coding.

The agents

• engine-research — a read-only research specialist. Design and trade-off questions (Vulkan vs. Dawn/WebGPU, windowing, build tooling, and rendering/voxel techniques: marching cubes, transvoxel, GPU-driven rendering, LOD, occlusion) get answered from current, official sources, not model memory. It investigates and reports; it never edits code. That keeps low-level decisions grounded where being subtly wrong is expensive.
• engine-reviewer — a C++/C review specialist. It reviews a diff for correctness bugs, simplification/dedup, C++/C best practices, and adherence to this project's architecture and testing gates, then reports structured, issue-ready findings. I run it after every significant change to the engine's native C++ source. It reports; it doesn't edit or merge.

The skills

On top of the agents, a set of custom skills — start-issue, commit, pr, review, new-issue — encode the repository's actual workflow (branching, signed commits, PR conventions). Crucially, they're thin orchestration over code and steps that are already deterministic and unit-tested — the skills exist to cut the amount of human input, not to replace the tested logic underneath. Net effect: fewer manual steps, same testable, reliable outcome.

The loop

flowchart TB
  T[Design question / task] --> R[engine-research
grounded in official docs · read-only]
  R --> IMPL[Implement in C++]
  IMPL --> REV[engine-reviewer
diff review vs architecture + gates]
  REV -->|findings| IMPL
  REV --> G{Testing gates}
  G -->|unit · GPU-vs-CPU ref · golden image| PASS[commit / pr skills]
  G -->|fail| IMPL
  PASS --> MERGE[Merge]
    

Why it's built this way

• Agents are advisory, gates are authoritative. Research and review agents report; correctness is still decided by deterministic unit tests, GPU-pipeline validation against a CPU reference, and headless golden-image comparison. The AI never has commit authority.
• Grounded, not remembered. Forcing the research agent to cite current official sources is what makes it trustworthy for graphics-API and algorithm decisions.
• Reusable discipline. This is the same instinct I apply to production tooling — encode the standards once, make the routine one command, keep humans and tests in the loop.