No, seriously. An AI agent explored my project, connected to my Unity editor, built the game, deployed the website, committed the code, pushed it to GitHub, and then wrote the blog post you're reading right now. In one session.
What Is OpenClaw
OpenClaw is an AI agent platform. You give it tools, connect it to your stuff, and talk to it over Telegram, Discord, whatever. It runs in a Docker container with access to your files, terminal, and any MCP servers you configure.
I connected it to two things: my Unity editor (via the MCP Unity server) and my GitHub repos (via the GitHub MCP server). Then I pointed it at my two project folders mounted from my Windows machine.
And then I just... talked to it.
The Setup
It wasn't plug-and-play. The first thing the agent did was try to talk to Unity and fail. The MCP Unity server was running inside Docker, Unity was running on Windows, and they couldn't see each other.
The problem: Unity's MCP server was only listening on localhost. Docker lives in its own network. It routes to the host machine through host.docker.internal, but Unity wasn't accepting connections from outside.
The fix: one checkbox. "Allow Remote Connections" in the MCP Unity window. That made it listen on 0.0.0.0 instead of 127.0.0.1. Suddenly the agent could see my Unity editor.
Building the Game
I have a custom editor window called Game Deploy that automates the entire build pipeline: delete old data, build Addressables, create a new version folder, build WebGL, update version strings across the website, and start the dev server. Eight steps, one button.
Problem: the agent could open the window via the Unity MCP execute_menu_item tool, but it couldn't click buttons. MCP gives you programmatic access to Unity, not mouse control.
So it wrote its own solution. It added a new menu item — Tools/Run Full Deploy — that calls the deploy function directly. Changed RunFullDeploy() from private to internal, told Unity to recompile, and then triggered the build. The whole thing ran: Addressables, WebGL build, version bump from v96 to v101, website started.
It adapted to a limitation it discovered in real time. That was kind of wild to watch.
Verifying the Deploy
After the build finished, the agent verified everything worked. It curled the website, hit the paywall (correct — that's supposed to be there), redeemed the free access code via POST request, followed the redirect, and confirmed the Unity WebGL loader was serving v101 assets.
End-to-end verification without opening a browser. It can't actually play the game — no WebGL renderer in a Docker container — but it confirmed the infrastructure was solid.
The Git Saga
Then came git. The agent tried to check what needed committing and git said everything was modified. Every single file in both repos.
Turns out: Windows uses \r\n line endings, Linux uses \n. The files are mounted from my Windows drive into a Linux Docker container through something called a 9p mount. Git inside Linux saw every line ending as a change.
Fix: added * text=auto to .gitattributes in both repos. Git now normalizes line endings automatically regardless of which OS does the commit. Problem solved permanently.
While we were at it, we also stopped tracking the /Game/ and /PreGame/ build folders. They were hundreds of WebGL build files that got recommitted every version bump. Removed them from git tracking, added them to .gitignore. Build artifacts don't belong in version control.
Commit and Push
The agent committed both repos and pushed to GitHub. The Unity repo was painfully slow through the Docker mount (9p + LFS = molasses), but it got there. Two clean commits, two pushes, done.
And Then This
Then I said "write a blog post about what we just did." And here it is.
The agent read the existing blog posts to match the style, created this HTML file, added it to the development index, and it's live on the site right now. No manual steps.
What This Means
I now have an AI that can:
- Read and edit C# scripts in my Unity project
- Interact with the live Unity editor (create objects, tweak components, read console logs)
- Trigger full WebGL builds and deployments
- Modify the website (HTML, Flask backend, Docker configs)
- Verify deployments work end-to-end
- Commit and push to GitHub
- Write blog posts about all of the above
I design and playtest. It builds. That's the deal.
Tools used: OpenClaw, MCP Unity, GitHub MCP, Docker, Telegram, and one checkbox labeled "Allow Remote Connections."
Cost of this blog post: About $20 in API credits. The entire session — exploring the project, debugging the MCP connection, building the game, fixing git, committing, pushing, and writing this post — burned through roughly $20 of Claude Opus tokens. Most of it went to the massive git diffs flooding the context window with hundreds of WebGL bundle filenames. Turns out, the real cost of build artifacts in version control isn't disk space. It's AI tokens.