Concept art skill for AI agents

concept-art is a skill from the Summer skill library: a guide your AI agent reads when the task matches, so it builds the good version on the first try. Explore art direction with 3-4 rough concept variants of a character, environment or prop.


Status	Stable
Domains	2D art, Asset pipeline
Version	`1.0.2`
Engine version	`>=4.6`
Recommended set	Yes, installed by `--recommended`

When your agent uses it

Exploring art direction with rough variants before committing to a final asset
The user wants a mood board, rough sketches, or ‘what could this look like’

Install

summer setup installs every skill for your agent. To add only this one:

npx -y summer-engine@latest skills install concept-art --agent claude-code

Swap claude-code for your agent, such as codex or cursor. See Skills for every option.

The skill

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

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:

Axis	Use when
Palette / mood	”Should this feel grim or hopeful?”
Era / setting	”Medieval, sci-fi, modern, post-apoc?”
Stylization	”Painterly, anime, photoreal, Mobius line-art?”
Silhouette / proportions	Character design — slim/bulky/childlike/monstrous
Time of day / lighting	Environment — dawn/noon/dusk/night

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.

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.

Goal	Prompt that works	Why
Character — palette axis	`young witch with raven familiar. <warm autumn palette / cold blue moonlit palette / sickly green swamp palette / monochrome ash palette>. concept art, painterly, atmospheric`	Locked subject + four explicit palettes
Character — silhouette axis	`goblin warrior. <slim wiry / hulking brute / childlike imp / multi-limbed mutant>. concept art, full body, rough painterly`	Forces real shape variation
Environment — mood axis	`swamp village at dusk. <hopeful warm lanterns / oppressive fog / abandoned ruins / overgrown nature reclaim>. concept art, wide shot, atmospheric`	Mood drives composition
Environment — stylization axis	`mountain temple. <Studio Ghibli soft painterly / Mobius clean line-art / dark Berserk ink / Hayao detailed wash>. concept art, wide establishing shot`	Names real reference styles the model recognizes
Prop — era axis	`royal sword. <bronze age / medieval / ornate baroque / sci-fi energy>. concept art, three-quarter view, neutral background`	Era as the only varying dimension
Creature — physiology axis	`forest spirit. <deer-like elegant / fungal grotesque / jellyfish floating / branch-and-moss elemental>. concept art, atmospheric, painterly`	Forces real morphological divergence

Bad prompts (and why)

Bad	Failure mode
`cool fantasy character`	No subject, no axis. All 4 variants will look interchangeable.
`make 4 different witches`	Model doesn’t render “4 of”; you must call 4 times.
`epic concept art masterpiece trending on artstation`	Adjective soup. Trending-on-artstation is a 2022 cliche; modern models render it as bland slop.
`same character but different`	”Different” is undefined. Pick an axis and name it.

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:

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.

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.

In this skill	Command
`assets.generate_image`, `summer_assets_generate_image`	`summer assets generate-image`
`summer_assets_search`	`summer assets search`
`summer_docs_read`	`summer docs read`
`summer_import_from_url`	`summer engine import-from-url`

character-portrait: Generate one polished character bust for dialogue UI, character select, lore cards or codex entries.
pixel-art: Generate pixel-art sprites, items, tiles and portraits at a set resolution with a limited palette.
tileable-texture: Generate a seamless tileable texture for walls, floors or terrain, wired as a StandardMaterial3D albedo.
ui-graphics: Generate game UI art (icons, buttons, panels, frames, HUD widgets) flat, on a transparent background.
asset-strategy: Route any ‘I need a [thing]’ asset request to the right skill: 2D, 3D, audio, video, VFX or animation.
create-asset-sheet: Generate a pack of 2D assets from one prompt (tile sheet, UI kit, character pack, biome), sliced.

Source: library/skills/concept-art/SKILL.md, rendered from summer-engine@4.3.0 on npm.

​When your agent uses it

​Install

​The skill

​When to use

​When NOT to use

​Steps

​1. Confirm exploration vs final

​2. Search for prior concepts

​3. Pick a variant axis

​4. Generate the batch

​5. Present the batch

​Prompt patterns

​Bad prompts (and why)

​Anti-patterns

​Edge cases

​Without Summer Engine

​Fallback (no MCP)

​Handoff

​See also

​From a shell

​Related skills