AI • PRODUCT DESIGN • ENTERPRISE UXParsel: Removing language barriers from design workflows
Parsel is an AI-assisted design tool that helps product teams understand, translate and document interfaces in languages they don't speak. The idea came from a recurring challenge in my work as a consultant on a Finnish telecom project, where I often had to navigate screens and documentation I couldn't read. I used that everyday frustration as a starting point to explore how AI could help designers make sense of unfamiliar interfaces faster.
Role
Lead designer
Focus
AI & Design Productivity
Status
Working prototype
Year
2026
About The Project
When the interface makes sense, but the language doesn’t.
Working across international product teams often means stepping into products shaped by people, markets and languages you don't fully know. The interface might be familiar, but the meaning behind its content isn't always obvious.
A designer can inspect the layout, components and interactions in a Figma file, but understanding why something is written a certain way can mean translating dozens of strings, checking them against the interface and creating documentation for others to review.
When this happens across an entire flow, language becomes an unexpected barrier to understanding the design itself.
I started Parsel from that everyday problem. Instead of treating it as a simple translation task, I wanted to explore whether AI could help designers understand the interface in context, while keeping people responsible for deciding what is correct.
The problem in practice
A typical screen might contain dozens of pieces of copy: navigation, labels, buttons, notifications, form fields, errors and help text.
To understand the screen properly, I would need to:
The problem isn’t simply that the text is in another language.
It’s that translation, context and documentation are disconnected from the design workflow.
01 Decode
Reading the interface, not just the words.
Parsel reads every text layer in a Figma frame, or a plain screenshot when Figma access isn't available, and turns each string into a typed, translated, confidence-scored item.
The experience pairs image reasoning with the text layers and positions that a Figma file provides, so each string stays anchored to the element it came from rather than being guessed.
The main challenge was resisting the urge to make the tool sound certain. Ambiguous product names, idioms and legal phrasing needed to be flagged, not confidently mistranslated.
Understanding the problem: Early versions relied purely on screenshots, asking the tool to both read the text and work out where it sat. Moving to the structure of Figma's layer data made positioning exact and let the AI focus entirely on meaning.
Shaping the experience: Translation confidence became a core part of the interface rather than a hidden technical note. High-confidence strings move straight to draft, while uncertain ones carry a note explaining why.
Making it real: Every prompt, fall back and connection message was tested agains the limits of the sandbox the prototype runs in, which blocks direct calls to external services like Figma’s API.
02 Review
Designed for handoff, built for certainty.
Every decoded string populates a documentation table with the element type, original text, English draft and status. Two features make this more than a static list:
Find it on screen instantly: Hovering a row highlights the matching text in the interface preview with a soft yellow marker over the real screenshot, instead of a vague bounding box. On a crowded screen, this saves minutes of scanning.
Documentation ready: “Copy table” pastes straight into Confluence, Word or Notion, and “Copy markdown” does the same for developer tools, so there’s no need to build a separate translation list by hand.
The review experience handles screens of any size and varying levels of certainty:
High confidence: Most strings resolve cleanly, sitting in the table as drafts ready for a quick human check.
Uncertain and flagged: Ambiguous terms get a visible note explaining what's unclear, rather than a silent guess.
No live connection: Pasting a real Figma link says plainly that the prototype can't reach Figma from its current environment, instead of faking a result.
The Result & Impact
Turning hours of manual translation into design clarity.
What began as a personal frustration with untranslatable files became a working decoding engine, an interaction model for handling uncertainty, and a refined visual identity.
Working AI core
Decoding is powered by a real AI modal that reads real screenshots, extracts the text and returns structured, confidence-scored translations.
Rapid iteration:
Refined across dozens of rounds, from a screenshot-only concept to a tool designed around Figma’s data
Clear production path:
Every simulated part of the prototype maps to a scoped next step: a Figma personal access token (the field already exists in the interface) paired with a lightweight backend.
Estimated Time Savings
Before Parsel, handling a complex screen meant opening the live file, translating string by string, cross-checking locations and building a separate table from scratch. That took about ~3 hours*.
With Parsel, I paste the frame, scan the review table and spot-check the flags, do the manual design swap, and copy the table straight to copywriting with no extra documentation step. That comes to about 1.5 hours*.
That's roughly 1–2 hours saved per screen. Across an 8–10 screen flow, it adds up to a full working day or more, moving time from manual translation into design review.
What’s next?
Moving from a working prototype to production.
Parsel shows that multimodal AI can bridge the gap in international design handoffs. The core architecture, interaction model and translation engine are in place. What remains is connecting them to real work.
The next phase bridges the gap between a standalone prototype and daily production:
Environment migration: Rebuilding the tool inside my client's development environment using GitHub Copilot.
Connecting live infrastructure: Replacing the simulated state with live API connections that pull real Figma frames directly into the workflow.
Real-world validation: Deploying the tool on active project work to test its efficiency at scale and gather concrete performance metrics.

