A prompt kit that compiles and lints your image requests

Treating a prompt like something you compile

This is a skill for a coding agent that turns a vague image request into a finished, production-ready prompt for a specific image model, and then checks that prompt against a set of rules before you generate anything. The metaphor the project uses for itself is a compiler, and it is the right one.

The problem it targets is familiar to anyone who has typed a one-line request into an image model. Ask for a nice poster and the model returns exactly the vagueness you gave it. The gap between what you pictured and what you typed is where the disappointment lives, and closing it by hand means knowing a great deal about how to describe an image in terms the model actually responds to.

The skill's answer is to treat that translation as a compilation step. A rough request is mapped through a routing table to a single pattern, and that pattern expands into a complete prized prompt written the way the target model wants. The routing library is sizeable, spanning cinematic, poster and typography families, each a numbered entry the router can select.

The audience is someone generating images with this particular model who keeps getting mediocre results from short prompts and wants the accumulated knowledge of how to prompt it well, packaged as something they run rather than something they have to learn first.

Why the compiler framing actually fits

It would be easy to dismiss the compiler language as branding, so it is worth checking whether it holds. It does, in three specific ways.

A compiler maps a high-level intent to a lower-level form through defined rules rather than guesswork, and that is exactly the routing table's job: a request signal becomes one row, and that row determines the structure of the output. A compiler rejects input that violates its rules before producing anything, which is precisely what the validator does. And a compiler produces output in a target language with its own conventions, which here is the dialect of description this image model responds to rather than a general one.

That third point is the substance. The skill is not a generic prompt improver. It is tuned to one model, and the whole value is in encoding that model's specific preferences, down to which phrasings help and which actively hurt. A prompt compiler for a different model would need a different rule set, and the project is honest that generation itself is out of scope, pointing elsewhere for that step.

The separation of concerns there is worth crediting. This tool compiles and validates a prompt; it does not generate the image, delegating that to a separate tool. Keeping the two apart means the hard, opinionated work of writing a good prompt is a self-contained artefact you can inspect and check, independent of whatever runs the generation.

The one rule that undoes years of habit

The most important thing the skill teaches is stated as a prohibition: no negative prompts. You do not tell this model what to leave out; you describe what you want, positively, instead.

That single rule matters more than it looks, because it directly contradicts how a generation of users learned to prompt. The previous dominant family of image models used negative prompts heavily, and typing a long list of things to avoid became a reflex. On the model this skill targets, the project states that excluded words are liable to be rendered rather than suppressed, so a negative prompt can summon the very thing it was meant to banish. Rewriting an exclusion as a positive description of the desired scene is the fix, and the skill makes that rewriting the default with only two narrowly defined exceptions.

This is the kind of knowledge that is genuinely hard to acquire on your own, because it requires knowing that a habit which used to work now backfires, and most users never get told. Encoding it as an enforced rule, rather than a paragraph of advice someone might skim, is the difference between the lesson landing and not.

The related rule is the ban on vocabulary inherited from that earlier era: the quality-incantation words, the numeric weight syntax, the flag-style aspect-ratio switches. The project treats all of these as noise on this model and reduces them to concrete description instead. It is, in effect, a deprogramming of Stable-Diffusion-era habits for a model that does not share their assumptions.

A house style with numbers in it

Beyond the headline rule, the doctrine is a set of concrete conversions, and their concreteness is what makes them usable rather than aspirational.

Equipment specifications become described results: the model does not know what a particular camera and aperture do, so instead of naming them you write the visible outcome, such as a shallow depth of field with the background falling away softly. Empty adjectives like pretty or premium become numbers and physical detail, because a model can act on a hex palette, a colour temperature and a lighting ratio in a way it cannot act on a compliment.

The layout rules are equally specific. One row is one image is one generation call, so multiple shots are multiple rows rather than a grid crammed onto a single canvas. Text is rendered inside the image by the prompt, never composited on afterward with a graphics library, because letters pasted over a finished picture drift in font, spacing and tone; a text error is fixed by editing the prompt and regenerating, not by patching the pixels.

There is also a size lock, restricting output to a small set of known-good dimensions for the generation path and forbidding the automatic option and stray aspect-ratio markers, with a single canonical token at the end of the prompt.

Each of these is a small piece of hard-won practice, the sort of thing you otherwise learn by producing a hundred disappointing images and slowly working out why. Collected and enforced, they are the actual product.

A validator that says no before you spend money

What separates this from a well-written guide is that the rules are executable. The skill ships a validator script that you run over a prompt, and it returns a small structured result reporting whether the prompt passed, its detected format and tier, and any errors and warnings.

node skills/image-prompt/scripts/check_prompt.mjs examples/poster.txt

The list of things it catches is precisely the doctrine turned into checks: a negative outside the narrow whitelist, a piece of deprecated vocabulary, a size-lock violation. These are stopped at the validator with an error before the prompt ever reaches generation.

That gate is the genuinely valuable engineering here, for a reason that is easy to overlook. Image generation costs money and time, and a prompt that violates these rules does not fail loudly; it quietly produces a worse image, and you may not even know which rule cost you the result. A lint step that rejects the prompt beforehand converts a silent, paid failure into an immediate, free one. Turning prompt-writing advice into a check that runs before you spend anything is the move that makes the whole doctrine stick, because a rule that is merely written down is a rule that gets skipped under deadline.

The repository includes passing and failing sample prompts so the validator's behaviour can be seen directly, which is the right way to document a checker: not by describing its rules but by shipping inputs that exercise them.

Installing it, and the shape of its limits

Installation is a clone and a symbolic link into the agent's skills directory:

git clone https://github.com/gongnyang/gongnyang-prompt-kit
ln -s "$PWD/gongnyang-prompt-kit/skills/image-prompt" ~/.claude/skills/image-prompt

The README notes that installing by link means repository updates are reflected automatically, which is the small correct touch. The skill then runs from trigger phrases or an explicit command inside the agent, and the validator needs a Node runtime; carrying a compiled prompt through to an actual image needs the separate generation tool the project points to.

The limits are worth stating plainly, and none is a defect so much as a boundary. The skill is tuned to one specific image model, so its rules, especially the size lock and the vocabulary bans, are tied to that model's current behaviour and would need revising if the model changed or if you used a different one. The output prompts are written in Korean, and while the repository provides English and Japanese documentation, the compiled prompts and the routing library reflect that primary language. And the routing library is an opinionated house style; its cinematic and typography patterns are someone's aesthetic, which is a strength when it matches what you want and a constraint when it does not.

The project is MIT licensed, which is permissive and raises nothing for reuse, and reports 325 stars, 55 forks and no open issues, with the last push on 2026-07-27 and release notes describing an active refactor toward a single routing table. This is not legal advice.

Before adopting it, three steps in order. Confirm you are generating with the model it targets, since the rules are meaningless for a different one. Install by symbolic link and run the validator on the shipped samples first, so you see what it accepts and rejects before trusting it on your own work. Then read the doctrine even if you never run the skill, because the no-negatives rule and the deprecated-vocabulary list are worth knowing for anyone prompting this model by hand.

Editorial conclusion

This skill fits someone generating with the image model it targets who keeps getting weak results from short prompts and would rather run the accumulated knowledge of how to prompt it than learn it the slow way. Its real contribution is turning that knowledge into enforced rules, above all the counter-intuitive ban on negative prompts, which reverses a habit a whole generation of users carried over from earlier models where it used to work. Confirm you are using the model it is tuned for, since the size lock and vocabulary rules are meaningless elsewhere, run the validator on the shipped sample prompts first so you can see what it accepts and rejects, and read the doctrine even if you never install the skill, because the positive-description rule and the deprecated-vocabulary list are worth knowing for anyone prompting this model by hand.

Frequently asked questions

Official sources

1. gongnyang/gongnyang-prompt-kit on GitHub
2. License: MIT
3. Project website
4. README
5. Releases