The look of a game: decisions, the board, locks

A game's art direction lives in games/<id>/codex/decisions.json (private, like the codex) and is drawn in the Game Codex's Art direction tab: every decision with its value, its why, and its state. It is the style bible. Everything made for the game (models, textures, covers, title cards) is made under it and records the revision it was made under, so the game stays one game.

State	Meaning	Who changes it
auto	your pick, with its why	you, freely
steered	the person nudged it ("warmer")	you may refine within the nudge, never undo it
pinned	the first asset built on it pinned it (locked by use)	you only while nothing paid or published depends on it; else ask
locked	the person froze it	only the person: unlock needs their reason, after they saw the blast radius

A lock protects taste, not money: no signed approval, but you never change a locked value on your own, and you record their words when you lock for them.

The automatic path (the default: no questions)

npx --no-install homie-studio style init <id> --prompt "<the person's own words about the game>"

It fills about thirty decisions from their words, the codex and the genre, writes style.json (the palette, fonts, light and camera the game draws with) and redraws the codex. Say ONE line: "Look: flat low-poly, autumn grove palette, golden hour, high three-quarter camera; open the codex to change anything." Then build with free routes only (the engine and the starter library: the models skill) unless the plan set an art budget. The first asset you add pins the decisions it was made under.

The hands-on path

When the person wants to steer the look closely (only when they request it), show the style board:

npx --no-install homie-studio style board <id>

(In an app with Homie's cards: style_explore; the card has Pick, Mix, Steer and Lock.) Three coherent directions, each drawn by the game's own engine: its palette on a ground and a sky, its light and fog, its camera, its material model (flat, toon with ink outlines, painted, PBR, pixel), a character stand-in at the decided proportions, and the starter library family's own pieces re-tinted into the palette, with the title in its display font. Free, about 20 seconds, saved under games/<id>/codex/board/. Look at all three yourself before you show them (file_read), and say in one line each what is different.

• Pick: style pick <id> b. Mix: style pick <id> --mix style.palette=b,style.camera=c.
• Steer: style steer <id> style.palette "warmer" (warmer, cooler, less saturated, darker, lighter, a hex colour with its job; light: golden hour, night, harder shadows; camera: closer, further, higher, top-down; shape: chunkier, sharper; materials: add outlines). Words it does not know are recorded; refine the value with style set within them.
• Lock when the person says so: style lock <id> style.palette --words "<what they said>", or the whole style: style lock <id> style --words "…".
• A painted mood image per direction is optional and PAID (quoted through the official MCP, the person's own fal account, the official fal MCP): a picture the engine cannot draw is a target, never a promise, and the card says so. Offer it only when the engine's swatches leave the person unsure.
• Golden images: once the style is locked, two to six approved pictures (a chosen mood image, a concept they loved, their own art) become the references of every generated concept: style golden <id> add <image>.

The characters: the cast card

cast_plan (or npx --no-install homie-studio cast <id>) shows the decisions that shape characters together: proportions (heads tall, metres), the shape language and its silhouette rule (every character readable black on white at 64 px: the lineup checks it), the palette, the library family, the skeleton family (rig.skeleton) and where rigs come from; then every character made or planned, with its source, skeleton, bones, triangles and clips. A library character comes in free (asset_add); a generated one through the models skill's character (paid, priced first); their clips and feel are the animate skill's. A starter game's own style.json is what style init starts from: it never repaints a working game behind its back.

Changing a locked decision: the blast radius first

When the person wants a locked or pinned decision changed, never just change it:

npx --no-install homie-studio style blast <id> style.palette            # what goes stale, and the cost
npx --no-install homie-studio style set <id> style.palette <value> --unlock --reason "<their words>"          # shows it again, changes nothing
npx --no-install homie-studio style set <id> style.palette <value> --unlock --reason "<their words>" --confirm  # after their yes

Tell them the list in plain words: which assets go stale, which are fixed for free (a palette re-tint of flat-coloured models, another library match, a procedural one regenerated) and what remaking the generated ones would cost. Nothing is remade by itself: remaking is a new, priced job they approve (the models skill).

One look end to end

• The game draws with games/<id>/style.json (palette, fonts, light, camera): read it rather than hard-coding colours, so a change of the palette reaches the HUD and the world.
• The codex wears a steered or locked palette and fonts; the landing and the trailer's title cards use them too (a game with no landing.theme takes its accent and glow from style.json).
• style prompt <id> is the derived style prompt (about 80 words: medium, shape, palette hexes, light, framing) every generated picture starts from. It is computed, never edited by hand.

Never

• Never change a locked decision without the person's yes after the blast radius; never remake anything by yourself; never lock on your own.
• Never present a painted mood image as what the game looks like.
• Never name a living artist in a style ("in the style of …"): describe the look in words.
• Never "upgrade" a game whose procedural look is its strength to generated meshes without the owner's ask.

Painted style references

Use the art skill and official fal MCP for optional painted mood images. Build the prompt from the derived style and approved references; record the style revision, cost and rights with each result. Keep boards in the codex and mark targets distinct from playable frames.

Official generation workflow

The owner's AI uses the provider's official plugin/MCP in its own client. Homie never asks for, stores, reads or prints provider credentials. Read the current provider skill and discover its available tools and input schemas; host prefixes vary. Connection instructions and verified sources: official integrations. If tools are missing, connect that official plugin once in the client's browser flow. Do not fall back to a Homie client, key file, environment key or CLI generation wrapper.

Before spending, state the model, count/duration, estimated cost and remaining approved budget. Use the owner's existing authorization; ask only if the spend is outside it. Record the request ID as soon as accepted. Poll that same request; never resubmit to retry a slow job. Unknown cost is unknown, never zero. Provider billing is authoritative; Homie's local receipt cannot enforce spending in another client.

Place and prove the result

Download the completed tool's output using the AI client's file/download facilities. Keep temporary signed URLs out of committed records. Keep the original in the studio's art/job folder; put the optimized delivered asset beside its game/app, or in music/ or videos/ for a published work. Record a receipt with these fields:

{
  "provider": "fal",
  "tool": "run_model",
  "model": "exact endpoint returned by the provider",
  "requestId": "actual request ID",
  "prompt": "the actual prompt, including style constraints",
  "styleRevision": "revision from the studio's style",
  "rights": {"source": "provider/model terms URL", "checkedAt": "YYYY-MM-DD", "commercial": false, "note": "record the actual plan and permitted use"},
  "cost": {"status": "unknown"}
}

For ElevenLabs use its actual discovered tool and model, and its flow/session or request identifier. A measured cost uses {"status":"actual","amount":1,"unit":"credits"}; a quote uses estimate. Never claim commercial rights from the fact that generation succeeded. Read the provider and model terms for the account's plan; record attribution, reference-image permissions and any restrictions. Mark test fixtures "fixture": true.

Wire the delivered path into the scene or manifest, then run:

npx --no-install homie-studio media import --file <downloaded-file> --receipt <receipt.json> --out games/<id>/assets/<name> --used-by games/<id>/view.ts

This copies bytes, verifies a static reference, hashes the asset and records allowlisted provenance in media/provenance.json. Reimporting the same output is idempotent; it never generates or charges. Include each generation step's receipt for derived assets. Run the scene and look/listen: a file and static reference are not proof that it renders or plays. Report the placed path, usage evidence, rights and actual/estimated cost.

The toolkit’s lib/media-workflows.mjs declares this skill’s verified tool references. Validate them against the host’s current tool inventory before execution; tool discovery is required for generation capabilities that have no stable documented name.