Dremio — brand & creative systems.

What I walked into

No documented brand strategy. A visual identity that leaned on gradients and aesthetics but struggled in daily use, and a design system that didn’t match the freshly redesigned website, so the customer journey felt disjointed depending on where you met the brand. Every request routed through design, which made brand a queue rather than a capability. It was the second time I’d watched an identity optimised for how it looks fail at how it works.

What I built

The foundation first: strategy, positioning, voice, and a visual identity aligned to the website’s design language, so web, print, events, and video read as one brand. Then the system to carry it: a governed design system and guidelines built as a single source of truth, with brand tools and documentation that make the right thing the easy thing.

On top of that, the AI layer: generative workflows that let any team produce on‑brand copy, documents, and decks for themselves, automation that rebrands a full legacy deck in minutes instead of an afternoon, and a coded motion system whose animations run on the live homepage. The video above is one of them.

The foundation, written down

The strategy and identity are digitised as living documentation, structured the way people actually work: one core guide holds the fundamentals, and each function gets its own focused rules. Which logo variant, how much clear space, what good imagery looks like, how to write for each channel. Under deadline pressure you go straight to your function’s rules and ship, without wading through everyone else’s.

The same pages are written for machines as much as for people. The imagery rules draw a hard line: the logo is never AI‑generated, only composited from approved files. The self‑serve layer below is safe to hand to everyone precisely because the AI works from the same rules.

fig. — two pages from the live guidelines: logo clearspace, and the AI imagery rules with their hard line on logo generation.

Self-serve, shipped as a plug-in

The self-serve layer ships as a skill: a package anyone at Dremio can load into their AI assistant, the way you’d install a plug-in. That choice was about adoption as much as engineering. A workflow that lives in one team’s tooling is a bottleneck with extra steps. A skill in the enterprise environment means everyone natively gets the workflows, and nothing has to route through a brand person.

Governance travels inside the package. The rules and voice live in the references, the producers are skills of their own, and deterministic scripts gate every output: vocabulary and AI tells in the copy, palette and contrast in the layout, pixel checks on the final render. The build tooling goes a step further: it refuses to save a deck that fails validation.

dremio-brand/                   v1.9
├── SKILL.md                    ← routing: CHECKER / APPLIER / sub-skills
├── references/
│   ├── visual-tokens.md
│   ├── voice-and-tone.md
│   ├── design-judgment.md
│   ├── slide-layouts.md        ← the 33-layout library
│   ├── channel-rules/          ← web, blog, email, social, ads, sales, events
│   ├── generated/              ← machine tokens: tables, opacity, palette
│   └── qa/                     ← copy, design, accessibility checklists
├── skills/                     ← 18 producers + governors, routed by intent
│   ├── slide-workflow.md       ← one entry point for anything slides
│   ├── slide-deck-producer.md  ← net-new decks from a content brief
│   ├── deck-converter.md       ← legacy decks onto the new system
│   ├── deck-design-review.md   ← render, checklist, cite-a-rule fixes
│   ├── brand-copywriter.md
│   ├── brand-reviewer.md       ← autonomous review-fix-validate loop
│   └── … ads, blog, docs, ebooks, events, social, web
├── scripts/
│   ├── brand_lint.py           ← vocabulary, AI tells, forbidden phrases
│   ├── audit_html.py · audit_pptx.py
│   └── review_render.py        ← pixel QA on every render
└── tools/dremio-brand-py/      ← build helpers that refuse to save off-brand

fig. — the brand, as software: the actual package structure. Rules in references, producers in skills, deterministic governance in scripts.

A deck from a brief

One run, start to finish. The brief asks for a prospect overview deck for a first meeting: pull the content from dremio.com, keep the numbers real, keep it under ten slides. The agent loads the brand skill, researches the live site, drafts the narrative, and builds the PowerPoint file through the slide workflow in the tree above.

The governance is the part to watch. The build tooling refuses to save a deck that fails validation, so the agent reads the errors and repairs them. Then it renders every slide to an image and reviews its own work, catching an overlapping subtitle and a white logo sitting invisible on a white card, fixing each before calling the deck presenter‑ready. A twenty‑four‑minute run, compressed into sixty‑nine seconds.

fig. — the full run. Recorded from the live session, then directed in my demo platform: the pacing, camera moves, and highlights are data on the capture, not edits, and the video itself is rendered by code.

fig. — the eight slides it delivered, exactly as produced: real content from the live site, the brand system enforced throughout.

The deck problem, up close

That video is net‑new production. The library of existing decks was its own problem. The old template baked its gradients in as full‑bleed images. That made text contrast a daily fight, and it made files enormous: thirty slides of high‑res backgrounds pushed a deck past attachment limits, so emails carrying them were flagged as spam or never sent at all. Not everyone could work in Google Slides either, so downloading those heavy files was the norm rather than the exception.

The refresh moved everything to native colours, gradients, and layouts. Accessible contrast by construction, a fraction of the file size, and decks light enough to actually email. The deeper shift was the same one as everywhere else: slides built around the story being told, not the decoration behind it.

before

after

↔

fig. — the same deck, before and after the refresh. Drag the handle. Six representative slides: the old template’s baked-in image gradients on the left, the rebuilt native system on the right.

Motion, written as code

The homepage animations are React components, rendered by Remotion. The same source plays in the browser and renders the MP4, so a palette tweak or a copy change is a pull request, not an After Effects re-render. Drag to see the source behind the animation.

/**
 * comp1 "Semantic Layer" — root composition rebuilt as one editable file.
 *
 * Every AE layer is explicit JSX with its own position / anchor / opacity
 * inline. Keyframed motion lives next to the layer it animates (one
 * `interpolate()` call); the few dense AE sampled curves (working robot pop,
 * SQL slide-up) are named constants at the top.
 */
import { AbsoluteFill, Easing, interpolate, useCurrentFrame } from "remotion";
import { reach } from "../../lib/aeReachEasings";
import { AgentBubble } from "./AgentBubble";
import { AnswerPanel } from "./AnswerPanel";
import { SearchSweep } from "./SearchSweep";
import { TablesAndSources } from "./TablesAndSources";
import { COLOR } from "./scene";

// Smooth in-out for short shuttles like the sweep highlight; reach.easeOut
// (fast start, slow settle) for the master scroll and component fades.
const SMOOTH_INOUT = Easing.bezier(0.4, 0, 0.6, 1);

const clamp = {
  extrapolateLeft: "clamp" as const,
  extrapolateRight: "clamp" as const,
};
const lerp = (frame: number, f: number[], v: number[]) =>
  interpolate(frame, f, v, clamp);

fig. — one file, both sides of the handle: the composition source and the animation it renders, live on the homepage today.

The website, prompt to production

The last bottleneck was the website itself: WordPress, where publishing a page meant a developer, a build, and a wait. I prototyped the replacement: the design system rebuilt as coded components on a modern stack, Next.js on Vercel with content structured in Sanity, and twenty‑five of the brand’s product visuals written as React components instead of exported images.

The prototype’s real argument was the workflow on top. Claude takes a brief, grounds itself in the company’s documented strategy, product facts, competitive intel, and brand rules, composes the page from the design system’s sections, and publishes it as structured content. From prompt to a live, on‑brand product page in under a minute: no git, no build, no deploy. And because every section lands as content rather than code, a marketer can refine any of it in the editor afterwards, no developer involved.

brief → live page                     one prompt, under sixty seconds
│
├── 1 · brief      "Create a product page for Open Catalog"
├── 2 · ground     strategy · product facts · competitive intel · brand rules
├── 3 · compose    sections assembled from the coded design system
├── 4 · publish    created and published as structured content, wired into nav
└── 5 · live       /open-catalog serving in seconds. No build, no deploy.

fig. — the pipeline the prototype proved, from the validated dry run: a brief in, a grounded page live in under a minute, still editable by humans in the CMS.

fig. — the prototype itself: the homepage and a trial landing page. Every section is structured content; every product visual is a coded React component, not an exported image.

It’s the same thesis as the skill, applied to the web: agents work from the same written‑down rules people do, so governance lives in the system rather than in review. The dry‑run page shipped with every claim traceable to a documented source. This prototype is what won approval for the re‑platform.

What changed

Brand stopped being a checkpoint and became infrastructure. Teams ship consistent work without waiting, production that took hours happens in minutes, and the brand holds together everywhere a customer meets it.

Agentic marketing teams operate differently. Everyone is a creator, both in terms of building agents, but also in terms of building content and experiences. Brand has to operate differently in this environment. Everyone needs to be able to create enterprise‑grade assets that adhere to brand standards. Few have the product management skill, agentic knowledge, and brand expertise to help construct an agentic marketing platform. Patrick is one of the rare few with the confluence of skills to excel in the agentic era.

Read Maloney, Chief Marketing Officer, Dremio