Agentic Game Development with the Dev Thicket Ecosystem

Building a game from scratch is slow. You set up a window, write a render loop, load textures, wire up input, build a camera system, implement z-ordering, and then you still do not have a single game mechanic working. Most of that work is structural. It is necessary, but it is not what makes your game unique. What if an AI agent could handle the structural parts while you focus on what matters?

That is exactly what happens when you pair the Dev Thicket ecosystem with an agentic coding tool like Claude Code. The combination turns hours of boilerplate into minutes of directed conversation. You describe what you want, the agent writes it, and the ecosystem's layered architecture means there is far less to write in the first place.

Why ecosystems matter for AI agents

AI coding agents are only as effective as the tools and libraries they work with. Give an agent a blank canvas and a low-level graphics API, and it will spend most of its token budget reinventing wheels. Give it a well-documented, layered ecosystem with clear abstractions, and it can jump straight to the interesting parts.

Dev Thicket has two stacks, each built in layers that stack cleanly.

The Go stack (available now)

The Go stack is production-ready today. It runs on Ebitengine, a mature 2D game engine for Go, and layers Dev Thicket's scene graph and UI on top:

• Willow provides a PixiJS-style scene graph on top of Ebitengine: sprites, containers, cameras, z-ordering, blend modes, and batched rendering. All the structural plumbing that would otherwise take hundreds of lines of setup.
• Willow UI adds a full widget library on top of Willow: buttons, sliders, text inputs, panels, reactive data bindings, XML templates, and theming.

The C++ stack (coming soon)

The C++ stack is under active development and will bring the same layered philosophy to native C++ development with its own platform foundation:

• Heartwood is the platform layer: windowing, input, audio, GPU abstraction, asset loading. It replaces Ebitengine's role, giving you a cross-platform foundation built from the ground up.
• Willow (C++) is a C++ port of the scene graph, sitting on top of Heartwood instead of Ebitengine. Same concepts, native performance.
• Willow UI (C++) brings the widget library to C++ with the same reactive model and theming system.
• ThicketScript adds a scripting layer compiled to bytecode for a C++ VM. Write game logic in .tks files with full IDE support, and the full C++ stack available underneath.

Both stacks share the same design philosophy and API patterns. If you learn Willow in Go today, the C++ version will feel familiar. The agent benefits from this consistency too; patterns it learns from one stack transfer to the other.

Each layer reduces the surface area of code an agent needs to generate. Instead of writing a sprite batcher from scratch, the agent calls willow.NewSprite(). Instead of building a settings menu widget by widget with raw draw calls, the agent uses Willow UI's Slider, Toggle, and Button components. Less generated code means fewer mistakes and faster iteration.

Documentation is the interface

An agent cannot use what it cannot understand. This is where most game development ecosystems fall short for AI-assisted workflows. The documentation is scattered, incomplete, or locked in video tutorials that agents cannot consume.

Dev Thicket's documentation is written with both humans and agents in mind. Every project has structured API references, getting-started guides, and concept explanations. When you point Claude Code at the Dev Thicket docs, or when the agent reads the source code directly, it finds consistent patterns, clear naming, and thorough doc comments.

This matters more than it sounds. An agent that can look up how DisplayObject.SetPosition() works, what parameters NewTileMap() takes, or how reactive bindings connect in Willow UI does not need to guess. It writes correct code on the first try.

What this looks like in practice

Here is a real workflow. You open a terminal, start Claude Code, and say:

"Create a top-down RPG with a tilemap, a player character that moves with WASD, a camera that follows the player, and a health bar overlay."

With a raw Ebitengine project, the agent would need to:

1. Set up the game struct and draw/update loop
2. Load and slice a spritesheet
3. Build a tilemap renderer with chunked drawing
4. Implement a camera with viewport culling
5. Write WASD input handling with frame-rate-independent movement
6. Build a health bar from raw image draws
7. Handle z-ordering so the UI draws on top

That is hundreds of lines of structural code before anything game-specific happens. With Willow and Willow UI, the same request becomes:

1. Create a Stage and add a Viewport
2. Add a TileMap node to the viewport
3. Add a player Sprite to the viewport
4. Attach a Camera that follows the sprite
5. Read WASD input and update the sprite's position
6. Add a Willow UI MeterBar bound to a health Ref

The agent writes maybe 60 lines of meaningful code instead of 300 lines of plumbing. The tilemap handles its own chunked rendering. The camera handles viewport culling. The health bar updates reactively when the ref changes. The scene graph handles draw order. Every piece just works because the ecosystem handles the hard parts.

MCP servers: first-class agent integration

Documentation is the baseline. The next step is giving agents direct, structured access to ecosystem knowledge through MCP (Model Context Protocol) servers.

MCP servers on our roadmap will let agents query Dev Thicket APIs, look up widget catalogs, retrieve code examples, and understand project structure through tool calls rather than searching through docs. Instead of the agent reading a page about Willow UI's slider API, it calls a tool that returns the exact function signature, parameter types, and a usage example. Structured data in, correct code out.

This is not hypothetical tooling bolted on after the fact. It is a first-class design goal. As both the Go and C++ stacks grow, so does the agent surface area. Every new widget, every new API, every new feature ships with the metadata that makes it agent-accessible.

Vertical slices in minutes, not hours

The real unlock is speed. A vertical slice, a thin but complete cut through your game's stack from input to rendering to UI, is the most valuable artifact in early development. It proves your idea works. It gives you something to playtest. It tells you whether the game feels right before you invest weeks of effort.

Traditionally, getting a vertical slice takes a full day or more. You are fighting boilerplate, debugging rendering order, wiring up input systems, and manually laying out UI. With an agentic workflow on top of Dev Thicket, you describe the slice in natural language and iterate in real time.

• "Add a minimap in the top-right corner that shows the tilemap at 0.2x scale."
• "Make the player sprite flash red when health drops below 20."
• "Add a pause menu with resume and quit buttons, darken the background behind it."

Each of these is a single prompt. The agent knows the ecosystem's APIs, generates code that uses the right abstractions, and you see the result in seconds. What used to be an afternoon of work becomes a few minutes of conversation.

The compound effect

This is not just about saving time on one task. It compounds. When the agent generates code that uses Willow's scene graph correctly, that code is maintainable. When it uses Willow UI's reactive bindings instead of manual state synchronization, the UI stays consistent as your game grows. When it builds on Ebitengine's asset handling instead of hand-rolling texture loading, you get the engine's built-in optimizations for free.

Good abstractions make AI-generated code better, not just faster. The agent cannot introduce z-ordering bugs when the scene graph handles draw order. It cannot forget to update the health bar when the reactive binding does it automatically. The ecosystem's guardrails keep the generated code on the right track.

Getting started

If you want to try this workflow today:

1. Set up a Go project with Willow and Ebitengine.
2. Install Claude Code or your preferred agentic coding tool.
3. Point the agent at the Willow documentation and start describing what you want to build.
4. Iterate. Describe features, let the agent generate, review, adjust, repeat.

The ecosystem does the heavy lifting. The agent does the typing. You do the thinking. That is how you get an MVP vertical slice out the door in minutes instead of hours.

As MCP servers and dedicated AI tool calls roll out across the Dev Thicket ecosystem, this workflow only gets faster. The goal is simple: make the distance between "I have an idea" and "I have a playable prototype" as short as possible.