Concept Art

concept-art — Batch-of-Variants for Art Direction

This skill produces 3-4 rough concept images of the same subject under different stylistic interpretations. The goal is not the final asset — the goal is to give the user something visual to react to so they can lock a direction. Variants are deliberately divergent (different palette, mood, framing, era) so the user has real choices, not four near-identical takes.

If the user wants ONE polished image (a dialogue portrait, a hero card), this is the wrong skill — route to character-portrait. The asset-strategy meta-router uses the disambiguation phrase "Quick check — exploring the look (3-4 variants for art direction) or generating a final character portrait for dialogue UI?" to send users to one of the two. If you arrived here without that question being asked, ask it before generating.

When to use

• "I'm not sure what this character should look like — give me some options."
• "Show me 3-4 directions for the witch."
• "I want a mood board for the swamp level."
• Early-project art direction, before the GameSoul.md visual style is locked.
• The user describes a vibe ("dark fantasy", "Ghibli-esque", "Mobius") and wants to see it rendered.

When NOT to use

• The user wants a single locked portrait for a dialogue UI → character-portrait.
• The user wants pixel art specifically → pixel-art.
• The user wants a UI icon or HUD element → ui-graphics.
• The user wants a tileable wall/floor texture → tileable-texture.
• The user wants an image-to-3D reference → asset-strategy (the 3D pipeline has its own prompt suffix).

Steps

1. Confirm exploration vs final

Before generating, ask once:

Quick check — exploring the look (3-4 variants for art direction) or generating a final character portrait for dialogue UI?

If "final" → hand off to character-portrait. If "explore" → continue.

2. Search for prior concepts

Copy code
assets.search({ query: "<subject> concept", assetType: "2d_image", scope: "all" })

If something already exists, ask if the user wants to riff on it (img2img via referenceImageUrl) or start fresh.

3. Pick a variant axis

Variants must differ on one explicit axis, not noise. Pick one:

State the axis to the user before generating: "I'll vary on stylization — painterly, anime, line-art, photoreal. OK?"

4. Generate the batch

Issue 3-4 calls in parallel, one per variant. Use the same subject phrasing across all four; only the style-modifier changes.

Copy code
assets.generate_image({
  prompt: "<subject>. <axis variant 1>. concept art, evocative, rough painterly, atmospheric lighting, wide cinematic framing",
  model: "nano-banana-2",
  style: "none"
})

style: "none" is intentional: only cartoon and anime append anything to the prompt, realistic and none append nothing, and any other value is coerced to none. So the preset cannot override the prompt's stylistic direction — it just contributes nothing, which is what concept art wants. All four variants' divergence has to come from the prompt.

For a shape other than square, pass aspectRatio ("16:9", "9:16", ...) or width + height; the result reports the real width and height and the model that ran. Exploration images are thrown away, so square is usually fine. Background removal is the removeBackground argument (there is no options object). Four variants are four charges: dryRun: true on one call shows its credits.

5. Present the batch

After all 4 return, show the user the thumbnails (link thumbnailUrl for each) and ask:

Which direction lands? I can generate variants on the chosen one, or hand off to character-portrait for a final.

Do NOT import any of these as res:// assets yet. Concept art is reference, not shipped art. Only import once the user picks a winner — then either it goes to character-portrait for a polished version or directly to summer_import_from_url if they want to use it as-is as a reference.

Prompt patterns

The structure: subject + axis variant + "concept art" + lighting/atmosphere. Keep prompts under 30 words.

Bad prompts (and why)

Anti-patterns

• Generating 4 near-identical variants because you didn't pick a real axis. The user can't choose between four images that all look like the same painting.
• Importing concept art as final assets. These are exploration. The polished version comes from character-portrait after a direction is picked.
• Treating style as the variant axis. The presets are realistic | cartoon | anime | none, and only two of them append anything. Four "stylization" variants have to differ in their prompt text, not in the style argument.
• Skipping the disambiguation question. If you don't ask, you may generate four rough variants when the user wanted one polished bust.
• Generating before the GameSoul.md is written. If .summer/GameSoul.md exists, read it first — its visual-style section narrows the axis.

Edge cases

• User says "just one" after you propose 4. That's a character-portrait job. Hand off.
• User wants 8+ variants. Generate 4 first; if the user wants more on the same axis, generate 4 more. Don't dump 8 at once — overload paralyzes choice.
• Subject is a fully described scene, not an asset. You're producing key art, not asset reference. Pass aspectRatio: "16:9" (or width: 1920, height: 1080 for store key art) and bias toward atmospheric.
• User wants the final to be 3D. After they pick a direction, route to asset-strategy — concept-art images are not 3D-ready references (they have backgrounds, scene context, dramatic lighting baked in). The 3D pipeline needs its own clean white-background reference.

Without Summer Engine

In a session without Summer Engine tools (the assets profile; the summer-assets skill has the whole loop), every step works. Pass out with the person's folder so the batch lands there (the summer-assets skill says how), and skip summer_import_from_url.

Fallback (no MCP)

Print the 4 prompts and the call for each:

Copy code
assets.generate_image({ prompt: "<variant 1>", model: "nano-banana-2", style: "none" })
assets.generate_image({ prompt: "<variant 2>", ... })
...

Tell the user to run via the Summer dashboard, then come back and summer_import_from_url the winning variant.

Handoff

Once the user picks a direction:

• Character / NPC final → character-portrait (use the picked variant as referenceImageUrl).
• 3D model from this concept → asset-strategy (regenerate a 3D-ready reference; concept art is not 3D-ready as-is).
• Tileable texture from this mood → tileable-texture.
• Pixel-art version → pixel-art.
• Lock the visual direction → write the choice into .summer/GameSoul.md under ## Visual style so future asset skills inherit it.

See also

• asset-strategy — meta-router that delegates here vs other 2d-assets skills.
• character-portrait — the polished single-image counterpart.
• summer_docs_read id reference/mcp-tools-reference — how to call assets.generate_image.

From a shell

No Summer MCP tools in this session? Run each one as a command; when summer --version is missing or below 4.0, use npx -y summer-engine@latest in place of summer. Fields are flags in kebab-case (--scene-path res://main.tscn) or one --input '<json>', and summer ops describe <op> prints the exact input. The summer-cli skill has the rest.