generative-ai-design

AI-assisted design workflows: prompt engineering for image generation (Midjourney, DALL-E 3, Stable Diffusion, Flux), achieving style consistency across a generated asset set, post-processing AI outputs for production use, legal and licensing considerations, and when AI generation is and isn't appropriate. For teams integrating generative AI into their design workflow.

8 stars

Best use case

generative-ai-design is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

AI-assisted design workflows: prompt engineering for image generation (Midjourney, DALL-E 3, Stable Diffusion, Flux), achieving style consistency across a generated asset set, post-processing AI outputs for production use, legal and licensing considerations, and when AI generation is and isn't appropriate. For teams integrating generative AI into their design workflow.

Teams using generative-ai-design should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/generative-ai-design/SKILL.md --create-dirs "https://raw.githubusercontent.com/marvinrichter/clarc/main/skills/generative-ai-design/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/generative-ai-design/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How generative-ai-design Compares

Feature / Agentgenerative-ai-designStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

AI-assisted design workflows: prompt engineering for image generation (Midjourney, DALL-E 3, Stable Diffusion, Flux), achieving style consistency across a generated asset set, post-processing AI outputs for production use, legal and licensing considerations, and when AI generation is and isn't appropriate. For teams integrating generative AI into their design workflow.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Generative AI Design Skill

## When to Activate

- Using Midjourney, DALL-E, Stable Diffusion, or Flux to generate design assets
- Maintaining visual consistency across a set of AI-generated images
- Deciding whether AI generation fits a design requirement
- Post-processing and preparing AI outputs for production
- Understanding licensing and copyright implications

---

## When to Use (and Not Use) AI Generation

### Appropriate uses

```
✓ Mood boarding — fast visual direction exploration
✓ Background textures and patterns — no identity risk
✓ Abstract illustrations — non-representational art
✓ Concept art for presentations — not for product UI
✓ Placeholder images — to be replaced with real photography
✓ Marketing experiments — low-brand-stakes A/B tests
✓ Reference images for briefing a human designer
```

### Inappropriate uses

```
✗ Brand identity elements (logo, icon system) — inconsistency, identity risk
✗ Illustrations requiring exact style match to existing set
✗ People with specific demographics — hallucination, bias, legal risk
✗ Realistic-looking fake events, products, or endorsements
✗ Images involving recognizable faces without consent
✗ Medical, legal, or safety-critical visual content
✗ Content that will be passed off as photography without disclosure
```

---

## Prompt Engineering for Image Generation

### Universal structure

```
[Style adjective(s)] [medium/technique] [subject description],
[color palette / mood], [lighting], [camera/perspective],
[technical quality spec], [negative prompt if supported]
```

### Style adjectives that work reliably

```
Illustration styles:
  flat vector illustration
  isometric illustration
  line art
  editorial illustration
  hand-drawn illustration
  geometric abstract

Photography styles:
  product photography
  editorial photography
  documentary photography
  aerial photography

Art direction:
  minimalist
  bold and graphic
  soft and dreamy
  high contrast
  muted palette
  vibrant
```

### Midjourney-specific syntax

```
Basic:
/imagine flat vector illustration of a developer at a laptop,
indigo and amber palette, minimal style, white background,
geometric shapes, no shadows --v 6.1 --ar 16:9

Style reference (--sref):
--sref [image URL]   # style match to reference image

Character reference (--cref):
--cref [image URL]   # maintain character appearance

Stylize (--s):
--s 0    # minimal stylization, follows prompt closely
--s 100  # balanced (default)
--s 750  # strong stylization, more creative

Seed for consistency (--seed):
--seed 12345   # reproducible results for series

Negative prompt (--no):
--no text, watermark, logo, signature, border
```

### DALL-E 3 (via ChatGPT/API)

```
Strengths:  Strong instruction-following, text in images, safety
Weaknesses: Less stylistic control than Midjourney, can refuse edge cases
Best for:   Concept art, marketing copy images, illustrations with text

Prompt tips:
- Be explicit about style: "in the style of a flat vector illustration"
- Specify what NOT to include: "no text, no people, no shadows"
- Request revisions by describing the delta: "same composition but with
  a darker background and remove the people"
```

### Stable Diffusion / Flux prompt structure

```
Flux.1 (Schnell / Dev):
  Strong prompt adherence, faster than SDXL
  Works well with natural language descriptions
  No need for comma-separated token lists

Example (Flux):
A clean isometric illustration of a cloud server rack surrounded by
floating data icons. Deep blue and cyan color palette. Minimal flat style.
Technical, precise. White background. No text. No people.

Stable Diffusion XL:
  [positive tags], masterpiece, best quality, 8k
  Negative: bad quality, blurry, distorted, text, watermark

ControlNet modes:
  Canny  → preserve edge structure (for consistent composition)
  Depth  → preserve 3D structure
  Pose   → preserve character pose (useful for character consistency)
  IP-Adapter → style transfer from reference image
```

---

## Style Consistency Across a Set

The hardest problem in AI design: making 10 illustrations look like they're from the same series.

### Method 1: Seed locking (Midjourney)

```
1. Create first image: /imagine [prompt] --seed 42
2. Note the job ID and seed from the image details
3. All subsequent images use same seed: --seed 42
4. Variations will share compositional DNA
```

### Method 2: Style reference (Midjourney --sref)

```
1. Create approved "reference" image
2. Add --sref [URL] to all subsequent prompts
3. The style (colors, shapes, lighting) transfers
4. Subject still controlled by text prompt

Example:
/imagine empty state for a search feature, friendly character,
indigo palette --sref https://[your-reference-image-url] --sw 100
```

### Method 3: IP-Adapter / image reference (Stable Diffusion)

```
1. Load IP-Adapter extension in ComfyUI or A1111
2. Use reference image at 0.6-0.8 weight
3. Write prompt for new subject
4. Style and color palette transfer while subject changes
```

### Method 4: Consistent prompting (any tool)

Write a "style fingerprint" — a fixed block you append to every prompt:

```
[Subject-specific prompt]

Style: flat 2D vector illustration, muted indigo and amber color palette,
simple geometric shapes, round corners, minimal detail, no gradients,
white background, no shadows, no text, no borders, editorial illustration style
```

Keep this block identical for every image in the series.

---

## Post-Processing AI Outputs

AI outputs are almost never production-ready. Budget time for cleanup.

### Standard pipeline

```
Raw AI output (JPG/PNG, 1024×1024)
        ↓
Remove background (remove.bg, Photoshop, Figma plugin)
        ↓
Color correction (match to brand palette in Figma/Photoshop)
        ↓
Crop to final format (1200×628 OG, 1080×1080 Instagram, etc.)
        ↓
Compress (Squoosh.app, ImageOptim)
        ↓
Export at correct resolution (2× for retina)
```

### Vectorization (when SVG is needed)

```
AI images are raster. For scalable SVG:

1. Adobe Illustrator → Image Trace
   Best settings: "16 Colors" preset → expand → ungroup → clean up

2. Vector Magic (vectormagic.com)
   Better for illustrations with clear shapes

3. Manual redraw in Figma
   For simple shapes — faster than tracing, cleaner result

Rule: Don't vectorize complex photorealistic outputs — only works for
flat, simple illustrations.
```

### Color correction to match brand

```
In Figma:
1. Import AI image
2. Create overlay rectangle with brand color
3. Set blend mode to "Color"
4. Adjust opacity until palette feels cohesive
5. Export as PNG

In CSS (for web use):
img.brand-tinted {
  filter: hue-rotate(30deg) saturate(0.8) brightness(1.1);
}
```

---

## Legal and Licensing Considerations

### Copyright status (as of 2025)

```
United States: AI-generated images with no human authorship are
  not copyrightable. Works with significant human creative input
  (prompting + selection + editing) may qualify.

European Union: Under active regulation. Human authorship required
  for full protection.

Practical rule: Treat AI-generated assets as unprotected until
  your legal counsel advises otherwise.
```

### Training data licensing

| Tool | Training data transparency | Commercial use |
|------|---------------------------|----------------|
| Midjourney | Undisclosed | Allowed (paid plans) |
| DALL-E 3 | OpenAI policy | Allowed (all tiers) |
| Stable Diffusion (open) | LAION dataset | Allowed (check model card) |
| Flux.1 Dev | Black Forest Labs | Research/personal only |
| Flux.1 Schnell | Black Forest Labs | Allowed (Apache 2.0) |
| Adobe Firefly | Adobe Stock (licensed) | Commercially safe |

**Safest for commercial use**: Adobe Firefly (indemnified), DALL-E 3, Flux.1 Schnell

### Disclosure requirements

- Do not pass off AI-generated content as original photography to consumers
- Some clients and platforms require disclosure of AI-generated content
- Establish an internal policy: label AI assets in your file system (`ai-generated/` folder)

---

## AI Design Tools Reference

| Tool | URL | Strengths | Pricing |
|------|-----|-----------|---------|
| **Midjourney** | midjourney.com | Best image quality, style control | $10-$60/mo |
| **DALL-E 3** | via ChatGPT / API | Instruction-following, API access | Pay per use |
| **Flux.1** | via replicate.com / local | Open weights, high quality | Free/API |
| **Adobe Firefly** | firefly.adobe.com | Commercial-safe, Photoshop integration | Creative Cloud |
| **Ideogram** | ideogram.ai | Best text-in-image generation | Free tier |
| **Recraft** | recraft.ai | Vector output, style library | Free tier |
| **Krea** | krea.ai | Real-time generation, style transfer | Free tier |

---

## Checklist

- [ ] Use case validated: AI generation appropriate for this asset (not brand/identity)
- [ ] Style fingerprint written and applied consistently across all prompts
- [ ] Seed or style reference used for series consistency
- [ ] AI output post-processed: background removed, colors matched to brand
- [ ] File format correct for use case (JPG for photos, PNG for transparency, SVG for scalable)
- [ ] Image compressed (target: <300KB for web)
- [ ] AI-generated files stored in labeled folder (`ai-generated/`)
- [ ] Commercial licensing verified for the tool used
- [ ] Disclosure added if required (internal policy or client requirement)
- [ ] Human designer reviewed before high-brand-stakes publication

Related Skills

typography-design

8
from marvinrichter/clarc

Typography as a creative discipline: typeface selection criteria, type pairing (serif + sans, display + body), modular scale systems, line-height and tracking ratios, hierarchy construction, and web/mobile rendering considerations. The decisions behind design tokens, not the tokens themselves.

sdk-design-patterns

8
from marvinrichter/clarc

SDK design patterns — API ergonomics, backward compatibility (semantic versioning, deprecation), multi-language SDK generation (openapi-generator vs Speakeasy), error hierarchy design, SDK testing strategies, and documentation as first-class SDK artifact.

presentation-design

8
from marvinrichter/clarc

Presentation structure, narrative design, and slide layout principles. Covers the problem-solution-evidence arc, slide density rules (one idea per slide), slide type catalogue, opening hooks, and closing patterns. Use when structuring any slide deck — conference talk, demo, investor pitch, or team update.

marketing-design

8
from marvinrichter/clarc

Marketing asset design for developers: Open Graph / social media card specs and HTML generation, email template HTML/CSS patterns (table-based layout, Outlook compatibility, dark mode), banner and ad creative dimensions, print-safe PDF generation, and brand consistency across marketing touchpoints. From OG image code to email that renders in Outlook.

liquid-glass-design

8
from marvinrichter/clarc

iOS 26 Liquid Glass design system — dynamic glass material with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit.

experiment-design

8
from marvinrichter/clarc

A/B testing and experimentation workflow: hypothesis design, metric selection, sample size calculation, statistical significance, common pitfalls (peeking, SRM, novelty effect), and experiment lifecycle. Complements feature-flags (implementation) with statistical rigor.

design-system

8
from marvinrichter/clarc

Design system architecture: design tokens (color, spacing, typography, radius), component library layers (Primitive → Composite → Pattern), theming with CSS Custom Properties and Tailwind, Storybook documentation, and dark mode. The foundation for consistent UI across an entire product.

design-ops

8
from marvinrichter/clarc

Design Operations: Figma file organization standards, design-to-dev handoff workflow, design QA checklist, design token sync pipeline (Figma Variables → Style Dictionary → CSS/Tailwind), design system versioning and governance, component audit methodology, and design-dev collaboration patterns. Bridges the gap between design tools and production code.

dashboard-design

8
from marvinrichter/clarc

Dashboard architecture and UX: KPI hierarchy, information density decisions, filter patterns, drill-down navigation, real-time update strategies (polling vs. WebSocket vs. SSE), empty and loading states for charts, and responsive dashboard layouts. Use when designing or building any analytics dashboard.

api-design-advanced

8
from marvinrichter/clarc

Advanced API design — per-language implementation patterns (TypeScript/Next.js, Go/net-http), anti-patterns (200 for everything, 500 for validation, contract breaking), and full pre-ship checklist.

api-design

8
from marvinrichter/clarc

REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.

zero-trust-patterns

8
from marvinrichter/clarc

Zero-Trust security patterns — mTLS between microservices (Istio/SPIFFE), SPIRE workload identity, OPA/Envoy authorization, NetworkPolicy default-deny-all, short-lived credentials, service mesh security, and Kubernetes RBAC hardening.