Image to Prompt Negative: How Much of the Line You Can Name

Across 480 composed lines, only 28.4% of the measured words sit in a fragment they own outright. The lines carry 14,048 words; 2,964 of them are scaffolding the composer writes, and 11,084 come off your picture. Of those 11,084, 3,149 form a fragment that is theirs alone, 4,790 live inside a phrase that brings its own comma, and 3,145 share a fragment with scaffolding. Write --no into the line the way Midjourney writes it — a space, then the flag — and the number is worse: 0 of 3,304 namings came back as a fragment the parser could read as one thing. Switch to a comma before the flag and 1,406 of 3,304 do. The gap between those two numbers is the whole subject of this page.

What these numbers are. Forty real files — 39 photographs at 640 × 360 and one code screenshot at 800 × 450 — decoded on this machine, box-downsampled to the 192 × 192 grid the live tool measures on, and composed into four shapes at three lengths: 480 lines. Each line was rebuilt a second time with every fragment tagged by which slot it came from, and that rebuild matched the real output on all 480 lines, character for character. Every figure below comes from running that pipeline and feeding the results to the site’s own weight parser. No image generator was run and no image was generated — there is no image model behind this site and none was called. This page is about which words the tool writes and how a parser reads them, never about what any model would draw.

How much of the line a word actually owns

A negative prompt can only remove what the line states as a separable unit. So the first measurement is ownership: of the words the composer writes off your picture, how many stand alone between two commas, and how many are welded to something else. Three things stop a word from standing alone. The phrase it belongs to may carry a comma of its own — bright, high-key lighting is one exposure reading but two fragments. It may sit next to scaffolding — on the Midjourney shape the framing reading is widescreen 16:9 composition, and the word composition belongs to the composer, not to the picture. Or it may be a value the sentence shapes never isolate at all.

Two rows decide most of it. Framing appears in all 480 lines and owns 0 words: on the two list shapes it is followed by the word composition, on the two sentence shapes it is wrapped in A … image. — there is no version of this line where the ratio stands alone. The palette appears in all 480 lines too and every one of its 2,040 words splits, because the composer joins the colour names with commas: dominant palette of silver, moss green, cream, grey is one reading of your picture and four fragments. Naming one colour in a negative names one of the four.

The shape of the output decides the rest. On the Flux shape, not one measured value forms a fragment it owns — every value is inside a sentence, and the sentence carries the capital letter and the full stop. Delete every value that owns its fragment on a Flux line and 100% of the characters stay, because there is nothing to take out without also taking scaffolding. The list shapes are the opposite: on Stable Diffusion at long length, removing the values that do stand alone leaves 52.2% of the characters and takes 6 values with it; on Midjourney at long length, 55.8% and 5. Across all 480 lines the deletion removes 892 values and 22.7% of the characters — 104,497 down to 80,825.

What happens when --no goes into the same line

Ownership is the ceiling. The next measurement is what actually happens when you write the value in after the flag. Each of the 480 lines had each of its values named once with a leading comma — , --no <value> — and once with a leading space, the way a Midjourney parameter is written — --no <value>. Both were then read back through the site’s own weight parser. Four outcomes are possible: the naming comes back as one fragment, identical to what was written; it sticks to the previous fragment because a space does not split anything; it is cut into several fragments because the value brought a comma; or it comes back as one fragment whose text has been rewritten.

The two totals: with a comma, 1,406 of 3,304 namings are intact, 1,298 are split, 600 are rewritten and 600 new out-of-range terms appear. With a space, 0 are intact, 2,006 stick to the previous fragment, 480 split and 818 are rewritten. Every value that survives intact with a comma — temp, dist, vert, subject, and most of detail, contrast and mood — is a value written as a single phrase with no comma inside it. Every value that never survives is one the composer writes with a comma in it, or one that contains a colon.

The colon is the expensive one. Framing and --ar are the only two slots whose values contain a number after a colon, and the parser reads a colon followed by digits as an explicit weight. Naming 16:9 produces --no 16 at weight 9; naming widescreen 16:9 produces --no widescreen 16 at weight 9. That is where the 600 new out-of-range terms come from — 480 from framing and 120 from the ratio parameter. The value you wanted to remove is not only still in the line, it is now carrying a weight of nine.

write  "widescreen 16:9"                ->  read  "--no widescreen 16"   @ 9
write  "16:9"                           ->  read  "--no 16"              @ 9
write  "silver, moss green, cream, grey" ->  read  "--no silver" | "moss green" | "cream" | "grey"
write  "bright, high-key lighting"       ->  read  "--no bright"  | "high-key lighting"
write  "muted, desaturated tones"        ->  read  "--no muted"   | "desaturated tones"
write  "neutral colour temperature"      ->  read  "--no neutral colour temperature"  @ 1   (comma style)

One number in that table deserves to be called out as a trap rather than a result. With a space, 800 out-of-range terms disappear — and every one of them is on the Midjourney shape, where all 120 lines are affected and 6.7 of the namings on a typical line make the ratio’s weight-9 term vanish. That looks like the naming fixed something. It did not. Appending --no <value> after the ratio means the line no longer ends in a colon and a number, so the parser stops reading the ratio as a weight at all. The round-trip check goes from 2,264 of 3,304 to 2,704, which is the same effect seen from the other side. A negative that makes a weight disappear has removed the parameter’s only legal position, not the weight.

The negative field on its own

The cleaner case is the one where the negative never touches the positive line: a separate field, with the value written into it alone. That is what Stable Diffusion and most of its interfaces do, and it removes the collision problem entirely. It does leave one. Of the 86 distinct values the composer produced across these 480 lines, the parser read 215 terms out of them — 2.5 per value — because 56 of the 86 contain a comma and a comma is the parser’s delimiter. Removing the comma from those 56 leaves 0 that still split.

Only two of the 86 carry a non-unit weight, and they are the same two that broke the line-level test: the framing reading and the ratio, both because a colon followed by digits is a weight as far as this parser is concerned. Everything else is a plain term at weight one. So a negative field is a genuinely safer place to put these words — the only thing you still have to do by hand is take the comma out of muted, desaturated tones before you paste it.

How many other values each slot has left

The last question is the one that decides whether naming a value is worth doing at all: after you remove the reading this picture produced, how many other readings can that slot still hold? If the answer is none, the negative is not steering — it is deleting the only thing the slot can say. On this corpus three slots have exactly one value across all 480 lines: framing, subject and the ratio. Forty files, all 16:9, so the framing reading never varied; the subject reading appeared on 48 lines and was the same phrase every time.

Put the four measurements together and the practical rules fall out in order of how much they cost you:

1. Put the naming in a negative field rather than in the positive line. Of 86 distinct values, only 2 arrive with a weight the parser did not ask for, and both are the ones containing a colon and a number. In the positive line the same naming adds 600 out-of-range terms.
2. If it has to go in the line, put a comma in front of the flag, not a space. A comma gives 1,406 intact namings out of 3,304; a space gives 0, because the flag and the value are absorbed into the fragment before them.
3. Take the comma out of the value before you name it. 56 of the 86 values contain one — all of exposure, all of palette, most of saturation — and the parser splits on it. Removing it leaves 0 that still split.
4. Never name the framing or the ratio. Both carry a colon and a number, both come back as a weight of 9, and both are the only value their slot can produce on this corpus, so there is nothing left for the model to choose instead.

That last rule has a consequence worth stating plainly. The line this tool writes describes a picture it has already measured. A negative does not add a second opinion; it removes one of the 12 things the line says, and on three of those twelve there is no alternative for the model to fall back on. Where the slot has 37 values, as the palette does, naming one is a real instruction. Where it has one, naming it is a request for something the line cannot express.

What the 3,304 namings and 14,048 words were measured on

Forty files, twelve lines each: 480 baselines. Every line was rebuilt a second time with each fragment tagged by the slot it came from, and that rebuild matched the real composer output on all 480 lines character for character; the 14,048 words and their 2,964 / 11,084 split come from that tagged rebuild, not from counting the output directly. The naming test wrote each value in each line twice — once as , --no <value>, once as --no <value> — for 3,304 namings per style, and read each result back through the same weight parser the site ships. The field-only test fed all 86 distinct values to that parser on their own. The deletion test removed every value that owns its fragment and measured what was left: 892 values and 23,672 characters across the corpus.

Three limits belong next to these numbers. Nothing here involves a generator: no model was called and no image was produced, so every statement is about the words this tool writes and about how a weight parser reads them — it is not a claim about what any image model does with a negative. The parser is the one in this repository, which implements the WebUI rules for parentheses, brackets and explicit weights; a different parser would split differently, though all four outcome classes would still exist. And the corpus is forty stock photographs plus one screenshot, all 16:9, which is why three slots have only one value: a corpus with square or portrait files would give framing and the ratio more than one reading, and the “left after naming one” column would rise accordingly.

For the syntax of weights and negatives themselves, including what a bracket does to a negative and where a WebUI puts its negative field, see how to weight a prompt and write a negative. For the twelve measurements these words are read off, see what an image to prompt tool measures; for the cut points at which each phrase flips to another, the twenty-nine cut points; and for how much of the picture the line actually retains, how much of your picture survives.