prompt1 already covers prompting in real depth — clarity, context, constraints, role prompting, few-shot examples, chain-of-thought, iterative refinement. If prompting an image model were just "the same skill applied to pictures," this course wouldn't need to exist; it could be a single bonus chapter tacked onto the end of prompt1. It isn't, because the thing being prompted is a genuinely different kind of system.

What prompt1 Actually Assumes

prompt1-2's own anatomy of a good prompt — Clarity, Context, Constraints, Output Format — rests on one load-bearing assumption: that the model being prompted can follow an instruction. Claude reads "summarize this in three bullet points, using a formal tone" and does something recognizable as obeying that instruction, because Claude was trained, via RLHF and instruction-tuning, specifically to map instructions to compliant behavior. Every technique prompt1 teaches — role prompting (prompt1-3), few-shot examples (prompt1-4), chain-of-thought (prompt1-5) — is a way of shaping how an instruction-following system carries out an instruction.

An image model was never trained to do that.

What an Image Model Was Actually Trained to Do

Tools like Midjourney, Stable Diffusion, and DALL-E are built on diffusion models (the full mechanism is imgai1-2's own subject — this chapter only needs the shape of the idea). During training, the model sees millions of (image, text caption) pairs and learns a statistical association between patches of text and patches of visual pattern — "a photo of a golden retriever" pulls the generation process toward pixel arrangements statistically associated with that caption in the training data. There is no step anywhere in that process resembling "read this sentence, form an understanding of what is being asked, and comply." The model has no representation of your request as a request at all — only as a string of text to condition image generation on.

Descriptor Composition, Not Instruction-Giving

If an image prompt isn't an instruction, what is it? The working model this course builds toward, starting concretely in imgai1-3: a prompt is closer to a dense list of descriptors — subject, style, composition, lighting, medium — than to a sentence directed at a listener. "Write a poem about the ocean" (an instruction, aimed at prompt1's own kind of model) and "a weathered lighthouse at dusk, oil painting, dramatic lighting, wide shot" (a descriptor composition, aimed at this course's own kind of model) are doing fundamentally different jobs, even though both are grammatically similar-looking strings of English.

Three Tools, Three Real Trade-offs

This course doesn't teach one image model — it teaches three, deliberately chosen because each makes a genuinely different trade-off, not because "more tools" is inherently better coverage:

• Midjourney (imgai1-4) — cloud-only, Discord-based, a distinctive bracketed --parameter syntax, and a well-documented painterly/stylized bias baked into the model itself.
• Stable Diffusion (imgai1-5) — open-source, can run entirely locally, and exposes real technical knobs (CFG scale, sampler choice, checkpoints, LoRAs) no other tool in this course offers.
• DALL-E (imgai1-6) — integrated directly into ChatGPT's own conversational interface, which makes it, genuinely, the one tool in this course closest to prompt1's own territory. It's covered last specifically so that convergence lands as a real observation, not a starting assumption.

Hands-On Exercises

The History of AI trilogy's own closing chapter, historyai3-8, named "diffusion models" in passing as one of the developments bringing that course up to the present day, alongside multimodal AI and the AGI/alignment debate — a namecheck, not an explanation. This chapter delivers the explanation, and does it specifically because imgai1-1's central claim — that an image prompt is descriptor composition, not instruction-giving — is only a slogan until you can see the actual mechanism that makes it true.

Step One: Learning to Destroy Images

Diffusion models are trained backwards from how you'd expect. Training starts with real images from a large captioned dataset, and a fixed, non-learned process called forward diffusion: a small amount of random (Gaussian) noise is added to the image, repeatedly, over many steps — a few hundred to a few thousand, depending on the model — until the image is statistically indistinguishable from pure noise. This forward process needs no learning at all; it's just repeated noise addition, and it's identical for every image in the dataset.

The interesting part — the part that's actually trained — is the reverse direction: a neural network is trained to look at a noisy image at some step and predict what noise was added, so that subtracting its prediction moves the image one step closer to clean. Do this once, and you've removed a little noise. Do it hundreds of times in sequence, starting from pure random noise instead of a slightly-noised real image, and the network — which has only ever seen "slightly less noisy version of this" as its training signal — ends up hallucinating a coherent image out of static, one small denoising step at a time.

Step Two: Bringing Text Into the Process

Everything above describes an unconditional diffusion model — one that generates images with no text input at all, denoising toward whatever the training data made statistically likely in general. To make text prompting work, the denoising network needs the text to actually steer each denoising step, not just describe the final result after the fact.

This is where CLIP (Contrastive Language-Image Pretraining, an OpenAI model) or a similar text-image embedding model comes in. CLIP is trained on a separate, simpler task: given a large set of (image, caption) pairs, learn to map both images and text into the same numerical vector space, such that a genuinely matching image and caption land close together in that space, and mismatched pairs land far apart. The result is a text embedding — a long list of numbers — that captures, in a form the diffusion network can use, what "a photo of a golden retriever" means in visual terms.

During both training and generation, that text embedding is fed into the denoising network alongside the noisy image at every single step, biasing each prediction toward the region of "clean image space" the embedding points at. The prompt doesn't get read once and remembered — it's re-injected at every denoising step, continually pulling the emerging image toward the text's own embedding.

A Preview of Two Terms This Course Will Need Later

Two mechanical details, previewed here and covered in full technical depth in imgai1-5:

• Latent diffusion: running the denoising process directly on full-resolution pixels is expensive. Stable Diffusion instead compresses images into a smaller "latent" representation first (via a separate encoder network), runs the entire noise/denoise process there, and decompresses back to pixels only at the end — the same mechanism described above, just operating on a compressed representation rather than raw pixels.
• Classifier-free guidance: the network is actually trained to predict noise both with and without the text embedding, and generation blends the two predictions, amplifying the difference the text makes. Stable Diffusion's own CFG scale parameter (imgai1-5) controls exactly how strongly that difference gets amplified.

Why This Mechanism Predicts Real, Later Failure Modes

Hands-On Exercises

prompt1-2 built its own anatomy of a good prompt around four instruction-oriented pillars: Clarity, Context, Constraints, Output Format. That anatomy makes sense for a system built to comply with a request (imgai1-1). An image model needs a genuinely different anatomy — one built around description, not instruction — because, per imgai1-2's own mechanism, every word in the prompt is just another statistical anchor pulling the denoising process toward a region of image space, over and over, at every step. This chapter builds that anatomy: six descriptor categories every tool-specific chapter from here on (imgai1-4 through imgai1-6) assumes without re-teaching.

Six Categories, One Shared Vocabulary

Regardless of which of the three tools this course covers, a strong prompt tends to touch some combination of the same six things. Syntax differs wildly by tool (covered next, in imgai1-4–imgai1-6) — this vocabulary doesn't.

A Worked Before/After Example

Notice the "after" version doesn't read as an instruction to a listener — it reads as a dense list of descriptors, exactly as imgai1-1 predicted. Nothing in it asks the model to do anything; every phrase describes what the finished image should look like.

Ordering Carries Real Weight

Across most tools, terms earlier in a prompt tend to exert more influence on the final image than terms later in it — not a hard universal rule, but a consistent enough pattern to plan around. This is one reason subject conventionally comes first: it's the single most important thing to get right, so it goes where it has the most leverage. imgai1-7 covers the more precise, tool-specific mechanisms for controlling relative influence (term weighting) directly.

Hands-On Exercises

imgai1-3's six-category vocabulary is shared across every tool in this course — but how that vocabulary is delivered to the model, and what the model does with it once it has it, differs a great deal by tool. This chapter is the first of three (imgai1-4–imgai1-6) covering that tool-specific layer, starting with the one running the most cloud-only, most curated, most parameter-driven of the three.

The Discord-Based Workflow

Midjourney has no standalone desktop app and no local install — it runs entirely in the cloud, and (traditionally) was accessed through Discord: joining Midjourney's own Discord server (or inviting its bot to a private server), typing /imagine followed by a prompt in a text channel, and receiving a 2×2 grid of four candidate images a short time later. A newer web-based interface now exists alongside Discord, but the underlying workflow is the same: submit a prompt, get four options, then either upscale one, generate variations of one, or rerun the whole prompt.

Parameters — Appended, Not Woven In

Midjourney prompts follow a consistent shape: the descriptive prompt itself (built from imgai1-3's six categories), followed by one or more --parameter flags appended at the end. Parameters configure the generation process itself rather than describing the image's content.

a weathered lighthouse on a rocky cliff, oil painting, dramatic golden-hour lighting --ar 16:9 --stylize 250 --chaos 15

Midjourney's Own Well-Documented Artistic Bias

Midjourney is widely and consistently observed — by its own users, in its own documentation, and across independent comparisons — to lean toward a dramatic, painterly, highly polished aesthetic even when a prompt doesn't ask for one. Flat, neutral, purely documentary-style requests often come back with cinematic lighting, rich color grading, and a level of visual "finish" the prompt never specified. This isn't a bug or an inconsistency; it's a real, deliberate product characteristic, widely understood to result from how Midjourney curates and fine-tunes its own model toward outputs its own community and internal review consistently rate as more visually striking.

This matters directly for how you write Midjourney prompts: getting a genuinely neutral, unstylized result on purpose usually takes deliberate, explicit effort (a low --stylize value, explicit style-suppressing language) rather than simply omitting style descriptors and expecting a blank slate.

Hands-On Exercises

imgai1-4's own warn-box drew a real line: Midjourney's parameters can only be described by their observed behavior, because its architecture is never published. Stable Diffusion is the other side of that line. Its model weights, training methodology, and source code are all public — which means this chapter can do something imgai1-4 explicitly couldn't: explain exactly what its own parameters do to the mechanism imgai1-2 already introduced, not just what they're observed to produce.

Local, Self-Hosted, and Genuinely Open

Where Midjourney is cloud-only with no local install (imgai1-4), Stable Diffusion's model weights can be downloaded and run entirely on your own hardware — no account, no subscription, no internet connection required once set up. In practice, most people run it through a community-built interface (Automatic1111's web UI, ComfyUI, or InvokeAI are the most common) rather than writing raw code against the model directly, but the defining fact remains: nothing about running it requires anyone else's server.

CFG Scale — Now Explainable in Full

imgai1-2 previewed classifier-free guidance in one sentence: the network is trained to predict noise both with and without the text embedding, and generation blends the two predictions. Here's the full picture. At every denoising step, the model computes two separate noise predictions from the same noisy image: an unconditional prediction (as if no text prompt existed at all) and a conditional prediction (steered by the text embedding, per imgai1-2's own CLIP mechanism). The final prediction actually used is the unconditional one, plus the difference between the two, amplified by the CFG scale:

final_prediction = unconditional_prediction + CFG_scale × (conditional_prediction − unconditional_prediction)

A CFG scale of 1 uses the conditional prediction roughly as-is. Higher values (commonly 7–12 as a working range) amplify the direction the text embedding is already pulling toward, producing results that adhere to the prompt more strongly. Pushed too high, that amplification overshoots — oversaturated colors, harsh contrast, and visible artifacting, sometimes called "overcooked" output. Lower values produce looser, more creative departures from the literal prompt, at the cost of adherence.

Sampling Steps & Samplers

Steps is simply how many times the reverse denoising loop (imgai1-2) actually runs — more steps generally mean a more fully resolved image, with sharply diminishing returns past a certain point (often somewhere around 20–50, depending on the sampler). Samplers (Euler, DPM++, DDIM, and others) are different numerical algorithms for solving that same denoising process — they don't change what the model has learned, only how efficiently and in what character it converges toward a final image. Different samplers can produce visibly different results from an identical prompt and seed, and some converge acceptably in far fewer steps than others.

Negative Prompts as a First-Class Mechanism

imgai1-4 covered Midjourney's own --no parameter as a simple exclusion list. Stable Diffusion's negative prompt is a genuinely deeper mechanism, and the CFG formula above explains exactly why: instead of using a truly "unconditional" prediction (as if no text existed) as the baseline, a negative prompt is itself run through CLIP the same way the positive prompt is, and its own embedding replaces the unconditional prediction in the formula:

final_prediction = negative_prediction + CFG_scale × (positive_prediction − negative_prediction)

This doesn't just avoid the negative prompt's content — it actively steers generation away from that region of embedding space, at every single denoising step, amplified by the same CFG scale governing how strongly the positive prompt pulls toward its own target. A negative prompt is treated by the mechanism as a full, first-class second prompt, not a simple exclusion filter layered on afterward.

Checkpoints & LoRAs — A Genuinely Unique Capability

Because Stable Diffusion's weights are public, the community has trained thousands of alternate checkpoints — full, re-trained or fine-tuned versions of the base model, often specialized toward a particular art style, subject matter, or level of photorealism. Swapping checkpoints changes the model's own underlying visual "instincts" before a single prompt word is even considered. LoRAs (Low-Rank Adaptation) are smaller, lighter-weight adapter files that can be layered on top of a checkpoint to nudge it toward a narrower style, character, or concept, without the cost of training or storing an entirely new full model. Neither of these has a real equivalent on Midjourney or DALL-E (imgai1-6) — both are closed, single-model, hosted-only systems with nothing analogous to swap in.

Hands-On Exercises

imgai1-4 and imgai1-5 both required learning a real syntax layer on top of imgai1-3's shared vocabulary — bracketed --parameters for Midjourney, a CFG scale and sampler choice for Stable Diffusion. DALL-E, as used today, has none of that. There's no parameter list to learn. As imgai1-1 predicted back at the start of this course, this is the one tool genuinely close to prompt1's own conversational territory — but understanding exactly why requires being precise about what's actually converging, and what isn't.

How It's Actually Used

DALL-E is used today primarily through ChatGPT's own conversational interface (a standalone API also exists for developers, but the conversational route is how most people actually prompt it). You type a plain-English description — no brackets, no flags — directly into the chat, the same way you'd talk to Claude in prompt1.

The Detail Most Tutorials Skip: ChatGPT Rewrites Your Prompt

Here's the part worth being precise about. When you type a request into ChatGPT for an image, ChatGPT itself — a real, instruction-following LLM — reads your message, and internally rewrites and expands it into a more detailed, descriptor-rich prompt before that rewritten version is ever handed to the underlying image-generation model. Your own words are almost never the literal text the image model receives.

Iterative, Conversational Refinement — A Genuine Convergence

This is where the convergence with prompt1-6's own iterative refinement technique is real and direct, not just superficial. Because generation happens inside an ongoing chat, you can follow up with plain conversational corrections — "make the sky more dramatic," "remove the hat," "try it at night instead" — and ChatGPT interprets that follow-up in context, using the same instruction-following comprehension it uses for any other conversational task, then produces a new expanded prompt reflecting the change. Midjourney's own variation/rerun workflow (imgai1-4) and Stable Diffusion's own re-run-with-adjusted-parameters workflow (imgai1-5) both require you to reconstruct or edit the underlying prompt/parameters yourself. DALL-E's own refinement loop is the only one of the three where a genuinely comprehending system is doing that reconstruction work for you.

What's Gained, and What's Genuinely Lost

The trade-off is exactly what you'd expect once the mechanism is understood: accessibility and natural iteration in exchange for the fine-grained, direct control imgai1-5's own CFG scale, sampler choice, and checkpoints/LoRAs provide. There's no way to hand ChatGPT a specific CFG value or swap in a community checkpoint — that whole layer of control is delegated to ChatGPT's own rewriting step, which is a black box in the sense that you don't see the expanded prompt it actually generates.

A Practical Consequence for How You Prompt It

Because ChatGPT fills gaps in your description before generation, a short, vague prompt on DALL-E doesn't collapse into the same kind of "generic" result imgai1-3's own warn-box predicted for Midjourney or Stable Diffusion — ChatGPT will typically add its own reasonable specifics (a plausible style, lighting, composition) rather than leaving the model to average over a huge, under-specified region on its own. This doesn't mean specificity stops mattering — a genuinely detailed request still steers the result more precisely than a vague one — but the cost of vagueness is softer here than on the other two tools, because a real comprehending system is doing the gap-filling instead of the diffusion model itself.

Hands-On Exercises

imgai1-4–imgai1-6 each covered one tool's own particular syntax. This chapter zooms back out to three techniques that recur — in some form — across most of them, despite genuinely different syntax: weighting individual terms, excluding content, and starting from an existing image rather than pure noise. Each section cross-references back to the tool-specific version already covered.

Term Weighting

A whole-prompt CFG scale (imgai1-5) controls how strongly the entire prompt's embedding pulls generation. Term weighting is the more granular version of the same idea — controlling how strongly one specific word or phrase contributes to that overall pull, relative to the rest of the prompt.

Negative Prompts, Recapped Across Tools

imgai1-4 and imgai1-5 already covered this in tool-specific depth — this section is a deliberately short recap, not new material. The goal is the same everywhere (exclude unwanted content), but the depth of mechanism genuinely differs:

img2img — Starting From an Image, Not Pure Noise

imgai1-2 described generation as starting from pure random noise and denoising down to a coherent image. img2img changes the starting point: instead of pure noise, the process starts from a real, existing image with only a partial amount of noise added, then runs the same trained denoising steps from there. Because the starting point already resembles a real image rather than static, the result tends to preserve the original's overall composition and structure while the denoising process fills in whatever the new text prompt specifies.

The amount of noise added to the starting image — often exposed directly as a denoising strength parameter — controls the trade-off precisely: a low value keeps the result very close to the original image (only lightly re-touched by the prompt), while a high value approaches full, pure-noise generation, where the original image's influence becomes minimal.

Inpainting & Outpainting — A Genuinely Distinct Capability

img2img re-generates an entire image, just anchored to a starting point. Inpainting is more surgical: a mask marks a specific region of an existing image (a bad hand, an unwanted object), and only that masked region is regenerated — the rest of the image is held fixed at every denoising step, rather than merely encouraged to stay similar. Outpainting runs the same masking idea in reverse, extending an image past its original borders and generating new content in the newly added space that plausibly continues what's already there.

Both are available, with different interfaces, across all three tools — Stable Diffusion exposes inpainting/outpainting directly as a masking tool in most community interfaces; Midjourney and DALL-E both offer a comparable region-select-and-regenerate workflow through their own editing interfaces, without exposing the underlying masking mechanism directly.

Hands-On Exercises

imgai1-2's own warn-box previewed two failure modes in a single paragraph: hands, and legible text. This chapter delivers the full treatment of both, adds a third (prompt bleeding), and holds every one of them to the same standard set back then — a mechanical explanation traced to what the network's training signal actually was, never a shrug toward "AI isn't perfect yet."

Anatomical Errors, In Full

imgai1-2 already named the root cause: "hands... are small, highly variable, articulated structures that appear in countless different poses across training images, so the statistical pattern is much fuzzier than something like 'a face.'" There is no rule anywhere in the network's training resembling "exactly five digits, each with a fixed number of joints" — only an averaged statistical impression of what hand-shaped regions of pixels tend to look like, blurred across an enormous range of real poses, angles, and partial occlusions.

Newer models have genuinely gotten better at this — larger, higher-resolution training sets and dedicated fine-tuning specifically targeting hands have measurably reduced how often extra or fused fingers appear. It's worth being precise about what that improvement actually is: a better-fitted statistical pattern, not a newly learned structural rule. The underlying mechanism hasn't changed; the average has simply gotten sharper.

Text Rendering, In Full

imgai1-2's own explanation: "nothing in the training signal ever represents letters as discrete symbols with a required exact sequence, only as visual textures that loosely correlate with certain image regions." A word is, to the network, a texture that tends to co-occur with signage, book covers, and similar contexts — not a sequence of discrete, individually meaningful characters that must appear in a specific, correct order.

Some newer tools have made real, visible progress here — but, honestly, mostly by adding something extra rather than by the same diffusion mechanism simply improving with scale: dedicated architectural components specifically for rendering legible text, or specialized training passes focused on typography, layered on top of the general diffusion process rather than emerging naturally from it. This is a meaningfully different kind of improvement from the hands case above — less "the same statistical pattern got sharper," more "a second, specialized mechanism was bolted on for this one problem."

Prompt Bleeding & Concept Mixing

A prompt describing two distinct subjects with distinct attributes — a red car and a blue house — doesn't guarantee those attributes stay cleanly attached to their intended nouns. The result might show a car with blue trim, or a house with a red door, or some blend of both. This is prompt bleeding, and it has its own distinct mechanical cause.

Per imgai1-2, the entire prompt is processed into a conditioning signal that steers the denoising network — but nothing in that process works like a strict grammatical parser that hard-binds each adjective to exactly the noun a human reader would assign it to. The network's own internal attention mechanism (how it decides which parts of the text embedding influence which regions of the developing image) is itself a learned, statistical association, not a rule-based binding — so during the many steps of denoising, a color or style term can end up influencing a region of the image other than the one it was "meant" for, especially when multiple similar subjects or attributes compete for the same visual region.

What "Getting Better" Actually Means Here

Hands-On Exercises

This chapter is deliberately substantive, matching the seriousness this site has given ethics elsewhere — pentest1-1's written-authorization precondition, crypto1's own real case studies. Four genuinely distinct issues are covered here, not one blurred-together "AI ethics" concern — they have different causes, different degrees of legal settlement, and different people actually responsible for addressing them. Treating them as one issue would obscure exactly the distinctions that matter.

Issue 1: Training-Data Copyright — Genuinely Unresolved

Issue 2: Living-Artist Style Mimicry — A Legal Question and an Ethical Question, Kept Separate

Issue 3: Deepfakes & Consent — The Clearest-Cut Case in This Chapter

Issue 4: Training-Data Bias Surfacing in Generated Output

Four Issues, Different Responsibility

Hands-On Exercises

One creative brief, taken through five real refinement passes, on one tool — Stable Diffusion (imgai1-5), chosen specifically because it's the only tool in this course whose mechanism (imgai1-2) can be reasoned about precisely at every step, rather than described only behaviorally (imgai1-4) or mediated through a rewriting layer (imgai1-6).

Pass 1 — The Naive Prompt

a coffee shop interior

Pass 2 — Applying the Six-Category Vocabulary (imgai1-3)

a cozy artisan coffee shop interior, a barista standing behind a wooden counter, hand-lettered chalkboard menu board on the wall behind [subject]; warm rustic photorealistic style [style]; wide shot, counter centered, chalkboard visible in background [composition]; warm golden interior lighting, soft window light from the left [lighting]; 35mm lens, shallow depth of field [camera/lens]; photograph [medium]

Pass 3 — Negative Prompt & CFG Adjustment (imgai1-5)

negative prompt: blurry, extra limbs, deformed hands, watermark, oversaturated, cartoon, illustration
CFG scale: 8

Pass 4 — Term Weighting (imgai1-7)

a cozy artisan coffee shop interior, a barista standing behind a wooden counter, (hands resting on the counter, not visibly gripping anything:1.2), hand-lettered chalkboard menu board on the wall behind ...

Pass 5 — A Checkpoint Swap (imgai1-5)

Chapter Attribution

Honest Scope Note

Hands-On Exercises