A production pipeline I assembled from ChatGPT, Claude, Claude Code, Meshy, Blender, Flow (labs.google), Suno, ElevenLabs, and Firebase — used to ship three games across mobile, desktop, and VR with a one-to-three-person team. Not "AI did it." AI in specific roles, with the human owning the decisions that matter.
A modern game needs concept art, 3D models, animation, music, voice acting, narrative, dialogue trees, level design, UI/UX, gameplay code, telemetry, monetization, store-page assets — each historically a specialist's full-time job. A solo developer or two-person team has to drop scope, hire fractionally, or burn out.
The 2024–25 generation of AI tools doesn't replace specialists. What it does is collapse a specific bottleneck: the time between thought and prototype. Done well, this lets a small team operate at studio scope without studio headcount. Done badly — and most attempts are done badly — it produces generic slop and a graveyard of half-built features.
The difference is the discipline: what you delegate, what you keep, and how the tools compose as a pipeline rather than a heap of browser tabs. This case study walks through the pipeline I built — and the rules I follow to keep it from devolving.
Every project moves through these stages. Most tools serve exactly one stage; a couple (Claude, ChatGPT) sit across multiple. The point isn't tool count — it's that each stage has a primary tool with a known failure mode, so I know what to verify.
bpy Python API for batch operations and parametric edits.The asymmetry that matters: each tool has a job specific enough that I can verify its output. Voice is right or wrong; mesh topology is clean or it isn't; code compiles and runs or it doesn't. The pipeline isn't "AI agent goes brrr" — it's a chain of human-checkable artefacts produced faster than I could produce them alone.
The most non-obvious combination in the pipeline is Meshy + Blender + Claude. Meshy produces a textured base mesh from text or an image in about a minute — fast, but never ship-ready. Blender, driven by Claude through the bpy Python API (via the Blender MCP server), does the surgery that turns the raw output into a game-ready asset: slicing, adding, retopologizing, rigging, animating.
The trap most teams fall into is treating Meshy output as final. The geometry is dense and triangulated, the topology has no edge loops at deformation joints, the mesh is a single shell with no rig points. Drop it into Unity directly and you get a static prop that can't move. The pipeline below is what gets you the rest of the way.
bpy.ops.mesh.bisect at wrist / ankle / neck planes to separate the limbs into clean parts with their own edge loops. For Karma's hungry-ghost villagers, the mask separates from the body so it can rotate independently — the spirit's gaze drifts off-center while the body holds still.bpy.ops.mesh.extrude_region_move, primitive_cylinder_add, vertex welding — wherever Meshy comes back without something. Riley's mine-cart got its wheels rebuilt this way; Meshy returned a clean cart body, Claude added the four wheel cylinders + axle constraints.smart_project. Texture is rebaked from the Meshy original onto the cleaner UVs.bpy.ops.armature.bone_primitive_add, parents the slices to bones, then applies parent_set(type='ARMATURE_AUTO') for heat-diffusion weighting. Vertex group cleanup respects the slice boundaries so weights don't bleed across joints.
Three pulls from the pipeline: a character (Ananda the child-monk from Karma) and a prop (Riley's mine cart) — both fresh out of Meshy — alongside the same prop after Blender + Unity finished with it: in-engine, riding through Riley's lava world. The Meshy step gets you a clean base. The Blender step (the wide-mock above — the rig surgery happening) is what makes it move. The in-engine result is what the player ends up with.
The same workflow built Karma's hungry-ghost villagers (the masked spirits with internal craving orbs), Sammy's wardrobe variants, Ananda's temple geometry, the Hum Tunnel's neon arch in Riley, and most of Riley's overworld props. Meshy is the input. Blender + Claude is what makes it ship.
The pipeline isn't a template — each game pulls a different combination of tools. Below: which tool did what on each project, and why that combination.
The reason most "AI-augmented" workflows produce mush is that they skip the boring part — the discipline that keeps the human in the loop where it matters and out of the loop where it doesn't. Five rules I keep:
The combined effect of those five rules is that the ratio of intention to execution inverts. The decisions that used to take weeks — "what should this chapter feel like?" "what's the right cutscene rhythm?" "is this fail-soft or just soft?" — get the time they deserve. The translation from decision to working build compresses to hours.
A few stills from real working sessions across the three games — same five rules, three different fictions:
↑ different worlds. one pipeline. one human.
A game that doesn't ship is a hobby. The ship-stack handles the boring infra so the design can stay sharp:
level_attempt_summary — answers ~60% of design questions on its own.The portfolio you're on right now is itself an artefact of this pipeline. singhabhilasha.com was built end-to-end with Claude Code — HTML, CSS, JavaScript, case-study writing, deployment, and DNS migration. No CMS, no build step, no framework.
case-study.css design system; one HTML file per case study; custom interactions (animated dachshunds in the footer, cursor follower, ticker, konami-code easter egg) hand-written.master branch root of abiee17/singhabhilasha-website. Custom domain wired via a CNAME file in the repo. Let's Encrypt cert auto-provisioned and auto-renewed by GitHub. Deploy = git push. Static HTML cached at GitHub's CDN edge for sub-second TTFB globally.gh CLI, created the public repo, pushed 168 files in a single commit, enabled Pages via gh api, and set the custom CNAME. We walked through DNS cutover at GoDaddy together — moving authority off Wix's nameservers, pointing A records at GitHub's 185.199.108–111.153 block, setting CNAME www → abiee17.github.io, and finally tracking down a stray apex "Parked" record that was silently blocking Let's Encrypt's HTTP-01 validation. Once it was deleted, the cert issued; HTTPS came up; site went live.principle-list, scope-card, outcome-row, pull-quote, callout), same typographic scale. Visual consistency without per-page hand-tuning, because the pattern lives in Claude's working context as a kept invariant.There's a small recursion to enjoy here. The case-study format you're reading is the case-study format I co-designed with Claude. Sections, callouts, the dark-stripe rhythm, the way the eyebrow lines anchor each block — all part of the system. When the system is the artefact, every new case study slots in for free.
Three projects in different genres on different platforms — Match-3 on mobile, narrative RPG on desktop, companion mechanic exploring AR/VR — all carried by a stack of nine specialized AI tools, with one designer-developer-engineer at the centre.
The lesson generalizes: you don't need an AI agent that does everything. You need a pipeline where each stage has a tool with a verifiable output, a human in the loop where taste matters, and a clear rule for when to ship vs. when to redo. The work that used to require six full-time specialists now runs on one human plus nine specialized assistants — each doing the job a senior in that craft would do, faster than the human alone.
The frontier from here is the games where AI isn't just in the pipeline but in the gameplay — where the player interacts with a model at runtime, not just with content the model produced offline. My Friend Riley sits on that line. The same discipline applies: design docs first, verifiable output, taste stays human.