Fireworks-Tech-Graph: When the Model Says "Done Drawing," That Doesn't Count

You tell an agent one sentence: "Draw a Mem0 memory architecture diagram, dark theme." The old approach: the model spits out an image directly. If you're lucky it's usable; if not, lines cross, labels overlap, nodes squeeze into a clump, and you keep tweaking the prompt. A GitHub skill called fireworks-tech-graph takes a different approach: don't expect the model to draw it right — expect the validator to catch the errors. Created April 10, it hit 11,000 stars in under five months, and broke out of the developer bubble in early September via promotional posts on Zhihu. This post goes through its README and SKILL.md line by line to examine what's actually worth looking at.

Clearing Customs First

The source material is a Zhihu promotional article from the account "Muyan Agent" in early September; its 11,000-star figure was a snapshot at the time. Our own check in early October found 11,612 stars — only 600 gained in a month. The project's last commit was September 5, the day before the promotional article was published. Since then: zero commits, zero open issues. The promotion didn't drive sustained growth; the project has plateaued.

On the numbers, the source material is high quality. Twelve styles (eleven generators plus one AI hand-drawn style), fourteen diagram types including full UML support, GIFs defaulting to 960px wide, 5.75 seconds, 20fps — all match the README and SKILL.md verbatim. The geometric rules weren't oversold either: the README states zero crossings, at most two bends per edge, and minimum 40px node spacing. It's even stricter than the promotional piece claimed: at most eight bends across all edges total, and minimum 20px container spacing.

Two small flaws worth noting. The article says the predecessor project diagram-design supports 39 diagram types; that repo's current README says 42 — a version discrepancy. More interesting: fireworks' own repo description still says "7 styles," while the README has long since expanded to twelve. The project's own signboard lags behind the interior decoration — this kind of self-description drift is common in fast-moving skill projects.

The Skeleton: A Five-Gate Verification Loop

The pipeline works like this: first intent classification (what type of diagram, which style), then conversion to a semantic intermediate representation (the diagram is no longer pixels but typed structure), then SVG construction, followed by two verification passes — structural validation and visual re-inspection.

Structural validation checks XML integrity, node references, label placement, and edge overlaps. Visual re-inspection is more interesting: the exported PNG is checked again for cropping, overlap, label misalignment, and routing regressions. Problems found trigger targeted fixes — but fixes are capped at two rounds. The README's stated reason for the two-round limit is refreshingly blunt: to prevent unbounded self-editing loops.

That sentence deserves a pause. The biggest risk in a self-correcting system isn't that it fixes poorly — it's that it can't stop. Hardcoding the correction budget into the contract means verification itself gets a budget. Verification isn't free: every round of visual re-inspection costs the agent's attention. This skill's author understands that.

A third detail is, in our view, the best design of all: if the runtime agent lacks image-reading capability, the output report contains the line visual_review: skipped (image reader unavailable). Not a fake pass, not a silent skip — an explicit statement: "this gate was not verified, because it couldn't be." Saying "not verified" when it wasn't verified — that level of honesty is scarce in tool design.

The Geometry Budget: Turning "Looks Good" into Executable Constraints

For twenty years, the acceptance standard for diagramming tools has been "looks right," and the reviewer has been the human eye. Visio, draw.io, and Mermaid all assume a person is checking the output. Once models draw diagrams, the eye is gone — humans only see the result — and "looks good" must become rules a machine can check.

Zero crossings is one rule: line crossings make humans misread a diagram's topology, and machines count crossings trivially. Two bends per edge is one: too many bends and readers lose the line's path. Forty-pixel node spacing is one: crowded nodes are as good as no nodes. Each rule corresponds to a specific human reading error. So this isn't an aesthetics budget — it's a readability budget, encoding twenty years of implicit knowledge about "diagrams must be understandable" into one page of explicit constraints.

The promotional article calls these "geometric gates." We'd put it differently: this is assertion/execution separation for diagramming. The model's output is the assertion ("I drew it"); the validator is the execution (counting crossings edge by edge, measuring spacing point by point). Assertions don't count; execution counts. By contrast, the predecessor diagram-design takes another route: producing editable HTML, leaving final correction authority to the human. One bets "machines can verify it," the other bets "humans can edit it." It's the same fork we described in September for PPT skills: deliverables are either verifiable or editable — nobody has both yet.

The Two Weeks It Was Born

Zooming out from one project: fireworks was created April 10. Five days later, archify was born (April 15); six days after fireworks, diagram-design (April 16). Eleven days earlier, colleague.skill launched March 30, and the persona-distillation nuwa.skill on April 5. Those two weeks in early April were the Cambrian explosion of the entire skill ecosystem — diagramming, distillation, presentations, several major categories bursting out in the same window.

Taking stock of this cohort in October, half a year later: archify leads the category at 78,760 stars (we covered its typed IR design in late August, before recording star counts; it still commits daily), diagram-design has 44,155, colleague.skill 25,338, and fireworks 11,612. The category keeps splitting: an academic paper figure skill (created April 23, 2,231 stars) serves academic writing, and four days ago someone uploaded an animated architecture diagram skill (631 stars). The promotional ecosystem has matured alongside — Zhihu accounts like Muyan Agent promoted diagram-design in late August and fireworks in early September, round after round carrying skills from developer timelines into ordinary users' feeds.

This morning we wrote about how GitHub's 225 million accounts include many people who don't code. Diagramming skills are the other side of the same story: among stars stockpiled by non-coders, diagramming tools are one of the biggest categories. They're easy to understand, easy to demo, easy to promote — one forwarded GIF and anyone gets what this thing does.

Back to That One Line of Status

Finally, back to the skill itself. All its flourishes — twelve styles, the full UML family, the C4 review canvas, the 960px animated GIFs — are skin. The skeleton is that line in the output report: visual_review: passed. For the first time in twenty years of diagramming, "I drew it" has changed from a model's sentence into a checkable line of status: what was verified, how many rounds, and why the unverified parts weren't.

As for who verifies the verifier — whether machine-defined rules can actually contain the model's errors — that's the next question. But for now, at least, the act of verification exists, and the account of it is on record.