been experimenting a lot with autonomous design recently and decided to write down some thoughts about how I was building the idem's brand foundations https://x.com/i/article/2118666903908499457
Brand Machine: How we built our autonomous brand system in a week
A little pre-story
Recently we pivoted into building @tryidem full time. I was excited to work on the native app (for 4 OS' lol) — but first, as the only creative on the team, I needed to build the brand and the design system, ideally by the end of the week. When I first approached it, my first thought was that I didn't want to end up doing all the manual promo production work myself, like I did at Latitude.
Our CEO Sesar already had the positioning figured out, so my job was turning it into a brand that could scale without a designer stuck in the loop. Astra had just dropped, and it was good enough at following rules that making the brand self-driving felt possible.
Most autonomous branding promises are full of shit and turn into a slop factory that needs constant fixing — but I wanted the manual work off my plate regardless.
Monday - Tuesday : Nuclear approach
The first thing idem needed was a centerpiece, sitting at the heart of the brand, with every deliverable that came after it, a banner, a landing page, a slide, physically glued back to the same core.
To keep the consistent level of the visual output, I needed one entity to act as that glue — some kind of graphics or effect. It had to be a) programmable, not AI-generated b) able to create both abstract material with no specifics as well as combined with any footage, keeping the brand scalable and diverse without losing the core.
After a little manual exploration, the wanted effect was defined — a replicable oil paint brush strokes effect. For that matter, I built a simple paint-brush renderer: feed it a palette and it paints from nothing; feed it an image and it repaints the photo's own pigments instead. That's the nucleus everything else in the brand orbits.
Wednesday: Initial human input as building blocks
Despite models getting better at independent tasteful judgement, they still tend to flatten original design concepts rather than develop them. What they're good at is shuffling existing human-made constants. To play on that, I built the brand design system as pieces of easy-to-use Lego bricks: an adaptable grid, color palettes bulk-tested on the paint effect, the app icon and logo lockups — still hand-drawn, then folded back into the same system as everything else — UI layouts, and a reference library of old master paintings I kept checking the paint effect's palette and light against.
It takes a bit more time upfront, but it works much better than just asking your agent to build a brand off one single banner you designed and called a "design concept."
Brand machine
Thursday morning, once I had the bits and pieces in place, I needed a single source of truth. So I put together a zip containing everything about idem's brand, with .md guidelines being the most important part (partly following the ideas from "The HTML Brand: The Rise of Input-Based Outcomes" by @emmetshine). From there I distilled it into a couple of brand-replicating tools, like the custom banner builder, which let our team create high-quality banners without me being part of the process.
This loop is what lets idem be proactive, not just responsive: it can see an event on the calendar or marketing agenda, prepare the materials on its own, reach out for guidance if something gets complex, digest the feedback, iterate, and deliver everything back to marketing — without being asked first.
Agent-first brand machine
Thursday afternoon, however, as I mentioned, I wanted the agent to do all the work, so it can integrate into the workflow of our marketing people fully. So they can actually ask their agent or even idem itself to prepare the full-cycle campaign materials in the same chat and get the bulletproof promo banners, branded landing page and, perhaps, even some merch designs. That was the reason for the next logical step — a custom MCP server, which enabled agents to use the guidelines and the banner builder directly. The shape of it ends up as two linked loops: human and agent in a constant back-and-forth, and agent and brand machine in a tighter one it dips into on demand and comes back from with the actual deliverable.
Judgement
Friday, last piece. Despite the progress, sometimes the agent would pick footage that produced bad contrast with the other elements, or leave a line hanging weirdly — so my judgement was still needed, and I was convinced agents could be the taste judges here if someone told them what "bad" looks like.
So I treated it like writing unit tests for code: everything I could turn into an objective check, I did. Every candidate layout gets run against the real copy and background and tested on five fronts: fit (overflow, excessive shrinking, type too small to read, titles that don't fill their box), contrast, hierarchy, spacing and negative space (orphan lines, broken words, busy backgrounds sitting behind text, content that reads as disconnected), and overlap — a real test suite for a banner, not a vibe check. Whatever fails gets flagged, the layout with the fewest and smallest failures wins, and the agent gets the preview back with the actual failures named instead of a vague "try again."
Not everything worth checking is objective, though. Some of it is just taste — mine, built over years of looking at this stuff — and no unit test catches "this looks cheap" or "this composition is boring." So the last piece was writing that down too: every instinct I'd normally keep in my head, distilled into judgement criteria that act as the taste police on top of the five checks above, down to the compositions I'd reach for first and the ones I'd never ship. The five checks catch what's broken. The taste police catches what's merely uninspired.
Friday evening, marketing ran their first real campaign through the whole thing without pinging me once, just by talking with idem itself.
It didn't turn into a slop factory, at least not yet, because the agent runs the whole thing itself without ever actually improvising: every choice available to it — the renderer, the building blocks, the rules, the judgement criteria — is something I already knew and had already distilled into a tool, a reference, or a guideline it follows, and I still test and tighten that ruleset every now and then. The outcome is autonomous. The range of outcomes isn't. Already, the system saves me a few hours every week, and as idem scales, it's expected to only make more sense.