I built a thing because the thing I needed stopped existing, which is how most tools get made I suppose. In this particular case, I sat staring at a prototype full of placeholder text wondering why the existing solution went dark and whether it would be faster to manually copy-paste everything or spend a weekend learning how Figma plugins work.
The weekend won.
This is a story about prototypes and placeholders and the peculiar satisfaction of building something that didn't exist in the space of a weekend in drips and drops whenever I had a few minutes to sit at my desk. It's also a story about collaboration with a machine that turned out to be just the sort of augmentation to make me really go, though I hadn't anticipated that part when I started.
The prototype in question was dense with fake data. Names that needed to be real names. Prices that needed to be real prices. Product images that needed to be actual product images instead of gray rectangles. The kind of document where you look at sixty layers and think about updating each one by hand and then you think about anything else instead.
Google Sheets Sync by Dave Williames had solved this problem once. You'd name your layers with hashtags, point the plugin at a spreadsheet, and watch the data flow into your designs. Simple and elegant. But the plugin had gone quiet, its last update years distant, and somewhere in the accumulation of Figma updates it had stopped working in the ways I needed it to work.
So there I was on a Saturday morning with a choice. Sixty layers of manual updates, or the unknown territory of Figma plugin development. I chose the unknown because the unknown at least contained the possibility of making something that might be useful again later, whereas the manual approach was just hours of my life traded for the illusion of an app, a prototype.
I opened Claude Code with the kind of uncertainty that comes from not knowing if you can actually do the thing you're about to attempt. I'd used it before for smaller tasks, but this was different. This was a full application with parsing logic and network requests and a user interface and all the complexity that implies.
The first several hours I didn't write any code at all. I wrote requirements instead. Twenty-five tickets in total, each one a discrete piece of functionality that I could imagine working if only it existed. URL parsing. Data fetching. Layer name syntax. Text synchronization. Image loading. Component swapping. Visibility and color and opacity and dimensions. Repeat frames for auto-duplication. Preview mode. Error handling. Performance optimization. Each ticket contained acceptance criteria and technical specifications and examples of how the thing should behave when it was finally real.
This turned out to be the crucial decision. The tickets became a shared language between me and Claude Code, a way to communicate intent without ambiguity. When I pointed at a ticket and said "implement this," the response came back with an understanding of what I actually wanted, not some adjacent interpretation that would require correction and clarification and all the back-and-forth that usually characterizes these conversations.
Working through the tickets became a rhythm. I'd sit at my computer for a few minutes, point Claude Code at the next ticket, and send it on its way. Then I'd leave. My son wanted to play in the snow, so we played in the snow. The floors needed vacuuming, so I vacuumed the floors. The cats required attention, so I attended to the cats. Lunch needed making, so I made lunch. And when I found another few minutes to sit down, I'd test what had been built, note any issues, and kick off the next ticket.
This is not how I imagined programming would work. The mental model I had was one of sustained concentration, hours of uninterrupted focus staring at code and thinking about logic. What I experienced instead was something more like delegating to a collaborator who happened to be very fast and very patient and very willing to implement exactly what was specified without complaint.
By Sunday evening, all twenty-five tickets were complete. Many of them on a single attempt, no revisions necessary. The plugin could parse Google Sheets URLs in all their various formats. It could fetch data and detect sheet orientation automatically. It could update text layers and load images and swap components and apply colors and toggle visibility and duplicate repeat frames to match the number of rows in a spreadsheet. It worked.
Monday I turned to polish. The functionality was there but the experience of using it needed refinement. The spacing between UI elements. The feedback when something was happening. The preview mode where you could click around your data and see which columns would map to which layers before committing to the sync. Small adjustments that made the difference between a tool that technically worked and a tool that felt good to use.
Tuesday I worked through edge cases in the form of questions. "What happens if the plugin modifies a text layer but the font for that layer is missing?" This turned out to be an excellent way to discover problems before users discovered them for me. Each question surfaced another scenario that needed handling, another potential failure mode that needed a graceful response instead of a cryptic error. The plugin learned to load fonts before modifying text, to warn when components couldn't be found, to explain when images failed to fetch.
Wednesday I created a Figma playground file. Examples of everything the plugin could do, organized so a designer could open the file and immediately understand the syntax. Text bindings and image fills and component swaps and repeat frames, all documented in a format that was also itself a demonstration. I made the community assets, wrote the descriptions, and submitted the whole thing for review.
I keep thinking about what this experience means for designers and other creative types who don't traditionally write code. The barrier to building custom tools has lowered in ways that weren't true even a year ago. The weekend that would have gone to manual updates went instead to making something that will save manual updates forever forward. Not just for me but for anyone who needs spreadsheet data in their Figma files.
Claude Code has opened my eyes to a range of possibilities. The twenty-five tickets that seemed ambitious on Saturday morning were complete by Sunday night. The polish and edge cases and documentation that would have taken another week compressed into a few more days of intermittent attention. I still don't know how to write a Figma plugin from scratch, not really, not in the way that implies I could sit down with a blank file and produce one through sustained effort. But I know how to describe what I want, and I know how to break a large problem into small pieces, and I know how to test whether something works the way I intended it to work.
Maybe that's enough. Maybe that's a new kind of enough.
The plugin is live now. The prototype that started all of this finally has real data in it. And now you'll have to excuse me, my kid wants to wrestle.
——
Links