AI-driven content delivery

Content design was catching the blame for slow delivery on work we didn’t actually own. The bottleneck was the manual process of building Evergreen tables, what we called EG tables, in Confluence. A finalized Figma frame would sit for days while a product owner copied strings into a Confluence table row by row, applied tags from memory, and tracked down the right Jira tickets. Tickets averaged 6 to 8 hours. Most of that time was rework.

Everyone had accepted this as the cost of doing the job. I didn’t want to.

I wrote rules for the firm’s internal LLM suite: rules for how content should pull from Figma, how tags should be applied, and how the table should be structured. I tested those rules and partnered with producers and product owners to verify the output was correct. I worked with a developer to build a Figma plugin and the API integration that let users invoke the agent directly from a frame. We presented the prototype to leadership. With their support, I rolled the tool out across 25 content design teams over 9 months, building a measurement dashboard with our DMO and analytics team to track the lift.

The result: 80% efficiency gains in content delivery. Per-ticket completion time dropped from 6–8 hours to under 2.

The problem

Building EG tables in Confluence was a manual job that scaled badly. A simple flow took a few hours. A complex onboarding experience could take days. Every step was retyping or re-checking something that already existed somewhere else.

Strings got copied from Figma instead of read from it, which meant a copy update in design didn’t always make it to the table. Tags got applied from memory, which meant teams used different vocabulary for the same thing. Jira tickets had to be hunted down per row. Tables shipped with missing rows that QA caught weeks later.

The cost was visible: 6 to 8 hours per ticket on average. The harder cost was political. Content design was the named owner on the work, so we caught the heat for the delays. The fix had to come from inside content design, because no one else had a reason to build it.

Writing the rules

The fix was to move the work upstream. Figma already held the source of truth for copy and components, so the agent needed to read from Figma directly. I wrote the rules that taught it three things: how content should pull from a frame so it landed in the right cell, how tags should be applied so vocabulary stayed consistent, and how the table should be structured so the output matched the firm’s expected format.

I tested those rules against the firm’s internal LLM suite and refined them until the output was reliable. Producers and product owners reviewed the results on real projects. Where the agent got something wrong, the fix was almost always a clearer rule, not a different model.

A Figma design routes through an AI agent (trained on the rules I wrote) and outputs a complete Evergreen table in Confluence.

The agent has a UI. Users open the plugin in a Figma frame and ask it in plain language to build an EG table. The agent confirms what it’s doing, generates the table, and asks the user to review before sending it to Confluence. The two-step pattern, review then commit, was the most-debated part of the design. We tested a one-click version. Content designers didn’t trust it. The version where the agent shows its work and waits for confirmation is what got people to actually use the tool.

Before and after, on a real frame

Take a typical password reset flow: a header, a body sentence, two form fields with labels and helper text, a CTA button, and a resend timer. Seven components, all of them shipping copy.

The same EG table, two ways. Manual entry averaged 6 to 8 hours per ticket. The agent generates a complete, tagged, Jira-linked table in under a minute.

Before: 6 to 8 hours per ticket, often blocked partway through on legal review of a single string of microcopy. The “TODO: confirm copy w/ legal” placeholder isn’t hypothetical. It was the most common reason a table sat unfinished.

After: under a minute. Every row pulls its copy from the Figma source, every component gets a tag from the agent’s vocabulary, and every Jira ticket linked to the design surfaces in the corresponding row. When design updates a button label in Figma, regenerating the table produces the new label automatically. The source of truth stays the source of truth.

Pitching it, then rolling it out

Once the prototype worked, we pitched to leadership. The case wasn’t hard to make once they saw the dashboard data: hours per ticket, before and after, on real projects. With their support, I rolled out the tool across 25 content design teams over 9 months.

Each onboarding had two parts: a walkthrough of the agent and a working session where the team ran it on one of their own projects. The political work was harder than the training work. Some teams had built their own EG conventions and were skeptical of standardizing. The way through that wasn’t to argue. It was to show them their own throughput improving in the dashboard. Teams that adopted early became the proof the next teams used to decide.

I built the measurement dashboard with our DMO and analytics partners. It tracked ticket completion time before and after the agent, broken out by team, so anyone could see whether the tool was actually doing what it claimed.

Outcomes

Measured against the pre-agent baseline:

What I learned

Three things stuck with me from this work:

The hardest part wasn’t the technical build. It was deciding to take the work on. Everyone could see the EG-table process was tedious, but it was no one’s explicit job to fix. Refusing to accept the workaround as the workflow is what made the rest of the project possible.

Writing rules for an AI is content design with a different reader. The agent’s output was only as good as the rules I wrote. The model needed to know the intent of a piece of copy, not just its surface form. Treating the model as a reader with user needs is what produced reliable output. That’s a content design instinct, not an engineering one.

The two-step generate-and-confirm pattern wasn’t an obvious choice. Teams wanted speed. Engineering wanted parameter control. I shipped the version where users could review the table before sending it to Confluence, because content designers didn’t trust a one-click flow. The conversational copy is what got 25 teams to use the tool with their actual work.