RemakeBench/skills

# Model the thing, not its outline

## The rule

> Model what the object is, not what its outline looks like: every asset must show the parts
> that would exist because it functions in the real world — how it is joined, supported,
> opened, carried, loaded, worn or maintained — because those parts are what separate an asset
> from a primitive with a texture. Apply this equally to every asset with no hero/background
> tiering, bevel every edge that catches light, and give every surface real thickness. An asset
> is only finished when it passes this test: rendered close-up at viewer height, a person
> unfamiliar with the project can identify what it is, how it is built, and how it is used —
> from geometry alone, with textures disabled. Anything that still reads as a primitive with a
> texture applied has failed and must be rebuilt, not adjusted. The deliverable is a close-up
> render of every asset plus a manifest, not the asset files — files existing on disk is not

# The judge loop: nobody passes their own work

Companion to `3d-asset-quality`, which defines the bar for ONE asset. This skill defines how a
BATCH of assets actually reaches that bar. Load both.

## The two failure modes this exists to kill

Both were observed, repeatedly, on real runs:

1. **Effort dilution.** Told to build nine assets to the same bar, a model spends real craft on
   three and ships six as textured boxes. The wider the scope, the worse the spread. No prompt
   wording fixes this — the builder's own "done" is the broken instrument, so done must be a
   verdict someone else issues.
2. **Score gaming by global levers.** When a score exists, models drift to shaders, lighting and

# Codex as a subagent

A second model, callable from Bash, structured-output-capable, and safely parallel. Requires an
authenticated `codex` CLI and `jq`; run `codex-doctor` before the first fanout.

## Defaults — do not restate them on the command line

| | default | why |
|---|---|---|
| model | `gpt-5.6-sol` | Override with `CODEX_SUB_MODEL` when your account uses another available model. |
| effort | **`medium`** | A practical balance for reviews and fanouts; raise deliberately for hard reasoning. |
| sandbox | **`read-only`** | Public-safe default. Pass `-s workspace-write` or `-s danger-full-access` only when the user authorized writes and the task requires them. |
| timeout | 900s | |

# Stages, gates, and which skill owns each

This is a routing document. The craft lives in the specialist skills; this map exists so they
load at the right moments instead of by trigger luck, and so ordering mistakes that have each
cost real projects real rounds are not re-made.

## The map

| stage | work | exit gate | loads |
|---|---|---|---|
| **0 — Art direction** | Hero image, site plan, section, elevations, materials sheet, character sheet — generated, pinned, hashed | Operator approves the hero (cheapest rejection point) + **congruence pass done, spec-as-text written** | `reference-pack-authority` |
| **1 — Playable sandbox** | Template adopted WHOLE if one is used; capsule player; greybox world built from the layout's own collision data; core loop playable | **`verify-by-playing`** — real input, route traversed, camera owned | `verify-by-playing` |
| **2a ∥ Environment** | Batch assets, coherent PBR surfaces, layout geometry | Judge passes the batch | `asset-judge-loop`, `3d-asset-quality` |
| **2b ∥ Character** | Model, rig, clips (generate high-poly → bake route) | Rig proven by MEASURED joint motion; sockets by read-back through the actual loader | `3d-asset-quality` |

# Grok as a subagent

A second non-Claude model, callable from Bash, natively structured-output-capable, and safely
parallel. Requires an installed and authenticated `grok` CLI plus `jq`. Run `grok-doctor` before
the first paid or high-fanout use.

## Defaults — do not restate them on the command line

| | default | why |
|---|---|---|
| model | `grok-4.6` | Configurable with `-m` or `GROK_SUB_MODEL`; availability depends on the installed CLI and account. |
| effort | **`medium`** | A practical public default. Raise it for difficult reasoning or lower it for wide fanouts. |
| sandbox | **`read-only`** | Public-safe default. Pass `-s workspace` or `-s off` only when the user authorized writes and the task requires them. |
| timeout | 900s | **The single most common cause of a failed Grok run.** See the budget section below — raise it for interactive MCP work. |

# Image-To-3D Modular Kit

Use this skill when the deliverable is a set of images that will be fed into an image-to-3D
service, then assembled, retopologized, rigged, fitted, or cloth-simmed in Blender, Unreal, or
another game engine. The output is a reconstruction pack: geometry guidance first, pretty
concept art second.

When available, also load:

- An image-generation skill or tool for generating or editing the raster reference plates.
- `3d-asset-quality` before deciding what each module needs to show as real geometry.

## Core Rule

# A generated pack is N plausible worlds, not one

## The failure class — why this is structural, not a model problem

No current image model carries a 3D representation between generations. Tested directly on a
real pack: an image-to-image uplift of the project's own render, explicitly told to move
nothing, came back reframed with a landmark reproportioned; of four models given a 1920×1080
source, all returned 1024×1024 and three invented a third torii. **Each image is individually
plausible; nothing makes them mutually consistent.** A better model does not fix this. Structure
does.

What it cost, measured: a site plan drew the bridge parallel to the gate axis while the
cinematic showed it perpendicular — no camera reconciles them; the plan labelled one torii
where the pack elsewhere implied two; and site elevation was defined by NO image at all, so

# Green gates cannot see whether the thing is playable

## The record that justifies the rule

One project shipped, in sequence, past a fully green harness (capture green, validator 20/20,
selftest 15/15): a keyboard that did nothing, a level sealed by its own colliders, a camera
that hijacked the view seconds into play, a stair that could not be climbed, and enemies whose
signature death effect silently did not happen. **Every one was found by the operator playing.**
The common cause was always the same: acceptance ran a scripted path with the camera locked, so
nothing ever pressed a key, walked the route, or checked which camera was rendering. A judge
grades a frame; a validator grades artifacts; neither can see playability.

## The gate — five proofs, all from REAL input