Codex Forge: Unity Production Toolkit

A Codex-powered Unity production toolkit demonstrated in a stealth exploration game, combining editor tools, data-driven systems, validators, documentation, and GitHub PR workflows.

Comment

Inspiration

Solo game development requires constant context switching between gameplay programming, data authoring, content placement, debugging, documentation, and source control.

I wanted to test whether Codex could work not only as a code generator, but as a practical engineering partner inside a real, long-running Unity project.

Codex Forge is the production layer created and expanded during OpenAI Build Week for an existing first-person stealth exploration game. This submission focuses only on the systems, editor tools, and workflows added or meaningfully expanded during the event.

What it does

Codex Forge turns repeated Unity development tasks into structured, data-driven workflows.

The Build Week implementation includes:

  • Seeded free-stage generation using placement slots and weighted item pools
  • Editor previews and validators for randomized stage content
  • An item placement manager for inspecting scene objects and configuration issues
  • Item risk previews and an in-stage investigation inventory
  • ScriptableObject catalogs for equipment, materials, recipes, and sound effects
  • Data-driven equipment shops and loadout management
  • Equipment upgrades using money, materials, recipes, and saved ownership states
  • Save-data migration, validation, rollback, and atomic transactions
  • Stage reward integration for upgrade materials
  • Verification guides, project documentation, and GitHub pull-request workflows

These systems are demonstrated inside a family-safe stealth exploration scenario.

How we built it

The project is built with Unity and C#.

Configuration data is separated from gameplay code using ScriptableObjects and catalogs. Editor windows and validators make it possible to inspect project data without manually searching through scenes and assets.

Several interfaces are generated at runtime, which allowed new functionality to be added while minimizing risky changes to existing scenes and prefabs.

The development loop was:

  1. I defined the gameplay goal, constraints, and acceptance criteria.
  2. Codex proposed an implementation and created reviewable code and documentation changes.
  3. I tested the result inside Unity and returned screenshots, logs, and concrete observations.
  4. Codex analyzed integration problems and revised the implementation.
  5. Changes were merged only after manual verification.

GPT-5.6 supported architecture decisions, debugging, prioritization, and documentation. Codex was used extensively for Unity C# implementation, editor tooling, GitHub workflows, and iterative fixes.

Anthropic Claude was also used for a limited subset of supporting work. The final submission documentation identifies the roles of each tool. All gameplay decisions, testing, acceptance criteria, and final approvals remained human-controlled.

Challenges

Extending an existing project safely

This was not a blank prototype. New systems had to coexist with existing scenes, save data, UI, and gameplay logic.

To reduce regression risk, I used:

  • Save format versioning
  • Rollback on failed transactions
  • Runtime fallbacks
  • Editor validators
  • Small, reviewable pull requests
  • Step-by-step verification documents

Separating the submission from the commercial project

The original project contains purchased assets and unreleased production content.

This submission therefore uses a sanitized demonstration scope. Purchased assets, unreleased character-production tools, and proprietary production content are excluded.

Making AI-assisted development verifiable

The goal was not simply to generate a large amount of code. Each feature needed to be understandable, testable, and traceable.

The project uses commit history, pull requests, verification documents, and Codex session evidence to distinguish the Build Week work from the pre-existing project.

Accomplishments

I am especially proud of completing a connected production loop:

stage completion → material rewards → saved inventory → upgrade recipes → upgraded equipment → player loadout

I also created editor tools that replace repeated manual scene inspection with searchable lists, previews, and validation results.

Most importantly, the project demonstrates a repeatable human–AI workflow: natural-language design decisions are converted into testable Unity systems, reviewed in the real game, corrected through feedback, and documented before merging.

What we learned

The largest benefit of AI-assisted development was not typing code faster.

The real benefit was reducing context switching between design, implementation, debugging, documentation, and source control.

I also learned that AI development works best when it is paired with:

  • Clear acceptance criteria
  • Small pull requests
  • Human testing in the target environment
  • Screenshots and logs as grounded feedback
  • Explicit documentation of assumptions and limitations

What's next

Next, I plan to:

  • Package more of the generic editor tooling into reusable modules
  • Expand automated regression testing
  • Improve the visual presentation of the demonstration
  • Continue developing the commercial game
  • Preserve the human-review workflow as the project grows

Built With

Share this project:

Updates