DEV Community: Tomer Bar-Meir (Tom)

We Benchmarked a Rotation-Detection Model Against ChatGPT on 400 Real Product Photos

Tomer Bar-Meir (Tom) — Tue, 13 Oct 2026 08:21:58 +0000

The question

Can a general-purpose vision model (ChatGPT) reliably tell which way a product photo needs to be rotated to be upright? We built a specialized model for this exact task (BlueVetaUpright) and ran a real comparison to find out.

Setup

400 real product photos, split across two independently-built 200-photo batches with zero shared source photos
Each photo rotated to a random quadrant (90/180/270°); the task is predicting the correction needed
ChatGPT used through its standard consumer chat interface (not a pinned API snapshot — more on why that matters below)
Scored for quadrant accuracy only (0/90/180/270°), same task given to both systems

Result

BlueVetaUpright: 91.1%
ChatGPT: 75.9%

+15.2 percentage points, 95% CI [+10.4, +20.0] via a photo-cluster bootstrap (10,000 resamples, clustered by source photo so one confusing photo can't skew the result).

The first 200-photo batch alone was directionally positive but not statistically significant (its CI touched zero). We built a second, independent 200-photo batch specifically to resolve that, and the combined result holds.

A real, disclosed limitation

The two 200-photo batches did not score identically for ChatGPT — 82.1% on the first, 69.9% on the second, concentrated in the harder tilt buckets. BlueVetaUpright stayed consistent across both (88.2% / 94.0%). Our best explanation: a consumer chat UI gives no pinned model guarantee — no controlled snapshot, no guarantee against backend routing changes between sessions. That's a real limitation of comparing against a moving target, disclosed here rather than smoothed over.

Why this is harder than it looks

Rotation detection sounds trivial until you try it on real product photography: labels at odd angles, symmetric packaging, flat-lay shots with no obvious "up." A model trained specifically for this narrow task (ours fuses a quadrant classifier with a separate fine-tilt model and an arbitration layer) consistently beats a general-purpose vision model that was never specifically optimized for it.

Full methodology + paper

Full methodology, bucket breakdowns, and limitations are public: blueveta.com/upright/research. The underlying research is also archived with a DOI on Zenodo: 10.5281/zenodo.22975679.

Try the tool free: blueveta.com/upright

AI product photo tools for small sellers: Pebblely vs PhotoRoom vs Flair.ai vs BlueVeta

Tomer Bar-Meir (Tom) — Mon, 12 Oct 2026 16:39:17 +0000

Disclosure: I'm the founder of BlueVeta.com, so I know that one best. I only list features each tool states on its own website, and I say where another tool is the better pick.

If you sell a physical product, you need the same things over and over: a clean photo, a few lifestyle scenes, a short video, and copy for every place you sell. Here is how four tools split that work.

Pebblely

Pebblely is built around product photos. You describe a background in plain text, generate it in bulk, start from 100+ templates, and resize one image into formats for marketplaces, social, email banners and ads. Its site describes images only; I did not find video or written copy.

Best for: sellers who already have their copy and just need many good-looking product backgrounds.

PhotoRoom

PhotoRoom is the widest editing toolbox of the four: background removal, AI backgrounds, product staging, fashion models and try-on, ghost mannequin, shadows, retouching, object removal, batch processing, a product catalog and an API. A video generator is listed on its higher plans. Its site does not describe copywriting.

Best for: sellers with many photos to clean up or batch-process, and teams that want fine control over each edit.

Flair.ai

Flair.ai is a design canvas for product shoots. You place your product on a 3D canvas with props and build on-model shots. It also lists product video, ad generation with brand templates, and team collaboration. Its site does not mention written copy.

Best for: brands that want to art-direct each scene themselves, including fashion and jewelry on AI models.

BlueVeta.com

BlueVeta.com works the other way round. You upload one product photo, answer a few questions, and a few minutes later you get a complete set:

a studio render
two lifestyle scenes
a short vertical video
every image resized and ready for each platform's format
copy for 20 platforms: social posts, marketplace listings (Etsy, Shopify, Amazon) and campaign pieces like a press kit and email

It remembers your brand voice across packs. Pricing is $9.99 per pack with no subscription, and there is a free demo with no signup. Try it at https://blueveta.com

Where it is weaker: it is not an image editor. You will not get PhotoRoom's per-image editing tools or Flair.ai's drag-and-drop scene control. It is built for getting a whole campaign out fast, not for fine retouching.

Best for: solo and small brand owners who need the whole kit, copy included, and don't have time for a photographer, designer and copywriter.

How to choose

Need only backgrounds: Pebblely.
Need to edit and batch many photos: PhotoRoom.
Want to art-direct each scene: Flair.ai.
Need photos, video and copy for every platform from one upload: BlueVeta.com.

Many sellers will end up using two of these. Try the free options first and judge on your own product.

One product photo in, a full campaign out: what BlueVeta makes from a single phone photo

Tomer Bar-Meir (Tom) — Mon, 05 Oct 2026 14:06:52 +0000

Selling a physical product online means a studio shot, lifestyle scenes, a short video and copy that fits each platform. For a small brand that is a photographer, a designer and a copywriter on every launch. That gap is what I built BlueVeta to close.

What BlueVeta does

You upload one product photo. A few minutes later you get:

a studio shot
lifestyle scenes
a short video
ready-to-post copy for 20 platforms

Here is the 15-second demo:

Two real examples

A phone photo of a plant fertilizer, and the studio shot made from it:

A phone photo of a pack of mini pita bread, and the lifestyle scene built from it:

How I keep generated images honest

Image models are good at scenes and weaker at text, so I run the same five checks on every generated photo before it goes into a listing: label text, logo and colour, edges and scale, reflections and shadows, and order (the real photo stays as image #1, generated scenes come after it).

Pricing

There is a free demo at BlueVeta.com. Paid packs start at $9.99 a pack, with no subscription.

Feedback welcome

What would make you trust a generated product image enough to list it? I would like to hear how you check yours.

I am the founder of BlueVeta. The tool is also from the same team as UprightAI, which detects sideways product photos and returns the exact fix.

I built a rotation checker for product photos, then a whole campaign tool on top of it

Tomer Bar-Meir (Tom) — Sat, 03 Oct 2026 18:52:30 +0000

Two products came out of one problem. Sellers kept uploading product photos that looked fine on their phone and came out sideways on the marketplace, because the camera's rotation tag and the pixels disagreed.

So I built UprightAI. It reads the pixels and tells you the exact rotation needed, rather than trusting the tag.

Once the rotation worked, the next question was what sellers do with the photo afterwards. Most then need studio shots, lifestyle scenes, a short video, and copy for each platform. That's BlueVeta: one product photo in, a full campaign out. It's pay-per-pack, with no subscription, from $9.99, and every purchase has a 30-minute refund guarantee. Site: blueveta.com.

How it's built: several Claude Code sessions, each owning one piece. What's worked is the clear split of ownership. What hasn't: image models sometimes redraw label text wrong, so every generated image needs a check against the real package.

Question for anyone who sells physical products online: what would make you trust a generated product image enough to list it?

Why 90 and 270 Degree Rotations Are the Hardest for Vision Models to Catch

Tomer Bar-Meir (Tom) — Fri, 02 Oct 2026 09:51:54 +0000

Ask most people to guess which rotation is hardest to detect automatically, and they'll say "upside-down" (180 degrees) — it looks the most obviously wrong. In practice, the opposite is true. 90 and 270 degree rotations are consistently the hardest for a model to catch, and the reason comes down to a basic property of how convolutional and transformer vision backbones represent images.

The real failure mode

A 180 degree rotation flips an image top-to-bottom AND left-to-right at once. For almost any real-world photo, that double flip breaks enough spatial relationships (sky vs. ground, light source direction, text orientation, where shadows fall) that the error is visually obvious, even to a model that was never trained specifically for orientation.

A 90 or 270 degree rotation only swaps one axis. The image keeps a coherent "up" in one direction, and depending on the subject, that direction can look entirely plausible. A bottle lying on its side, a box shot top-down, a piece of jewelry on a flat surface, a close crop with no visible horizon — these are exactly the cases where a 90 degree error produces a photo that still reads as "correctly oriented" to a general-purpose model, because nothing about the pixel content screams "wrong."

RotBench (arXiv:2508.13968), a recent benchmark built specifically to test this, found exactly this asymmetry in frontier multimodal models: strong accuracy on upright-vs-upside-down discrimination, and a real, measurable drop on the quadrant-rotation task specifically. It's not a dataset artifact — it's a structural blind spot. A model trained on "does this look like a normal photo" has no explicit signal for "which way is actually up" when the subject itself doesn't encode gravity.

What actually works

The fix isn't a bigger general model — it's training specifically for the task. A classifier trained end-to-end on the 4-way rotation problem (0/90/180/270) learns cues a general vision-language model never gets reinforced on: label/text baseline direction, product-specific "expected" orientation priors, shadow and lighting consistency across the specific rotation axis.

Two things made the biggest real difference when I built a dedicated rotation-detection model for product photos:

Separating the coarse (4-axis) and fine (exact-angle) problems into two cooperating signals instead of one combined regression. The quadrant call and the fine-tilt correction have different failure modes and benefit from being trained and arbitrated separately rather than forced into one loss function.
An arbitration step between two models with different strengths (one stronger on clean/easy cases, one stronger on hard tilt) beats either model alone, and beats a single bigger model trained the same way. Complementary failure modes are worth more than raw parameter count here.

Real, measured results on this approach: ~99% on clean quadrant rotations, ~97% across the full realistic range including fine-tilt correction, down to ~84% on the hardest cases (severe tilt, no clean quadrant to anchor on). The gap between "clean" and "hardest case" numbers is itself evidence for the asymmetry above — the easy end of the distribution is dominated by 180-degree-style errors, the hard end is dominated by exactly the 90/270 ambiguity this post is about.

Why this matters beyond research

If you're building anything that processes user-submitted photos at scale (marketplaces, print-on-demand, document pipelines, any bulk-upload flow), "just run it through a vision LLM and ask if it's rotated" will quietly fail on exactly this category, silently, with no error to catch. It's worth knowing which specific failure mode you're exposed to before it shows up as a support ticket.

Full accuracy breakdown and methodology: blueveta.com/upright/research. Happy to go deeper on the arbitration approach in the comments if useful.

I run my whole company through a coordinated team of Claude Code sessions

Tomer Bar-Meir (Tom) — Sun, 27 Sep 2026 11:22:55 +0000

I'm the sole founder of BlueVeta — upload one product photo, get back a full marketing campaign (studio shots, lifestyle scenes, video, and platform-ready copy for 20 platforms) in a few minutes. But the story I don't usually tell is how it's actually built and run.

Every part of the company — the generation engine, the dashboard, image gen, copy gen, auth/billing, marketing — is its own persistent Claude Code session, each with clearly scoped ownership of one domain, each in its own git worktree so nothing collides. They message each other directly when work crosses domains. They read and write a set of shared docs that function as the company's institutional memory. And one hard rule governs every one of them: investigation is always free, but nothing gets built, deployed, or spent without coming to me first with what was found and why. I'm not a coder — I make the calls, the sessions do the work, always with me in the loop before anything ships.

It's not "I used AI to code faster." It's closer to running a distributed team where every teammate happens to be a Claude Code session — coordinating, catching each other's mistakes (today alone, one session caught another about to mislabel a real customer's private photos as internal test data, before anything went out), pushing back when something looks off, and asking before spending my money.

Real, current state: real Stripe payments proven, real (if still small) customers, and roughly 75% of the actual work in every customer pack — seeing the photo, planning the campaign, writing every platform's copy, checking its own output — done by Claude, not a human.

Happy to answer anything about how the coordination actually works day to day.

Try it: BlueVeta.com

Why General-Purpose Vision AI Can't Tell Which Way Your Product Photo Is Rotated

Tomer Bar-Meir (Tom) — Sat, 26 Sep 2026 12:42:43 +0000

Every product-photo pipeline we've built makes one quiet assumption: the photo is right-side up. It almost never is, and when it isn't, everything downstream degrades a little without anyone noticing why.

We assumed a modern vision-language model would just handle this. It doesn't. An independent, peer-reviewed paper (RotBench, EACL 2026, arXiv:2508.13968) found that GPT-5, o3, and Gemini-2.5-Pro all reliably confuse a 90 degree rotation with a 270 degree one -- not a small effect, roughly half of their errors fall in that one direction. We ran our own comparison against ChatGPT, Gemini, and Claude on real product photos and found the exact same failure mode. In our Claude evaluation specifically, this single confusion accounted for 37% of every error the model made.

What we built instead

A domain-specialized system, not a prompt or a wrapper around an existing model:

One model finds the nearest clean 90 degree turn (a 4-class classifier)
A second model reads the precise leftover tilt (fine-angle regression, 360-bin circular target)
A third, small trained model arbitrates between them when they disagree, using both models' own confidence signals

The two base models have genuinely complementary blind spots -- one is excellent on clean, easy photos and weak on heavy tilt, the other is the reverse. Combining them beats either alone by a real, statistically significant margin, verified via photo-cluster bootstrap (not a naive per-image confidence interval, which would overstate significance given correlated crops from the same source photo).

The numbers

Measured on a large, individually hand-verified pool of real product photos, not a synthetic benchmark:

99.02% accuracy on a clean quarter-turn
96.67% across the full 360 degree rotation range
84.65% on the single hardest case -- a tilt exactly halfway between two clean angles

Against ChatGPT specifically, on a consolidated 394-photo sample: a +15.2 percentage-point lead on quadrant accuracy (91.1% vs. 75.9%), 95% CI [+10.4pp, +20.0pp] via photo-cluster bootstrap. Across every assistant tested, the same 90/270 confusion RotBench documented showed up again, independently, in our own data. Our system shows no equivalent pattern anywhere in its results.

What we don't hide

The full paper discloses what we'd want to know before trusting a number like this ourselves: a genuine tilt right at the halfway point between two angles is still the hardest case (84.65%, not 99%); the system hasn't been tested on photos with more than one valid "upright" (a flat-lay, a floating render); and one internal component's raw confidence turned out to be structurally uninformative at the high end -- confidently wrong almost as often as confidently right -- which we root-caused and partially mitigated with a same-model consistency check, not swept under the rug.

Full paper, methodology, and dataset construction: https://doi.org/10.5281/zenodo.22975679

Happy to go deeper on the arbitration layer, the calibration issue, or the eval methodology in the comments.