Showcase: A year of using SD for indie game asset creation.

Over the past twelve months, my small indie studio has transitioned from a mixed pipeline of contracted art and purchased asset packs to a predominantly AI-assisted workflow centered on Stable Diffusion. This shift was not a simple replacement but a complex integration project, requiring careful tool evaluation, pipeline design, and iterative refinement. Our primary use cases include generating concept art, creating consistent in-game sprite sheets (particularly for items and environmental props), and producing promotional materials. The goal of this post is to provide a detailed, side-by-side comparison of the tools and techniques that proved most effective, alongside the specific technical hurdles we overcame.

Our core stack evolved significantly. We began with the Automatic1111 web UI for its extensive community and plugin ecosystem, but later integrated ComfyUI for reproducible, graph-based pipelines, especially for batch processing. For model architecture, we settled on a hybrid approach:
- **Base Models:** `sd_xl_base_1.0` for high-concept initial imagery due to its compositional strength, fine-tuned with DreamBooth on our own asset style.
- **Specialized Checkpoints:** `protogenV2.2` for general fantasy assets, and a custom-trained LoRA (trained on ~150 of our own rendered style frames) to enforce consistency across generated assets.
- **Upscalers:** A dedicated pipeline using `4x-UltraSharp` within ComfyUI, followed by a gentle pass of `ESRGAN` for final texture detail.

The most critical technical challenge was maintaining character and item consistency across multiple angles and states. We achieved this not through prompting alone, but by implementing a rigid workflow:

1. **Initial Seed Capture:** A successful generation for a "Hero" asset is locked with a fixed seed and a detailed prompt template.
2. **ControlNet Integration:** We use `openpose` for character posture consistency across animations frames and `canny` or `depth` maps for item rotations. The key was training our custom LoRA on the *output* of this controlled generation to reinforce the style.
3. **Batch Processing Script:** A ComfyUI workflow is converted into a Python script that processes a JSON file defining a batch of assets (e.g., "Goblin_Club," "Goblin_Shield") with their respective ControlNet references and seed offsets.

Here is a simplified snippet of the configuration node we use in ComfyUI to embed our custom-trained LoRA and trigger the ControlNet conditioning:

```json
{
"node": "LoraLoader",
"inputs": {
"model": "MODEL_STREAM",
"lora_name": "indie_game_style_v3.safetensors",
"strength_model": 0.7,
"strength_clip": 0.7
}
},
{
"node": "ControlNetApplyAdvanced",
"inputs": {
"conditioning": "CONDITIONING_STREAM",
"control_net": "controlnet_canny_model",
"image": "CANNY_EDGE_MAP_IMAGE",
"strength": 1.2,
"start_percent": 0.0,
"end_percent": 0.8
}
}
```

Pricing and resource feedback is a crucial consideration for indie teams. Our local setup (RTX 4090, 24GB VRAM) handles training and large batches efficiently, but initial costs are non-trivial. Cloud alternatives like RunPod for training and large-scale batch jobs proved cost-effective for burst needs. The real expense, however, is time, not compute. The hours invested in:
- Curating and tagging a high-quality dataset for LoRA training.
- Iterating on prompt engineering and negative embeddings to eliminate common artifacts (e.g., malformed hands, aberrant textures).
- Developing and debugging the ComfyUI pipelines to be fault-tolerant.

The primary pitfalls we encountered were not in image quality, but in integration. File management and version control for thousands of generated assets became a significant issue. We addressed this by developing a simple metadata tagging system where each generated image's prompt, seed, model, and LoRA weights are stored in a sidecar `.json` file, ingested into a small SQLite database for searchability. Another major lesson was that SD cannot replace a cohesive art direction; it requires a strong, guiding hand and a clear stylistic vision to be used effectively as a production tool, rather than a mere novelty. The toolchain is now stable, but it required a year of diligent comparison, testing, and systems thinking to reach that point.