TL;DR
- Context: Pre-seed startup exploring alternatives to licensed game content to reduce strategic dependency
- Problem: Unclear whether AI could autonomously generate complete, playable games at usable quality
- Intervention: Designed and built an end-to-end autonomous generation pipeline as a feasibility PoC
- Impact: Validated a defensible product direction without committing a full engineering team
Intro
This work was done as part of my full-time role at Plutus during an exploration of how to reduce long-term dependency on licensed third-party games. The central question was whether modern foundation models could autonomously generate complete, playable games, not prototypes or snippets, but end-to-end experiences, fast enough to be product-viable.
Problem
- Licensing third-party games created long-term strategic dependency
- It was unclear whether LLMs could generate complete games reliably
- Free-form prompting risked brittle outputs and poor iteration
- Committing a full team without feasibility proof carried high opportunity cost
Intervention
- Treated the problem as a systems feasibility question, not a model demo
- Evaluated multiple frontier models for end-to-end code generation capability
- Designed a structured generation pipeline to eliminate ambiguity
- Built a production adjacent PoC that supported generation, iteration, and hosting
Impact
- Demonstrated that autonomous game generation was technically feasible
- Produced a working, playable PoC without allocating a full team
- De-risked a new product direction before roadmap commitment
- Established architectural patterns reusable across future AI products
Why This Matters
Ambitious AI ideas often fail not because models are weak, but because systems around them are underdesigned. Early feasibility work that surfaces real constraints can save months of misdirected execution and prevent teams from scaling the wrong abstraction.
Technical Deep Dive (Optional)
This section expands on model evaluation, system architecture, and execution details for readers who want technical depth.
View technical deep dive
Feasibility Validation
Goal
- Determine whether a single system could autonomously generate complete, playable browser games
Models Evaluated
- Claude 4
- ChatGPT-4.5
- Gemini
Observed Results
- Gemini and Claude produced playable JavaScript games in a single pass
- ChatGPT-4.5 required 2–3 iterations to reach comparable output
- Output quality was sufficient for browser-based games with simple mechanics
Conclusion End-to-end generation was feasible, but reliability required system-level constraints.
Core Architectural Principle
Autonomous generation requires structured intent, not free-form prompting.
The system was designed to progressively constrain ambiguity before code generation.
Generation Pipeline
1. Idea → Structured Game Brief
- Users submit a rough idea in natural language
- System converts it into a structured JSON brief:
- Game mechanics
- Controls
- Visual style
- Difficulty
- Win/loss conditions
- User explicitly reviews and approves the brief
This step eliminated ambiguity before execution.
2. Autonomous Multi-Agent Generation
Expansion Agent
- Converts the brief into a detailed technical specification
Coding Agent
- Generates full game code in a sandboxed environment
Context Management
- All generated files indexed in a RAG-backed memory layer
- Enabled multi-step reasoning over an expanding codebase
This allowed agents to maintain coherence beyond single prompts.
3. Compile, Host, Serve
- Automatic compilation and validation
- Deployed to a unique, playable URL
- Time-to-play measured in minutes rather than hours or days
4. Iteration Loop
- Users request changes in natural language
- Agent searches the indexed codebase via RAG
- Applies targeted edits rather than regenerating everything
- Recompiles and redeploys automatically
This supported iterative refinement without manual intervention.
Platform Capabilities
Beyond core generation, the PoC included:
- User authentication and session management
- Credit-based model usage and limits
- Payment and usage tracking
- Integration hooks compatible with Plutus hosting
The system was production-adjacent, not a throwaway demo.
Scope & Disclosure
- This work covered feasibility validation and PoC implementation only
- Pixelsurf evolved significantly after my departure due to a health-related sabbatical
- Fine-tuning, orchestration optimizations, and later-stage improvements are intentionally excluded
Key Lessons
- Feasibility beats ambition — validate before scaling teams
- Systems matter more than prompts — structure enables reliability
- Iteration is the real test — generation without editability is a dead end
- Early constraints unlock speed — ambiguity is the biggest bottleneck
Completed during the pre-seed stage at Plutus as a feasibility-led PoC.