In Vol. 1 of this series I tested a banner image with text in it, a color-only edit, and a GIF attempt. Those were all image tasks: does it look right, and does the text survive?
Diagrams and charts are a different job. Nobody judges a flowchart by how pretty it is. They judge it by whether the labels are spelled correctly, the steps are in the right order, the arrows go where they should, and the numbers are right. A chart with a wrong bar height looks fine and tells the wrong story.
The good news is that those requirements can be written down exactly and checked exactly. You can read the labels by eye, and you can measure bar heights in pixels. So I ran four small tests built around that idea: generate a flowchart, generate a bar chart from specified values, edit one label on the flowchart, and edit one value on the chart.
This article covers the headline results and the habits I would carry into any diagram or chart request. The complete prompts and the full measurement data are in the paid download linked further down.
This article covers
- How to specify a flowchart so you can check the result
- How to specify a chart so you can check both the printed numbers and the bar heights
- How to word an edit so it separates what changes from what stays
- What happened in the four tests, including one edit that did not come out right
- Where the full prompts and the pixel-measured data are, and what these results do and don't establish
How to specify a flowchart so you can check it
I write a flowchart prompt so it reads like a checklist. Before you generate anything, decide what "correct" means, and put each part of that definition in the prompt.
For my flowchart, the checklist had five items:
- The exact text of every box, in quotation marks, so the wording is fixed rather than up to the model.
- The order, stated explicitly ("from top to bottom").
- The structure: how many boxes, how they are arranged, and how they are connected (stacked vertically, joined by downward arrows).
- The look: background, box fill, outline, and text color, kept short.
- What must not appear: no title, no other text, no logos.
That last item matters more than it seems. Extra text is easy for a generated diagram to add, and easy to miss if you only skim the image. If you ask for "no other text," then any text beyond your list is a failure you can spot.
When the image comes back, check it against your list one line at a time. Read each label letter by letter. Count the boxes. Count the arrows and confirm which boxes each one connects. Don't ask "does this look right?" Ask "does it match item 1, item 2, item 3?"
How to specify a chart so you can check it
A chart has one more layer than a flowchart: the data. My rule is to give the values as data, not as a description.
"A chart showing growth over the week" leaves the numbers up to the model. "Mon 10, Tue 25, Wed 15, Thu 30" gives it something it can be held to. I also specified:
- the chart title, in quotation marks
- the category labels on the horizontal axis, in quotation marks
- that each value should be printed on top of its bar
- the label for the vertical axis
- colors and style
- what should not appear (no other text, no legend)
Then check two different things, because they can fail independently:
- The printed numbers. Do the labels on the bars say what you specified?
- The bar heights. Are the bars actually proportional to those numbers?
The first check is a quick read by eye. The second is the easy one to skip — and a bar whose printed number and height disagree can still look plausible at a glance. To check, measure each bar from the shared baseline in pixels, treat one bar as the unit, and compute what value each bar's height implies. If the implied values match your data, the bar heights match the data. If you can't measure, at least compare bars with a ruler or a screenshot tool, and check the proportions between them.
One thing to expect: the model may add things you didn't ask for. In my chart it added y-axis tick labels and light gridlines. The prompt neither requested nor forbade them. In this case they were consistent with the bar heights, so they did no harm, but they were the model's choice. If extra elements would matter to you, forbid them in the prompt.
For edits, separate what changes from what stays
This is the same principle as Vol. 1. When you edit an image, the instruction has two jobs: say precisely what should change, and say precisely what must stay the same.
An instruction that only says what to change leaves everything else open. So each of my edit instructions had two parts:
- The change, stated narrowly: one label in one box, or one bar's value.
- The keep list: everything else, named. Other text, positions, arrows, colors, background for the flowchart; title, other bars, labels, colors, background for the chart.
For a data edit there is a third point, specific to charts. If the value changes, say that both the number and the geometry must change. In my chart edit I wrote that the label and the bar height should both be updated to match the new value. I was asking for two changes that have to agree with each other, and the check afterward needs to cover both.
After an edit, check twice. First, did the requested change happen? Second, did anything else move? The second check matters as much as the first.
What happened in the tests
I ran all four tests through the image-generation tool in my agent environment. Outputs were saved and converted to PNG copies for inspection. I checked every result by eye against the saved files, and I measured bar heights in pixels with PIL and numpy.
Test A: flowchart generation. The flowchart came out exactly right in one generation. All four labels were spelled correctly and in the requested order: "Collect data", "Clean data", "Train model", "Evaluate". There were three downward arrows, one between each pair of boxes. The colors matched the request, and there was no title, no extra text, and no logos. I had nothing to correct.
Test B: bar chart generation. The title and the vertical axis label were correct, and the four value labels read 10 / 25 / 15 / 30, as specified. Then I measured the bars in pixels. The heights were proportional to the specified values within about 1%. (The full measured values are in the paid log.) As noted above, the model also added y-axis tick labels and gridlines that I hadn't asked for.
Test C: edit one flowchart label. I asked for the third box to change from "Train model" to "Tune model" and for everything else to stay the same. The third box read "Tune model", and the other labels, arrows, and colors looked exactly as before. The image was also the same size as the input.
The pixel comparison showed something worth knowing, though. About 3–6% of pixels differed in every box region, including boxes that were not supposed to change. This was a faithful redraw, not a pixel-level patch. Nothing visible moved or changed meaning, but the file is not identical outside the edited box. If you need the unchanged parts to be byte-for-byte or pixel-for-pixel untouched, an AI edit like this is not that.
Test D: edit one chart value. This is the one that did not fully work. I asked for the Tue bar to change from 25 to 20, with both the number on top and the bar height updated to match.
The label now reads 20. The bar did get shorter, but not by enough. Measured the same way as in Test B, the Tue bar shrank from 25 to about 22, not to 20, which is roughly 10% too tall for its new label. The number and the bar disagree. (The full measured values are in the paid log.)
The rest of the chart kept its content: the title, the other three labels, the axis label, and the colors. As in Test C, the whole image was redrawn rather than patched, and this time the dimensions changed too, from 1824×1248 to 1872×1264.
If I had only looked at the result, I would have seen "20" on a shorter bar and moved on. The measurement is what caught it.
Get the complete prompts and measurement log ($5)
The sections above give you the method and the headline results. The complete record is a separate download, so you can rerun the same four tests and score them against the same checklist.
What's inside
- All four prompts and instructions, verbatim: the flowchart prompt, the bar chart prompt, the label edit instruction, and the value edit instruction
- The full pixel-measured bar-height data for both charts, the original and the edited one
- The pixel-diff check on the label edit, showing how much of the image changed outside the edited box
- Output sizes and whole-call times for all four tests
Read claims and measurements separately
A few limits on what this article shows.
I tested no vendor claims. Nothing here confirms or disputes anything a vendor says about speed, quality, or consistency. Every result describes one run of each test, through one route: the image-generation tool in my agent environment. A different app, account, or tool may behave differently.
The times in the log are wall-clock brackets around the whole tool call, from one date call to the next. They cover the entire call, not just the generation, and they are rough figures. Treat them as "about this long on this route," nothing more.
The tests are also small. One flowchart, one chart, and two edits can show that something is possible and show one way it fails. They can't tell you how often it fails. The value edit miss is a single observation, not a failure rate.
What I would take from these tests is the shape of the checking, which holds regardless of the route: write the requirements so each one can be verified, and verify the number and the picture separately.
Start with one diagram or chart
If you want to try this, keep it small.
Pick one diagram or one chart you actually need. Write the requirements down first: exact labels in quotation marks, the order, the number of elements, the connections, and what must not appear. If it's a chart, write the values as data.
Generate it once. Then check it against your list, line by line. Read the labels, count the arrows, compare the printed numbers to the data, and measure the bar heights, even roughly.
If you then want to edit it, use the two-part instruction: what changes, and what stays. Check both after the edit, and for a chart, check that the number and the bar still agree.
That one pass will tell you more about whether you can trust the output than any amount of looking at it and thinking "that seems fine."
This article was written with AI assistance from the author's own measurement log; all prompts, images, and measurements are from the test described above.




