Hand the method to your agent.

What the skill is

The AI Photography Accuracy skill is a free, open-source package that teaches an AI agent, or you, how to make an AI product image physically truthful to the real product. It lives on GitHub at github.com/bertrand-do/ai-photography-accuracy, it is public, and it is licensed CC BY 4.0, so you can share it, adapt it, and use it commercially as long as you cite the source. It is not theory written in the abstract. It is the distilled doctrine behind a working practice that ships these images for money, and behind the Dezygn platform.

The repository is small on purpose. `SKILL.md` is the compact operating doctrine: the laws that describe how these models actually behave, the Visual Syntax v2.0 language, the diagnosis-first Route Map that names the defect on eight fidelity axes and dispatches it to one technique, and the measured decision rules. A `references/` folder holds the depth: the 21 techniques with their moves, and the eval findings behind every rule. Those findings come from 276 images generated and judged blind, not from what someone hopes usually works. You drop the repo into your agent's skills directory and it runs the whole method on any product-accuracy task. It also reads top to bottom as a course.

Why it exists

You spin up a product shot and it looks incredible. Then you look closer. The bottle is the wrong shape. The label reads like gibberish. The linen shines like plastic. So you rewrite the prompt and spin again, hunting for the one that finally looks like your product. That is not a workflow, it is a slot machine. And close enough is not a style choice. Close enough is a two-star review, an item-not-as-pictured complaint, and a refund.

The skill exists to replace that guessing with a method. Instead of rewriting the whole prompt and rolling again, you name the exact defect, route it to the technique built for it, and lean on measurements instead of hope. As far as I know it is the only published, blind-judge-measured system for AI product photography accuracy on the Nano Banana model family. The goal has a name in the doctrine: Conversion Integrity, an image a customer would accept as the real product. That is Accuracy plus Realism plus Branding. Miss one and the image hurts the brand.

The vocabulary it coins

A lot of the value is language. Once a problem has a name, you can point at it and clear it instead of saying it just looks off. Most of these terms are published nowhere else.

Visual Syntax is the six ingredients (Style, Subject, Action, Scene, Camera, Brand) and the three rules that turn prompting from description into assembly. The full treatment is here at the Visual Syntax framework. The Route Map is diagnosis on eight fidelity axes dispatching to one technique, the idea that there are many ways to cook the same dish and choosing one is the diagnosis; the full table is at the product accuracy route map. Lock-and-Outpaint means freeze the product's pixels and paint the world around them, because never redrawn means never wrong. Shannon Descent means isolate the smallest failing piece, solve it alone, and rebuild around it. Conversion Integrity is the trio a client actually buys. These are not decoration. Each one is a defect class or a technique you can dispatch to.

How to use it, three ways

First, as a Claude or ChatGPT skill. Drop the repository into your agent's skills directory. `SKILL.md` carries the frontmatter and doctrine the agent follows; the `references/` files load when depth is needed. It triggers on product photography and product-accuracy tasks, so your agent starts running the diagnosis-first method on its own instead of freelancing.

Second, as a reading course. Read `SKILL.md` top to bottom: the laws, then the six ingredients, then the Route Map (the heart), then the four measured rules. Reach for the techniques file when a specific route comes up, and the evals file when you want the evidence behind a rule. Nothing about that requires an agent. It is a compact way to learn the craft for free.

Third, on rails inside Dezygn, where these techniques are built into the product and our assistant runs them for you instead of living in my head. The skill teaches the what and the why compactly; the full technique treatments live here at dezygn.com/resources, which is canonical. So the skill is the bridge, and the deep dives are the destination.

What you need to run it for real

Reading costs nothing. Generating accurate images needs one thing beyond the doctrine: API access to a current image model that accepts reference images, image-to-image. We use and recommend fal.ai running the Nano Banana family, a cheap tier for iteration bursts, a standard tier for candidates, and the Pro tier for finals only. That is the Draft Cheap, Finish Expensive dial: spend on confidence, never on exploration.

The doctrine is model-agnostic on purpose, because model names change every six months and the principle does not. The skill tells the agent not to assume endpoint IDs from the document but to look up the provider's current model registry at run time and map the cheap, standard, and premium roles to whatever the current equivalents are. So the repository stays correct even when the models get renamed. If you want the measured backbone before you commit, start with product accuracy on Nano Banana, which is the pillar this whole library hangs off.

One-shot and chaining are peers, not a rule and its exception

A point the skill is careful about, because people get it wrong. One-shot prompting and the sequential pipeline are peer techniques with different jobs, not a default and a fading exception. Try one-shot first with a sharp reference, because in a measured test a single jump from a sharp reference beat chaining, since every extra chain step re-renders the product and accumulates drift. But chain when you need control: an angle that has to be created first, a multi-product composition, or a consistent model built separately. Measure the delta and match the technique to it.

The deeper lesson from that eval is that the input, not the method, is usually the bottleneck. The same task went from zero strict fidelity with a blurry reference to 75% with a sharp one, just by sharpening the reference. Fix the reference before you blame the technique. That is the kind of measured rule the skill exists to hand you, so you stop debating and start diagnosing.

Star it and build on it

The skill is free and it stays free. If it gets Nano Banana to respect your product, star the repo on GitHub so the next person drowning in close enough can find it. Then come read the full technique treatments here at /resources, where every route has its own deep dive with the evals and the exact prompts behind it.

Related Resources.