Why I no longer AI-generate my IG images

TL;DR

• Until recently I had an image model generate my Instagram posts end to end, headline and call to action baked straight into the picture, and the text kept breaking.
• FeedFoundry now renders the visible post text deterministically from templates, no AI-generated text in branded images anymore.
• AI still runs, but only for optional backgrounds, and every result passes through a vision judge that rejects any image containing text.
• BuilderBob decides content and quality on its own, publishes itself via the Meta Graph API, and calls FeedFoundry only for the finished image.
• The loop closes with real reach, saves, and likes flowing back into planning, not estimated metrics.

Why I stopped AI-generating my IG images

For a while I had an image model generate my Instagram graphics completely on its own. Prompt in, image out, headline and call to action included right in the picture. That worked fine as long as nobody looked closely.

Text in generated images is a known problem, but I only understood it properly once I started checking branded posts systematically. Letters that half exist. Words that render differently from the prompt. Lines that cut off mid sentence. On a single image, maybe nobody notices. On a feed that serves several brands every week, it turns into a pattern, and a pattern is a trust problem.

A branded post with broken text says something about the care behind it, whether I intended that or not. And because I run several brands in parallel, the failure surface is not one image. It is every image, every week, for every brand.

For a while I tried to fix this with better prompts. More context, tighter format constraints, generating several variants and picking the best one by hand. That improved the hit rate a little, but never enough to trust it unattended. I still ended up proofreading every image before it went out, and that manual check was exactly the step I wanted automation to remove, not preserve.

So I flipped the question: if AI-generated text is unreliable, why let the AI write text at all?

FeedFoundry's answer: text from templates, AI only for the background

FeedFoundry is the tool where I turned that decision into an actual system. It is a multi-brand Instagram content engine for my own brands, including @gotzendorfer.at.

The core design change: the visible post text is no longer generated, it is rendered. FeedFoundry takes a headline, numbers, and a call to action from a structured source and places them into a fixed layout via templates, technically through Satori and @vercel/og. The result is deterministic. The same input always produces the same text, in the same place, in the same font. No hallucination, because nothing is generated at that step.

AI still shows up, but for exactly one narrow job: the optional background behind the template. And even there, every result passes through a second check before it is allowed to compete at all, a vision judge. The judge gets the generated background image and one question: does this image contain text? If yes, it gets rejected, no matter how good the rest looks.

This is where the old uncertainty is cleanly contained. A background that misses the mark visually is a matter of taste, not a trust question. A background with half-broken text used to be the real risk, and that exact case is now structurally excluded, because the judge never lets it through. The AI still gets to be creative, just only in the space where a wrong call costs nothing more than taste, never in the space where it costs trust.

That is a deliberate trade. I give up the flexibility of letting the AI compose freely, and in exchange I get branded images whose text I never have to proofread, because it cannot break.

The precise division of labor: Bob decides, Bob posts, Bob only calls for the image

This is worth being precise about, because it is easy to assume FeedFoundry and BuilderBob form one continuous pipeline. They do not.

BuilderBob is my platform agent, responsible among other things for the Instagram presence of @gotzendorfer.at. He decides what gets posted, checks it against a brand-voice gate, and publishes it himself via the Meta Graph API, under his own authorization, not through a detour. The content decision and the quality check sit entirely with Bob.

FeedFoundry has exactly one job in this flow: when Bob needs a finished, on-brand rendered image, he calls FeedFoundry's public render endpoint, /api/og, and gets the image back. That is the whole interaction. FeedFoundry decides nothing about content, timing, or tone, and Bob delegates nothing beyond the image rendering.

The distinction is more than semantics. A pipeline suggests one continuous, orchestrated process from idea to publication, where each step automatically flows into the next. What exists here is two independent systems with a single, clearly defined interface between them: an image request and an image response. Bob remains responsible for everything else, including the decision to request an image in the first place.

The closed learning loop: real engagement flows back

What makes FeedFoundry interesting to me is not the rendering itself, it is what happens after. Once a post is live, the loop collects real engagement metrics from the Instagram presence, specifically reach, saves, and likes. No estimates, no proxy metrics, just what Instagram actually reports back.

Those numbers flow back into content planning. A template, a topic angle, or a phrasing that resonates with real users gets more weight in the next planning round. What underperforms gets repeated less often. The loop does not close at publication, it closes only once the real result feeds back into the next decision.

In practice that means next week's planning round is not a blank page, it starts from what actually worked the week before. No guessing which format goes next, but a prioritization grounded in real numbers from the account itself rather than a generic best-practices list from somewhere else.

That is a different claim than "AI generates content." It is a system that measures what actually works and takes that measurement seriously, instead of relying on gut feeling or aesthetic preference.

Why separate responsibilities beat one giant pipeline

I could have built FeedFoundry and BuilderBob as a single, continuous agent that handles everything from idea to publication itself. I deliberately chose not to.

Separate responsibilities with a narrow interface are easier to debug. If an image looks wrong, I know immediately whether the problem sits in rendering, with FeedFoundry, or in the decision of what to post, with Bob. In a merged pipeline I would have to trace the entire flow to find the fault.

It also lets the systems evolve independently. I can work on FeedFoundry's rendering without touching Bob's decision logic, and the other way around. And it limits the blast radius when something breaks. A rendering bug produces at worst a wrong image, not wrong posting behavior, because Bob is the one who decides whether to post at all.

Not merging the two systems into a tighter pipeline today is not a missing integration. It is a deliberate boundary.

What actually changed for me day to day

The most noticeable difference is that I no longer proofread branded images before they go out. Checking text in an image used to be a fixed step in every publication, no matter how small the post. That step is gone now, because the text no longer comes from a model, it comes from the same source as the rest of a brand's content, rendered instead of guessed.

That frees up time for the questions that actually deserve attention: which topic goes next, how an offer is best phrased, whether a line of copy fits the brand. Questions where my judgment adds something, instead of questions where I am just correcting a model.

The tech stack, named honestly

So nothing here stays vague: FeedFoundry runs on Next.js with Supabase as the data layer, hosted on Vercel. Rendering uses @vercel/og, built on Satori, for the template-based image layout. Publishing runs through the Meta Graph API. No other hidden AI model sits in the rendering path, aside from the optional background step described above, gated by the vision judge in front of it.

That is not an exotic stack. The point is not the technology, it is how responsibilities are distributed within it: deterministic rendering for everything that must be guaranteed correct, AI with a checking instance for everything that is optional and tolerant of variance.

Conclusion

I no longer AI-generate my IG images end to end, because broken text in branded content is a trust problem, not a minor detail. The fix was not removing AI, it was giving it the right, narrow job: optional backgrounds, checked by a vision judge, while text comes deterministically from templates.

The precise division of labor between BuilderBob and FeedFoundry matters to me to state clearly, because it is the opposite of one giant pipeline. Bob decides, checks, and publishes. FeedFoundry renders an image when asked, and nothing more. And the loop that learns from real reach, real saves, and real likes turns that into something that gets better over time, not just bigger.