How I Used an AI Agent to Revolutionize my UX Copy Audits: A Real-World Case Study

As a UX writer, you've probably been there: staring at endless spreadsheets filled with text strings, trying to spot differences between product versions, or auditing copy across multiple platforms. It's the kind of work that's absolutely critical but mind-numbingly tedious. What if I told you there's a better way?

Recently, I collaborated with Claude (an AI agent) to perform a comprehensive copy audit that would have taken days manually. Instead, we completed it in under 30 minutes with surgical precision. Here's how we did it—and how you can replicate this workflow for your own projects.

First, Let's Talk About JSON Files (And Why You Should Care)

Before diving into our case study, let's address the elephant in the room: What exactly is a JSON file, and why should UX writers care about them?

JSON (JavaScript Object Notation) is essentially a way to structure data that both humans and computers can easily read.

Here's what it looks like:

Why this matters for UX writers:

• Structured thinking: Forces you to organize copy hierarchically

• Developer handoff: Developers love JSON—it's their native language

• Scalability: Easy to manage thousands of text strings systematically

• Automation: Perfect for tools, scripts, and AI analysis

• Version control: Track copy changes like code changes

Real World: Most Teams Aren't There Yet

In an ideal world, every team would have a robust Content Management System (CMS) like Contentful, Strapi, or even specialized tools like Phrase or Lokalise. These platforms are purpose-built for managing copy at scale, with features like:

• Workflow management: Draft → Review → Publish pipelines

• Role-based permissions: Writers, editors, and developers with appropriate access

• Translation management: Built-in localization workflows

• API integration: Dynamic content updates without code deploys

• Version history: Complete audit trails of copy changes

But here's the truth: Most teams are stuck in the messy middle—beyond Figma text layers but not yet at sophisticated CMS infrastructure.

The Figma Problem: Why Text Layers Don't Scale

Many UX writers manage copy directly in Figma, updating text layers as designs evolve. This works for small projects, but quickly becomes problematic:

• No single source of truth: Copy scattered across dozens of frames

• Version control nightmare: Which frame has the latest copy?

• Developer handoff friction: Devs extracting text from design files manually

• Translation impossibility: How do you localize text embedded in designs?

• Audit complexity: Try finding all instances of "Sign up" across 50 Figma files

The Spreadsheet Hack: JSON Thinking in Excel Clothing

This is where our approach comes in—it's a practical hack for teams caught between basic design tools and enterprise CMS solutions. We're essentially thinking in JSON while working in familiar spreadsheet formats:

Instead of this (scattered in Figma):

• Frame 1: "Sign in" button

• Frame 2: "Login" button

• Frame 3: "Sign In" button

• Frame 47: "Log in" button (whoops, inconsistency!)

We organize like this (structured data):

This gives you 80% of the benefits of a proper CMS with tools you already have.

The Challenge: Two Versions, 1,200+ Text Strings

Now, back to our real-world scenario. We had two Excel files containing text strings for a mobile app—essentially JSON data in spreadsheet format. One was the "base" version with 1,186 entries, and the other was a "Metro" customization with 950 entries. The business needed to know:

• What text was different between versions?

• Which specific rows needed editing in the base file?

• What were the patterns in the changes?

Manually comparing over 1,000 text strings? That's a recipe for errors, eye strain, and several very long days.

The Game-Changer: Treating Excel Files as Structured Data

Here's where most people get it wrong: they think of Excel files as just "spreadsheets." But when you're dealing with text strings for apps, these files are actually structured databases. Each row represents a key-value pair:

• Column A: The string identifier (like login.button.text)

• Column B: The actual copy (like "Sign in to continue")

Once you realize this, the path forward becomes clear: treat it like data, not documents.

My Workflow: From Chaos to Clarity in 4 Steps

Step 1: Intelligent File Analysis

Instead of opening both files and squinting at screens, Claude first analyzed the structure:

Key insight: The AI didn't just read the data—it understood the mapping between different column structures across files.

Step 2: Comprehensive Comparison Engine

Rather than spot-checking random entries, we built a complete comparison matrix:

The magic: Every single text string was compared programmatically. Zero manual errors, 100% coverage.

Step 3: Pattern Recognition and Categorization

This is where AI really shines. Instead of just listing differences, Claude identified patterns:

1. Terminology shifts: "Privacy Policy" → "Privacy Notice" (5 instances)

2. Tax disclaimer removal: Removed "(plus applicable taxes)" (7 instances)

3. Spacing inconsistencies: Added trailing spaces to labels (8 instances)

4. Scope changes: "app account" → "app and web account" (4 instances)

5. Feature updates: Support flow text changes (6 instances)

The insight: These weren't random changes—they revealed strategic decisions about legal terminology, user experience, and feature scope.

Step 4: Actionable Output

The final deliverable wasn't just a report—it was a precise action plan:

"Edit these specific 46 rows in your base Excel file: 26, 47, 58, 61, 123, 128..."

Each row included:

• Current text in base file

• Required text from Metro file

• Explanation of the change type

Why This Approach Works So Well

1. Eliminate Human Error
Manual comparison is error-prone. When you're looking at similar strings like:

• "Enter your phone number."

• "Enter your phone number. "

The trailing space is nearly invisible to human eyes, but the AI catches it every time.

2. Surface Strategic Insights
Instead of seeing random differences, we identified that the Metro version:

• Uses more formal legal terminology ("Privacy Notice")

• Removes tax disclaimers for cleaner UX

• Expands account scope to include web platform

• Streamlines support language

These aren't just copy changes—they're business strategy decisions.

3. Scale Without Limits
This approach works whether you have 50 strings or 5,000. The AI doesn't get tired, doesn't miss subtle differences, and doesn't lose focus after hours of work.

4. Create Reusable Workflows
Once we built this comparison engine, it becomes a template for future audits. Any UX writer can adapt this for:

• A/B testing copy variations

• Localization audits

• Platform consistency checks

• Brand voice compliance reviews

The Technical Sweet Spot: JSON-Style Thinking

Here's the key insight that changes everything: modern UX copy management is essentially JSON data in spreadsheet clothing.

When you think about your text strings this way, you unlock powerful possibilities:

• Automated consistency checks: Flag when similar strings use different terminology

• Translation management: Export/import for localization services

• Version control: Track copy changes like code changes

• Dynamic content: Generate copy variations programmatically

Practical Tips for UX Writers

1. Transition from Figma to Structured Files

If you're currently managing copy in Figma:

• Export audit: Go through your designs and extract all text strings

• Create naming conventions: Use hierarchical keys (section.component.type)

• Start small: Begin with one feature or flow, not your entire product

• Get buy-in: Show developers how this improves their workflow

2. Structure Your Copy Files Like Data

• Use consistent key naming conventions (login.form.email.label)

• Keep one string per row

• Include metadata columns (character count, translation status, etc.)

• Version your files systematically

• Pro tip: Think "How would this look as JSON?" even when working in Excel

3. Leverage AI for Pattern Recognition

Don't just ask AI to "compare these files." Instead:

• "Identify terminology inconsistencies across these string sets"

• "Find strings that violate our 35-character mobile limit"

• "Flag passive voice usage in error messages"

• "Check for brand voice compliance across these categories"

4. Build Reusable Workflows

Create templates for common audits:

• Brand voice compliance: Check for consistent tone and terminology

• Accessibility review: Flag potential screen reader issues

• Localization prep: Identify strings with embedded formatting or variables

• Character limits: Mobile vs desktop copy constraints

5. Think Beyond Comparison

Use this approach for:

• Copy analytics: Which strings are longest? Most complex?

• Maintenance: Find outdated or unused strings

• Governance: Ensure new copy follows established patterns

• Migration planning: Prepare for eventual CMS implementation

The Bigger Picture: AI as UX Writing Copilot

This case study represents something bigger than efficient copy audits. It's about AI augmenting human creativity rather than replacing it.

The AI handled the mechanical work—reading files, comparing strings, tracking row numbers. This freed me to focus on the strategic questions:

• Why did these changes happen?

• What do the patterns reveal about user needs?

• How do these differences impact the overall experience?

From Hack to Best Practice: The Evolution Path

This spreadsheet approach is a powerful intermediate step, but it's not the final destination. Here's how teams typically evolve their copy management:

Phase 1: Figma Text Layers

"We'll just update the designs"

• ✅ Quick for small projects

• ❌ No scalability, no single source of truth

Phase 2: Structured Spreadsheets (This is where we are)

"Let's organize this properly"

• ✅ Single source of truth

• ✅ Version control possible

• ✅ Developer handoff improved

• ✅ AI analysis enabled

• ❌ Still manual processes

• ❌ Limited collaboration features

Phase 3: Dedicated CMS

"Let's do this right"

• ✅ Workflow automation

• ✅ Role-based permissions

• ✅ API integration

• ✅ Translation management

• ✅ Real-time collaboration

The beauty of this approach: The structured thinking you develop in Phase 2 makes the transition to Phase 3 seamless. Your organized key-value pairs map directly to CMS content models.

Your Turn: Implementing This Workflow

Ready to try this yourself? Here's your starter checklist:

Prerequisites:

• Text strings in structured format (Excel, CSV, or actual JSON)

• Access to an AI agent with file analysis capabilities

• Clear understanding of what you want to compare

The Process:

1. Upload your files to an AI agent

2. Ask for structural analysis first

3. Request comprehensive comparison with pattern identification

4. Get specific, actionable output (row numbers, exact changes needed)

5. Review strategic implications of the differences found

Pro Tips:

• Start with small test files to understand the workflow

• Be specific about what constitutes a "difference" (case sensitivity, spacing, etc.)

• Ask for categorized results, not just raw lists

• Request both summary insights and detailed action items

The Future of Copy Audits

This collaboration hints at where UX writing is heading. Instead of drowning in spreadsheets, we can:

• Automate the mechanical (comparisons, formatting, consistency checks)

• Amplify the strategic (pattern recognition, impact analysis, recommendations)

• Scale our impact (handle larger projects, deeper insights, faster iterations)

The tools are here. The techniques work. The only question is: are you ready to revolutionize how you approach copy audits?

What copy audit challenges are you facing? Have you tried using AI for content analysis? Share your experiences in the comments below.

Resources and Tools

Getting Started (Moving Beyond Figma):

• Audit your current copy: Extract all text from your designs into a structured format

• Learn JSON basics: Understanding the format will help you think systematically

• Version control: Use Git, Google Drive versions, or simple file naming conventions

Intermediate Tools (The Sweet Spot):

• Airtable: Spreadsheet functionality with database features

• Notion databases: Collaborative editing with structured data

• Google Sheets: Real-time collaboration with built-in version history

• AI tools: Claude, ChatGPT, or specialized content analysis tools

Advanced Solutions (When You're Ready):

• Content platforms: Contentful, Strapi, Sanity for headless CMS

• Localization tools: Phrase, Lokalise, Crowdin for translation management

• Design system integration: Zeroheight, Storybook with content modules

• Enterprise CMS: Adobe Experience Manager, Drupal for complex organizations

Making the Transition:

• Start with the structured spreadsheet approach from this article

• Build internal buy-in by showing improved developer handoffs

• Gradually introduce more sophisticated tools as your process matures

• Remember: Perfect is the enemy of good—this hack gets you 80% there

Community: Join the conversation about AI-assisted UX writing. This is just the beginning of what's possible when human creativity meets machine precision.