Skip to content
XpansionIT
All Blogs
Custom Software and SaaS Development6 min read

Figma Can Now Edit Your Code. Should Designers Be Opening Pull Requests?

Figma's new code layers let designers pull in a GitHub repo, change the code and send it back as a pull request. It's a big step forward, and a line many teams aren't ready to cross. Here's where we land.

Afif Alamgir

Engineering lead

  • Figma code layers
  • Figma GitHub
  • designers and code
  • design to code
  • design handoff
  • product design
Figma Can Now Edit Your Code. Should Designers Be Opening Pull Requests?

What Did Figma Just Change?

Figma now lets designers work on real code without leaving the design canvas. With code layers, launched in open beta on 15 October 2026, you can import a GitHub repository onto the canvas, change it by prompting Figma's AI agent or editing the code directly, and send those changes back to GitHub as a pull request for the team to review (Figma).

That one feature reopens an old argument in every product team: who should be allowed to change the code? Designers have wanted this for years. Plenty of developers are nervous about it. We think both sides are right, and the answer depends on where you draw the line.

What Code Layers Do

Code layers are interactive, code-backed prototypes that sit on the Figma canvas next to ordinary design frames. Figma says you can create one in four ways: converting a design frame, importing a GitHub repo, capturing a live website with the Figma Chrome extension, or prompting from scratch (Figma Forum).

Alongside them, Figma announced code sources, now in closed beta. It lets you import code from GitHub repositories or npm packages so Figma's agent builds with your real components instead of inventing look-alikes.

A few practical details:

  • It's in beta. Things will change, and some features are still limited to certain plans.
  • It runs on AI credits. Creating and editing code layers is free on paid plans until 4 November 2026, then it draws on your AI credits.
  • Changes go through a pull request. Nothing lands in your main project until someone reviews and merges it.

That last point matters most, and it's where the debate really sits.

The Case For: Fewer Things Lost in Handoff

Anyone who has shipped a product knows the handoff problem. A designer spends days on spacing, states and small details. A developer rebuilds it from a static file under deadline. Somewhere along the way, the button padding changes, the hover state goes missing and the empty state never gets built. Then a round of "can you just move this four pixels" tickets begins.

Code layers attack that problem directly:

  • Designers test real behaviour, with real components and real data, not a clickable picture that only looks like the product.
  • Small visual fixes stop clogging the backlog. A spacing or copy change can arrive as a ready-made pull request instead of a ticket.
  • Prototypes become a starting point, not a throwaway. What gets approved is already code.
  • Everyone looks at the same thing, so fewer decisions get lost between the design file and the build.

For small teams in particular, where one designer sits next to one or two developers, this could save real time every week.

The Case Against: Code Is More Than What You Can See

The worry from developers isn't snobbery. A screen that looks right can still be wrong in ways nobody sees on the canvas:

  • Accessibility. Keyboard navigation, screen reader labels and focus order rarely show up in a visual review.
  • Performance and security. A change can slow a page or open a gap without changing how it looks.
  • Business logic and data. A component isn't just pixels. It may validate forms, handle payments or talk to other systems.
  • Design system drift. An AI agent that "nearly" matches your components can quietly create duplicates and one-off styles.
  • Review load. If every design tweak becomes a pull request, developers can end up spending their week reviewing instead of building.

There's also a familiar risk. Much of this editing will happen through an AI agent, and AI-written code that nobody reads closely tends to cause trouble a few months later. We wrote about that pattern in vibe coding and the bill that arrives at 90 days.

Where We Draw the Line

We build products where design and engineering sit side by side, so here's our honest position. Designers opening pull requests is a good thing, as long as the pull request is the start of a conversation, not the end of one.

ChangeDesigner opens the pull request?Developer review needed?
Copy, spacing, colour or icon tweaksYesQuick check
New layout using existing componentsYesNormal review
A new componentPrototype it, then hand overFull review and rebuild where needed
Anything touching forms, payments, logins or dataNoDeveloper-led
Accessibility-critical flowsPrototype onlyDeveloper-led, with testing

In other words: designers should own how it looks and feels, developers should own how it works, and the pull request is where the two meet.

How to Try It Without Breaking Anything

If your team wants to experiment, a few guardrails make it safe:

  • Protect your main branch so nothing merges without an approved review.
  • Run your automated tests and checks on every pull request, including accessibility checks where you can.
  • Connect your real design system through code sources or Code Connect, so the agent uses your actual components.
  • Start with a test repository or a low-risk project, not your checkout flow.
  • Agree the rules first, using a table like the one above, before the first designer pull request lands.
  • Watch your AI credit use once the free period ends, especially if several people are experimenting at once.

What This Means If You're Not a Designer

If you run a business and pay for design and development, this matters to you too. Done well, it can mean faster changes, fewer rounds of revisions and a product that matches what you approved. Done badly, it can mean a codebase full of near-duplicates that costs more to maintain later. When you're choosing a partner, it's worth asking how they handle design changes and who reviews the code. Our guide to scoping a software project before getting quotes covers the other questions worth asking.

Why This Matters to Us

We're a small Adelaide team where design and engineering work closely, so this update lands right in our day-to-day work. We like anything that stops good design getting lost in the build. We also know a pull request isn't magic: someone still has to understand what it changes. Tools like this make that conversation faster. They don't replace it.

So, Where Do You Stand?

Should designers be changing production code, or should code layers stay a prototyping tool? We'd like to hear how your team is handling it, especially if you've already tried it.

And if you're planning a product and want design and development that work as one team, see how we approach product design, or tell us what you're building. One fixed price, agreed up front, and the code is yours.

FAQ

Questions readers ask

  • What are Figma code layers?

    Code layers are interactive, code-backed prototypes that sit on the Figma canvas. You can create them from a design frame, a GitHub repo, a captured website or a prompt, then edit them with Figma's AI agent or a built-in code editor.

  • Can Figma push changes to GitHub?

    Yes. With code layers, you can import a GitHub repository, make changes in Figma, and open a pull request back to the repository so the team can review it before merging.

  • Are Figma code layers free?

    Code layers use AI credits. On paid plans, creating and editing code layers is free until 4 November 2026. The feature is in open beta.

  • Will Figma code layers replace front-end developers?

    No. They make it easier for designers to make visual changes and build realistic prototypes, but accessibility, performance, security, data and business logic still need developers, and every change still needs review.

  • Should designers edit production code?

    For small visual changes like copy, spacing and colour, yes, through a reviewed pull request. Anything touching forms, payments, logins or data should stay developer-led.

Share