Agent skills are the most commonly used platform by content designers right now. They're cheap, and relatively easy to make by anyone. Once they're available, any coding agent can read and use them dynamically whenever it's faced with a writing task.

According to the research, many content designers — for example at Wix, Intercom or PayFit — took the liberty of making those skills on their own, and distributing them to the rest of the organization.

The anatomy of a skill

The best skills use a concept called Progressive Disclosure, where the main SKILL.md file is short and contains the purpose, process and success criteria, while referencing other files for terminology, examples, per-surface rules and more.

This method allows the agent to pick and choose the correct references for each run, and avoids overloading the context windowEverything the model can currently "see": instructions, retrieved rules, the conversation, file contents. Finite and precious — which is why methods that select what goes in (routing, progressive disclosure) beat dumping everything. of the agent.

TipAfter writing a skill, ask your model to optimize its own files. Reducing the length of the file can help minimize context usage and optimize token costs.

Distribution

While skills are relatively easy to save and use on any computer, their distribution method does pose a challenge: since they are essentially files saved locally, they can go out of date on someone's machine without anyone noticing.

One way to overcome this challenge is saving the skill in the Claude marketplace and installing it from there. However, that ties your org's distribution to Claude: the skill format itself is an open standard that Codex and Cursor can also read, but nobody on those tools can install or update from that marketplace.

Who's using agent skills?

An MCPModel Context Protocol — an open standard that lets an AI agent call external tools and data sources. Think "USB for agents": a server exposes named tools, and any compatible agent can discover and call them. server can expose live capabilities — tools that any compatible agent (including Claude Chat or Gemini) could call in order to get information or perform an action.

Because this is a live source of truth — answers from a library or a check that can change without republishing a skill file — it is commonly used by commercial vendors like Ditto, Frontitude and Dovetail.

The shape of an MCP

MCPs can have as many tools as you want — the servers in this report run from four tools to more than forty. Every tool can do something specific, like search a term in a glossary, or get guidelines for a named component.

Each tool has a name and a description that the agent will use in order to determine what tool to call for each task. The MCP also has guidelines that help the agent understand how to use it.

MCPs are a more technical build compared to agent skills, but it's not impossible for a non-engineer to build one.

Distribution

MCPs only need to be added to the coding agent once, and then they retrieve live information forever.

However, they do tend to disconnect and require reconnection, and if it's a private MCP, you might need to find out how to handle authentication within your organization.

By late 2026 the same doorway also carried content-design jobs that are not “own the string library.” ContentRX runs one editorial review standard from chat, the editor, a pull request, and the command line. Gummble lets an agent search real shipped screens and microcopy before it invents a line. Raven is an open toolkit for voice systems and audits that name the rule and quote the broken phrase. None of those replaces a system of record like Ditto or Frontitude — they sit beside it as review, evidence, and taste checks.

Who's using agent tool servers?

A hook is a small script that your setup runs automatically at a specific point in the agent's work. The two points that matter for content are just before the agent edits a file, and the moment it decides it has finished. At either one, a hook can look at what is about to happen and stop it.

Hooks exist because agent skills are probabilistic, and the model can simply decide not to load one. A hook doesn't get that choice, which is why hooks tend to be used for the rules that have to hold every single time.

The shape of a hook

Underneath, a hook is a few lines of config that point at a script. The config says which moments to watch, and those moments have names — PreToolUse is the one that fires just before the agent edits a file, and Stop is the one that fires when it thinks it has finished. The config also says which files the hook applies to.

The script is what does the actual checking – it returns a code that tells the agent whether the change can go through, and when it can't, it sends back the reason.

{ "hooks": { "PreToolUse": [ {
      "matcher": "Edit|Write",
      "hooks": [{ "type": "command",
                  "command": "python3 .claude/check_strings.py" }]
} ] } }

For example, a config can apply the script to a file with product strings, and the script can check every edit to that file against nine mechanical rules defined by the owner of the hook. If an edit to that file fails this check, the edit will not go through.

You can also chain several hooks together. Windy Road uses four of them, each one setting up the next: the first hands the work to a voice-and-tone agent, the second blocks any edit to copy files until a review has actually happened, the third is the review agent itself, which leaves a marker to say that it ran, and the fourth deletes that marker so the next round needs a fresh review. This turns the review from something optional into something that has to happen.

Hooks are the most technical build on this list, since you're writing an actual script rather than instructions. It's worth keeping judgment out of them, because a hook should only enforce the kind of rule a script can decide with certainty.

Distribution

Hooks are easy to share, since they're just a script and a few lines of config that sit in the repo alongside the code. Anyone working in that repo gets them without having to install anything.

However, a hook only covers the door it's attached to. It runs inside the agent's session, on that machine, in that repo, so anything that arrives another way – including a person editing by hand – won't be caught by it.

Who's using hooks?

The Figma agent is the assistant that's built into Figma Design and Figma Make. Building something for it used to mean making a plugin, which meant designing a UI, hosting a backend and calling a model API. Since August 2026 there's a much lighter option: you publish a single markdown file to Figma Community, and it runs without anything to host.

This is the only platform that works on the design file rather than on code, so it can run before anything has been built. What the skill reads is the layer tree – the text, the layer names and the structure – so it's still reading a file rather than a rendered screen, the same way a coding agent reads source code.

It's also the least tested platform here, since none of the seven UX-writing skills published for it comes with any evaluation at all, so there's no evidence yet that their rules improve the copy.

The shape of a Figma skill

"The skill must be a single Markdown (.md) file that follows the Agent Skills specification. Custom skills do not support optional directories such as scripts/, references/, and assets/, which might sometimes be packaged with an agent skill."Figma Help Center, custom skills for the Figma agent

This means Progressive Disclosure isn't possible here. The short entry file that points to other reference files, which is how agent skills are usually built, can't exist on this platform. Files end up long as a result – better-interface is around 60 KB in a single file, because there's nowhere else for it to go. One published skill even asks the agent to open a references/ file that can't exist.

There's also a second limit: only the first skill mentioned in a prompt will run, so you can't ask for a writing review and an accessibility review in the same request.

This is the easiest build on the list. It's one markdown file, with no repo, no hosting and no code.

Distribution

You publish the skill to Figma Community and anyone can install it from there, with nothing to host and nothing to keep running.

A hard limit of this platform, from Coinbase’s described Figma build: checking each string on its own can still approve a broken screen. The title, body, and buttons each look fine; together they disagree. Review the frame as one experience.

However, the skill can't reach your codebase. Figma's documentation says connectors can pull in live context from tools like Notion, Drive, Slack and Asana over MCP, but none of the seven UX-writing skills currently declares one, so in practice a Figma skill only sees what's on the canvas.

Who's using Figma agent skills?

And reaching the canvas the older way, as plugins rather than agent skills:

A chat platform is a hosted assistant that you upload your style guide, glossaries and patterns into, and then people ask it questions in a chat window. The vendor takes care of the searching, the permissions and the hosting, so there's very little for you to build.

This is where most internal content tools lived between 2023 and 2025. These days it works best as a starting point, since it's a way to find out what people actually ask before you invest in putting that knowledge somewhere harder to change.

The shape of a chat assistant

You set it up in the vendor's own console rather than in code: you upload the documents, write the instructions and decide who can see what. Most of the quality comes from how well those documents are organised and labelled, which is why PayFit spent their effort on labelling documents clearly and routing each question to the right one.

Atlassian's Content Assistant is the same pattern running at full scale, with four layers of governance around it: context stores, embedded agents, risk-tiered review and feedback loops.

Two 2026 writeups show content designers owning this platform end to end. Lexi uses named review modes (copy, flow, education, support) so the assistant is asked a structural question, not only “make this nicer.” Coinbase ran a chat agent on modular prompts over a thick guideline library, then rebuilt the same rules as skill files when they needed the help inside Figma — because the chat “agent” was configuration, not something you could drop onto the canvas.

This is the least technical build on the list. If you can write a clear instruction and organise a folder of documents, you can make one.

Distribution

There's very little to distribute, since it's a URL or a Slack bot and everyone in the organization already has access to it.

However, it's a place people have to remember to visit. PayFit names this as the biggest limitation of the approach, because the tool ends up sitting outside the workflow it's supposed to support. Coinbase’s writeup is the same limitation from the other side: designers left Figma to upload a screenshot and wait, which is exactly why they tried the plugin path.

Who's using chat platforms?

A CI check runs when code is merged, and leaves comments directly on the strings it flags. A failing check can block the merge, so this is the last point at which something can be stopped before it ships — a hook can also block an edit, but only inside the agent's own session.

There are two ways to get one. You can buy it, and Ditto's GitHub bot will review the strings in a pull request against your style rules and suggest existing strings to reuse instead. Or you can wire an open-source tool into your workflow, like vale-action, slop-no-more, or cd-agency.

The shape of a CI check

A CI check is a workflow file that says what to run and when to run it, plus whatever tool does the actual checking. The tool running the CI check leaves comments on the problematic lines, and also an exit code. If the exit code is anything other than 0, it will block the entire PR from merging.

When running a CI check, the most useful thing you can do is look only at the code that actually changed. cd-agency asks the pull request which files changed and only checks those, rather than scanning the whole repository, which is what keeps a check like this fast enough to run every single time.

The cost of that is a narrow view of the product. The check sees a changed string without the screen it belongs to, so it can tell you a sentence is long without knowing that it's the only thing on an empty state.

Since the CI flow is a general tool that the whole engineering department already uses, you only need to configure your own specific check and run it inside that flow. It is relatively technical, so you might need the help of an engineer the first time.

Distribution

This has the best distribution of anything on the list. The check is committed to the repo, so it runs for everyone on every pull request, and there's nothing for anyone to install or keep up to date.

However, it runs late. By the time a pull request exists the copy is written and the design is settled, so every finding turns into rework. A hook catches things while the agent is still working, whereas CI only catches them on the way into the repository.

Who's using CI checks?

A self-hosted model is one you've trained on your own examples and run yourself. It's the only platform here that isn't configuration layered on top of somebody else's model, since the weights themselves are yours.

There's exactly one documented build of this in the whole report, which gives you a sense of how rare it is. Grounding a general model is much cheaper and far easier to update, so this is somewhere you'd go only after the other methods have stopped improving (or as a fun experiment!).

The shape of a tuned model

ux-writing-1 (June 2026) makes the economics fairly concrete: it's an open model with 27 billion parameters, QLoRAActually changing a model's weights by training on your examples. LoRA/QLoRA are cheap variants that train a small "adapter" instead of the whole model. Almost nobody in this field does it in production — grounding is cheaper and easier to update.-tuned for somewhere between $9 and $15 of compute, and served at around $0.31 per 1,000 strings. There's a version small enough to run on a laptop too.

This is the most technical build on the list by some distance, and it's the only one that needs training data rather than written rules. You need a set of inputs and approved outputs that's good enough to learn from.

Distribution

You train it once and then serve it wherever you like: a hosted endpoint, plain transformers, or a smaller build running locally on a laptop. There's nothing to install and no per-seat licence.

However, everything the model knows is frozen into the weights. Updating your style guide means training the model again, where a set of documents the model reads as it works would just get a new file added to it.

Who's using self-hosted models?