<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Elisa Trippetti on Medium]]></title>
        <description><![CDATA[Stories by Elisa Trippetti on Medium]]></description>
        <link>https://medium.com/@elisa-trippetti?source=rss-e519c469a193------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Zn70u-WvzY4TJfY-A_VKcQ.jpeg</url>
            <title>Stories by Elisa Trippetti on Medium</title>
            <link>https://medium.com/@elisa-trippetti?source=rss-e519c469a193------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 04:07:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@elisa-trippetti/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[SOUL.md and AGENTS.md for content designers]]></title>
            <link>https://elisa-trippetti.medium.com/soul-md-and-agents-md-for-content-designers-c152c971ac58?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/c152c971ac58</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ux-writing]]></category>
            <category><![CDATA[content-design]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Fri, 30 Oct 2026 17:00:43 GMT</pubDate>
            <atom:updated>2026-10-30T18:10:17.736Z</atom:updated>
            <content:encoded><![CDATA[<h4>What I learned writing and testing agent instructions</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ttO_fWUwWn9oY-ZS" /><figcaption>Photo by <a href="https://unsplash.com/@timmossholder?utm_source=ghost&amp;utm_medium=referral&amp;utm_campaign=api-credit">Tim Mossholder</a> / <a href="https://unsplash.com/?utm_source=ghost&amp;utm_medium=referral&amp;utm_campaign=api-credit">Unsplash</a></figcaption></figure><p>I was working on how an AI assistant should structure its answers. The problem was a familiar one: users asking complex questions had to scroll to the very bottom of every answer to find the verdict. They were doing the sifting the product should have done for them.</p><p>When I asked the engineers where the changes would go, they said that either SOUL.md or AGENTS.md could work. We couldn’t be sure beforehand, so I’d have to try both and compare the results.</p><p>But wait, what even are these files?</p><p>This post is about what I’ve learned in the last few days. I used SOUL.md and AGENTS.md to turn a UX pattern into instructions and tested my approach without writing code. If you’re a content designer starting from a similar place, I hope this saves you some time.</p><p>I tested on our own AI platform, where I could attach the files to the agent and read its logs. You may not have that, so I’ll also show how to do the same in a model playground.</p><h3>What are SOUL.md and AGENTS.md?</h3><p>They’re two Markdown files that tell an AI agent how to behave in every conversation. Several agent frameworks use them. In many setups, both files are added to the top of the system instructions each time the model is called: when the user sends a message, and again after each tool it uses.</p><p><strong>SOUL.md</strong> is about identity and tone: who the agent is and how it sounds. It names the agent, says what it’s for and sets its voice. General rules: be direct and concise, reply in the user’s language. It rarely changes.</p><pre># SOUL.md<br><br>You are [Name], an AI assistant for business teams.<br>Be direct, concise and polite. Reply in the language the user writes in.<br>Say plainly when you don&#39;t know something.</pre><p><strong>AGENTS.md</strong> is for working instructions: how the agent does its job. The file usually covers how to stay accurate, how to handle files and actions, when to ask for clarification, how to structure answers and what to say when something goes wrong. It’s where an answer format belongs.</p><pre># AGENTS.md<br><br>## Accuracy<br><br>Base your answers on the data you retrieved or were given. Never invent figures or sources.<br><br>## Clarification<br><br>If a request is missing information you need, ask for all of it in one message.</pre><p>They’re typically short, a few hundred words each. Because these files end up in the same prompt, we need to make sure they don’t contradict each other. If one says “Be concise” and the other says “Always include all the context the user needs”, the model gets both and the output it generates could be inconsistent.</p><p>You’ll meet these files, or their equivalents, in a few places.</p><ul><li><strong>Open-source agent frameworks</strong>, such as OpenClaw and Hermes Agent, use SOUL.md for the agent’s personality.</li><li><strong>Many coding agents</strong>, like OpenAI Codex and Cursor, read an AGENTS.md file from the project folder.</li><li><strong>Chat products</strong> can have the same idea under other names: project instructions in Claude, custom GPTs in ChatGPT or Gems in Gemini.</li></ul><h3>Turning a UX pattern into instructions</h3><p>The model reads these instructions with every message, from “Good morning” to a complex request, and applies them literally. So when we write them, we should spell out exactly what we need.</p><p>I followed a similar process for error messages in <a href="https://medium.com/@elisa-trippetti/llm-content-design-for-ux-writers-a-day-in-the-life-6cd4e48ab0f1">AI content design for UX writers: a day in the life</a>.</p><p><a href="https://elisa-trippetti.medium.com/llm-content-design-for-ux-writers-a-day-in-the-life-6cd4e48ab0f1">AI content design for UX writers: a day in the life</a></p><p>For an answer format, it helps to work through these questions:</p><ul><li><strong>When does the format apply?</strong> Write one question the model can ask itself before answering, plus what to do in each case. For example: “Does the user want a recommendation? If yes, use [your structure]. If not, keep the reply simple and to the point.”</li><li><strong>What should each part contain?</strong> Describe what goes in each part: “Start with a summary of the key points in one to three sentences” works better than “Summary”.</li><li><strong>What should the model avoid?</strong> You can include a few short rules, such as “Don’t restate the question” and “Never invent a source”.</li></ul><p>Here’s an example:</p><pre>## Answers<br><br>Before answering, ask: is the user trying to make a decision or take action?<br><br>- Yes: start with your recommendation in one to three sentences. Then show the data behind it, with sources, and end with next steps in priority order.<br>- No: answer in one to three sentences or a short list, with no headings.<br><br>Don&#39;t restate the question. Never invent a figure to support your recommendation.</pre><p>Try to keep the instructions as short as you can. A couple of hundred extra words add a few hundred tokens to every model call. In an agent that also receives tool descriptions, files and a long conversation, that’s usually a small share. But each extra line can also conflict with the rest of the files or dilute the rules that matter most.</p><p>I ran into this when testing <a href="https://medium.com/@elisa-trippetti/can-claude-help-you-automate-your-product-docs-a5bc1e1ab9f1">Claude on product docs</a>: the model ignored some instructions, and one lesson was to put critical rules at the start or end of the prompt.</p><p><a href="https://elisa-trippetti.medium.com/can-claude-help-you-automate-your-product-docs-a5bc1e1ab9f1">Can Claude help you automate your product docs?</a></p><h3>How I tested it</h3><p>You can test instruction changes without writing code, as long as you have a method.</p><p><strong>Keep a baseline.</strong> Run the current files unchanged. Otherwise, you won’t be able to tell whether a change had any impact on the output.</p><p><strong>Change one thing at a time.</strong> I set up two versions of the agent with the same new instructions: one had them in SOUL.md, the other in AGENTS.md. Only the location changed, so any difference in the answers came from that.</p><p><strong>Write a set of test prompts and run it on each version.</strong> Use the same prompts every time, so the results are comparable. I included requests where the instructions should apply, but focused most of the set on the cases likely to go wrong. These were requests where the instructions shouldn’t apply (like greetings or quick lookups), gray areas, attempts to override the structure and vague requests where the agent should ask instead of guessing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gAc7dX5u9npQ-tatedRCrQ.png" /><figcaption>Examples from a set of test prompts</figcaption></figure><p><strong>Keep the test simple.</strong> Turn off web search and other outside sources, and put the facts the agent needs (like numbers and dates) in the prompts. Otherwise you can’t tell whether a change came from your instructions or from what the agent found.</p><p><strong>Score two aspects.</strong> For each answer, check whether it used the structure you expected and how closely it followed your instructions.</p><h4>What if you don’t have a test environment?</h4><p>Several model providers offer a playground where you can follow the same method. For example, Google AI Studio has a free plan, while Anthropic’s and OpenAI’s playgrounds charge per use.</p><ul><li>Paste SOUL.md, then AGENTS.md, into the system instructions field.</li><li>Start a new chat for each prompt. If a prompt has a follow-up question, ask it in the same chat.</li><li>Record each output and your comments in a spreadsheet. If you can export your test conversations, an AI assistant can help you review a large volume of answers faster.</li></ul><h3>What I learned</h3><p>Before any changes, the agent gave the kind of answer I expected about 50% of the time. The new instructions raised that to about 75%, whichever file they were in, and a few rounds of fixes took it above 90%.</p><p><strong>Placement mattered less than wording.</strong> We’re back to the engineers’ question: SOUL.md or AGENTS.md? Both versions performed about the same. What moved the results was rewording the instructions. That means you can choose by purpose: identity in SOUL.md, instructions on how to answer in AGENTS.md.</p><p><strong>A structure can raise the bar for answering.</strong> With a detailed format to fill, the agent started asking questions instead of answering, as if it needed more information first. What fixed most of it was telling the agent to answer with what it has, state its assumptions and ask only when it can’t help otherwise.</p><p><strong>If a rule fails three times, change the design.</strong> I tried three wordings of a rule that added a section on what’s uncertain only when something couldn’t be established. All three failed. I turned it into a short closing list of what to verify, which is often useful anyway.</p><p><strong>Formatting rules need to cover every answer.</strong> When a formatting rule applies only to some answers, the rest fall back to the model’s defaults: one answer gets large headings, the next small ones or none. Set formatting once for all answers, such as heading sizes, lists and tables, so the experience stays consistent.</p><p><strong>Every fix can create a new problem.</strong> A rule meant to fix one thing can break another in ways you don’t expect. A small formatting change, for example, can make answers open with filler instead of getting to the point. That’s why it’s worth rerunning the whole set after each change and keeping an eye on answer length.</p><h3>What to ask your engineers</h3><p>If you’ve read my post on <a href="https://medium.com/@elisa-trippetti/what-content-designers-need-to-know-about-typed-parts-1ded984f1714">typed parts</a>, some of these will sound familiar.</p><p><strong>How do the files work in our system?</strong> Ask for the exact file names and how to check the agent has picked them up. When I first uploaded mine under different names, the agent treated them as ordinary documents instead of instructions, and nothing changed.</p><p><strong>Do my files replace the defaults or add to them?</strong> If they add, old rules can contradict yours and make answers inconsistent.</p><p><strong>Which file is shared across agents, and which is specific to one?</strong> Some setups use one file for all agents in the product and a separate one for each agent. That decides where a rule belongs: one that should apply everywhere goes in the shared file, and one for a single agent or use case goes in that agent’s file.</p><p><strong>What else is in the prompt?</strong> Your files share the prompt with other instructions, such as descriptions of the tools the agent can use. Those can push the agent to behave in ways you don’t expect, so it helps to know they’re there.</p><p><strong>Can I see the logs?</strong> Conversation logs record what the agent did behind the scenes, such as the instructions it actually received and which tools it called. They can tell a content designer more about the whole interaction than the answers alone do.</p><p><strong>Is there a test copy of the agent?</strong> If there is, try your changes there before they reach real users.</p><p><strong>Can I propose changes to these files the way code changes are proposed?</strong> In most software teams, code changes go through a pull request and someone reviews them before they go live. Doing the same for these files means someone will check your wording first.</p><p><a href="https://elisa-trippetti.medium.com/what-content-designers-need-to-know-about-typed-parts-1ded984f1714">What content designers need to know about typed parts</a></p><h3>Where to start if you’re unsure</h3><p>You can start without access to your company’s agent. First, ask the engineers who maintain the agent to share its SOUL.md and AGENTS.md. If you’d rather find them yourself, ask where they’re kept: depending on the setup, they might be in a code repository or be uploaded to the platform the agent runs on.</p><p>Once you have them, read both side by side and mark anything that contradicts your content guidelines (or each other). That list alone will show you where to start, before you test anything.</p><p>When you’re ready to try a fix, a playground is the easiest option. Just keep in mind that it doesn’t have your agent’s tools or the rest of its setup, so treat what you see as a first signal.</p><h3>Still figuring this out</h3><p>This is still a work in progress, as usual. Here’s what I plan to do next, and you can do the same if you want to go further.</p><ul><li>Ask your team, and even people outside it, to use the files and share feedback on the answers. Do they notice an improvement over the baseline?</li><li>Rerun each prompt more than once, since the same prompt can get a different answer every time.</li><li>Add more of the tricky prompts where the versions behaved differently.</li><li>Once you know the most common problems and how to fix them, test more complex prompts that need real data from the web or connected tools.</li></ul><p>My main problem now is the opening line of each answer. About half of the structured answers still lead with a sentence of framing before getting to the point, and I’m looking for ways to stop that.</p><p>This will probably move slowly for me, but I’ll share anything else I learn in a future post.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c152c971ac58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What content designers need to know about typed parts]]></title>
            <link>https://elisa-trippetti.medium.com/what-content-designers-need-to-know-about-typed-parts-1ded984f1714?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ded984f1714</guid>
            <category><![CDATA[ux-writing]]></category>
            <category><![CDATA[content-design]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Sun, 27 Sep 2026 00:51:01 GMT</pubDate>
            <atom:updated>2026-09-30T19:13:15.860Z</atom:updated>
            <content:encoded><![CDATA[<h4>Writing rules for copy we don’t control: my first days in the engineers’ schema</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3neQ7T1WlSFEQNKE" /><figcaption>Photo by <a href="https://unsplash.com/@lziize?utm_source=medium&amp;utm_medium=referral">Elizabeth George</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>My team was presenting a UX proposal to a group of technical colleagues.</p><p>While I was explaining the rationale behind my writing choices, the engineering lead said that some of the fields were meant to be dynamic so they could adapt to different use cases.</p><p>He referred to these as <strong>typed parts</strong> and said they’d be controlled by guidelines rather than static copy.</p><p>The next day, I asked him to share the parts we already had. The snippet I got looks something like this:</p><pre>class Part(BaseModel):<br>    text: str | None = Field(default=None, description=&quot;Text part&quot;)<br>    code: str | None = Field(default=None, description=&quot;Code part&quot;)<br>    ...</pre><p>Several fields followed. Much of what the model sends to users in a conversation passes through them, but it was hard for me to tell which part carried what.</p><p>I spent a few days working this out with help from the machine learning team, and these are the notes I wish I’d had at the start.</p><h3>What typed parts are</h3><p>When a model replies to a user, the backend sends the answer as a sequence of pieces. Each piece carries a label saying what kind of content it is: text, a code block, a chart, a file or a link, for example.</p><p>The type is a contract between backend and frontend. The backend guarantees which types can appear and what fields each one has, and the frontend decides how each is rendered.</p><h3>Why they matter for content design</h3><p>The list of typed parts is effectively the list of things we have to write for, and the part type tells us whether we need static copy or guidelines.</p><p>For a normal screen we write and deliver the strings. This is good old UX writing as we know it: loading states, error messages, placeholders, tooltips, labels, buttons and so on.</p><p>For the parts where the model generates the content, we don’t control the exact copy users will see. Those strings aren’t deterministic and will be different every time.</p><p>So we write guidelines instead: rules about how the copy should behave, with examples of what follows a rule and what breaks it.</p><h3>What changes when copy becomes rules</h3><p>Most guidelines can start as plain Markdown: the rule, the reason for it and examples.</p><pre>### Empty results<br><br>If a search returns nothing, say so in one sentence and offer an<br>alternative. Don&#39;t apologize: the user needs a next step, not<br>reassurance.<br><br>- **Do:** No results for X. Want me to try Y?<br>- **Don&#39;t:** I&#39;m sorry, unfortunately I wasn&#39;t able to find…</pre><p>Rules like this one are broad. They cover tone, what to do when something fails and how much to explain. They mostly read like the documents we already maintain as content designers. Anyone on the team can review them and push back, which matters while the rules are still taking shape.</p><p>At some point, though, each rule will need a way to be checked. Without one there’s no way to tell whether a prompt change affected the output, and no way to hand the rules to an engineer who wants to test them.</p><p>This is the <strong>eval</strong> portion, and it’s where a more structured format helps. The examples below are written in YAML, a format that keeps each field on its own labelled line so a script can read them. We pair our rules with a criterion something or someone can score:</p><pre>- id: text-002<br>  rule: &quot;If a search returns nothing, say so in one sentence and<br>         offer an alternative. Don&#39;t apologize.&quot;<br>  negative_example: &quot;I&#39;m sorry, unfortunately I wasn&#39;t able to find…&quot;<br>  positive_example: &quot;No results for X. Want me to try Y?&quot;<br>  eval:<br>    criterion: &quot;The response states that nothing was found, without<br>                apology language, and offers a next step.&quot;<br>    type: pass_fail<br>    judge: llm</pre><p>Same rule as above, with the parts a script can read: an id, the two examples as separate fields and the criterion to score against.</p><p>There are three things we need to decide for each rule: what gets checked, how it’s scored and who scores it.</p><p><strong>What gets checked</strong> is the criterion. It should describe an observable property of the output, narrow enough that two people reading the same response would reach the same verdict. A rule you can’t turn into a criterion is usually too vague for the model to follow.</p><p><strong>How it’s scored</strong> comes down to three options:</p><ul><li>Pass/fail is for anything that’s either there or not there. For example, if the rule says a confirmation message should anticipate the consequences of a destructive action for the user and that explanation isn’t there, that’s a fail.</li><li>A 1 to 5 scale suits judgment calls like tone or clarity, provided you write anchors for at least 1, 3 and 5 and say which score counts as passing.</li><li>The third option is a regex or a small script, for literal strings and formats. It’s the cheapest to run and the least arguable, so it’s worth using wherever a rule allows it.</li></ul><pre>- id: text-007<br>  rule: &quot;Explain errors in terms of what the user can do next,<br>         not what the system did wrong internally.&quot;<br>  negative_example: &quot;The upstream provider returned a 401.&quot;<br>  positive_example: &quot;Your connection to Drive expired. Reconnect<br>                     to keep using it.&quot;<br>  eval:<br>    criterion: &quot;How actionable is the error message for a<br>                non-technical user?&quot;<br>    type: scale_1_5<br>    anchors:<br>      1: &quot;Names internal components or HTTP codes, no action given.&quot;<br>      3: &quot;Plain language, but the user has to infer the next step.&quot;<br>      5: &quot;States the cause in user terms and names one clear action.&quot;<br>    judge: llm<br>    threshold: 4</pre><p><strong>Who scores it</strong> is either a person reviewing a sample of outputs, or another model prompted with your criterion. Model-as-judge is what makes it possible to check more than a handful, and it depends on how specific the criterion is.</p><p>Handing over a concrete rule set gives people something to correct, and the corrections are often where you learn the most.</p><h3>Which format to write rules in</h3><p>Should you always prefer YAML over Markdown, then? Not necessarily. In fact, not every rule you write needs to be that specific from the beginning.</p><p>If you only have general guidelines and commentary, Markdown should be fine as a starting point. Structured material, like individual questions and their feedback, can go in YAML, because single examples can then be pulled out programmatically.</p><p>A mixed setup also works: two files, one for the broader considerations and one for the specific examples.</p><p>It’s also a question for the team that will use your file. Whatever you pick will probably change once someone tries to test the rules.</p><p>If you’ve never collaborated with your machine learning engineers this way, talk to them. Together you’ll figure out how to start and what to adjust as you go.</p><h3>What to ask your engineers</h3><p>Most of what I’ve understood so far comes from questions. These are the ones that have been most useful for me:</p><ul><li><strong>Who owns the schema?</strong> If several teams can add types, we need to know who to reach out to and how to access it.</li><li><strong>Can a part hold more than one kind of content at a time, or always exactly one?</strong> Fields are often all optional, which leaves it open. If more than one is possible, we need to know which takes precedence on screen.</li><li><strong>What shows when a part fails, expires or arrives empty?</strong> Raw backend strings can still show up in testing environments if no one manages them.</li><li><strong>Can each new type ship with a line saying what fills it and where it renders?</strong> A description is useful when it says something the type doesn’t. This way it’s easier to filter new parts as the list grows, and to understand what each one does.</li></ul><h3>Where to start if you’re unsure</h3><p>Start with the parts you already recognize in the product, rather than the ones with the clearest definitions in the code. Understanding what fills a part and where it appears is what lets you write anything real about it. Your product knowledge will really influence how solid your rule set is.</p><p>For the rest, the question I’ve found most useful is <strong>who writes the content</strong>:</p><ul><li><strong>Does the model generate it?</strong> Then it needs rules and a way to check them.</li><li><strong>Is it fixed?</strong> Then it’s UX copy you write and ship together with the design spec.</li><li><strong>Does someone else write it?</strong> If your type carries a custom module or was built by someone external, you can’t write the content or score it. What you can do is set constraints: what the component must contain, maximum lengths and what renders when one arrives malformed or empty.</li></ul><h3>Still figuring this out</h3><p>This is a work in progress for me! I still have open questions about how to write the rules, especially the YAML ones, which clients are involved and which teams I should ask.</p><p>I’ll probably write more about the topic as I continue learning. Stay tuned.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ded984f1714" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The UX writer who merged a pull request]]></title>
            <link>https://elisa-trippetti.medium.com/the-ux-writer-who-merged-a-pull-request-8d6413bd35a2?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d6413bd35a2</guid>
            <category><![CDATA[pull-request]]></category>
            <category><![CDATA[ux-writing]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[localization]]></category>
            <category><![CDATA[documentation]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Wed, 15 Jul 2026 18:48:24 GMT</pubDate>
            <atom:updated>2026-07-15T18:48:24.822Z</atom:updated>
            <content:encoded><![CDATA[<h4>How we were (quite literally) handed the keys</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6DGIh4Ak5ZOpbgAA" /><figcaption>Photo by <a href="https://unsplash.com/@dluan?utm_source=medium&amp;utm_medium=referral">Denny Luan</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>My UX writing team doesn’t write code, yet we’ve been working with GitHub for years. How does that work?</p><h3>Before</h3><h4>GitHub for software localization</h4><p>Our product is available in five languages and the copy, which we originally write in English, lives in Figma together with the designs. Once the English source is final and we’re ready to start translating, we move to Lokalise, the software we currently use to centralize localization management.</p><p>There we create and update translation keys, which are associated with one string in each of the five languages of our UI. Then we merge the project branch into the main branch and check for any conflicts.</p><p>If everything looks fine, we can export the keys to GitHub. Lokalise is connected to our product’s repository, and we have it configured so that each export opens a pull request directly on GitHub.</p><p>GitHub receives our push as a package containing five .json files, one per language. One of our lovely frontend developers then reviews, approves and merges the pull request. Each code release has its own translations, and the translations are always kept up to date across our web and mobile platforms.</p><h4>GitHub for product documentation</h4><p>Our product docs and API reference are largely prepared by technical colleagues, with UX writers acting as the editorial team. We take care of the layout, content structure, terminology, tone and style, among other things.</p><p>I’ve talked about experimenting with docs and LLMs in this post:</p><p><a href="https://elisa-trippetti.medium.com/can-claude-help-you-automate-your-product-docs-a5bc1e1ab9f1">Can Claude help you automate your product docs?</a></p><p>To work on our product docs (which we host on Docusaurus), we open and publish a new branch on GitHub, then make our changes in markdown in Visual Studio Code.</p><p>We check and commit our changes locally before pushing them to GitHub, where we create a pull request. Then a reviewer from frontend or another technical team reviews, approves and merges the pull request.</p><h3>After</h3><p>You’ve probably noticed that, in both cases, we stopped just short of closing the circle. We put in the work and covered a good portion of the workflow, but never took it end-to-end. It was always someone else who had to step in and sign off.</p><p>Thanks to our immensely patient and cooperative frontend lead, this has changed now. One morning, he just came over and said:</p><blockquote>What if I gave you folks ownership of the merge? Nobody knows the copy better than you.</blockquote><p>The same afternoon he talked with our director of engineering, and they both concluded there was no reason why we UX writers shouldn’t fully manage our own pull requests.</p><figure><img alt="A GitHub pull request title showing that the design team has been added as a co-owner for translations." src="https://cdn-images-1.medium.com/max/1024/0*_zpPGdlrvcsCSHsf.png" /><figcaption>And so it begins!</figcaption></figure><p>What made it possible?</p><p>We’ve come a long way as writers in this team. Over the last few years we’ve shown interest in trying new tools and processes, we’ve been prompt, we’ve coordinated often. I like to think we’ve earned enough trust and reached enough maturity for this to be a natural next step.</p><p>But there’s a practical reason as well: what’s a mundane, repetitive task for busy developers is added value for us in UX, as we gradually pivot into more technical roles. We take something off their plate, we gain more ownership and become independent in our software localization and product documentation work.</p><p>Now we have a deeper understanding of what happens, and we’re a lot more involved with GitHub.</p><p>Before, we’d only export the keys to Figma and link them to the designs as string variables. We’d switch between the five languages and test the multilingual experience that way. These were effectively our writing specs.</p><p>While preparing the content, we now also check how both the keys and the docs look in real time. We can review the real thing (not just the designs) in two local testing environments that frontend has helped us set up.</p><p>After the content is ready, we go through the diff in each language, edit descriptions and changesets, leave comments for others. As we do this, we can familiarize ourselves with the checks that are happening in parallel, such as the automated QA test suite and security vulnerability scans.</p><p>Then, we can finally approach the last mile ourselves: approve another writer’s pull request, merge our own, or debug and close those that don’t look right.</p><figure><img alt="An automated GitHub notification in Slack showing that the post’s author has approved a pull request." src="https://cdn-images-1.medium.com/max/1024/0*Xa_ufufJgbEtVw7K.png" /><figcaption>How exciting</figcaption></figure><p>The title of this post is inspired by <a href="https://kessler-r-sarah.medium.com/">Sarah Kessler</a>’s “The Content Designer Who Opened a Pull Request”.</p><p>Go read about all the cool content design tools she’s been vibe-coding to solve actual problems for her team.</p><p><a href="https://technology.justworks.com/the-content-designer-who-opened-a-pull-request-6c1e5a8790ce">The Content Designer Who Opened a Pull Request</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d6413bd35a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How multi-layer outsourcing undermines language talent]]></title>
            <link>https://elisa-trippetti.medium.com/how-multi-layer-outsourcing-undermines-language-talent-ab66d528018a?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab66d528018a</guid>
            <category><![CDATA[language]]></category>
            <category><![CDATA[recruitment-agencies]]></category>
            <category><![CDATA[outsourcing]]></category>
            <category><![CDATA[multilingualism]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 22:19:23 GMT</pubDate>
            <atom:updated>2026-06-29T22:19:23.734Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>There’s (still) a recruitment problem in the language sector</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VSlZ_0QbOxrgRpvr5KCD8Q.jpeg" /><figcaption><a href="https://unsplash.com/illustrations/six-colorful-emoji-faces-depict-different-emotions-prh25nRZXog?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Illustration</a> by <a href="https://unsplash.com/@anniespratt/illustrations?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Annie Spratt</a> on <a href="https://unsplash.com/illustrations?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>It’s the early days of January 2020. In less than a month, both coronavirus and Brexit will hit Europe.</p><p>I get a message in my LinkedIn inbox.</p><blockquote>Hi Elisa,</blockquote><blockquote>Came across your profile and it’s a great fit for an exciting opportunity with our client in [European city] as a [language specialist role].</blockquote><blockquote>You’d join a multicultural environment with full training, great facilities and a relocation package. Let me know if you’re interested!</blockquote><p>Yes, it’s one of those “exciting opportunities” where the “multicultural environment” is presented as a benefit rather than the norm for most international applicants.</p><p>But it’s a vulnerable time, so I choose to ignore the warning signs and reply to the message.</p><p>In the weeks that follow, I’m interviewed twice. I endure a recruiter yawning in my face without covering his mouth as I talk about my work experience.</p><p>Then, silence.</p><p>A month passes and I’m told the position has been “closed by the client”. I stay in touch with the agency anyway, but no more concrete offers come after the first one, and I just move on.</p><p><strong>Why am I embarrassing myself with this story?</strong></p><p>Because, after over six years, it keeps repeating.</p><p>A few weeks ago I was transported back in time after receiving an email that sounded suspiciously similar to the message above.</p><p>I check, and it’s a similar type of operation. It’s 2020 all over again, plus AI and a few new wars.</p><p>I compare the old message with the new email, and sadly they have many things in common. Way too many.</p><p>So, let’s go through the new email.</p><p><strong>What does an exciting opportunity look like for language talent in 2026?</strong></p><p>The candidate is willing to relocate to a different European country and start working on-site within weeks of the first contact.</p><p>The workweek is Monday to Sunday on a 24/7 schedule with rotating shifts of 8 hours, including night shifts from 10:00 PM to 7:00 AM, and two rotating days off per week.</p><p>Given all that, surely the next sentence will be about how competitive the salary is, right?</p><p>No.</p><p>The base compensation, pumped up with a generic bonus and daily meal allowance, is unlivable even by Southern European standards.</p><p>They do provide affordable accommodation for a while as part of the relocation package, but your flight will be reimbursed after six months.</p><p>There’s an additional welcome bonus that is paid in twelve monthly installments, presumably to retain new hires longer.</p><p>And the role match is perhaps even more worrying. It’s about helping patients and healthcare professionals operate a home medical device for a chronic condition.</p><p>The requirements? My native Italian, a high-school diploma and the ever-present “customer-first approach”.</p><p>Six years ago I was offered product localization and QA, so at least it was relevant to my resume. This time they’re setting me up with something that’s as high-stakes as it is random, and I’m obviously unqualified for it.</p><p>Reddit posters have reported that agencies like this are part of a <strong>multi-layer outsourcing arrangement</strong>.</p><p>The client, usually a large corporation, outsources recruitment to an international consultancy, which in turn subcontracts to regional staffing agencies.</p><p>Each intermediary takes a cut. The worker at the end of the line is left with peanuts.</p><p>Those of us who already have a few years of experience under our belt may no longer get these offers as often, or maybe we’ve just learned to automatically filter them out.</p><p>But the underlying structures are still in place, and early-career colleagues are paying the price.</p><p>Whether intentionally or due to a CRM slip, I got swept into the funnel once again, and caught a glimpse of it first-hand.</p><p>Same copy-pasted messages, same grim conditions. And even the same recipients, who are<strong> </strong>expected to uproot their lives on a whim in exchange for borderline pay, underwhelming perks and vague growth prospects.</p><p>What I see is a system built on squeezing value out of the people with the least leverage, while cutting as many corners as they can get away with.</p><p>Even the agency recruiters, who are multilingual and living abroad themselves, don’t seem too concerned about the market they help sustain, or how they’re effectively undermining other language professionals.</p><p>There’s a fundamental lack of understanding about language work at the root of these hierarchies. As long as you list a language other than English, your LinkedIn profile can be scraped and scrambled to fill an open spot in one of many locations.</p><p>Oh, you’re a native Spanish speaker? Here, take a look at this travel advisor position in Poland. You studied French at university? I bet you’ll love this opportunity to work in content moderation from Greece: it’s night shifts!</p><p>But if it gets to the point where they can’t tell the difference between entry-level back-office work and setting up medical devices, we’re all in trouble. The workers, the agency, the consultancy, the client and, most of all, <em>the patients.</em></p><p>The turnover may be high but ultimately it still works out cheaper for the client, so there’s no reason to stop or rethink the process.</p><p>Do you recognize yourself in these stories as a language professional? Have you experienced anything similar?</p><p>If so, let me know. I’d love to hear from you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab66d528018a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can Claude help you automate your product docs?]]></title>
            <link>https://elisa-trippetti.medium.com/can-claude-help-you-automate-your-product-docs-a5bc1e1ab9f1?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5bc1e1ab9f1</guid>
            <category><![CDATA[ai-writing]]></category>
            <category><![CDATA[ux-content]]></category>
            <category><![CDATA[product-documentation]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[claude-cowork]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Sat, 20 Jun 2026 19:07:04 GMT</pubDate>
            <atom:updated>2026-06-21T16:34:01.341Z</atom:updated>
            <content:encoded><![CDATA[<h4>I ran five tests. Here’s what didn’t work and how to do better next time.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rUqRXxT6mOEvNIqTjSmtcA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@simmerdownjpg?utm_source=medium&amp;utm_medium=referral">Jackson Simmer</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>My UX team has been looking for ways to automate parts of our product documentation process with AI.</p><p>In one experiment, I tested Claude Cowork with a content task: drafting a high-level overview for five different products.</p><p>The results looked promising at first. But then I realized it was all a little too good to be true.</p><h3>The goal</h3><p>“Why automation?” you might ask.</p><p>“Isn’t writing docs part of your job?” Yes, it is, and I enjoy creating support content (although not as much as writing for new features).</p><p>But there are exceptions.</p><p>Maybe you’re the sole UX writer at the company. Or maybe you’re one of many product and content designers in a growing engineering team that needs to ship faster and faster.</p><p>Wherever you stand, your time is usually better spent on more <strong>strategic</strong> activities: contributing to the product roadmap, rather than documenting it.</p><p>Sometimes, AI can actually help speed up the most time-consuming parts, like ingesting repo content, creating a layout or putting together a first draft.</p><p>When you ask an LLM to generate product docs, you’re still both the content’s <strong>owner</strong> and the <strong>editor</strong>.</p><p>You:</p><ul><li>Compare the user journey and specs against the actual implementation</li><li>Manage content <strong>structure</strong>, <strong>tone</strong> and <strong>style</strong></li><li>Make sure the content aligns with team and user <strong>goals</strong></li><li>Check that no <strong>errors</strong> or <strong>hallucinations</strong> slipped through the cracks</li><li>Involve other <strong>technical teams</strong> for support as needed</li></ul><p>In short, you need to oversee each task from start to finish and stay alert the whole time… And we’ll soon see why.</p><h3>The process, step by step</h3><p>I picked Claude Cowork as it performs better with long-context, long-form, structured content. The LLM is Opus 4.8, the latest available at the time of writing. I didn’t get to test Fable here — gone too soon!</p><p>Then I outlined the process I wanted to follow and started collecting information for my tests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*meyQXG5tDJjUtTnJ.png" /><figcaption>Sketching the steps in my process</figcaption></figure><h4>Choose relevant GitHub repos for testing</h4><p>I started looking for complex B2B or SaaS platforms that roughly compare to my product’s context.</p><p>These are the five products I settled on:</p><ul><li>A developer platform</li><li>A workflow automation SaaS</li><li>A B2B analytics SaaS</li><li>A visual AI agent builder</li><li>A low-code AI builder for agents and RAG</li></ul><p>All these products have a public repo where each product layer is separate and easy to identify (backend, frontend/UX, API surface). This should make it easier for an LLM to interpret and navigate the content.</p><p>Also, these are teams that ship frequently and have multiple active releases and changelogs.</p><h4>Select specific repo folders and files</h4><p>Within the five repos, I looked for sources like:</p><ul><li>README.md and other top-level documentation files</li><li>The /docs folder, if present</li><li>Feature-specific modules (authentication, APIs, integrations, permissions, billing)</li><li>Any SDK folders</li><li>API schemas and definitions</li><li>Code comments, types, config files</li><li>Release notes and changelogs</li></ul><p>For this test, the LLM should only generate a high-level product overview, so I was primarily interested in files like README.md, CONTRIBUTING.md, DEVELOPERS.md and any user-facing docs.</p><p>But I also wanted to keep <strong>layered ingestion </strong>in mind, with the overview being my first layer. Then, if the tests went well, I’d expand into specific features and their key modules. Finally, I’d go in depth on the actual behaviors.</p><h4>Provide guidelines</h4><p>Here, I didn’t include any proprietary guidelines on tone of voice, product terminology or UI components. I mainly wanted to see how the LLM would handle the information provided in the repos.</p><p>Here’s what I added instead:</p><ul><li><strong>Stylistic standards</strong>: language variant, capitalization, punctuation, abbreviations</li><li>The desired <strong>output format</strong> for each feature: why it exists, how it works, what the user can do, plus examples</li><li>A <strong>review checklist</strong>: only describe existing functionality, do not invent features or hallucinate details, always cross-check against schemas, flag uncertainty explicitly and suggest minimal updates rather than full rewrites</li></ul><h4>Test and review outputs</h4><p>At this point, I had everything I needed to start using Cowork.</p><p>In each of the five tests, I structured my request as follows:</p><blockquote><em>You are [technical writer persona: </em><strong><em>role</em></strong><em>, </em><strong><em>purpose</em></strong><em>, </em><strong><em>constraints</em></strong><em>].</em></blockquote><blockquote><em>Complete [</em><strong><em>task</em></strong><em>, e.g. writing a high-level product overview] to provide [</em><strong><em>target audience</em></strong><em>] with a big-picture understanding of [</em><strong><em>product</em></strong><em>].</em></blockquote><blockquote><em>Go to [</em><strong><em>GitHub repo link</em></strong><em>] and read [</em><strong><em>named folders and files</em></strong><em>]. Also, look for and include any other files that are helpful to [</em><strong><em>goal</em></strong><em>].</em></blockquote><blockquote><em>Follow [</em><strong><em>guidelines</em></strong><em>: output format, review checklist, stylistic standards].</em></blockquote><blockquote><em>Using [</em><strong><em>language</em></strong><em>, e.g. markdown], deliver a [</em><strong><em>format</em></strong><em>, e.g. .md or .mdx] file and save it to [</em><strong><em>local folder</em></strong><em>].</em></blockquote><blockquote><em>Use this example as a reference: [</em><strong><em>example</em></strong><em>].</em></blockquote><p>The writer persona, target audience, guidelines and example are four separate files I uploaded with the prompt. I also attached the team’s skill we use for product docs.</p><p>The LLM read the files and ran a few scripts. After a while, it returned the artifacts as requested, seemingly outlining everything I’d asked for.</p><p>The outputs defined how each product works, its target audience, several core features, how to get started, a few use cases and then resources, security, support and so on.</p><p>I spent some time reading through the artifacts, then went back to Cowork to introduce a QA step.</p><p>I asked the LLM to check my prompt against the outputs and answer these questions:</p><ul><li>Is everything <strong>fact-checked</strong>?</li><li>Is anything <strong>speculative</strong>?</li><li>Is anything <strong>undocumented</strong>?</li><li>Is anything <strong>outdated</strong>?</li><li>In short: have you followed all the instructions?</li></ul><h3>Where things fell apart</h3><p>The answers to those questions finally started showing the cracks.</p><p>The LLM candidly admitted to overlooking things here and there, and mishandling things here and there… in every test.</p><p><strong>Product 1: developer platform</strong></p><p>Output: 3,300 words approx.</p><ul><li>Decided to skip the /docs folder entirely</li><li>Missed an important security file</li><li>Speculated details on authentication and REST APIs</li><li>Conflated concepts on self-hosting</li><li>Couldn’t confirm what it read was current</li></ul><p><strong>Product 2: workflow automation SaaS</strong></p><p>Output: 2,500 words approx.</p><ul><li>Didn’t look beyond the named files, despite being asked to</li><li>Relied on the /docs navigation tree to write a section, but didn’t cross-check against code or schemas</li><li>Said it made up a claim about the product name, but it was actually right</li></ul><p><strong>Product 3: B2B analytics SaaS</strong></p><p>Output: 2,100 words approx.</p><ul><li>Overlooked a frontend products registry</li><li>Presented an unreleased feature as current</li><li>Got a product name wrong</li><li>Assumed two feature examples not stated in the source</li></ul><p><strong>Product 4: visual AI agent builder</strong></p><p>Output: 1,600 words approx.</p><ul><li>Didn’t verify the<strong> </strong>entire capabilities list against code or schemas</li><li>Omitted three files<strong> </strong>that would have strengthened the overview</li><li>Didn’t flag a versioning inconsistency between sources</li><li>Wrote an inaccurate example scenario on condition nodes</li></ul><p><strong>Product 5: low-code AI builder for agents and RAG</strong></p><p>Output: 2,400 words approx.</p><ul><li>Filled gaps through AI-generated search snippets (!) instead of relying on repo source files</li><li>Missed documented playground capabilities</li><li>Assumed UI labels and paths for share, API and tool access</li></ul><p>We’re talking about 1,000–3,000-word drafts that feature 3–5 prominent, repeated errors each.</p><p>But the main problem isn’t even that every single artifact comes with issues, although that’s alarming in itself.</p><p>The problem is that LLMs have <strong>structural limitations</strong> that you can’t fully overcome.</p><p>LLMs often fail to complete actions, ignore explicit instructions and deviate from the plan without letting you know.</p><p>And each time, they do so with full confidence.</p><p>LLMs optimize for appearing helpful over actually being helpful. They prioritize impressing with volume instead of adding value. It’s the illusion of efficiency.</p><p>Ask the LLM itself, and it will tell you exactly that.</p><p>All these and many more behaviors may be hard to spot if you don’t know what you’re doing.</p><h3>Lessons learned</h3><h4>Expertise</h4><p>One of the issues with running these tests with other public repos is that, as a UX writer, it’s harder to understand the full technical context I’m working with.</p><p>By contrast, within my own team I could count on an in-house engineer or developer to show me around and answer my questions.</p><p>I could use my insider knowledge of UX flows, needs and pain points. And I could rely on company subject matter experts to step in and correct any factual errors in the LLM output I’d otherwise miss.</p><h4>Chunking</h4><p>I thought drafting a high-level product overview would work as a contained unit I could manage. That’s why I treated it as my first ingestion layer.</p><p>But apparently it’s not the case, at least judging by the pattern of repeated mistakes in each test. I should probably break the task down into smaller parts.</p><p>First, I could take a few turns to evaluate the LLM’s knowledge of a certain topic against my expectations. Then, I could ask the LLM to gradually ingest the repo and verify its grasp on it. Only then would I make my first, tinier request, for example writing only the first chapter of the overview.</p><h4>Prompting</h4><p>In my tests, I named specific folders and files for the LLM to prioritize. I also explicitly asked to look for any other files within the repo that would be useful for the goal.</p><p>But since I’d also requested the LLM to work within the “provided code context”, my prompt got collapsed and a portion was outright ignored, overshadowed by later instructions.</p><p>Over time I’ve learned that I should place the most critical rules at the very start or very end of the prompt. Reiterating them in subsequent turns helps keep them in the active context window. I should have leaned more on concrete few-shot examples as well.</p><h4>Review gates</h4><p>Including only one QA step at the end wasn’t the right choice: it leaves too much room for uncertainty and I can easily lose control over what’s going on.</p><p>Along with chunking, I should have introduced a couple more review gates to make sure the LLM isn’t drifting off course, plus a final sign-off from a human expert on the most complex passages.</p><h3>Conclusions</h3><p>So, can Claude help you automate your product docs? Can any LLM, really, help you generate long-form product content?</p><p>I mean… There are several things I could have done better, for sure. But the tests went worse than I expected.</p><p>I’d say, you can give it a try if you understand the domain you’re working with, stay on top of the entire process and know which limitations you’ll run into.</p><p>Start with a small, non-critical task if you have a large volume of content to get through. Maybe have the LLM revise your draft instead of writing one from scratch, and see how it goes.</p><p>Measure whether it takes more time to spot and fix the errors than to do it all yourself. There are strategies to mitigate the risks, but you can’t eliminate failure entirely.</p><p>LLMs don’t have goals and can’t track progress against them. What looks like following a plan is them predicting what token should most likely come next. As Erik Munkby says, <a href="https://medium.com/data-dao/your-ai-agent-doesnt-care-about-your-codebase-78e0338c40ef">your AI agent doesn’t care about your codebase</a>. It doesn’t care about your product content, either.</p><p>Its job is to complete the task at hand. Your job, as the content’s owner and editor, is to deal with the complexity of maintaining a system with many moving parts.<strong> </strong>And without you being in charge, the result will look inconsistent and brittle, if not outright wrong.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5bc1e1ab9f1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI content design for UX writers: a day in the life]]></title>
            <link>https://elisa-trippetti.medium.com/llm-content-design-for-ux-writers-a-day-in-the-life-6cd4e48ab0f1?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/6cd4e48ab0f1</guid>
            <category><![CDATA[ai-writing]]></category>
            <category><![CDATA[generative-ai-use-cases]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[ux-writing]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Wed, 10 Jun 2026 23:25:58 GMT</pubDate>
            <atom:updated>2026-10-06T23:14:24.015Z</atom:updated>
            <content:encoded><![CDATA[<h4>How a UX writer and ML engineer collaborate to generate dynamic, user-facing error messages.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DxYwnMvjugcuSEr_" /><figcaption>Photo by <a href="https://unsplash.com/@adam_l_ee?utm_source=medium&amp;utm_medium=referral">ZHIDA LI</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>This project started with a nice surprise from an ML engineer.</p><p>He reached out to UX with a <strong>content problem</strong>, the kind of task that gets a product writer’s wheels spinning.</p><p>“OK, so how do I do that now?”</p><h3>Introducing the context</h3><p>Companies like OpenAI and Anthropic develop, host and provide access to LLMs. Agents use those LLMs as their reasoning engine to complete tasks, among other cool things.</p><p>When a user chats with an agent, the agent sends requests to a chosen LLM via a provider’s API. The LLM generates an output, and the agent uses that output to produce the final response for the user.</p><p>Every now and then, though, something goes wrong with an LLM provider:</p><ul><li>An API key expires — error <strong>401</strong> (Unauthorized)</li><li>You’ve sent too many requests in a short window or hit your rate limit — error <strong>429</strong> (Too many requests)</li><li>The service isn’t available due to server issues, maintenance or other reasons — error <strong>503</strong> (Service unavailable)</li></ul><p>Until recently, the conversation design solution would be heavily manual. We’d map the most frequent edge cases (the 2–3 main error codes) and prepare a fallback response to handle the rest. Rotating responses from a pool of available options was possible too.</p><p>Then we started bringing LLMs into the process.</p><h3>Understanding the use case</h3><p>The ML engineer explained that we’d have a specialized LLM generate dynamic messages based on the error’s status code and description.</p><p>This way, we would no longer need to re-work static microcopy on a case-by-case basis. Error messages would become <strong>context-sensitive</strong>, thus more relevant and timely.</p><p>But the LLM started producing outputs that were a little too obscure for the target audience. The unedited output didn’t look like something the average business user would be able to understand or act on.</p><p>That’s when the engineer came to the UX team for support. He was looking for specific instructions and examples on what the messages should and shouldn’t say, the level of detail and any style choices to follow.</p><p>So I started putting together a simple, lightweight <strong>framework</strong> that writers would be able to reuse.</p><h3>Reviewing the base output</h3><p>To start with, the engineer showed me an example of a system-generated error message.</p><p>If an API key isn’t valid, the client returns something like:</p><blockquote>Client error ‘401 Unauthorized’ for [URL]. For more information check [status code]</blockquote><p>When asked to take that error and turn it into a user-facing message, here’s what the LLM generated in three different calls:</p><blockquote>The error occurred because your request to the [LLM provider] API is missing valid authentication credentials (API key). Please verify your API key is correctly configured in the request headers.</blockquote><blockquote>The error occurred because the request to [LLM provider]’s API lacks valid authentication credentials (API key missing/incorrect).</blockquote><blockquote>The error “401 Unauthorized” indicates your request to the [LLM provider] API lacks valid authentication credentials (e.g., an API key).</blockquote><p>After seeing this, I had a clearer idea of how to make the output more effective. A lot has to do with context, clarity and flow.</p><p>First of all, this is meant to be a conversational message. But the LLM jumps straight into describing why an error occurred, without even signaling to the reader that something didn’t go as expected. It skips that step altogether.</p><p>Then, the LLM mentions the provider name. This is something business users may have never seen before. And they’re not supposed to: they’re just having a conversation with an agent. How would they know the question they asked got routed to a service that isn’t working right now?</p><p>However, an admin will get what this is about, and they have the access rights needed to look into the issue. The LLM’s message needs to address both audiences.</p><p>But even if someone is able to follow up on the message, they may receive instructions only in one out of the three calls above. This should be standardized as well.</p><p>And, to wrap up this quick overview: familiar, common words would help the average user understand what needs to be done. The error isn’t only for developers and engineers; business users should have the tools to take action too.</p><h3>Writing instructions</h3><p>It was now time to decide what to do next.</p><p>I sketched the framework to follow when reviewing LLM-generated content. Then, I started thinking about what would go in the “Instructions” container in this specific case.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*acUyX0-e9QUoz6TH.png" /><figcaption>Generating and reviewing LLM content</figcaption></figure><h4>Language</h4><p>First, I read through our style guide one-pager. The LLM already follows most of the internal editorial guidelines: language variant, grammar, syntax, spelling, punctuation, capitalization, acronyms and so on.</p><p>In this case, I wanted to strengthen the prompt with a bit about vocabulary and terminology. We should avoid overly technical terms that can confuse, alarm or break immersion for average business users.</p><p>Instead, we can state what’s wrong or missing (e.g., “API key”, “authentication details”, or the provider’s name) to guide an admin-level user in case the error is passed on to them.</p><p>However, the message shouldn’t mention the code and description string as-is (e.g., “401 Unauthorized”), as it doesn’t help non-technical users.</p><h4>Structure and content</h4><p>The error message should consist of two or three sentences at most. It should contain the following:</p><ul><li><strong>what went wrong</strong> (the first sentence or first part of the message)</li><li><strong>why</strong> (if relevant to understanding the error);</li><li><strong>how to fix it</strong> (the second sentence or last part of the message)</li></ul><h4>Context and expectations</h4><p>This is the most important portion of the instructions as it’s specific to each business and customer scenario. I’d argue this is the part that will influence the output the most.</p><p>In our case, who’s on the receiving end of the LLM-generated error message is likely a read-only user. This means they don’t have access to the product area where they can check and fix the issue.</p><p>The read-only user may not be aware of this underlying structure, but they should be able to notify an admin who can actually go and check.</p><h4>Examples</h4><p>Now for some few-shot prompting. Based on the instructions above, I provided a set of examples that the LLM can use as a reference.</p><blockquote>It looks like I can’t get to the information you need right now. This usually means the [LLM provider] API key needs updating. Ask a [role name] to check it, or try a different question in the meantime.</blockquote><blockquote>I couldn’t complete your request. The [LLM provider] authentication details on my side seem to be out of date. Have a [role name] take a look, or feel free to ask something else while this gets sorted out.</blockquote><blockquote>It seems I’m unable to access what you’re asking for at the moment. The [LLM provider] API key is likely missing or incorrect. Check with a [role name] to get it updated, or try a different question for now.</blockquote><h3>Testing and evaluating</h3><p>The ML team ran a first test applying the instructions to the <strong>401</strong> (Unauthorized) status code.<strong> </strong>Here are some examples of how the LLM responded in three different calls:</p><blockquote>It looks like I can’t complete your request right now because the [LLM provider] API key isn’t working. Ask a [role name] to update it, or try a different question in the meantime.</blockquote><blockquote>I wasn’t able to sign in to [LLM provider] to answer your question. Check if a [role name] can update the API key, or try asking something else for now.</blockquote><blockquote>I couldn’t get through to [LLM provider] just now. This usually means the API key needs updating. Ask a [role name] to check it, or try a different question while this gets resolved.</blockquote><p>Overall, the LLM followed the instructions quite closely, resulting in better output quality.</p><p>Here’s a breakdown of what worked and what to refine.</p><p><strong>What worked:</strong></p><ul><li>Style: the editorial guidelines are consistent</li><li>Value: overall, the messages are clearer and more actionable than before</li><li>Focus: the messages focus on the solution and on users who can’t access admin-only areas</li></ul><p><strong>What can be improved:</strong></p><ul><li>Content: one of the outputs seems to frame the issue as information missing on the model side, while the real cause is an authentication problem.</li><li>Structure: in the first sentence, the LLM still introduces technical concepts that a business user might find obscure or confusing (e.g., named providers or APIs). Since this is a conversational message, it could lead with a “what went wrong” introduction, then explain the solution in the following 1–2 sentences for progressive disclosure.</li><li>Length: LLM inference can produce longer outputs at times, but we can still highlight that they should be more concise.</li></ul><h3>Refining the output</h3><p>I strengthened my instructions with the points above and additional examples.</p><blockquote>It looks like I can’t reach [LLM provider] to answer your question right now. The API key probably needs updating. Ask a [role name] to check it, or try a different question in the meantime.</blockquote><blockquote>Sorry, I wasn’t able to complete your request. The [LLM provider] key I’m using doesn’t seem to be working anymore. Have a [role name] update it, or feel free to ask something else while this gets sorted out.</blockquote><blockquote>I couldn’t sign in to [LLM provider] just now, so I can’t get you that answer. This usually means the API key is out of date. Check with a [role name] to get it updated, or try a different question for now.</blockquote><p>Here’s how the LLM responded after this round.</p><blockquote>I can’t answer that right now. There seems to be a problem with the connection to the service. Ask a [role name] to update the [LLM provider] API key, or try again later.</blockquote><blockquote>Something’s not working on my end, so I can’t get you that answer. The [LLM provider] API key likely needs updating. Check with a [role name], or try a different question in the meantime.</blockquote><blockquote>I’m unable to complete your request at the moment. This usually means the [LLM provider] API key is out of date. Ask a [role name] to update it, or try again later.</blockquote><h3>Scaling the approach</h3><p>The guidelines were originally tested with the 401 error, but they’re designed to apply to similar scenarios as well.</p><p>Now that we have more solid instructions, we can extend them to the other error codes, <strong>429</strong> (Too many requests) and <strong>503</strong> (Service unavailable).</p><p>Too many requests:</p><blockquote>I can’t answer that right now. A lot of requests are coming in at once, so things are running slowly. Please wait a moment and try again.</blockquote><blockquote>I couldn’t get you an answer just now. The service is handling a high volume of requests at the moment. Give it a minute, or try a different question in the meantime.</blockquote><blockquote>Something’s holding things up right now, so I can’t complete your request. This usually clears up on its own pretty quickly. Try again in a little while.</blockquote><p>Service unavailable:</p><blockquote>I can’t answer that right now. The service is temporarily unavailable, possibly for maintenance. Please try again in a little while.</blockquote><blockquote>I’m unable to complete your request at the moment. The service seems to be down for now. Try a different question in the meantime, and let a [role name] know if it keeps happening.</blockquote><blockquote>Something’s not working right now, so I can’t get you that answer. This is usually temporary. Try again later, or let a [role name] know if it continues.</blockquote><h3>Wrapping up</h3><p>We’ve seen that it’s possible to quickly improve outputs in a limited number of iterations, then incorporate any relevant feedback until you get the desired result.</p><p>With a robust UX framework, writers can generate dynamic, contextual messages that apply to a variety of scenarios.</p><p>You already know how to maintain clear, well-structured guidelines over time. And you also understand the specific user context you’re writing for. Add close collaboration with ML engineers to the mix, and you’ll have a reusable process that scales beyond error messages.</p><p>Let me know what you think. Do you write for LLMs? How do you collaborate with ML engineers?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6cd4e48ab0f1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UX writing: from craft to commodity?]]></title>
            <link>https://elisa-trippetti.medium.com/ux-writing-from-craft-to-commodity-546d61808d8a?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/546d61808d8a</guid>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[ux-writing]]></category>
            <category><![CDATA[content-design]]></category>
            <category><![CDATA[ai-writing]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Sat, 06 Jun 2026 11:24:23 GMT</pubDate>
            <atom:updated>2026-06-12T17:28:12.655Z</atom:updated>
            <content:encoded><![CDATA[<h4>Conflicted thoughts on what we’re leaving behind, what’s changing and what may be hard to replace.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vyaOaYfG3njOxuOg" /><figcaption>Photo by <a href="https://unsplash.com/@jannesglas?utm_source=medium&amp;utm_medium=referral">Jannes Glas</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>At the beginning of 2023, I published a spec project on how to <a href="https://elisa-trippetti.medium.com/supporting-an-mvp-launch-with-content-a3ea60aa3643">support an MVP launch with content</a>.</p><p>The project came with a set of content guidelines (remember those?), which included tone of voice and editorial best practices.</p><p>I was so proud of it. And it was only three and a half years ago.</p><p>Doing something like that would be unimaginable today. I can’t think of anyone who would click on the document, read it top to bottom and then diligently go apply the guidelines. As Rita Kind-Envy rightly points out, <a href="https://uxdesign.cc/most-products-dont-need-tone-of-voice-they-need-a-point-cf37f7c752ac">tone of voice may be the least of your problems</a>.</p><p>Less than a year later, our team decided to bring writing guidelines closer to design. We created component-specific specs and embedded them in Figma.</p><p>That was actually a clever move back then. We were treating content as a system that extends beyond the page. But we no longer use it. It’s not working anymore.</p><p>Now, UX writers like me create skills for a whole host of tasks. We feed them templates, glossaries, taxonomies, audits, rubrics: things we used to write from scratch or even outsource until not long ago.</p><p>We use AI to <a href="https://elisa-trippetti.medium.com/repurpose-your-ux-content-assets-with-ai-69f4144d23bb">repurpose existing content</a>. We pair with ML engineers on prompt engineering and <a href="https://elisa-trippetti.medium.com/llm-content-design-for-ux-writers-a-day-in-the-life-6cd4e48ab0f1">LLM content design</a> tasks. Some of us write copy in a single source of truth so it can be translated dynamically.</p><p>What’s left after we’ve trained the LLM on everything we’re good at?</p><p>What happens when the tech folks and the non-writers don’t need our input anymore because they’ve already generated three variations of the deliverable on their own?</p><p>Are we just going to turn into agent orchestrators after all?</p><p>I don’t know. Since I use AI and work at an AI company, it may seem like I’ve already picked sides. Actually, I’m very conflicted.</p><p>I listen to both the doomers and the boosters. Maybe the bubble pops tomorrow. Maybe we’ve allowed AI to seep into our work life so much that we can’t come back unscathed.</p><p>But while the technology takes care of some lower-stakes, repeatable workflows, other opportunities are starting to emerge.</p><h3>UX writing is becoming more focused.</h3><p>There are a few aspects writers don’t have to worry about anymore, and honestly I’m relieved.</p><p>Capitalization. Punctuation. Revisiting brand personality every six months. And, as Kinneret Yifrah explains, <a href="https://blog.prototypr.io/breaking-the-rules-when-consistency-in-microcopy-does-more-harm-than-good-a841b23475f0">obsessing over consistency for the sake of it</a>.</p><p>These things are no longer a concern, either because a tool can easily handle them for us or because UX writing has moved past that stage.</p><p>This means we’ve freed up time for the more interesting stuff: refining user journeys, creating flowcharts that get validated by engineers, presenting UX proposals to decision-makers.</p><h3>UX writing is becoming more technical.</h3><p>We use Cursor, v0 or Claude to vibe-code mockups that would otherwise have taken days to design. We discard what doesn’t work faster, without taking bandwidth away from frontend.</p><p>On our team, we’ve quickly learned how to bring instructions and product docs to GitHub via VS Code. We open pull requests to push localization strings to developers. And we’ll soon be able to merge them too, which means owning that process end-to-end.</p><p>This is scary, even if you like all the new tools and skills you’re being exposed to. And it’s also kind of needed to stay in the industry.</p><p>Being more technical means you’re more autonomous, more in demand and part of the wider engineering team. From this position, you can continue to define and oversee how language is used across the product.</p><h3>UX writing is becoming more context-sensitive.</h3><p>Greg Petroff argues that <a href="https://gregpetroff.substack.com/p/the-feature-is-dead-the-job-remains">proprietary and user data are the two layers that make the difference</a>. Writers generally know who the customer is, what they do at their company, which devices they use our product on.</p><p>But do we actually know what these people need to get done, how hard it is for them and how they manage to get around the problem anyway?</p><p>We can fill that gap by spending more time with our internal subject matter experts, like actively inviting delivery teams and business stakeholders into the room and asking them for feedback. Or by seeking work with organizations that value and facilitate this kind of collaboration.</p><p>That domain expertise is hard to capture and translate to features for humans, let alone LLMs.</p><p>Take your knowledge of tasks and intents, and start asking questions. Combine that information with a deeper understanding of the business and user context.</p><p>The definition of “expected output” is now a lot more concrete, and it can soon turn into a user journey, a technical spec or a sequence diagram.</p><h3>UX writing is still very human.</h3><p>Every function within the product team now has the resources to learn, test and iterate faster than we ever could.</p><p>But that doesn’t mean we’re shipping more. We’re all running, but we don’t know where to.</p><p>The truth is, you can’t automate the human factor in product development. A lot of experience design still happens over conversations with engineers and customer-facing people.</p><p>Technical leads sit in meetings for hours on end. Then we, the writers and designers, bring that decision to life. More back and forth. We brainstorm. We shave things off. We merge.</p><p>And we go back to the leads, walk through our rationale, listen, get frustrated, revisit the flow until we finally come to an agreement.</p><p>If we don’t talk, and if we don’t write things down, features don’t move forward.</p><p>That’s not something the machine can easily replicate… just yet.</p><p>Let me know what you think. Is this silly? Are we doomed anyway? Should we move to the Alps and learn to make cheese instead?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=546d61808d8a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Repurpose your UX content assets with AI]]></title>
            <link>https://elisa-trippetti.medium.com/repurpose-your-ux-content-assets-with-ai-69f4144d23bb?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/69f4144d23bb</guid>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[ai-content-repurposing]]></category>
            <category><![CDATA[content-repurposing]]></category>
            <category><![CDATA[ux-content]]></category>
            <category><![CDATA[ux-writing]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Tue, 02 Jun 2026 02:18:42 GMT</pubDate>
            <atom:updated>2026-06-05T15:49:00.074Z</atom:updated>
            <content:encoded><![CDATA[<h4>The internal doc you built for one approval meeting can have a second life, and you get to own the process.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lMeuTN5OiLCznL9O" /><figcaption>Photo by <a href="https://unsplash.com/@europeana?utm_source=medium&amp;utm_medium=referral">Europeana</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I’ve been working on a new, complex B2B flow with a senior product designer. It’s an entirely new product layer with its own dedicated role.</p><p>After we finished the first version, I packaged a <strong>UX proposal</strong> that describes what users get from the feature step by step. This doc includes the flowcharts, designs, links and explanations a technical stakeholder needs from UX to get the conversation going.</p><p>It’s an important resource for us on the UX team, because it gets shared quite a bit across engineering and delivery teams. People use it to clarify behaviors, comment on requirements and agree on what we’ll be doing next.</p><p>But it’s a pity for this type of asset to sink into obscurity after we approve the flow. So I thought I’d do a little <strong>content repurposing</strong> experiment to try and extend its lifecycle.</p><p>In particular, I wanted to use this UX proposal as a starting point and instruct Claude to derive different types of content from it. Here’s how it went.</p><h3>Who needs this</h3><p>There are a few writer profiles who can benefit from this AI-enhanced approach. For example, it makes sense if you’re a UX writing freelancer or contractor <strong>managing multiple clients</strong> at once.</p><p>The same goes if you’re the <strong>sole UX writer</strong> at the company, or one of very few writers in a growing engineering team.</p><p>In general, this applies whenever the writer-to-designer <strong>ratio is off balance</strong>, meaning you divide your time among several designers and developers.</p><p>Staffing and ratios aside, this may be for you if you want to position yourself as the <strong>go-to content person</strong> on your team. You not only deliver product content, but also create the tools and frameworks that help other writers (or non-writers!) do their job a little better.</p><h3>How I did it</h3><p>To start with, I selected the three types of assets I find the most reusable based on my current work.</p><ul><li>A UX proposal <strong>template</strong></li><li>A Claude <strong>skill</strong></li><li>A multilingual <strong>taxonomy</strong></li></ul><h4>The template</h4><p>We’ve been writing a few UX proposals lately, but we hadn’t created an <strong>abstraction</strong> yet. This document has a strong <strong>repeatable</strong> structure, so it’s time to standardize it to make future proposals more consistent and easier to draft.</p><p>I asked Claude to analyze two of our most recent proposals and extract <strong>common patterns</strong>. I compared the results, chose the most relevant sections and asked Claude to rearrange and clean up the layout. I got back a markdown artifact that we can import or duplicate as a Confluence page.</p><ul><li><strong>Title</strong>: {Feature name} v{n} | {Asset type}</li><li><strong>Links</strong>: user journey, roadmap, Figma designs</li><li><strong>Intro</strong>: goal + scope, 1–2 sentences</li><li><strong>Flow</strong>: list of capabilities framed by role + flowcharts (As a {role}, you can…)</li><li><strong>Walkthrough</strong>: entry point, task sections and sub-action grouping, with explanations and captioned screenshots</li><li><strong>Edge cases</strong> and error handling</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0rfvJ7bqaIitkcEq.png" /><figcaption>Editing the UX proposal template</figcaption></figure><p>I read the output and started doing my refinements. As I went through the doc, I adjusted the language and style to sound like us, and added realistic examples for each section.</p><p>I also noticed that Claude had included an “Authoring notes” section at the bottom of the page with guidelines on how to use voice and tense, terminology, cross-references and placeholders. These instructions don’t belong in a feature-specific UX proposal, so I asked Claude to remove them from the template but set them aside for our next asset.</p><h4>The skill</h4><p>A template controls the form, but what about the substance? On our team, both writers and designers draft UX proposals. We roughly know what we want to capture, but we may get stuck along the way or miss something important.</p><p>So I thought a Claude skill would fit here.</p><p>I like building skills because they’re a great way to practice product writing to address a real problem. You get to test them right away and measure how close you can get to the desired result. If you find any gaps, you can easily course-correct and create your own list of best practices.</p><p>For this particular skill, it was natural to <strong>bundle</strong> the newly created template with the reference proposals above. I also wanted internal users to experience it as a <strong>Q&amp;A session</strong>, where the skill itself nudges you in the right direction and helps you populate the template.</p><p>When the skill is invoked or mentioned, Claude should act as follows:</p><ul><li>Analyze the <strong>user input</strong> and select the portions that are relevant to the template.</li><li>If nothing in the user input can be used to flesh out the proposal, start asking follow-up <strong>questions</strong>: feature name, version, product roles involved, scope, main tasks, links and so on.</li><li>Ask the user if they’d like to include <strong>visuals</strong> at this stage. If they don’t, offer to write a caption placeholder that summarizes each task.</li><li>Once you have everything you need, share a <strong>recap</strong> with the user and get their <strong>approval</strong> on the content before moving forward.</li><li>Apply the <strong>authoring rules</strong> on voice, grouping, captions, terminology.</li><li>Package the proposal following the <strong>structure and layout</strong> in the template and deliver it as a .md file.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Z6Eke7rVlwB9TU48.png" /><figcaption>Reviewing the skill</figcaption></figure><p>A functional skill is portable, autonomous and self-contained. It should work with the context all target users can access and understand.</p><p>Claude isn’t very good at this on the first try: it will often point to other assets mentioned earlier in the conversation. But those aren’t bundled in the skill, so the reader wouldn’t know what Claude is talking about.</p><p>I removed any out-of-place references to:</p><ul><li>Documents I considered using, but which eventually didn’t make it</li><li>Assumptions and conclusions from the conversation</li><li>Attachments like Figma embeds or pasted images</li><li>External icon libraries (Claude kept bringing them up now and then)</li></ul><h4>The taxonomy</h4><p>Our third asset is <strong>localization</strong>-specific. We can use it as a terminology <strong>source of truth</strong>, attach it as context in future agent sessions and also share it with delivery teams so they know how to introduce the feature to customers.</p><p>I asked Claude to study a <a href="https://littlelanguagemodels.com/taxonomy-spreadsheet-template/">taxonomy spreadsheet template</a> created by information architect Delfina Hoxha.</p><p>This is a very useful blueprint because it covers pretty much all the columns we need to get started localizing the feature: terms, definitions, status, usage, product area, part of speech, ownership and translations.</p><p><a href="https://littlelanguagemodels.com/taxonomy-spreadsheet-template/">How to build a taxonomy that increases conversions (Spreadsheet template) - Little Language Models</a></p><p>After that, I had Claude review my original UX proposal. My intention was to fill out the spreadsheet using my feature-specific walkthrough.</p><p>I then realized this would work a lot better if I also uploaded a multilingual glossary with confirmed terms and translations. Claude would compare and merge the concepts extracted from each asset to improve accuracy, then localize them into 4 UI languages.</p><p>While reviewing the output, I noticed a term collision, meaning that two distinct product concepts would share the same word. This is a point that should definitely be discussed with other stakeholders, so I instructed Claude to reflect the conflict more explicitly in the status, usage and product area columns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*etXIW1kAiyxbBDZsc8mM_A.png" /><figcaption>My glossary template (Lokalise export)</figcaption></figure><h3>What else I can do</h3><p>These are just three ideas I spun up from one source asset. Here are more reuse examples:</p><ul><li>A user-facing <strong>help center article</strong> (or individual modules to spread across articles). I’d pair this up with the multilingual taxonomy</li><li>A <strong>changelog</strong></li><li><strong>Release notes</strong></li><li>A <strong>testing checklist</strong> for the QA team that covers tasks, expected behaviors, edge cases and errors</li><li>A script for new <strong>onboarding emails</strong></li><li>A <strong>one-pager</strong> for business stakeholders, trimmed down to the feature’s goal, scope and main capabilities</li></ul><h3>When this works</h3><p>You always need to make sure all parties involved are on board with you using AI with their <strong>proprietary information</strong>.</p><p>Yes, I know AI mandates and tokenmaxxing are a thing (and we’ll see how long this can last). But I’ve come across creative agencies, publishers and consulting firms that are never OK with their customer data being fed to an LLM.</p><p>Also: the task needs to have a clear <strong>purpose</strong>. Just like with good old non-AI writing, you understand your goal, the target audience and the<strong> </strong>use case very well.</p><p>There’s no point in blindly increasing output if the deliverables don’t fit any real scenario. If the assets you provide are too generic or off-topic, they can’t help others do anything productive.</p><p>And one more thing: try AI repurposing if your role gives you room to own the production process <strong>end-to-end</strong>. Ideally, when you’re done iterating you should be able to monitor who can access the assets, how they’re used and what impact they have.</p><p>This is step one: repurposing the content.</p><p>But did we reuse the template, invoke the skill, share the taxonomy?</p><p>I’ll talk about how the assets are put to work in an upcoming post.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=69f4144d23bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sustainable context switching for busy UX writers]]></title>
            <link>https://elisa-trippetti.medium.com/sustainable-context-switching-for-busy-ux-writers-95d0a31b7e52?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/95d0a31b7e52</guid>
            <category><![CDATA[content-design]]></category>
            <category><![CDATA[ux-writing]]></category>
            <category><![CDATA[multitasking]]></category>
            <category><![CDATA[context-switching]]></category>
            <category><![CDATA[day-in-the-life]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Sun, 31 May 2026 14:29:33 GMT</pubDate>
            <atom:updated>2026-06-20T17:50:03.854Z</atom:updated>
            <content:encoded><![CDATA[<h4>Notes from a content person who multitasks and decided to do something about it.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3ARaQl8Z9cJAZqtG" /><figcaption>Photo by <a href="https://unsplash.com/@thisisengineering?utm_source=medium&amp;utm_medium=referral">ThisisEngineering</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>You’ve just started writing for a new flow. The flow is a small addition to an existing feature, but you need to tweak it for desktop, iOS and Android. You’re working from a short brief and you just know there’ll be a lot of questions.</p><p>At the same time, there’s another big, bad feature looming. This one has a long, detailed user journey for you to digest. The designer has started drafting flowcharts, and you’ve already spotted a few places that will require a lot of terminology research.</p><p>And that’s not all.</p><p>You’ve been off for a day and you already have a backlog. Frontend is looking for localization support, while QA raised a couple of scenarios nobody had thought of. You have to come up with quick (yet solid) fixes on the go.</p><p>As you do that, you’re also making an effort to keep multiple threads together: creating artifacts and content assets for yourself, other writers and non-writers, and making sure the output stays consistent across the product.</p><p>All the while, your company and the industry at large are nudging you to pivot, ever so steadily, into a more technical version of yourself.</p><p>I may have just described a normal day at your UX writing job. And I feel this is increasingly the reality for many of us.</p><p>More often than not, my default anxiety mode kicks in and I start pushing through by working faster. But I know this almost certainly leads to the opposite effect: it takes me more time to finish the thing. It also exposes me to more mistakes and leaves me <strong>depleted</strong> by the end of the day.</p><p>So how do you manage all this?</p><p>There are a few <strong>behaviors</strong> you can put in place to make your life less stressful during the heavier days (like when you’re approaching a deadline). Here are the accommodations that work for me.</p><h3>Understand when switching works for you</h3><p>I assume most knowledge workers would rather avoid context switching as much as they can, although that’s not always possible.</p><p>You need to factor in that at some point you’ll get distracted, lose the context you built up and then spend time recovering information before you can make your first move on the original task again. The effort to reorient yourself only leads to more stress and frustration.</p><p>And there are more variables that can come into play.</p><p>Context switching comes at a higher <strong>cognitive cost</strong> for neurodivergent writers and people with disabilities. Maybe you work in a busy office where coworkers stop by your desk all the time. Maybe you work from home while caring for young kids or an elderly parent.</p><p>Because of what life throws at you on any given day, it doesn’t look like we can choose to avoid context switching altogether.</p><p>Whatever the case, finding workspaces and practices that consistently work for you can be even harder than usual.</p><p>I’m a content person with long-standing attention problems and a tendency to multitask. In my experience, I’ve found that it’s kind of <strong>manageable</strong> with small, low-effort tasks and quick fixes in flows you’ve been following from the very start.</p><p>It <strong>doesn’t work well</strong> with deep writing sessions, complex sequences of steps you’re learning, new-feature onboarding and high-stakes, high-visibility flows that need all your attention.</p><p>That said, there’s some wiggle room, and that’s where we’ll make our adjustments.</p><h3>Listen for cues</h3><p>You never know when an interruption is going to pull you away, but you can start to pick up the signals around you.</p><p>Context switches are easier to anticipate if you observe how your workday usually develops. For example, they tend to increase or decrease based on where you are in the release cycle.</p><p>Here’s when interruptions happen the <strong>most</strong> for me:</p><ul><li>Customer-facing stakeholders share new customer needs and UX starts to flesh out user journeys</li><li>UX submits a proposal to engineering leads and feedback starts to trickle in</li><li>UX hands off a new flow to frontend, and both teams need frequent check-ins and follow-ups</li><li>A new feature goes into integration or testing, and UX supports developers and the QA team</li></ul><p>And here’s when I experience <strong>fewer</strong> distractions:</p><ul><li>Early in the morning and up to the first standup meeting</li><li>Right before and right after lunchtime</li><li>Late in the afternoon (unless we’re approaching a release)</li></ul><p>I try to plan around these windows accordingly. For example, I batch routine tasks that don’t require a lot of effort in the slots where I expect the most disruptions, and I spend more time on research, audits and drafts when things are naturally quiet.</p><p>I don’t treat this as formal time-blocking, though, since the workday is fluid and I want to stay flexible.</p><h3>Manage interruptions</h3><p>Since I can’t avoid switching altogether and can’t know exactly when the next disruption will happen, I try to make adjustments upfront. They mostly apply to long-running projects and big, complex flows, but you can test them with smaller branching tasks too.</p><p>Here’s what I do:</p><ol><li><strong>During the day</strong> — Keep a decision log</li><li><strong>Before the interruption</strong> — Write a handoff note</li><li><strong>After the interruption</strong> — Resume with a routine</li></ol><p>Let’s see what each step is about.</p><h4>Keep a decision log</h4><p>Not long ago I realized I’d fallen into the bad habit of not keeping track of my decisions during early exploration work.</p><p>For example, when collecting screens to kick off a competitor audit, I wasn’t always writing down which product the screen was taken from, which flow it was part of or what worked and what didn’t. So I ended up with a bunch of out-of-context screens in a FigJam file.</p><p>When brainstorming alternatives for a component or working through a first copy draft for a new user flow, I wasn’t documenting the rationale behind my choices. This meant that if I got distracted and then switched back to the task, I had to reconstruct my process from memory.</p><p>I found myself wasting precious time just to remember why I’d crossed a certain item off my list.</p><p>A simple decision log you <strong>update as you go</strong> can help. You can structure it as a brief or a table where you note down regular checkpoints.</p><p>Here’s a template you can adapt to your needs:</p><ul><li>Date</li><li>Project or flow</li><li>Decision</li><li>Options considered</li><li>Rationale</li><li>Technical owner</li><li>Follow-up</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zCj61mNBZJwGlXZi.png" /><figcaption>A sample decision log</figcaption></figure><p>This approach is also useful when drafting internal documentation, preparing Q&amp;A sessions or simply retracing what you did on any given day.</p><p>Also, if you’re out of office and another UX writer picks up your work, they’ll definitely find it easier to understand what’s been done before they step in.</p><h4>Write a handoff note</h4><p>Decision logs are good for organizing your day effectively and preparing for interruptions upfront. Handoff notes come into play when the interruption itself happens, or when you recognize potential warning signals.</p><p>Realistic handoff notes are <strong>quick and to the point</strong>. I usually write down the open question I’m working on and the exact place to restart.</p><p>The first point reduces my resumption lag; the second helps me locate the precise sentence where I left off among half a dozen Confluence pages and Figma tabs.</p><p>Here are some examples:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7EhlvYteCqvtZ_uM.png" /><figcaption>Sample handoff notes</figcaption></figure><p>You may not always have the luxury of a pre-switch window to write down your handoff note (“<em>Hey, let me just wrap this up and I’ll be with you in 5 minutes</em>”). If you do, give it a try; I think it does reduce the time you’ll need to get back on track afterward.</p><p>And if you don’t, there’s your fallback already in place: the decision log.</p><h4>Resume with a routine</h4><p>At this point, the thing that distracted you is taken care of; you’ve left the interruption behind and you’re now ready to switch back to the original task.</p><p>How do you collect your thoughts? How do you make restarting cheaper?</p><p>Define a <strong>re-entry checklist</strong> that works for you. If you’ve prepared upfront, you’ll notice that it’s easier to piece everything back together.</p><p>Scan the last handoff note and check if it answers these questions:</p><ul><li>Where was I exactly?</li><li>What constraints am I working with?</li><li>What am I supposed to do next?</li></ul><p>If you feel you have what you need, you can resume. If the handoff note isn’t fully clear, or you didn’t have the time to write one, re-read the last few entries in the decision log for additional context.</p><p>I know this last part may sound a bit too obvious if you don’t generally experience attention problems or restlessness, but some of us definitely benefit from fixed little rituals as we try to make multitasking more tolerable.</p><p>These were the least-annoying techniques I’ve been testing to manage interruptions and context switching.</p><p>Sure, I haven’t yet mastered every single step every single time. Some sprints are crazier than others and throw me off track. Some days, especially if I’m getting back after time off, I’m all over the place.</p><p>But I’m getting there.</p><p>I can definitely see how creating a system around my needs and shortcomings alleviates some of the stress. You can give it a try: adjust it based on how you function and how your workday looks.</p><p>I’d love to know how it goes for you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95d0a31b7e52" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to decide which feature you’ll ship next]]></title>
            <link>https://elisa-trippetti.medium.com/how-to-decide-which-feature-youll-ship-next-ffedcd82de40?source=rss-e519c469a193------2</link>
            <guid isPermaLink="false">https://medium.com/p/ffedcd82de40</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[stakeholder-management]]></category>
            <category><![CDATA[product-roadmap]]></category>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Elisa Trippetti]]></dc:creator>
            <pubDate>Sat, 30 May 2026 10:01:59 GMT</pubDate>
            <atom:updated>2026-05-30T10:01:59.959Z</atom:updated>
            <content:encoded><![CDATA[<h4>Not all the features you design will make it to release right away. Here’s how to decide what moves into development first.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lgrZAaRL9z9knI5y" /><figcaption>Photo by <a href="https://unsplash.com/@airfocus?utm_source=medium&amp;utm_medium=referral">airfocus</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>As part of the product department, your UX team is always looking ahead, researching needs and fleshing out concepts that should *hopefully* translate to new feature candidates.</p><p>At any given time, you likely have dozens of screenshots, messy diagrams, half-baked flows and unfinished designs sitting around in Figma drafts, waiting to be picked back up.</p><p>Not to mention the spreadsheets filled with user feedback from research, or the infamous Backlog™ of bugs and UI fixes.</p><p>So, how can you determine which feature ideas should make the cut? How do you prioritize the right candidates to develop?</p><p>Being on the team in charge of user experience gives you an advantage in leading this effort. You can weigh your <strong>product knowledge</strong> against the needs of both <strong>business</strong> and <strong>technical stakeholders</strong> and evaluate which ideas the organization is receptive to.</p><p>You want to be steady and efficient, but you can’t do that without enough <strong>clarity</strong>. You need to find out what matters to everybody else before getting started, or you might be blindsided when the project is already halfway through.</p><p>The goal is to align with other teams and reach a shared decision that can be implemented over the course of a few weeks.</p><p>Let’s see how to do this.</p><h3>Choose your features</h3><p>Working with your team lead, design and writing colleagues, select 3–4 improvements or projects you’ve fleshed out the most.</p><p>When I say “fleshed out”, I mean that you should try to come prepared with:</p><ul><li>The why and how</li><li>Stakeholder buy-in</li><li>Clarity on the user flow</li></ul><h4>The why and how</h4><p>You know which <strong>user problem</strong> your idea addresses and can describe how it will do so in simple terms.</p><h4>Stakeholder buy-in</h4><p>You’ve had <strong>conversations</strong> about your idea with different stakeholders, and they generally agree that implementing it would <strong>add value</strong> for the product and its users.</p><p>Perhaps it’s something that has long been in the works, but you’ve never been able to make the case for it. Taking note of which teams are familiar with your proposals and may already be on your side can help you gain more <strong>leverage</strong>.</p><h4>Clarity on the user flow</h4><p>You have a good grasp of the user flow, and perhaps even a lo-fi prototype to back it up. These are needed to help others outside the UX world <strong>visualize</strong> the process. They don’t need to be final. In fact, they’ll most likely change often as you progress.</p><p>Once you’ve made your pick, write down your feature ideas. In a couple of sentences, summarize what each feature aims to do and how. This will help bring everyone up to speed, especially those who are less involved with your line of work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*muUfhsLJp_7_T7kk.png" /><figcaption>Create a simple board to map your features</figcaption></figure><h3>Evaluate your options</h3><p>Now, set aside some time to go through these core aspects with the UX team:</p><ul><li>Business goals</li><li>Product roadmap</li><li>Technical feasibility</li><li>Resources (people and time)</li></ul><p>They’ll help you understand how much value each feature may add.</p><p>For each feature idea, write 1–2 sentences to answer the questions below to the best of your knowledge.</p><h4>Business goals</h4><p><strong>Question 1</strong>: <em>Does the feature meet our audience’s needs?</em></p><p>Your organization’s customer-facing teams may have identified a demographic that’s struggling or a segment that consistently drives more revenue. Or perhaps there’s a new type of prospect the business is interested in pursuing.</p><p>Learn more about these users, then try to understand whether your feature ideas could meet their wants and needs.</p><h4>Product roadmap</h4><p><strong>Question 2</strong>: <em>Does the feature address a shortcoming or existing problem with the product?</em></p><p>Part of your organization’s product roadmap will address legacy issues, long-standing tickets and strategic, user-reported bugs.</p><p>If you can connect one of your feature ideas to a critical task in the backlog pile, you likely have a candidate worth pursuing.</p><h4>Technical feasibility</h4><p><strong>Question 3</strong>: <em>Are we able to deliver on the technical requirements?</em></p><p>This ties back to my earlier point about setting the stage through conversations with other stakeholders. When you started exploring and researching your feature idea, you probably had a Q&amp;A session with tech teams, or perhaps they shared a preliminary list of requirements and constraints with you.</p><p>Gather the technical information you’ve received so far, review your designs and see if you can prepare an MVP proposal that aligns with both sides of the story: UX and engineering.</p><h4>Resources</h4><p><strong>Question 4</strong>: <em>Are there enough people and time to deliver the feature in the coming sprint(s)?</em></p><p>This one is pretty self-explanatory. You may have a feeling about how busy other teams are and what their day-to-day looks like. Impressions can be misleading, so it’s best to check regularly with leads and team members to see how they’re doing and if everything is on track.</p><p>After answering the questions, you might end up with something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xCgLYIydq_CA0zfj.png" /><figcaption>Capture answers for each feature</figcaption></figure><p>As you’ll have noticed, you won’t always have all the answers right away. You can speak for the UX team and give an informed opinion from your perspective, but you’ll need to check in with other stakeholders to get the <strong>full picture</strong> and figure out how to move forward.</p><p>That’s what the next step is about.</p><h3>Meet stakeholders</h3><p>Now you know where you stand on your feature ideas and can confidently argue for or against prioritizing each one.</p><p>It’s time to bring together other team representatives, hear what they think and make some decisions.</p><p>Organize a meeting with a few select leads from <strong>engineering</strong> and <strong>customer-facing roles</strong>. Think the usual suspects: front-end, back-end, security and data science (if your product requires it), but also sales, marketing, customer care and delivery.</p><p>When you’re ready to introduce your feature ideas, bring out the visual aids you’ve prepared: the user flows, the prototypes, anything that can quickly bring everybody up to speed.</p><p>Then, follow your notes to explain why you think each idea should or shouldn’t make it to the next step.</p><p>Once you finish the overview, ask everyone to express their opinion. You can even do an informal voting session to gauge the <strong>sentiment</strong>, like in a team retrospective.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iGMOlwbT5M67Zg0b.png" /><figcaption>Present and vote on your features with other teams</figcaption></figure><p>As we saw before, you might have less information about technical feasibility and available resources. This is the right time to fill in the gaps with engineering leads and understand how they feel about implementation.</p><p>If you notice pushback, suggest focusing on what’s feasible for the MVP to build momentum. You can always break down advanced requirements that need more research and save them for later increments.</p><p>By the end of the meeting, you should have a clearer idea of which features you all want to move forward with, and which ones will have to wait instead.</p><p>Record all results in a table to quickly see how the session went and make sharing easier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EYjYghiCawvxCJq9.png" /><figcaption>Document your results</figcaption></figure><h3>Next steps</h3><p>After this exercise, you’ll be aligned with important stakeholders across departments. Thanks to the materials you prepared before the meeting, you’ll also get a head start on planning the following UX activities and design sprints. You can time your tasks based on the other teams’ bandwidth and build your rationale around business and user needs as you go.</p><p>At first, reaching a consensus on the direction might be hard. As frustrating as it sounds, someone else’s opinion may end up having more weight than yours simply because of their title or seniority within the organization.</p><p>You’ll probably have disagreements or feel like you’re wasting time discussing the finer points and losing track of the bigger picture. Eventually, the group might approve a different course of action from what you had envisioned and hoped for.</p><p>What matters is not who wins the match, though. Your goal is to break down barriers and bring leadership together.</p><p>Structuring the discussion around criteria such as business goals, product roadmap, technical feasibility and resources shows you understand the variables that go into making <strong>complex decisions</strong>.</p><p>Your message is clear: <em>We know your field comes with unique challenges we may not always understand, but we care.</em></p><p>You’re introducing a good practice that will put your team on the map and increase your chances of being heard. When you show your cross-functional partners that you see them, they’ll start seeing you too.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffedcd82de40" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>