Best AI Prompts for Game Asset Creation with Leonardo.ai

Quick Answer

We solve the ‘Frankenstein game’ problem by training a custom Leonardo.ai model with your Visual DNA. This guide provides the exact prompt formulas to generate perfectly cohesive assets that match your unique art direction, moving beyond generic AI outputs to build a unified world.

Key Specifications

The Quest for Cohesive Game Art

Have you ever generated a stunning character concept in an AI tool, only to find that your environment assets look like they belong in a completely different game? This is the most common roadblock I see indie developers and small studios face when adopting AI. You have a unique vision for your game’s world, but generic AI models produce a beautiful but chaotic mess of mismatched styles. The result is a disjointed asset library that undermines the very soul of your project: its aesthetic identity.

This is where prompt engineering evolves from a neat trick into an essential development skill. But even the best prompts can only do so much when working with a model that doesn’t understand your specific art direction. That’s why a tool like Leonardo.ai has become a cornerstone of my professional workflow. Its true power lies in its Alchemi feature, which allows you to train a custom model on your own concept art or style references. This means you’re not just generating random assets; you’re teaching an AI the precise visual language of your game, from brushstroke to color palette.

This article is your blueprint for mastering that process. We’ll move beyond basic prompting and dive into the exact formulas for generating a perfectly cohesive asset library, powered by a custom model trained on your unique vision.

The Foundation: Why Consistency is the Holy Grail of Game Art

Have you ever played a game where the main character looks like they were ripped from a gritty, noir graphic novel, only to find the UI icons drawn in a whimsical, cartoon style? It’s a subtle but jarring disconnect. That feeling is the direct result of inconsistent art direction, and it’s one of the fastest ways to break a player’s immersion. In game development, consistency isn’t just an aesthetic preference; it’s the invisible glue that holds the entire world together, allowing players to suspend their disbelief and truly get lost in the experience.

When your art style is disjointed, you create what I call a “Frankenstein” game—a collection of mismatched parts that feel stitched together rather than organically built. This doesn’t just look unprofessional; it actively works against your narrative and gameplay. A cohesive visual identity, on the other hand, reinforces your game’s core themes and builds a powerful brand identity from the very first screenshot. It tells the player, “This world has rules, and you can trust them.” For an AI-first workflow, where you’re generating hundreds of assets, establishing this consistency before you even type a single prompt is the most critical step you can take.

Defining Your Visual DNA: The Five Pillars of Cohesion

To achieve true consistency, you need to break down your game’s art style into its fundamental components. Think of these as your project’s “Visual DNA.” Before you ask an AI to generate anything, you must have a clear, written definition for each of these pillars. This strategic framework ensures that every prompt you write is pulling in the same direction.

Here are the five core elements you need to define:

• Color Palette: This is more than just “bright” or “dark.” It’s about specific hex codes. Are you using a limited 4-color palette like a classic Game Boy game? Is it a vibrant, high-saturation cyberpunk scheme (think neon pinks and electric blues)? Or a desaturated, moody palette for a post-apocalyptic setting? Actionable Tip: Create a simple color swatch file with 3-5 primary and secondary colors. Reference these hex codes in your prompts (e.g., “dominant color #FF5733”).
• Line Weight & Form: How are objects outlined? Is it a heavy, confident black ink line like in Hollow Knight? Or are there no outlines at all, relying on painterly shapes like in Gris? Are the forms geometric and sharp, or soft and rounded? This distinction is crucial for generating assets that feel like they belong in the same world.
• Texture & Materiality: Does your world feel gritty and tactile, or smooth and digital? You need to define the surface quality. Are you aiming for a “rough canvas texture,” “clean vector art,” “hand-carved wood,” or “glossy plastic”? Specifying this helps the AI avoid generic outputs and adds a layer of believable detail.
• Lighting & Mood: Lighting dictates emotion. Is your world harshly lit with deep, high-contrast shadows (chiaroscuro)? Or is it softly illuminated with diffused, ambient light? Is the mood mysterious, cheerful, or tense? Defining this prevents a cheerful character from being rendered under moody, dramatic lighting, which would instantly clash with your established tone.

The Strategic Framework: Your Pre-Prompt Checklist

Once you have these five pillars defined, you have a strategic framework. This isn’t just a mood board; it’s a set of rules. When you sit down to write a prompt for a new asset—say, a “rusty key”—your framework guides you. You won’t just write “rusty key.” You’ll write:

“A heavy, ornate key, [heavy black line weight], with a [rough, corroded metal texture], rendered in a [desaturated, moody color palette of #4A4A4A and #6B5E52], under [soft, diffused ambient light]. Clean asset, isolated on a white background.”

This prompt is specific, actionable, and directly references your Visual DNA. It leaves almost nothing to chance. This is the difference between randomly generating images and systematically building a library. The AI is no longer a guessing machine; it’s a precision tool executing your art direction. This level of control is what separates amateur AI usage from a professional, scalable production pipeline.

Mastering the Leonardo.ai Alchemy: Training Your Custom Model

So, you’ve got a vision for your game’s art style—a unique aesthetic that sets it apart. The challenge is scaling that vision. How do you generate 500 assets that all feel like they came from the same artist’s hand? This is where most AI workflows break down, leading to a frustrating collection of mismatched assets. The solution is to stop treating the AI like a magic 8-ball and start acting like an art director training a new artist.

Leonardo.ai’s Alchemy feature is your training ground. By feeding it your specific visual references, you’re creating a custom model that understands your game’s DNA. This isn’t just about generating images; it’s about building a repeatable, scalable style engine. Let’s walk through how to build your own.

Phase 1: The Art Director’s Prep Work (Dataset Curation)

Before you even open Leonardo, your most critical work begins. The quality of your custom model is directly proportional to the quality of your dataset. Garbage in, garbage out. I’ve seen developers upload 20 images of wildly different styles and wonder why their Alchemy model produces inconsistent results.

Here are the core principles for building a powerful dataset:

• The Sweet Spot for Volume: Aim for 20-30 high-quality images. Less than 15, and the AI struggles to learn the style’s nuances. More than 50, and you risk confusing it with conflicting details unless every image is perfectly consistent.
• Specificity Over Variety: Your dataset should be a mood board for one specific asset type. If you’re training a model for your game’s characters, every image should be a character in a similar style. Don’t mix environment art with character concepts.
• Show, Don’t Just Tell: Include images that demonstrate how you want the AI to handle key elements. If you want a painterly style with thick brushstrokes, make sure your dataset clearly shows that. If you want clean line art, your references must be clean.

Golden Nugget: The “Style Anchor” Technique. For your 20-image dataset, make 15 of them extremely consistent and high-quality. Then, add 3-5 images that represent a “hard negative”—an example of a style you don’t want (e.g., a photorealistic image if you want a cartoon style). This helps the model define the boundaries of your style more sharply.

Phase 2: The Training Process in Leonardo.ai

Once your dataset is curated, it’s time to upload and train. Leonardo makes this process straightforward, but a few key decisions will impact your results.

1. Navigate to Alchemist: In the Leonardo.ai dashboard, find the “Alchemist” tool. This is your model creation hub.
2. Upload Your Dataset: You’ll be prompted to upload your images. Drag and drop your carefully selected folder of references. The system will process them.
3. Naming Convention (Crucial for Scalability): This is a step many skip, and they regret it later. Don’t just name your model “MyGame_Style.” Be descriptive and systematic. This becomes your library of specialized tools.
   • For Characters: MyGame_v1_Char_Painterly
   • For Environments: MyGame_v1_Env_DenseForest
   • For Weapons: MyGame_v1_Prop_OrnateWeapons
4. Set Your Parameters: You’ll have options for training steps and learning rate. For a first run, the default settings are a safe bet. As you gain experience, you can experiment with higher training steps for more detailed models, but be aware this increases generation time.
5. Train and Wait: The process takes some time. Use this to document your visual DNA (see below).

Phase 3: Activating Your Custom Model & Prompting for Cohesion

Once your Alchemy model is trained, it will appear in your model selection dropdown when generating images. Now, the real magic happens. You’re no longer just prompting; you’re directing your custom AI.

This is where you combine your custom model with a Visual DNA prompt. This is a prompt structure that locks in consistency.

The Visual DNA Prompt Structure:

[Subject Description] + [Action/Context] + [Style Keywords] + [Technical Parameters]

Let’s say you trained MyGame_v1_Char_Painterly. Your prompt should look like this:

Prompt: A female elven ranger, drawing her bow, dynamic pose, **MyGame_v1_Char_Painterly**, thick visible brushstrokes, muted earthy color palette, soft cinematic lighting, --s 75

Notice how the custom model name is a core part of the prompt. You are explicitly telling Leonardo: “Use the visual language I taught you.” The style keywords (thick visible brushstrokes, muted earthy color palette) act as a reinforcement, ensuring the model stays on track.

By following this process, you transform from a user into an AI art director. You’re not just generating assets; you’re building a cohesive, scalable visual library for your game, one perfectly trained model at a time.

The Prompting Framework: From Vague Idea to Specific Asset

Generating a generic “cool sword” in an AI tool is easy. Generating your game’s specific Ironwood Longsword, in the exact pixel art style of your environment art, with a transparent background, ready for your game engine—that’s a different skill entirely. The difference lies in moving from a simple description to a structured command. You need to think like an art director briefing a specialist, not just whispering a wish to a magic box.

After hundreds of hours spent building asset libraries for indie projects, I’ve developed a repeatable formula that consistently produces high-quality, usable assets. This isn’t just a random collection of words; it’s a structured prompt architecture designed to eliminate ambiguity and give the AI precise instructions. It’s the foundation of a professional workflow.

The 5-Part Prompt Architecture

Think of your prompt as a technical document. It needs to contain all the necessary information for the AI to execute the task flawlessly. The formula I rely on is: [Asset Type] + [Core Description] + [Style Adjectives] + [Technical Specifications] + [Negative Prompt].

Let’s break down each component:

• [Asset Type]: Start with the most direct, unambiguous term. Is it a UI Icon, Character Sprite, Environment Texture, Item Asset, or Loading Screen? This sets the initial context.
• [Core Description]: This is the “what.” Be specific and use nouns. Instead of “a scary monster,” use hulking stone golem with glowing cracks. Instead of “a potion,” use swirling purple potion in a corked glass vial. Use strong, descriptive nouns and adjectives that define the object’s core identity.
• [Style Adjectives]: This is where you leverage your custom model and define the “feel.” This is the most critical part for cohesion. You’ll use terms like painterly, cel-shaded, pixel art 16-bit, low poly, hand-drawn, gritty, ethereal. If you’ve trained a custom model in Leonardo.ai, you’ll reference it here by name (e.g., in the style of [YourModelName_v1]). This is your direct line to your game’s visual DNA.
• [Technical Specifications]: This is where you tell the AI how to deliver the asset. This is non-negotiable for game development.
  • Background: isolated on a white background, transparent background, on a transparent grid. This is essential for easy extraction.
  • Composition: centered, full body shot, close-up. This controls the framing.
  • Aspect Ratio: --ar 1:1 for icons, --ar 16:9 for backgrounds. This defines the canvas shape.
• [Negative Prompt]: This is your quality control. You tell the AI what to exclude. This is how you clean up common AI artifacts.
  • --no text, watermark, blur, noise, dither, signature, frame, border

Example in Action: Let’s say you need a simple health potion icon for your pixel art RPG.

Pixel art health potion icon, red liquid in a small glass bottle with a white cork, 16-bit style, centered, isolated on a white background, sharp edges —ar 1:1 —no text, blur, shadow, gradient, dither

This prompt is specific, actionable, and leaves almost nothing to chance. It defines the object, its contents, its style, its composition, its background, and what to avoid. This is the difference between randomly generating images and systematically building a library.

Leveraging Leonardo.ai’s Power Tools

A great prompt is only half the battle. Leonardo.ai provides powerful parameters that act as guardrails and enhancers for your framework. Understanding them is key to mastering the tool.

1. ControlNet: The Consistency Lock This is arguably the most critical feature for generating a cohesive set of assets, especially for characters or complex items. Let’s say you generate the perfect character sprite. You love the pose, the style, everything. Now you need that same character holding a different item or wearing new armor.

Instead of starting from scratch and hoping for a similar result, you use ControlNet.

• Upload your perfect character sprite as an image reference.
• Select a ControlNet model (like “Canny” for outlines or “Depth” for structure).
• In your new prompt, you write: same character, now holding a glowing sword, [YourModelName_v1] style.
• The AI will use the structure from your original image but apply the new details from your prompt.

This guarantees the character’s proportions, pose, and style remain identical. It’s the secret to creating sprite sheets and asset variations that look like they belong to the same entity.

2. Alchemy & Prompt Magic: The Refinement Engine These two features work together to elevate your base prompt.

• Alchemy: Think of this as the “quality on” switch. It dramatically improves lighting, color coherence, and overall detail. For game assets, I always keep Alchemy on. It helps generate assets that feel like they belong in the same world, even if they are generated in different sessions. It brings a level of polish that raw generation often lacks.
• Prompt Magic: This feature re-interprets your prompt to add more creative detail and coherence. While powerful, it can sometimes take your prompt in an unexpected direction. For game assets, where precision is paramount, I recommend using Prompt Magic on its “V3 (Creative)” or “V2 (Balanced)” setting, but always review the results carefully. If you need 100% adherence to your exact words, you might dial it back or turn it off. The key is to experiment and see how it enhances (or over-enhances) your specific prompt style.

By combining the 5-Part Prompt Architecture with Leonardo.ai’s ControlNet and Alchemy, you move from being a casual user to a professional AI art director. You’re no longer hoping for a good result; you’re engineering it.

Prompt Playbook: Best Prompts for Key Game Asset Categories

This is where theory meets the production line. You’ve trained your custom model in Leonardo.ai’s Alchemist, and now it’s time to put it to work. A generic prompt will only get you a generic result from your custom model. To truly leverage your trained style, you need to speak its language with precision. This playbook provides the exact prompt structures I use to generate specific asset categories, breaking down why each component is critical for achieving a cohesive, game-ready output.

Remember, the key is to always reference your custom model (e.g., MyGame_v1_Char_Painterly) and combine it with descriptive language, technical specifications, and negative prompts to lock in the result.

Characters & NPCs: The Face of Your Game

Consistency in characters is non-negotiable. A player needs to recognize an NPC from any angle or expression. These prompts are designed for generating turnarounds, expressions, and poses while using Leonardo’s features to maintain crucial facial consistency.

1. The Character Turnaround Sheet This prompt is essential for creating 3D model references or sprite sheets. It demands clear, distinct views with no overlapping, perfect for extracting assets.

• Prompt: character turnaround sheet for [MyGame_v1_Char_Painterly], a grizzled dwarven warrior with a braided beard, front view, side view, back view, flat lighting, white background, isolated, consistent facial features --ar 2:3
• Why it Works:
  • character turnaround sheet: This is a specific artistic term that tells the AI the desired format.
  • front view, side view, back view: Explicitly defines the required angles, preventing the AI from generating a dynamic but unusable action shot.
  • flat lighting: Removes complex shadows that can obscure design details, making it easier to see the character’s form.
  • isolated, white background: Ensures the character is easy to cut out for use in a game engine or editing software.
  • --ar 2:3: A vertical aspect ratio that comfortably fits three distinct views.

2. Expressive Faces with Character Lock To generate a set of expressions for a specific character, you need to prevent the AI from altering their core identity. This is a prime example of using Leonardo’s Image to Image or ControlNet features. You would first generate your base character, then use that image as a reference for this prompt.

• Prompt: [MyGame_v1_Char_Painterly], character sheet with 4 distinct facial expressions: neutral, happy, angry, surprised. Maintain identical facial structure, hair, and features in each panel. --ar 4:3
• Why it Works:
  • character sheet with 4 distinct facial expressions: Guides the layout and purpose of the output.
  • Maintain identical facial structure...: This is your consistency command. It’s an explicit instruction to the AI to prioritize structural integrity over variation.
  • Golden Nugget: For best results, generate your base character first. Then, use the Image to Image feature in Leonardo with a low “Init Strength” (0.2-0.4) and this prompt. This tells the AI: “Use this face as your blueprint, but change the expression.” It’s far more reliable than text alone.

3. Dynamic Action Poses Action poses sell the fantasy. The challenge is keeping the character recognizable.

• Prompt: [MyGame_v1_Char_Painterly], elven archer in a dynamic action pose, drawing a glowing bow, mid-jump, wind effects, motion blur on background, sharp focus on character, cinematic lighting --ar 16:9
• Why it Works:
  • dynamic action pose, drawing a glowing bow, mid-jump: Specific, sequential actions create a clear visual narrative.
  • motion blur on background: This is a key trick. It emphasizes the character’s movement without distorting the character itself, which should remain sharp.
  • cinematic lighting: Adds drama and depth, making the character feel like they belong in a larger world.

Environments & Tilesets: Building Your World

Your environment needs to be as consistent as your characters. The goal here is modularity and seamlessness, allowing you to build vast worlds from a small set of assets.

1. Seamless Texture Generation A seamless texture is the foundation of any good tileset. Leonardo has a dedicated “Seamless Texture” generation mode, but you can also guide it with your prompt.

• Prompt: seamless texture, ancient cobblestone path, moss growing in cracks, worn edges, top-down view, flat lighting, [MyGame_v1_Env_Dungeon] --ar 1:1
• Why it Works:
  • seamless texture: The most important command. It tells the AI to ensure the edges match up perfectly.
  • top-down view, flat lighting: Removes perspective and shadows that would break the illusion of a flat, repeatable surface.
  • --ar 1:1: A square aspect ratio is standard for textures.

2. Modular Environment Pieces These are the “Lego bricks” of your world. Consistency in style and scale is paramount.

• Prompt: [MyGame_v1_Env_Dungeon], modular stone wall piece, 3 sections, top-down perspective, clean edges for cutting, flat 2D asset, white background --ar 3:1
• Why it Works:
  • modular... piece, 3 sections: Defines the object’s purpose and layout.
  • clean edges for cutting: An instruction aimed at the AI’s rendering style, encouraging sharp, defined borders.
  • flat 2D asset: This is a crucial term to prevent the AI from adding complex shadows or perspective that would make it difficult to use in a 2D game engine.

3. Atmospheric Background Layers Parallax backgrounds add depth and life. Generating them in layers gives you control over the final look in-engine.

• Prompt: [MyGame_v1_Env_Forest], atmospheric background layer, distant mountains, soft morning mist, layered parallax style, painterly, no foreground elements, wide shot --ar 16:9
• Why it Works:
  • atmospheric background layer, distant mountains: Specifies the layer’s content and depth.
  • layered parallax style: A conceptual command that encourages the AI to create a composition with distinct depth planes.
  • no foreground elements: A critical negative instruction to keep the layer clean for your game’s actual foreground.

Props & Items: The Devil’s Details

Props make a world feel lived-in. From a distance, they need to be readable; up close, they need character.

1. Stylized Weapons Weapons are a core part of player identity. They need to be iconic and fit the world’s aesthetic.

• Prompt: [MyGame_v1_Prop_Weapons], ornate crystal sword, glowing runes on the blade, elegant hilt, fantasy style, held in a hand (cropped), cinematic lighting, high detail --ar 2:3
• Why it Works:
  • ornate crystal sword, glowing runes: Specific material and magical properties create a unique design.
  • held in a hand (cropped): Provides scale and context without needing to generate a full character. The (cropped) hint helps the AI focus on the object.
  • high detail: Nudges the model’s quality settings toward a more intricate result.

2. Potions and Interactive Objects These items need to be instantly recognizable to the player.

• Prompt: [MyGame_v1_Prop_Alchemy], glowing blue health potion in a corked glass vial, swirling liquid, sitting on a dark wooden table, soft magical glow, isometric view --ar 1:1
• Why it Works:
  • glowing blue health potion: The classic color-coding for health instantly communicates its function.
  • isometric view: Aligns the prop with an isometric game’s perspective, ensuring it looks correct when placed in the world.
  • soft magical glow: Adds a visual hook that makes the item feel special and interactive.

3. UI Icons UI icons demand simplicity and clarity. Your custom model’s style should be applied, but with extreme minimalism.

• Prompt: [MyGame_v1_Prop_Alchemy], inventory icon for a key, simple flat vector design, golden color, minimal detail, isolated on white background --ar 1:1
• Why it Works:
  • inventory icon: Sets the context for a small, simplified graphic.
  • simple flat vector design: Forces the AI to abandon complex shading and textures in favor of clean lines and shapes.
  • isolated on white background: Essential for easy extraction and use in a UI editor.

Special Effects (VFX): Bringing the World to Life

VFX are ephemeral, but they have a huge impact on game feel. The key is to describe motion and energy.

1. Particle Effects These are the building blocks of larger VFX, like explosions or magical auras.

• Prompt: [MyGame_v1_VFX], particle effect, magical sparkles, bright energy particles, soft glow, isolated on black background, 2D game asset --ar 1:1
• Why it Works:
  • particle effect, magical sparkles: Describes the form and function.
  • isolated on black background: The best way to generate VFX assets. Black backgrounds are easy to make transparent in editing software, isolating the light and color of the effect.
  • 2D game asset: A reminder to the AI to generate a usable game asset, not a photorealistic simulation.

2. Magic Spell Casts These need to communicate power and intent. Think about the moment of impact or activation.

• Prompt: [MyGame_v1_VFX], fireball spell impact, burst of flame and embers, shockwave, dynamic explosion, cinematic, vibrant orange and yellow, isolated on black background --ar 16:9
• Why it Works:
  • fireball spell impact, burst of flame: Focuses on a single, powerful moment.
  • shockwave: Adds a layer of visual complexity that sells the force of the spell.
  • vibrant orange and yellow: Color direction is crucial for VFX to ensure they are visible and convey the right energy.

3. UI Animations (as frames) While Leonardo doesn’t create animations, it’s perfect for generating the keyframes. You can generate a series of images showing a progress bar filling up or a button pulsing.

• Prompt: [MyGame_v1_VFX], glowing mana orb, pulsing energy, bright blue light, 3 distinct stages of pulse (low, medium, high), separated frames, black background --ar 3:1
• Why it Works:
  • 3 distinct stages of pulse: Instructs the AI to create a sequence of images in one generation.
  • separated frames: A hint to keep the stages distinct rather than blending them.
  • This technique allows you to quickly concept and create the visual assets for a UI animation, which you can then assemble in a tool like After Effects or Unity’s Animator.

Advanced Techniques: Achieving Pixel-Perfect Control and Variation

You’ve mastered the art of the initial prompt. You can conjure a beautiful character concept or a moody environment tile with a few lines of text. But now you’re facing the real game dev challenge: how do you create twenty variations of that character’s armor without losing the core design? How do you iterate on a weapon concept without starting from scratch every single time? This is where you graduate from being a prompter to a true AI art director, using Leonardo.ai’s advanced toolkit to collaborate with the machine, not just command it.

The secret is moving beyond simple text-to-image and embracing a more controlled, iterative workflow. We’re going to dive into the three pillars of advanced asset generation: Image to Image (img2img) for controlled evolution, ControlNet for locking in structure, and the Motion feature for breathing simple life into your creations. These tools transform the AI from a one-shot generator into a flexible creative partner.

Iterating with Image to Image (img2img)

Imagine you’ve generated the perfect “Cyberpunk Knight” helmet. The style is right, the color palette is locked in, but you want to see it with a different visor or some battle damage. A text prompt alone might give you a completely new helmet. This is where Image to Image (img2img) becomes your most valuable asset for maintaining consistency.

In Leonardo.ai, you upload your base image and then write a new prompt describing the changes you want. The key is the Init Strength slider. This controls how much the AI respects your original image versus how much it listens to your new text prompt.

• High Init Strength (0.75 - 0.9): The AI stays very close to your original image’s composition, shapes, and colors. Use this for minor tweaks like “add a glowing red stripe” or “make it look battle-damaged.” You’re essentially telling the AI, “Use this as a blueprint, but follow these new instructions.”
• Low Init Strength (0.3 - 0.5): The AI has more freedom to interpret your new prompt. Use this to generate significant variations while keeping the core style. For instance, your prompt could be “same helmet, but now it’s a heavy assault class with a full faceplate and integrated comms antenna.” The AI understands “helmet” and “heavy assault” but will create a new design based on the style of your uploaded image.

Pro-Tip for Consistency: When creating a set of armor variations, always use the same base image for all your img2img generations. This anchors every single output to that initial successful design, ensuring your entire set looks like it belongs to the same family.

Locking in Structure with ControlNet

What happens when you need absolute precision over a character’s pose or an object’s angle? A generic prompt like “a character holding a sword” is a roll of the dice. ControlNet is the AI’s skeleton key, allowing you to provide a structural guide that the AI must follow, eliminating guesswork.

ControlNet works by analyzing a reference image you provide for specific information—like depth, edges, or human pose—and applying that structure to the final generation. In Leonardo.ai, you’ll find several powerful models:

• Depth: This model understands the 3D space of your reference image. Use it when you need to maintain the exact composition of a scene, like a specific camera angle of a game environment. You can sketch a rough blockout of a room, and the AI will generate a fully detailed, textured environment that perfectly matches your layout.
• Lineart (or Canny): This model detects the edges and outlines in your reference. It’s perfect for taking a rough sketch of a character or weapon and turning it into a polished piece of art without losing your original design intent. It’s the bridge between hand-drawn concept art and AI-rendered final assets.
• Pose (or OpenPose): This is a game-changer for character artists. It detects the skeletal structure of a human figure in a reference image. You can find a reference photo of a dynamic pose, upload it to ControlNet Pose, and your AI-generated character will adopt that exact pose every single time. This is invaluable for creating consistent character sprite sheets or action shots.

Golden Nugget: Don’t feel constrained by using only final images as ControlNet references. A simple stick-figure drawing or a 3D model blockout often gives you better control because it’s free of distracting details. The AI has a clean blueprint to work from, leading to more accurate and less “muddy” results.

Bringing Assets to Life with Motion

In 2025, even a simple animation can make a static UI element feel infinitely more polished. Leonardo.ai’s Motion feature allows you to generate short, looping animations from a single image, turning a static asset into a dynamic one with just a few clicks.

This is perfect for creating eye-catching UI elements or environmental effects without needing an animator. Think of a glowing mana orb that pulses with energy, a flickering torch, or a banner waving in the wind.

The process is simple: generate or select your base image, open it in the editor, and select the Motion tool. You can adjust the Motion Strength to control the intensity of the movement. A low setting creates a subtle shimmer, while a high setting can create a more pronounced animation.

Prompting for Motion: When generating the base image, you can guide the AI towards better animations. For our mana orb example, you might use a prompt like: [MyGame_v1_VFX], glowing mana orb, pulsing energy, bright blue light, 3 distinct stages of pulse (low, medium, high), separated frames, black background --ar 3:1. By specifying “pulsing energy” and “3 distinct stages,” you’re giving the Motion feature a clearer direction for the final loop. This technique allows you to quickly concept and create the visual assets for a UI animation, which you can then assemble in a tool like After Effects or Unity’s Animator.

By mastering these three techniques, you’re no longer just generating assets; you’re building a system. You’re creating a library of base images, iterating on them with precision, dictating their structure, and adding a layer of life. This is the workflow that separates hobbyists from professionals and turns AI from a novelty into a core part of your game development pipeline.

Case Study: Building a Cohesive Asset Pack for a Fantasy RPG

How do you go from a single AI-generated image to a full set of game assets that look like they belong in the same universe? Theory and isolated prompts are one thing, but the real test is building a complete, usable pack from scratch. This case study walks you through the exact process I used to create a small asset pack for a hypothetical “Stylized Dark Fantasy” RPG, using Leonardo.ai’s custom model training to ensure every piece feels connected.

Our goal is to build a cohesive set featuring: a central character, a key environmental prop (a shrine), and a collection of smaller items (potions). The secret weapon here is the custom model. Before generating a single asset, I trained a model in Leonardo.ai using a dataset of 20 reference images. These weren’t random fantasy pictures; they were a curated collection of concept art with a specific look: desaturated color palette, heavy ink lines, and a painterly texture reminiscent of classic storybook illustrations. This initial 30-minute investment is the foundation of our entire consistency strategy.

Step 1: The Character - Establishing the Visual Anchor

The character is the heart of our visual identity. If we get this right, everything else will naturally fall into place. Our first prompt needs to lock in the core style we taught our model.

Initial Prompt: full body shot of a grim female ranger, leather and dark cloth armor, holding a gnarled wooden bow, our custom model 'DarkFable_v1', style consistency, heavy ink outlines, desaturated earthy tones, painterly texture, character concept art, full body, centered, white background --ar 2:3

This prompt is dense with purpose. We’re not just describing a ranger; we’re giving the AI a set of rules to follow.

• our custom model 'DarkFable_v1': This is the most critical command. It tells the generator to use our trained style as the absolute base.
• style consistency: A reinforcement phrase to minimize deviation.
• heavy ink outlines, desaturated earthy tones, painterly texture: These are the specific stylistic elements from our training data that we want to emphasize.

The result is our anchor asset. It’s not just a character; it’s the living embodiment of our game’s art style. Every subsequent asset will be cross-referenced against this image to ensure it matches.

Step 2: The Key Prop - Scaling the Style

Now for the environmental piece. The challenge is taking the character’s style and applying it to an inanimate, architectural object. The risk is that the AI might generate a generic stone shrine that doesn’t match our ranger’s ink-lined, painterly world. The solution is to explicitly reference our established style and use the same custom model.

Refined Prompt: ancient moss-covered stone shrine, a faint magical glow emanating from the central rune, our custom model 'DarkFable_v1', matching the style of our grim ranger character, heavy ink outlines, desaturated palette, painterly texture, isometric perspective, game asset, isolated on a white background --ar 1:1

Notice the evolution here. We’ve added a “golden nugget” instruction: matching the style of our grim ranger character. While the AI can’t “remember” the previous image in a new session, this phrasing acts as a powerful stylistic anchor, forcing it to recall the visual language we defined. The isometric perspective and game asset tags ensure it’s rendered in a way that’s immediately useful for level design.

Step 3: The Props - Generating Cohesive Items

Finally, we populate the world with smaller items. These are our potions. To create a set that feels like a collection, we use Leonardo’s Image Generation with Prompt Magic to create variations from a single base idea. We’ll start with one solid potion concept and then ask the AI to iterate.

Base Potion Prompt: health potion, dark glass bottle with a gnarled wooden stopper, filled with a thick crimson liquid, our custom model 'DarkFable_v1', heavy ink outlines, painterly texture, game icon, centered, white background --ar 1:1

Once we have a base we like, we can generate variations simply by modifying the core noun while keeping the rest of the prompt identical:

• ...mana potion, dark glass bottle... (swap “health” for “mana”)
• ...stamina potion, dark glass bottle... (swap “health” for “stamina”)

This rapid-iteration technique is where the power of a custom model truly shines. Because the foundational style is locked in, we can generate a whole set of items in minutes, confident they will all share the same DNA as our character and shrine.

The Final Pack: A Blueprint for Your Project

By the end of this process, we have a small but perfectly cohesive asset pack:

1. Character: A grim ranger that defines the style.
2. Environment: A stone shrine that scales the style to architecture.
3. Props: A set of potions that iterate on the style for items.

This case study demonstrates the blueprint for success in AI-assisted game development. It’s a workflow that prioritizes consistency over randomness. By investing time upfront to train a custom model and then using layered, reinforcing prompts, you move from being a passive image generator to an active art director. This is how you build a world that feels handcrafted, even when it’s powered by AI.

Conclusion: Your AI Art Director is Ready to Deploy

You’ve moved beyond simply typing a few words and hoping for the best. The core lesson is that AI doesn’t replace your creative vision; it requires you to define it with absolute clarity. We’ve seen how a structured prompting framework—combining subject, style, materiality, and negative prompts—transforms a chaotic generator into a precise instrument. This isn’t just about getting a single cool image; it’s about building a repeatable process that you can rely on.

The true power, however, is unlocked when you stop treating each asset as a one-off request. By training a custom model on your game’s specific aesthetic, you’re teaching the AI your unique visual language. This is the secret to achieving the kind of cohesion that makes a game world feel authentic and handcrafted, not like a random collection of AI-generated images. You’re no longer just a creator; you’re the architect of a visual system.

The developers who will thrive are those who can define a system, not just a single image. Your ability to communicate a clear, consistent vision is the skill that remains paramount.

The future of game development is a partnership between human creativity and machine efficiency. As AI tools become more deeply integrated into engines like Unity and Unreal, your role as the art director—the one who sets the style, defines the rules, and guides the process—becomes even more critical. The momentum you’ve built here is real.

Your next step is to put this blueprint into action. Start training your first custom model with a small, focused set of your own art. Then, take one of the prompt frameworks from this guide, adapt it to your world, and generate your first cohesive asset set. Your unique game world is waiting to be brought to life.

Expert Insight

Frequently Asked Questions

Q: How do I fix mismatched styles in AI game art

You must stop using generic prompts and instead train a custom ‘Alchemi’ model in Leonardo.ai on your own concept art to teach the AI your specific style

Q: What is the most important part of a prompt for consistency

Defining the ‘Visual DNA’—specific terms for color palette, line weight, and texture—is more critical than describing the object itself

Q: Can I use Leonardo.ai for 3D game assets

Yes, you can generate high-quality textures and concept art for 3D models, or use image-to-image workflows to style-match 3D renders