Game Feel & UX
Design & Feel
Games that feel good in your hands and explain themselves.
Everything responds at once: Motion, sound and vibration hit at the same moment, so every action feels solid.
Ready for the next move: Players can tap again immediately, even while the last animation is still playing.
Help at the right moment: I teach each control when it becomes useful, and hints appear only when someone is stuck.
Level Design
Design & Feel
Thousands of levels, built from my rules and checked one by one.
I set the rules: I decide how levels look, what makes them hard, and how the challenge grows.
Code builds every level: A level builder follows those rules and starts each level from a new random board.
Every level is checked: Levels that miss a rule are rebuilt, and I play a few from every difficulty.
UI Development
Design & Feel
Interfaces that stay clear on every screen, from phone to headset.
Built from reusable pieces: Buttons, badges, panels and charts are made once and reused everywhere.
One theme for everything: Colours, spacing and fonts live in one theme, so a new look reaches every screen.
Made for every device: Layouts fit notches and thumbs on phones, and float as comfortable panels in VR.
VR Interaction & Comfort
Design & Feel
VR that is easy to see, reach and adjust.
Placed in easy view: Content floats at a comfortable distance and height, right in front of you.
Stays where you put it: Look around freely, and the content stays exactly where you left it.
Easy to adjust: Move, tilt, resize or recenter it with a few simple controls.
Game Architecture
Build & Optimise
Clean systems that grow with the game, on every platform.
One shared game core: Rules, levels and game logic live in one place that every platform uses.
A layer for each platform: Phone and VR each get their own screens and controls on top of the same core.
Parts with one job each: Every part does one thing well, so it is easy to test, change and reuse.
Performance
Build & Optimise
Smooth on phones and VR headsets, and light to download.
Measured on the device: Frame times are measured on real phones and headsets, where players actually feel them.
Every frame on budget: Game logic, drawing and loading each get their share of every frame, so nothing stutters.
Small and quick to open: Lean downloads and fast launches, even with a thousand levels inside.
Testing & Quality
Build & Optimise
Every change is proven before a player ever sees it.
I test my own code: Hundreds of automated tests check the rules, the levels and the builds.
A test for every bug: Each fix comes with a test that proves the bug is gone for good.
Proven on real hardware: Release builds are checked on real phones and headsets before they ship.
Tools & AI Workflow
Ship & Lead
Tools and AI handle the repetition, so I focus on the game.
One-click testing: Try any level or idea instantly, without launching the full game.
AI agents as teammates: Agents write code, drive the editor and run tests while I play, judge and decide.
Tools the whole team uses: Editor tools for building, playtesting, screenshots and releases, one menu away.
Release & Publishing
Ship & Lead
From first prototype to live on the store, on phone and VR.
Store-ready from the start: Signed builds, store pages, privacy forms and crash reporting are part of the plan.
One game, many stores: The same game ships to Google Play and Meta Quest, each with its own tuned build.
Better after launch: Crash reports and player feedback shape every update that follows.
Team Leadership
Ship & Lead
A team that moves fast because everyone knows how we work.
Small, clear goals: Work is split into small steps, each with a clear way to check it's done.
Shared standards: Common rules for code, commits and reviews keep everyone's work easy to combine.
Helping people grow: I mentor engineers in architecture and debugging, so they can take on bigger work.
From first idea to live game
Mobile or VR, puzzle or simulator, every project walks the same six checkpoints. Nothing moves on before it's ready (I've tried).
Understand the goal
Who is it for, and how should it feel?
What gets made: A one-page goal: player, feeling, device and limits.
Ready when: The whole team can say it in one sentence.
Prove the fun
Is the core action worth repeating?
What gets made: The smallest playable version of that action.
Ready when: People want to play it again.
Build the foundation
Is it ready to grow?
What gets made: Clean structure, shared standards, quick-test tools and automated tests.
Ready when: New features fit in safely.
Create and tune content
Does it play the way it was planned?
What gets made: Levels, modes and screens built from rules, then tuned by playing.
Ready when: The challenge rises at just the right pace.
Polish and optimise
Is every moment clear, smooth and comfortable?
What gets made: Feel, clarity and speed work on real devices.
Ready when: Smooth on every target device, and clear to a first-time player.
Release and improve
Is it stable, and what comes next?
What gets made: Store-ready builds, tested the way players install them.
Ready when: It's live, stable, and the next update is planned.
Inside every checkpoint
Every change goes around the same loop.
Plan: Pick one small goal and how to test it.
Build: Tools and AI agents handle the repetitive work.
Play & test: Tests catch what's broken. Playing catches what's boring.
Fix: Say how it should feel instead, then build that.
Keep the lesson: Turn the fix into a test, rule or checklist, so it stays fixed.