I Had Never Built A VR App – 8 Days Later, Mine Was On The Quest Store

Until a little over a week ago, I had never built a VR app.

I’ve spent a few years using VR and writing about it, so I have a pretty good sense of what feels natural inside a headset. Building those experiences was something I had always left to people who actually knew how to code.

I don’t know C#. My Unity experience was minimal. I had never built an APK for Quest or submitted an app to the Meta Quest Store.

After watching how quickly AI coding tools were improving, I started wondering how much of that gap I could cross without becoming a programmer first.

So I decided to try.

I intentionally chose a very simple idea. Punchable Face is about as straightforward as the name suggests. You stand in front of an obnoxious carnival barker and punch him. Your punches are scored based on velocity, his head reacts when you hit him, his face gets redder as he takes more punishment, and the whole thing happens inside a small carnival environment.

Punchable Face was deliberately small enough that I could keep the problem bounded.

I wasn’t trying to prove I could suddenly become a game developer. I wanted to see whether I could take a simple VR idea all the way from an empty Unity project to something people could actually download from the Quest Store.

That meant getting through the entire process, including development, testing on a real headset, creating the store assets, submitting the app to Meta and getting it approved.

Starting With Almost No Development Experience

I started Punchable Face on the morning of Saturday, September 5.

My hardware was an M2 MacBook Air and a Quest 3. The project was built in Unity 6.3 LTS using Unity’s OpenXR plugin with Meta XR SDK components for Quest-specific functionality. I also tested the finished app on Quest 2.

I used ChatGPT throughout the project to help plan what I wanted to build, work through problems and make design decisions. Codex handled most of the code changes and Unity project modifications.

I mostly used GPT-5.6 Sol at Medium reasoning for day-to-day work, and switched to GPT-6 Astra Medium when I hit harder problems, including a persistent XR positioning issue.

That created a development process I had never experienced before.

I would describe what I wanted Codex to build. It would modify the project. I would run a new build, put on the Quest and try it.

Then I would take the headset off and tell it what was wrong.

There was usually something.

The character was too low. The gloves were pointing in the wrong direction. Punches didn’t feel strong enough. A sound effect didn’t have enough impact. A UI element needed to move.

Then I would prompt it again.

Most of the project followed the same basic loop:

Prompt. Wait. Build. Test in the headset. Give feedback. Repeat.

I wasn’t writing the code. Codex was doing a huge amount of work that I simply didn’t know how to do.

But I was spending a lot of time deciding whether what it built was actually any good.

Building It Piece By Piece

The first version of Punchable Face was barely anything.

There were placeholder hands, a target and basic punch detection. If I swung a controller fast enough and made contact, the app recognized it as a punch.

That was enough to tell me the basic idea worked.

From there, I kept adding one thing at a time.

The first target became the carnival barker. His head started reacting to punches with a spring-like motion. I added blinking, stronger haptics and visible damage feedback. Repeated punches caused his face to become increasingly red before slowly returning to normal.

I also used Meshy during character development, generating 3D mockups for both the Barker and the second target character, the Flexer, while I worked through their visual direction before settling on the versions used in the app.

The punch sound went through several versions. At one point I asked Codex to create something more elaborate and ended up liking the earlier, simpler sound better. I had it revert the change.

That happened more than once.

Codex could implement an idea very quickly. Sometimes I would put on the headset, try it and immediately decide the previous version was better.

The placeholder hands eventually became simple boxing gloves generated during the development process. I could have bought a more polished 3D asset, but for this first experiment I wanted to see how far I could get without adding paid art assets. The generated gloves worked well enough for what I was trying to learn, so I kept them and moved on.

I added an Impact Score ranging from 100 to 999 based on punch velocity, along with a Session Best score and an About panel explaining how the system worked.

Eventually I had a functioning punching mechanic and a character floating in space.

He needed somewhere to live, so I built out a carnival environment around him with a boardwalk, booths, lights, a Ferris wheel, coaster elements and a marquee. The Flexer got his own unique car meet environment. I kept both intentionally low-poly and simple, with the focus on the character. The environment just sets the right tone.

That expansion brought another set of problems.

You Still Have To Put The Headset On

This was probably the biggest lesson from the entire project.

Something can work exactly as implemented and still feel wrong in VR.

Character height became a surprisingly annoying example. The barker kept appearing too low when I put on the headset. Codex tried compensating for headset height before eventually tracing part of the problem to the XR Origin camera offset.

That was one of the points where I switched over to GPT-6 Astra Medium because the problem involved several pieces of the XR setup interacting with each other.

A sound could trigger correctly every time and still sound bad.

A boxing glove could be positioned correctly and still look wrong attached to my hand.

Those were things I could only really judge by putting on the Quest.

That was also where my own experience with VR became useful. I didn’t know how to write the systems underneath the experience, but I knew what I wanted those systems to feel like.

I could tell when a punch felt weak. I could tell when something was positioned awkwardly in three-dimensional space. I could tell when an effect was distracting or when an interaction felt natural.

My role in the development process was telling Codex what I wanted the experience to do, then repeatedly judging the result and translating what I experienced in VR into human terms I could feed back to Codex for refinements or changes.

From Saturday To Tuesday Night

By Tuesday night, September 8, I had a version of Punchable Face that I considered ready to submit.

That was essentially four days after I started.

I hesitate to say I “built a game in four days” because that makes it sound like I spent four full days sitting in front of Unity.

I didn’t.

It was Labor Day weekend. I was doing family things and living my normal life. Most of the development happened in blocks of several hours, often in the evening.

I also didn’t keep a time sheet, so I’m not going to guess at an exact number of development hours afterward.

A surprising amount of the process involved waiting.

I would wait for Codex to finish. Then I would run another Unity build. Then I would put on the headset, test it, take the headset off and explain what I wanted changed.

Then the cycle started again.

By Tuesday night, though, I had gone from almost no software development experience to an app I was willing to submit to Meta.

Then I Had To Actually Publish It

Finishing the app was only part of what I wanted to learn.

I still had to figure out how to release it.

That meant creating the store listing, making the app icon, thumbnail and key art, preparing the Android release build and working through Meta’s submission process.

Then I waited for Meta to review it.

Punchable Face was approved.

On September 13, eight days after I started the project, it went live on the Meta Quest Store for $1.99.

For the first time, something I had started building the previous weekend was publicly available on the Quest Store.

Anyone could buy it. Seeing it live on the Quest Store was genuinely exciting, and a little nerve-racking.

What This Actually Showed Me

I still can’t sit down and write Punchable Face from scratch in C#.

I didn’t become a programmer in eight days.

There are pieces of the Unity project that I understand far better now than I did when I started, but there are also plenty of things Codex handled that I would struggle to reproduce on my own.

What changed was what I could attempt.

Before this, having an idea for a VR experience and actually turning it into software felt like two very different things. The technical barrier between them was high enough that I would have stopped at the idea.

Using ChatGPT and Codex lowered that barrier enough for me to get through it.

I still had to decide what to build.

I still had to decide what looked good.

I still had to decide whether an interaction felt right.

I still had to recognize when something Codex produced wasn’t working and explain what I wanted instead.

And I still had to eventually stop tweaking things and decide the app was finished.

What I didn’t have to do was spend months learning enough C# and Unity programming to get to the point where I could start testing the idea.

The experiment also made the gap between “working” and “well built” much more obvious to me.

I could get a simple idea running surprisingly quickly, but I was still relying on a tool to make technical decisions I didn’t fully understand. On a larger project, questions around architecture, performance, maintainability, interaction design and production would become much harder to navigate without deeper development experience.

With Punchable Face, I could keep the scope small, lean on my experience as a VR user and tester, and make judgment calls about what felt good enough to ship. That does not mean the same workflow would scale cleanly to a much more ambitious game.

Eight days after I opened the project, Punchable Face was on the Quest Store.

And by then I had learned something else.

I had built the entire app without using several newer tools that can give AI coding agents more direct access to Unity and a running XR application.

So for my next VR project, I decided to try a very different workflow.

Stay tuned.