ai-artist

Original source / Raw SKILL.md

---
name: ai-artist
description: Write and optimize prompts for AI-generated outcomes across text and image models. Use when crafting prompts for LLMs (Claude, GPT, Gemini), image generators (Midjourney, DALL-E, Stable Diffusion, Imagen, Flux), or video generators (Veo, Runway). Covers prompt structure, style keywords, negative prompts, chain-of-thought, few-shot examples, iterative refinement, and domain-specific patterns for marketing, code, and creative writing.
version: 1.0.0
license: MIT
---

# AI Artist - Prompt Engineering

Craft effective prompts for AI text and image generation models.

## Core Principles

1. **Clarity** - Be specific, avoid ambiguity
2. **Context** - Set scene, role, constraints upfront
3. **Structure** - Use consistent formatting (markdown, XML tags, delimiters)
4. **Iteration** - Refine based on outputs, A/B test variations

## Quick Patterns

### LLM Prompts (Claude/GPT/Gemini)

```
[Role] You are a {expert type} specializing in {domain}.
[Context] {Background information and constraints}
[Task] {Specific action to perform}
[Format] {Output structure - JSON, markdown, list, etc.}
[Examples] {1-3 few-shot examples if needed}
```

### Image Generation (Midjourney/DALL-E/Stable Diffusion)

```
[Subject] {main subject with details}
[Style] {artistic style, medium, artist reference}
[Composition] {framing, angle, lighting}
[Quality] {resolution modifiers, rendering quality}
[Negative] {what to avoid - only if supported}
```

**Example**: `Portrait of a cyberpunk hacker, neon lighting, cinematic composition, detailed face, 8k, artstation quality --ar 16:9 --style raw`

## References

Load for detailed guidance:

| Topic | File | Description |
|-------|------|-------------|
| LLM | `references/llm-prompting.md` | System prompts, few-shot, CoT, output formatting |
| Image | `references/image-prompting.md` | Style keywords, model syntax, negative prompts |
| Nano Banana | `references/nano-banana.md` | Gemini image prompting, narrative style, multi-image input |
| Advanced | `references/advanced-techniques.md` | Meta-prompting, chaining, A/B testing |
| Domain Index | `references/domain-patterns.md` | Universal pattern, links to domain files |
| Marketing | `references/domain-marketing.md` | Headlines, product copy, emails, ads |
| Code | `references/domain-code.md` | Functions, review, refactoring, debugging |
| Writing | `references/domain-writing.md` | Stories, characters, dialogue, editing |
| Data | `references/domain-data.md` | Extraction, analysis, comparison |

## Model-Specific Tips

| Model | Key Syntax |
|-------|------------|
| Midjourney | `--ar`, `--style`, `--chaos`, `--weird`, `--v 6.1` |
| DALL-E 3 | Natural language, no parameters, HD quality option |
| Stable Diffusion | Weighted tokens `(word:1.2)`, LoRA, negative prompt |
| Flux | Natural prompts, style mixing, `--guidance` |
| Imagen/Veo | Descriptive text, aspect ratio, style references |

## Anti-Patterns

- Vague instructions ("make it better")
- Conflicting constraints
- Missing context for domain tasks
- Over-prompting with redundant details
- Ignoring model-specific strengths/limits


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### references/llm-prompting.md

```markdown
# LLM Prompting Reference

## Prompt Architecture

### System Prompt Structure
```
You are [ROLE] with expertise in [DOMAIN].

## Context
[Background, constraints, tone]

## Instructions
[Step-by-step task breakdown]

## Output Format
[Exact structure with example]

## Constraints
- [Hard limits]
- [Guardrails]
```

### User Prompt Structure
```xml
<context>[Background information]</context>
<task>[Specific action required]</task>
<format>[Output structure]</format>
<constraints>[Additional limits]</constraints>
```

## Reasoning Techniques

### Chain of Thought (CoT)
| Variant | Trigger | Best For |
|---------|---------|----------|
| Zero-shot | "Think step by step" | Quick reasoning tasks |
| Few-shot | 2-3 reasoning examples | Complex multi-step |
| Auto-CoT | "Let's approach systematically" | General reasoning |

### Tree of Thoughts (ToT)
```
Explore 3 approaches to [problem]:
For each: 1) Method 2) Pros/cons 3) Success probability
Evaluate branches, select best path.
```

### Self-Consistency
Run same prompt 3-5x with temp=0.7, take majority answer. Best for: math, logic, factual.

### ReAct Pattern
```
Thought: [Current reasoning]
Action: [Tool/step to take]
Observation: [Result]
...repeat...
Final Answer: [Conclusion]
```

### Least-to-Most
```
Break [complex task] into subproblems.
Solve easiest first, build up.
```

## Instruction Optimization

### Self-Refine Pattern
```
1. Generate initial response
2. Critique: "What's wrong with this?"
3. Refine: "Fix identified issues"
4. Repeat until satisfactory
```

### Role Optimization
- **Expert persona**: "As a senior [role] with 20 years..."
- **Constraint persona**: "You only respond with..."
- **Teaching persona**: "Explain as if to a..."

### Task Decomposition
```
<subtasks>
1. [First step - output X]
2. [Second step - using X, output Y]
3. [Final step - using Y, output Z]
</subtasks>
```

## Output Control

### JSON Enforcement
```
Respond in valid JSON only:
{"field": "type", "required": true}
No markdown, no explanation, just JSON.
```

### Length Control
| Goal | Phrase |
|------|--------|
| Brief | "In 2-3 sentences" |
| Detailed | "Comprehensive analysis in 500 words" |
| Structured | "5 bullet points, max 20 words each" |

### Hallucination Reduction
- "Only use information from provided context"
- "If unsure, say 'I don't know'"
- "Cite sources for each claim"
- "Confidence: high/medium/low for each point"

## Model-Specific Tips

### Claude
- XML tags: `<thinking>`, `<answer>`, `<context>`
- Extended thinking: "Think deeply before responding"
- Prefill: Start assistant response to guide format

### GPT-4
- JSON mode: `response_format: {"type": "json_object"}`
- Function calling for structured output
- System message for persistent instructions

### Gemini
- Multimodal: Image + text in same prompt
- Grounding: Enable Google Search for facts
- Safety settings: Adjust thresholds

## Context Engineering

### RAG Prompt Pattern
```
<retrieved_context>
[Document chunks with sources]
</retrieved_context>

Answer based ONLY on context above.
If not in context, say "Not found in documents."
```

### Window Optimization
- Front-load critical info (primacy effect)
- Repeat key constraints at end (recency effect)
- Chunk long documents with summaries

## Few-Shot Examples

### Structure
```
Example 1:
Input: [representative input]
Output: [ideal output]

Example 2:
Input: [edge case]
Output: [handling]

Now apply to:
Input: [actual task]
```

### Selection Criteria
- Diverse examples > similar examples
- Include edge cases
- Match complexity of target task
- 2-5 examples optimal (diminishing returns beyond)

```

### references/image-prompting.md

```markdown
# Image Generation Prompting

## Universal Structure
```
[Subject + Details] [Action/Pose] [Setting/Environment]
[Style/Medium] [Artist/Movement Reference]
[Lighting] [Camera/Lens] [Composition]
[Quality Modifiers] [Aspect Ratio]
```

## Platform Reference

### Midjourney v6.1
```
[prompt] --ar 16:9 --style raw --v 6.1
```

| Parameter | Values | Effect |
|-----------|--------|--------|
| `--ar` | 1:1, 16:9, 9:16, 4:3, 3:2, 21:9 | Aspect ratio |
| `--style` | raw, default | raw=photorealistic |
| `--stylize` | 0-1000 | Artistic interpretation (0=literal) |
| `--chaos` | 0-100 | Variation between outputs |
| `--weird` | 0-3000 | Unusual/experimental elements |
| `--quality` | .25, .5, 1, 2 | Detail level (cost) |
| `--seed` | number | Reproducibility |
| `--no` | [term] | Negative prompt inline |
| `--tile` | - | Seamless patterns |

**Multi-prompt weighting**: `cat::2 dog::1` (cat 2x stronger)
**Describe**: Upload image → get prompt suggestions
**Blend**: `/blend` to merge 2-5 images

### DALL-E 3
- Natural language only, no parameters
- Be descriptive, not keyword-heavy
- Specify: "HD quality" or "vivid style" in prompt
- Text rendering: Describe font, placement, content explicitly
- Avoid: Lists of keywords, technical jargon

### Stable Diffusion / SDXL / Flux
```
(important term:1.3), normal term, (less important:0.8)
Negative prompt: ugly, blurry, deformed, watermark
```

| Feature | Syntax |
|---------|--------|
| Weight up | `(word:1.2)` to `(word:1.5)` |
| Weight down | `(word:0.5)` to `(word:0.8)` |
| LoRA | `<lora:model_name:0.8>` |
| Embedding | `embedding:name` |
| Blend | `[cat|dog]` alternating |

**CFG Scale**: 7-12 typical (higher=more prompt adherence)
**Samplers**: DPM++ 2M Karras (quality), Euler a (speed)

### Nano Banana (Gemini)
```
[Narrative description, not keywords]
Captured with 85mm lens, soft bokeh, natural lighting
```

**Key features**:
- 32K token context (complex prompts OK)
- Narrative paragraphs > keyword lists
- Hex colors for precision: `#9F2B68`
- Text rendering: Describe font, placement explicitly
- Multi-image: Up to 14 reference images
- Search grounding: Real-time data (weather, events)
- Thinking mode: Complex composition reasoning

**Aspect ratios**: 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9
**Resolution**: 1K, 2K, 4K (use uppercase K)

**Best practices**:
- ALL CAPS for critical requirements
- Markdown lists for multiple rules
- "NEVER include..." for negative constraints
- Photography terms anchor quality

### Imagen 4 / Veo 3.1
- Natural language, descriptive
- Aspect ratio in text: "16:9 landscape format"
- Veo: Cinematography keywords most powerful
- Camera movements: pan, tilt, dolly, crane, tracking
- Scene transitions: cut, fade, dissolve

## Style Keywords

### Art Movements
photorealistic, hyperrealistic, impressionist, expressionist,
surrealist, art nouveau, art deco, pop art, cyberpunk, steampunk,
solarpunk, vaporwave, synthwave, brutalist, minimalist

### Media Types
oil painting, watercolor, digital art, 3D render, vector art,
pencil sketch, ink drawing, pastel, charcoal, gouache, fresco

### Photography Styles
portrait, landscape, macro, street, documentary, fashion,
editorial, product, architectural, aerial, underwater

## Lighting Vocabulary

| Term | Effect |
|------|--------|
| Golden hour | Warm, soft, directional |
| Blue hour | Cool, moody, twilight |
| Rembrandt | Triangle on cheek, dramatic |
| Butterfly | Shadow under nose, glamorous |
| Split | Half face lit, mysterious |
| Rim/back | Edge highlight, separation |
| Volumetric | Light rays visible |
| Neon glow | Colorful, cyberpunk |

## Camera/Lens Terms
- 50mm (standard), 85mm (portrait), 35mm (wide)
- Telephoto (compressed), Macro (close-up), Fisheye (distorted)
- Shallow DOF, Deep DOF, Bokeh
- Low angle, High angle, Dutch angle, Bird's eye, Worm's eye

## Composition Keywords
rule of thirds, golden ratio, centered, symmetrical,
leading lines, framing, negative space, filling frame,
foreground interest, layered depth

## Negative Prompts (SD/Flux)
```
ugly, deformed, blurry, low quality, bad anatomy,
extra limbs, missing limbs, disfigured, watermark,
text, signature, cropped, out of frame, duplicate,
poorly drawn, bad proportions, gross proportions
```

## Iterative Workflow
1. Start: Subject + style + quality modifier
2. Add: Lighting + composition + camera
3. Test: Generate 4 variations
4. Refine: Adjust weights, add negatives
5. Upscale: Select winner, increase resolution

```

### references/nano-banana.md

```markdown
# Nano Banana (Gemini Image)

## Models

| Model ID | Type | Best For |
|----------|------|----------|
| `gemini-2.5-flash-image` | Flash | Speed, high-volume |
| `gemini-3-pro-image-preview` | Pro | Text rendering, complex prompts |

## Core Principle

**Narrative paragraphs > keyword lists** (32K context). Write like briefing a photographer.

## Parameters

```python
responseModalities=['TEXT', 'IMAGE']
aspect_ratio="16:9"  # 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9
image_size="2K"      # 1K, 2K, 4K - MUST be uppercase K
```

## Prompt Templates

**Photorealistic**: `A [subject] in [location], [lens] lens. [Lighting] creates [mood]. [Details]. [Camera angle]. Professional photography, natural lighting.`

**Illustration**: `[Art style] illustration of [subject]. [Color palette]. [Line style]. [Background]. [Mood].`

**Text in Image**: `Image with text "[EXACT]" in [font]. Font: [style]. Color: [hex/#FF5733]. Position: [top/center/bottom]. Background: [desc]. Context: [poster/sign].`

**Product**: `[Product] on [surface]. Materials: [finish]. Lighting: [setup]. Camera: [angle]. Background: [type]. Style: [commercial/lifestyle].`

## Techniques

| Technique | Example |
|-----------|---------|
| Emphasis | `ALL CAPS` for critical requirements |
| Precision colors | `#9F2B68` instead of "dark magenta" |
| Negative constraints | `NEVER include text/watermarks. DO NOT add labels.` |
| Realism trigger | `Natural lighting, DOF. Captured with Canon EOS 90D DSLR.` |
| Structured edits | `Make ALL edits: - [1] - [2] - [3]` |
| Complex logic | `Kittens MUST have heterochromatic eyes matching fur colors` |

## Advanced Features

**Multi-Image Input** (up to 14): 6 object + 5 human refs. Tip: collage refs into single image.

**Search Grounding**: `tools=[{"google_search": {}}]` — real-time data (weather, charts, events).

**Thinking Mode** (Pro only): `part.thought` in response for complex reasoning.

## Workflow

1. Narrative description → 2. Photography terms → 3. ALL CAPS emphasis → 4. Multi-turn refine → 5. Negative constraints → 6. Set ratio/resolution

## Avoid

- Keyword spam ("4k, trending, masterpiece")
- Vague text ("add some text" → specify exact text, font, position)
- Lowercase resolution ("4k" rejected, use "4K")

```

### references/advanced-techniques.md

```markdown
# Advanced Prompt Engineering

## Prompt Optimization

### DSPy Framework
Automatic prompt optimization through:
1. Define task with input/output signatures
2. Compile with optimizer (BootstrapFewShot, MIPRO)
3. Model learns optimal prompting strategy
4. Export optimized prompts for production

### Meta-Prompting
```
You are a prompt engineer. Create 5 variations for [task]:
1. Direct instruction approach
2. Role-based approach
3. Few-shot example approach
4. Chain of thought approach
5. Constraint-focused approach

Evaluate each, select best.
```

### Self-Refinement Loop
```
Generate: [Initial response]
Critique: "What's wrong? Score 1-10."
Refine: "Fix issues, improve score."
Repeat until score ≥ 8.
```

## Prompt Chaining

### Sequential Chain
```
Chain 1: [Input] → Extract key points
Chain 2: Key points → Create outline
Chain 3: Outline → Write draft
Chain 4: Draft → Edit and polish
```

### Parallel Chain
Run independent subtasks simultaneously, merge results.

### Conditional Chain
```
If [condition A]: Execute prompt variant 1
If [condition B]: Execute prompt variant 2
Else: Execute default prompt
```

### Loop Pattern
```
While not [success condition]:
    Generate attempt
    Evaluate against criteria
    If pass: break
    Else: refine with feedback
```

## Evaluation Methods

### LLM-as-Judge
```
Rate this [output] on:
1. Accuracy (1-10)
2. Completeness (1-10)
3. Clarity (1-10)
4. Relevance (1-10)

Provide reasoning for each score.
Final: Pass/Fail threshold = 7 average.
```

### A/B Testing Protocol
1. Single variable per test
2. 20+ samples minimum
3. Score on defined criteria
4. Statistical significance check (p < 0.05)
5. Document winner, roll out

### Regression Testing
- Maintain test set of critical examples
- Run before deploying prompt changes
- Compare scores to baseline
- Block deployment if regression detected

## Agent Prompting

### Tool Use Design
```
You have access to these tools:
- search(query): Search the web
- calculate(expression): Math operations
- code(language, code): Execute code

To use: <tool_name>arguments</tool_name>
Wait for result before continuing.
```

### Planning Prompt
```
Task: [Complex goal]

Before acting:
1. Break into subtasks
2. Identify dependencies
3. Plan execution order
4. Note potential blockers

Then execute step by step.
```

### Reflection Pattern
```
After each step:
- What worked?
- What didn't?
- Adjust approach for next step.
```

## Parameter Tuning

| Parameter | Low | High | Use Case |
|-----------|-----|------|----------|
| Temperature | 0.0-0.3 | 0.7-1.0 | Factual vs Creative |
| Top-P | 0.8 | 0.95 | Focused vs Diverse |
| Top-K | 10 | 100 | Conservative vs Exploratory |

**Rule**: Tune temperature first. Only adjust top-p if needed. Never both at once.

## Safety Patterns

### Output Filtering
```
Before responding, check:
- No PII exposure
- No harmful content
- No policy violations
- Aligned with guidelines

If any fail: "I can't help with that."
```

### Jailbreak Prevention
- Clear system boundaries upfront
- Repeat constraints at end
- "Ignore previous" pattern detection
- Role-lock: "You are ONLY [role], never anything else"

### Confidence Calibration
```
For each claim, provide:
- Confidence: High/Medium/Low
- Source: [citation if available]
- Caveat: [limitations]
```

## Production Patterns

### Version Control
- Git for prompt files
- Semantic versioning (1.0.0, 1.1.0)
- Changelog per version
- Rollback capability

### Caching
- Cache common queries
- TTL based on content freshness
- Invalidate on prompt update

### Fallbacks
```
Try: Primary prompt
If fail: Simplified fallback prompt
If still fail: Human escalation
Log all failures for analysis.
```

### Cost Optimization
- Shorter prompts = fewer tokens
- Remove redundant examples
- Use smaller model for simple tasks
- Batch similar requests

```

### references/domain-patterns.md

```markdown
# Domain-Specific Prompt Patterns

Quick reference index. Load specific domain file for detailed patterns.

## Domains

| Domain | File | Use Cases |
|--------|------|-----------|
| Marketing | `domain-marketing.md` | Headlines, product copy, emails, ads |
| Code | `domain-code.md` | Functions, review, refactoring, debugging |
| Writing | `domain-writing.md` | Stories, characters, dialogue, editing |
| Data | `domain-data.md` | Extraction, analysis, comparison, reasoning |

## Universal Pattern

All domain prompts follow:
```
<context>
[Domain-specific background]
</context>

<task>
[Specific action]
</task>

<constraints>
[Quality criteria, format, length, tone]
</constraints>

<output>
[Expected structure]
</output>
```

```

### references/domain-marketing.md

```markdown
# Marketing Copy Patterns

## Headlines
```
Write 5 headline variations for [product].
Frameworks:
1. How to [benefit]
2. [Number] ways to [solve problem]
3. The secret to [outcome]
4. Why [audience] love [product]
5. [Timeframe] to [transformation]
```

## Product Descriptions
```
<product>[Name, features]</product>
<audience>[Demographics, pain points]</audience>

Write description that:
- Opens with benefit (not feature)
- Addresses [main objection]
- Social proof placeholder
- Clear CTA
- Tone: [brand voice]
- Length: [word count]
```

## Email Subject Lines
```
Generate 10 subject lines for [campaign].
Mix approaches:
- Curiosity gap
- Urgency/scarcity
- Personalization
- Question format
- Number/list
Under 50 chars. Test 2-3 with emojis.
```

## Ad Copy
```
Platform: [Google/Meta/LinkedIn]
Objective: [awareness/conversion]
Character limit: [limit]

Create [N] variations with:
- Hook (first 5 words critical)
- Value proposition
- Social proof element
- CTA matching platform norms
```

## Landing Pages
```
<offer>[Product/service]</offer>
<goal>[signup/purchase/download]</goal>

Write sections:
1. Hero headline + subhead
2. Problem agitation
3. Solution introduction
4. 3-5 benefit bullets
5. Social proof
6. CTA with urgency
7. FAQ (3 objections)
```

```

### references/domain-code.md

```markdown
# Code Generation Patterns

## Function Implementation
```
Write a [language] function:
- Input: [params with types]
- Output: [return type]
- Behavior: [logic]

Requirements:
- Edge cases: [list]
- Error handling: [approach]
- Performance: O([complexity])
```

## Code Review
```
Review for:
1. Bugs/logic errors
2. Security vulnerabilities
3. Performance issues
4. Style violations
5. Missing edge cases

Format: Issue, line number, severity, fix.
```

## Refactoring
```
Refactor to:
- [Improvement goal]
- Maintain backward compatibility
- Keep public API
- Add comments for complex logic
Show before/after.
```

## Debugging
```
<error>[Error message/behavior]</error>
<code>[Relevant code]</code>
<context>[When it occurs]</context>

Analyze:
1. Root cause
2. Why it happens
3. Fix with explanation
4. Prevention strategy
```

## Test Generation
```
Generate tests for [function/class]:
- Framework: [jest/pytest/etc]
- Coverage: happy path, edge cases, errors
- Include: setup, assertion, cleanup
- Mock: [external dependencies]
```

## Documentation
```
Document this [function/class/API]:
- Format: [JSDoc/docstring/OpenAPI]
- Include: description, params, returns, examples
- Note: edge cases, errors, deprecations
```

```

### references/domain-writing.md

```markdown
# Creative Writing Patterns

## Story Outline
```
Create [length] story outline:
- Genre: [genre]
- Protagonist: [brief]
- Conflict: [type]
- Setting: [time/place]

Structure:
1. Hook/Opening
2. Inciting incident
3. Rising action (3 beats)
4. Climax
5. Resolution
```

## Character Voice
```
Write as [character]:
- Background: [history]
- Speech: [patterns, vocab]
- Emotion: [current state]
- Goal: [scene objective]

Maintain voice consistency.
```

## Dialogue
```
Write dialogue between [A] and [B]:
- Scene: [context]
- Tension: [conflict source]
- Subtext: [what's unsaid]

Each character distinct voice. Show don't tell.
```

## Scene Description
```
Describe [scene]:
- POV: [character/omniscient]
- Focus: [sensory details]
- Mood: [atmosphere]
- Pacing: [fast/slow/measured]

Use active verbs, concrete details.
```

## Editing Pass
```
Edit this [content type]:
Focus: [clarity/flow/voice/grammar]
Preserve: [author's style]
Flag: [major issues only]

Provide tracked changes with rationale.
```

## Genre Adaptation
```
Rewrite [content] as [genre]:
- Keep: core plot/message
- Add: genre conventions
- Tone: [genre-appropriate]
- Tropes: [use/subvert specific tropes]
```

```

### references/domain-data.md

```markdown
# Data & Analysis Patterns

## Structured Extraction
```
Extract from text:
<text>[content]</text>

Return JSON:
{
  "field1": "value or null",
  "field2": ["array"]
}

Rules:
- Exact matches only
- Confidence score if uncertain
- null for missing
```

## Document Analysis
```
Analyze [document type]:
1. Summary (2-3 sentences)
2. Key entities (people, orgs, dates)
3. Main topics (ranked)
4. Sentiment: positive/neutral/negative
5. Action items
```

## Comparison
```
Compare [A] and [B]:
| Criterion | A | B |
|-----------|---|---|
| [Factor 1] | | |
| [Factor 2] | | |

Recommendation: [choice] for [use case]
```

## Problem Solving
```
Problem: [description]

Analyze:
1. Root cause (5 whys)
2. Contributing factors
3. Options (pros/cons)
4. Recommendation
5. Implementation steps
6. Risk mitigation
```

## Data Transformation
```
Transform data:
- Input format: [CSV/JSON/etc]
- Output format: [target]
- Rules: [mapping logic]
- Validation: [constraints]

Handle: missing values, type mismatches.
```

## Summarization
```
Summarize [content]:
- Length: [sentences/words]
- Focus: [key themes]
- Audience: [technical/general]
- Preserve: [critical details]
```

```