# Stuart Jeff

> Stuart Jeff is a senior game engineer and studio leader (Wood Fired Games, Baltimore MD) with 25 years shipping games across PC, console, mobile, web, VR, and cloud — as core engineer, design director, and studio-leading executive. For the past two years he has rebuilt that craft around AI coding agents, in the open. He builds MECS (a proprietary networked Entity Component System engine) and wood-fired-tasks (open-source orchestration for fleets of AI coding agents), and a vendor-neutral AI observability stack that ties model spend to shipped output.

## Pages
- [Landing](https://www.stuartjeff.com/): Overview — 25 years in games, 2 years making AI coding agents trustworthy enough to ship with.
- [About](https://www.stuartjeff.com/about): Full career arc (Big Huge Games, Sparkypants, Bad Robot, Legends of Learning), the training-data asymmetry thesis, and the source-of-truth flip.
- [Practice](https://www.stuartjeff.com/practice): How AI is actually used here — prompt histories, commit volumes, source-line deltas, and how output is verified before it ships.
- [Tracks](https://www.stuartjeff.com/tracks): Three named problems studios bring me — trustworthy agent output, AI telemetry & governance, and agent orchestration — each scoped on a call, plus an entry-point AI Adoption Audit.
  - [Trustworthy Agent Output](https://www.stuartjeff.com/tracks/trustworthy-agent-output): Trust agent-authored PRs without slowing review — layered verification with tests, hooks, CI, and read-only grader agents instead of line-by-line reading.
  - [AI Telemetry & Governance](https://www.stuartjeff.com/tracks/ai-telemetry-governance): Know what your AI spend buys, per commit — vendor-neutral, per-developer cost and usage attribution and the observability stack behind it.
  - [Agent Orchestration](https://www.stuartjeff.com/tracks/agent-orchestration): Point a fleet of agents at one backlog without the chaos — wood-fired-tasks, parallel execution, and atomic claiming.
- [Tools](https://www.stuartjeff.com/tools): The solo-built toolchain — MECS engine + editor, backend platform services, Unity systems, observability stack, and wood-fired-tasks.
- [AI Adoption Audit](https://www.stuartjeff.com/audit): A one-week diagnostic of your team's AI coding-agent adoption — validation, telemetry, orchestration, governance — plus a free self-scoring checklist. The lower-friction entry to the consulting tracks.

## Guides
- [Agentic Software Development](https://www.stuartjeff.com/guides/agentic-software-development): A working guide to agentic development from two years of solo practice — constraining agents with the compiler and environment, why validation is the real bottleneck, and the shift from writing code to governing the systems that grade it.
- [AI Agent Observability](https://www.stuartjeff.com/guides/ai-agent-observability): A working guide to AI agent observability and governance — why an agent can't log itself, the fire-and-forget capture layer, per-commit cost attribution, and governing a fleet with atomic claiming and read-only graders.
- [Game Engine Architecture](https://www.stuartjeff.com/guides/game-engine-architecture): A working account of building MECS, a custom C# ECS engine, and turning it into a multiplayer platform — the authoring model, deterministic networked simulation, and the raw-UDP backend.

## Glossary
- [Agent observability](https://www.stuartjeff.com/glossary/agent-observability): Instrumenting AI agents from the outside — deriving cost, identity, and activity without the agent's cooperation, because an agent won't log itself.
- [AI-in-the-loop workflow](https://www.stuartjeff.com/glossary/ai-in-the-loop-workflow): A process where agents execute multi-step work autonomously and the human governs the structures that grade the output, rather than reviewing every line by hand.
- [Coding agent vs AI assistant](https://www.stuartjeff.com/glossary/coding-agent-vs-ai-assistant): An agent executes a goal autonomously across many edits and runs the tests; an assistant answers questions and suggests snippets you paste in yourself. The line is autonomous multi-step execution.

## Writing
- [All writing](https://www.stuartjeff.com/writing): The full index of long-form essays — AI-in-the-loop development, agent observability and governance, and game-engine architecture.
- [Stop paying your best model to type](https://www.stuartjeff.com/writing/stop-paying-your-best-model-to-type): Two weeks ago I claimed that putting a cheaper model on execution and a strong one on verification cost about a third of frontier-everything, and I dropped the number without showing my work. Here it is — a headless-Unity prototype drained as four milestones under three model policies, priced task by task against my own telemetry. The cheap-worker run shipped seven-for-seven first-pass at $1.66 a task, Fable cost the most for a reason that has nothing to do with how good it is, and the whole thing turned into a new release of wood-fired-tasks that routes models by role and by task size.
- [You can't ask an agent to log itself](https://www.stuartjeff.com/writing/you-cant-ask-an-agent-to-log-itself): No vendor sells a per-developer view of your agents across the fence, so I built one — a fire-and-forget capture path, identity derived without the agent's cooperation, and one schema every vendor lands in. Then the payoff: org-wide AI accounting, the true cost of a shipped commit, and a telemetry tool I can interrogate — including the day it told me to stop running milestones the way I had been.
- [How I stopped reading the code](https://www.stuartjeff.com/writing/how-i-stopped-reading-the-code): Code review was supposed to be the non-negotiable. When I open-sourced wood-fired-tasks, I had pre-read 3.3% of the AI-written files in it — and none of the security-critical ones. The replacement for line-by-line review isn't trust. It's overlapping systems that grade each other — tests, hooks, CI, verifier agents, second-vendor audits — improved with the same telemetry discipline game developers use to tune their mechanics.
- [Stop talking to your agents](https://www.stuartjeff.com/writing/stop-talking-to-your-agents): The dominant way people work with coding agents is conversational — describe, correct, re-describe. That mode has a hard ceiling. The more durable lever is to constrain the environment so the agent physically cannot produce the wrong thing. In C#, the place to do that is the compiler. Here is how I flipped my engine's pipeline from human-first to agent-first, and how Roslyn turned a class of rules I had been writing into prose for years into build errors that neither a human nor an agent can miss.
- [Introducing wood-fired-tasks](https://www.stuartjeff.com/writing/introducing-wood-fired-tasks): Coordination infrastructure for fleets of AI coding agents — the missing primitive between one Claude Code session and ten of them working the same backlog without stepping on each other. MIT, on npm, self-hostable. Here's the origin story, the design, and how I run it.
- [From workstation buildout to AI in the loop](https://www.stuartjeff.com/writing/from-workstation-buildout-to-ai-in-the-loop): Two and a half years of AI practice, told in three acts. The story of how I went from asking a chat assistant inside Rider for help with build errors to running an orchestration layer that ships work I could not have written alone — and the measurable output curve that confirms the compound.
- [From engine to platform](https://www.stuartjeff.com/writing/from-engine-to-platform): The October 2023 prototyping contract that finally moved MECS from an in-process model of authoritative-server multiplayer to a real UDP wire, the 2024 backend stand-up that grew up around the engine, and the five-layer architecture that turned the simulation and the services around it into one codebase.
- [Six years of an engine](https://www.stuartjeff.com/writing/six-years-of-an-engine): MECS is six years old. The thinking that produced it is twenty-three. This is the origin story — from peer-to-peer lockstep RTS networking in 2003, through the Dropzone ECS engine in the mid-2010s, into the educational-MMO project that made the case for a new engine, to the thesis I wrote down in late 2020 that became MECS.

## Machine access
- Every page is also available as Markdown — send `Accept: text/markdown`, or append `.md` to any page URL (e.g. https://www.stuartjeff.com/guides/agentic-software-development.md or https://www.stuartjeff.com/writing/<slug>.md).
- [llms-full.txt (full post bodies for ingestion)](https://www.stuartjeff.com/llms-full.txt)
- [Writing index (JSON)](https://www.stuartjeff.com/writing/index.json)
- [RSS feed (full post text)](https://www.stuartjeff.com/rss.xml)
- Content-usage preferences (robots.txt Content-Signal): search=yes, ai-input=yes, ai-train=no — please cite with attribution; not consented for model training.
- Scope: a static content/writing site. It offers the machine-readable content above, but no API, authentication/OAuth, MCP server, or executable agent skills — discovery probes for those (e.g. /.well-known/openid-configuration, /.well-known/oauth-protected-resource, /.well-known/api-catalog, /.well-known/mcp/server-card.json) return 404 by design.

## Resources
- [wood-fired-tasks on GitHub](https://github.com/Wood-Fired-Games/wood-fired-tasks)
- [Wood Fired Games studio](https://www.woodfiredgames.com)
- [LinkedIn](https://www.linkedin.com/in/stuartjeff/)
- [Substack](https://stuartjeff.substack.com)