CopyCat: Comms Framework

How I got here

Porter's partner app is where India's drivers and riders run their whole workday: orders, payments, penalties, support. Partners use it on the road: in the sun's glare, one-handed, glancing for a couple of seconds between tasks. The words on screen have to land in that moment or they don't land at all.

But the app had no shared system for its words. Copy was written ad-hoc, flow by flow, by whoever built the screen, in whatever tone they had that day. Nothing tied a sentence back to the brand or to what the partner was actually trying to do.

A copywriting pass wouldn't fix that. Copy debt regenerates every time a new feature ships new strings. The real gap was upstream: the org had no system for producing partner-legible language. The goals I set against it were blunt and operational: cut the time and cost of teaching partners the app, lighten the support load, and reduce the partners who end up walking into a city office just to understand a screen.

How I thought about it

I gave myself a narrower problem than "write better copy": build a framework that derives every copy decision from brand voice, tone, user intention, and product metrics, so the answer to what should this say? comes from the system, not from whoever happens to be typing.

Before touching AI, I did the reading. UX writing versus creative writing, NN/g's findings on how people actually scan a screen, and a full audit of the partner app's current copy as a baseline. Then a competitor study across Spotify, Airbnb, Duolingo, and FedEx, pulling out reusability, story-driven copy, personalisation, mascots, and the lesson that localisation is not translation. A researcher-validated partner persona kept all of it anchored to a real reader.

The core of the framework is a tonal matrix. Porter's rebrand handed me the brand voice: Genuine, Positive, Friendly. On top of that I built a two-part tone model: a primary tone per flow, and a secondary tone per instance, kept to a small deliberate set. I mapped it across the whole app: onboarding, the seven order-lifecycle stages, and the non-order surfaces like incentives, ledger, suspension, and rewards, so every screen carried a defined tone instead of a guess. As the engine matured it locked into a fuller taxonomy: nine tones across a 158-row decision matrix spanning ten flows.

photo drops here

What I actually did

I picked up the workstream when it had stalled, ran the tone exercises with the design team, and turned the model into something usable rather than a document that sits in a folder.

Productizing it came in two steps, and the order mattered. First a custom GPT copy assistant: a system prompt, a JSON knowledge base, and the partner-persona archetype, so a designer could describe a screen and get copy that already sat inside the matrix. Early versions produced generic, could-be-any-app copy: the classic LLM failure. The fix wasn't a cleverer prompt; it was doubling down on the framework: richer screen context, tone constraints pulled straight from the matrix, and validating outputs with the designers actually using it. Simplifying language turned out to be a deeply contextual exercise: not shortening text, but aligning it with the reader's reality.

photo drops here

Then the hackathon. At Porter's company-wide AI hackathon in July 2025, the framework became the knowledge base for a Figma plugin, CopyCat, that runs the tonal matrix directly in the canvas: select a screen, and it reads the context, infers the intended tone from the matrix, and generates on-voice copy options. CopyCat itself was a team build. Teammates built and named the plugin over those two days; my part was the framework and tonal matrix it runs on. It lives on beyond the hackathon as a custom Gem, the Figma plugin, and a Firebase Studio build.

photo drops here

One framing I keep: CopyCat is the words channel of a larger communication system: text alongside icons, illustration, and motion. The matrix is what keeps the words honest.

Where it landed

The sharpest external validation: CopyCat won the productivity track of Porter's company-wide AI hackathon. That's a real signal that the framework-first approach reads as useful, not just tidy.

I'd rather be honest about the rest than invent a launch number. The logic is built and the tool is real, but it's in active test-and-improve, and broad adoption is still pending. A plugin only counts once designers reach for it inside real work, and that's the measure I'm still chasing. The operational goals I started with (less training cost, a lighter support load, fewer partners walking into an office to decode a screen) were the whole point, but I haven't captured before/after numbers on them yet.

What I carry forward

AI didn't solve the copy problem. The tonal matrix did. The AI made the matrix enforceable at scale. That ordering, framework first and model second, has become my default for every AI intervention since: the model is only as good as the system it's allowed to operate in.