<?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 Max Sukach on Medium]]></title>
        <description><![CDATA[Stories by Max Sukach on Medium]]></description>
        <link>https://medium.com/@maxsukach?source=rss-5c62752dc55f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*RPbEmwZoPJUEiPWChkulBA.png</url>
            <title>Stories by Max Sukach on Medium</title>
            <link>https://medium.com/@maxsukach?source=rss-5c62752dc55f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 02:59:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@maxsukach/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[A Project-Aware Figma AI Plugin]]></title>
            <link>https://medium.com/@maxsukach/paradigma-a-project-aware-figma-ai-plugin-d0bd1fe6201d?source=rss-5c62752dc55f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0bd1fe6201d</guid>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[figma-plugin]]></category>
            <category><![CDATA[oauth]]></category>
            <dc:creator><![CDATA[Max Sukach]]></dc:creator>
            <pubDate>Fri, 07 Aug 2026 21:29:18 GMT</pubDate>
            <atom:updated>2026-08-07T21:47:20.450Z</atom:updated>
            <content:encoded><![CDATA[<h3>Case Study: A Project-Aware Figma AI Plugin</h3><h4>How design models and semantic layers turn prompting into context-aware design execution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GeV1F8pZG3xjfn94rCsleg.png" /></figure><h4>Intro</h4><p>Even in the age of <strong>AI coding</strong>, Figma still matters. Not as “a place where people draw pictures,” but as an environment for designing decisions.</p><p>Yes, code can help you prototype very fast. But for complex flows, I still need a visual map: screens, states, transitions, edge cases, empty/error/loading states. In Figma, it is faster to see the whole experience at once, compare options, move frames around, rebuild the flow, and understand where the UX breaks.</p><p>Also, a design mockups is already partly code. If it is built with components, tokens, variants, auto layout, naming, and design-system contracts, then it is not just a picture. It is a structured interface description that can be handed off to development much more precisely.</p><p>And the main point is this: in real teams, implementation is still done by developers inside an existing technical architecture, with specific languages, frameworks, quality standards, and codebase conventions.</p><p>So the designer’s job is not to replace code. The job is to prepare a high-quality, thoughtful, system-based context for implementation.</p><p>In this sense, Figma is still a bridge between product thinking, UX decisions, and production development.</p><p>That is precisely why I need a high-quality AI-assisted layout designer.</p><p>It was obvious that sooner or later <a href="https://www.figma.com/blog/the-figma-agent-is-here/"><strong>Figma</strong></a> would ship its own native AI composer. And it happened. A celebration. A miracle. AI finally lives right inside the main design tool. Hooray… hoo… ray.</p><p>But I did not build <strong>Plugin</strong> as an alternative to Figma AI. Before starting it, I tried different AI tools for Figma: well-known products, smaller experimental plugins, and open-source OpenClaw-like projects. Some of them worked better than others. Some were useful for quick actions, visual experiments, or simple generation. But for my own needs, they were not enough. But usually, these are<strong> just design fantasies</strong>.</p><p>I needed deeper project context. I needed the AI to understand not only the selected frame, but the product, the conditions, the system, the reusable patterns, the components, and the logic behind them. I wanted the composer to use design reasoning, not only visual guessing. I wanted it to be careful with existing patterns and components, instead of creating new UI from scratch every time.</p><p>So I designed Plugin as a system where design components, semantic layers, Figma context, and the code environment can speak the same language. On the semantic level, they should work almost like one virtual set of objects and entities. A button in Figma, a UI block in the catalog, a design-system rule, a token, and a future code component should not feel like separate worlds. They should be <strong>connected parts of one ecosystem</strong>.</p><p>For me, the most architectural part of this project was not the technical implementation or even the interface of the plugin itself. The real architecture was the <strong>design intelligence layer</strong>: the semantic layer through which the LLM composer captures context, reasons about it, and returns a result. This is where design models, project context, tokens, patterns, user flows, industry standards, and reusable UI blocks come together.</p><p>That is why this article is not only about building a Figma plugin. It is about building a <strong>context-aware design system around AI</strong>. A system where design is already structured enough to become prepared material for development.</p><p>And within this project, I worked on many things. So let me share some of them…</p><h3>The initial problem</h3><p>I started with a very simple question.</p><p><em>Why can AI already read Figma quite well, but still often works poorly inside Figma?</em></p><p>Not in the sense of “it gives bad answers in chat.”</p><p>I mean real product output.</p><p>When the task is not just to generate a nice-looking frame, but to keep the design system logic. To avoid breaking components. To avoid drawing a random button. To avoid turning a layout into a set of pretty rectangles with no contract.</p><p>Figma gives a lot of context. It knows pages, selection, components, variables, styles, instances, variants, and local libraries. But this context alone <strong>does not mean the model understands the product</strong>.</p><p>Most AI design flows have one weak point: the model gets a piece of canvas, a prompt, and maybe a screenshot. Then it tries to guess what is “correct.” Sometimes it gets it right. Often it does not.</p><p>I wanted to design a different approach.</p><p>Not “AI chat inside Figma.”</p><p>But a <strong>project-oriented semantic core for design</strong>. Here, the project becomes a structured context box, and AI works as an operator — not fantasist.</p><p>In other words, a system that collects context across many levels: Figma canvas, project intent, design system, design model, UI blocks, user flows, skills, prompt, artifacts, and execution rules. In the real-world design process, all of this often happens simultaneously. We are constantly making design decisions that take multimodality into account, and that’s how it should work here.</p><p>That is how I created the Paradigma Figma plugin, — as an attempt to create a <strong>multimodal design intelligence layer</strong> that takes into account your request, the project context and industry-standard design guidelines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sgi-ArqmvEKxESRCdo75nA.png" /><figcaption>Hero screenshot of the plugin in Figma: canvas on the left, Paradigma on the right with Chat open and active project/design-system context.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZGgHn7LIe7F2mrV4D1k3YQ.png" /><figcaption>Hero screenshot of the plugin in Figma: canvas on the left, Paradigma on the right with Chat open and active project/design-system context.</figcaption></figure><p>In Figma, you can already extract a lot of useful context.</p><p>You can read the selection.</p><p>You can get the page tree.</p><p>You can scan styles, variables, components, and component sets.</p><p>You can see that the user selected a specific frame, instance, or group.</p><p>At first glance, this should be enough.</p><p>But when I tried working with Figma through AI, the result was often unstable. The model could describe the current layout correctly, but then create UI that did not match the design system. Or it could use raw colors instead of tokens. Or it could reproduce the structure visually, but lose the semantics.</p><p>It feels like the difference between “seeing an interface” and “understanding a product system.”</p><p>For a designer, what is on the screen is not the only thing that matters.</p><p>What matters is why it is there.</p><p>What kind of product it is.</p><p>Who it is for.</p><p>What interface density is expected.</p><p>Which design system is connected.</p><p>Which components already exist.</p><p>Which rules must not be broken.</p><p>Which user flow this screen supports.</p><p>What type of output is needed right now: explanation, audit, proposal, canvas change, flow map, or handoff artifact.</p><p>One prompt cannot hold all of that.</p><p>Even a good prompt.</p><p>So the central idea became this: instead of one big prompt, we need a system of semantic layers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BUoHpBA0EqI89wt9QVMyuQ.png" /><figcaption>Comparison diagram: “single prompt AI” vs “semantic layers”: prompt alone versus a stack of Project, Design System, Design Model, UI Blocks, Figma Executor.</figcaption></figure><h3>The main idea: not a chat, but a semantic core</h3><p>I call this a project-oriented semantic core.</p><p>It is not a perfect name, but it describes the idea well.</p><p>At the center, there is no canvas and no LLM. At the center, there is <strong>Project</strong>.</p><p><strong>Project</strong> stores the intent: what exactly we are creating, for which platform, in which category, with which design system, with which artifacts, chats, attachments, and rules. At the end of the day — or actually at the very beginning — the PRD.</p><p>Context is collected around it.</p><p>Figma canvas gives the current state.</p><p><strong>Design System</strong> gives the materials: tokens, variables, styles, components, variants, themes, and library assets.</p><p><strong>Design Model</strong> gives the contract: principles, constraints, component policies, and validation checks.</p><p><strong>UI Blocks</strong> give structural building blocks: primitives, sections, and screens.</p><p><strong>User Flows</strong> give behavioral context: steps, states, transitions, errors, and success state.</p><p><strong>Skills</strong> give extra instructions for specific task types.</p><p><strong>Prompt</strong> gives the current user intent.</p><p><strong>Figma Executor</strong> gives the action: inspect, reason, code, execute, verify.</p><p>The result should not be just an answer. It should be an action or an artifact tied to the project.</p><p>That is the main product shift.</p><p>The plugin does not ask the model: “Make it beautiful.”</p><blockquote><em>It collects context and asks: </em><strong><em>“Given this project, this design system, this canvas, and these rules, what is the smallest correct action to take?”</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*thDqTa4bq0lUe78yxQlpSA.png" /><figcaption>Architecture diagram of the semantic core: Project in the center, surrounded by Figma Canvas, Design System, DESIGN.md, UI Blocks, Flows, Skills, Artifacts, Executor.</figcaption></figure><h3>Semantic layers of Design Plugin</h3><p>I intentionally split the system into several layers. For development. For maintenance. For understanding.</p><p>Each layer is responsible for its own type of meaning.</p><p>This matters because different types of context should not be mixed into one text blob. If you mix everything, the model gets a long prompt, but it does not get a clear decision structure.</p><h3>1. Figma Executor</h3><p>This is the operational layer.</p><p>It is responsible for interaction with the <strong>Figma Plugin API</strong>.</p><p>It has read tools: get_selection, get_page_nodes, get_node_by_id, get_pages, get_styles, get_variables, get_components.</p><p>It has write tools: creating variables, importing library variables, binding to selection, importing components/styles, and working with instance variants.</p><p>And it also has a more universal tool: run_figma_code.</p><p>This is an important part of the architecture. The Figma API is very broad. For an MVP, it is impossible to create a separate safe tool for every possible action. So you need a controlled escape hatch.</p><p>But the executor should not become “run any code without thinking.”</p><p>I designed the workflow like this:</p><ol><li>First, inspect.</li><li>Then reason.</li><li>Then code or artifact.</li><li>Then execute.</li><li>Then verify.</li></ol><p>For canvas writes, the agent should return a JSON-serializable summary: node ids, counts, names, dimensions, and status. After a write action, it should read the result back.</p><p>So the executor does not just draw. It closes the verification loop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8l3B1m1SKUtb9A7nqxQMRQ.png" /><figcaption>Flow diagram “inspect -&gt; reason -&gt; code -&gt; execute -&gt; verify -&gt; report” with examples of tools.</figcaption></figure><h3>2. Project layer</h3><p><strong>Project layer</strong> is responsible for long-term context.</p><p>This is what AI tools inside Figma usually lack.</p><p>In the product, <strong>Project</strong> consists of several things:</p><ul><li>project name;</li><li>project category;</li><li>product type;</li><li>domain;</li><li>platform;</li><li>active design system;</li><li>project brief;</li><li>project attachments;</li><li>active Design Models;</li><li>design-system bindings;</li><li>chats;</li><li>artifacts;</li><li>model settings;</li><li>execution settings.</li></ul><p><strong>Project layer</strong> exists so every new prompt does not start from zero.</p><p>If I am working on an AI agent workspace for B2B SaaS, the plugin should remember that this is not a marketing site and not a mobile game. If the active design system is focused on dense operational UI, the model should not generate a hero-like layout with large decorative blocks.</p><p>Project also solves the scope problem.</p><p>Chat history, artifacts, design models, and design-system bindings should be project-scoped. Otherwise, context from one Figma file or product can randomly affect another one.</p><p>In Figma, this is not always simple, because a public plugin does not always have a stable fileKey. So for the MVP, I use project identity through plugin data and local storage. If even that is not available, there is a fallback project, but with a warning.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f8RrYD-jyNR40nzLAaCDrQ.png" /><figcaption>Projects screen: list of recent projects, project preview sidebar with brief, platform tags, attachments, artifacts, and related chats.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cgYDJgXMX0194NV5WJZvtA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*apV2yubMcLaOAo_e2NzgtQ.png" /></figure><h3>3. Design System layer</h3><p><strong>Design System layer</strong> is responsible for the material side of design.</p><p>This is where the following live:</p><ul><li>Figma variables;</li><li>paint/text/effect/grid styles;</li><li>local components;</li><li>component sets;</li><li>instances;</li><li>published library assets;</li><li>imported variables;</li><li>themes;</li><li>token roles;</li><li>bindings.</li></ul><p>The key idea is simple: <strong>the model should not invent a button if the button already exists.</strong></p><p>It should not use raw hex if the system has a semantic token.</p><p>It should not detach an instance if the task can be solved through variant properties.</p><p>So the agent prompt has a policy:</p><p>First, inspect existing assets.</p><p>Then reuse.</p><p>Then bind.</p><p>And only if nothing fits, create the smallest possible new asset.</p><p>In the UI, this is placed in the <strong>Design Systems</strong> section. There, you can view design systems, themes, and models, scan local Figma assets, sync published libraries through the Figma OAuth service, and see counts for components, sets, styles, and variables.</p><p>This layer is important for result quality. It reduces the amount of “AI-looking UI,” where everything seems clean, but nothing is connected to the real system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GJnRenOWczwtebaqeOFG7Q.png" /><figcaption>Design Systems tab: sections for Design Systems, Themes, Models, cards with palettes, local assets scan sidebar with counts for components/styles/variables.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ltg-D-W58vP7yc9BJWKRFQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G9D7oNS-6-mLjQ02BlOCQg.png" /></figure><h3>4. Design Model layer</h3><p><strong>Design Model</strong> is not the same as Design System.</p><p>Design System gives assets.</p><p><strong>Design Model</strong> gives rules. It defines the core principles for building digital experiences and explains how to apply them.</p><p>I use **DESIGN.md** as a design-contract format. It is a Markdown document with optional frontmatter that describes design as a system of decisions.</p><p>It can include:</p><ul><li>product intent;</li><li>principles;</li><li>constraints;</li><li>semantic token policy;</li><li>component contracts;</li><li>layout rules;</li><li>responsive behavior;</li><li>accessibility checks;</li><li>validation rules;</li><li>do/don’t;</li><li>governance notes.</li></ul><p>For a human, this is documentation.</p><p>For an agent, this is a <strong>semantic-contract layer.</strong></p><p>In the prompt hierarchy, Design Model is higher than Skills and LLM Model defaults. If the active Design Model says “use semantic tokens” or “do not create custom buttons when Button component exists,” the agent should respect that before writing to the canvas.</p><p>It was important for me not to turn DESIGN.md into just another Skill.</p><p>Skill is a behavioral instruction.</p><p>Design Model is a project design contract.</p><p>It has scope, strictness, platform support, version, preview, export, activation, and validation.</p><p>In the UI, Design Model can be viewed as a live document: Overview, About, Components, Styles, Variables, DESIGN.md. Built-in models are read-only, but they can be <em>customized</em> or <em>duplicated</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4248aRyupcsiE3ijEpfUsg.png" /><figcaption>Design Model preview sidebar with the DESIGN.md tab and a live system preview next to it.</figcaption></figure><h3>5. UI Blocks layer</h3><p><strong>UI Blocks</strong> is the structural layer.</p><p>It answers the question: what semantic blocks does the interface consist of?</p><p>There are primitives, which are UI Components, and sections, which are UI Sections.</p><p>A primitive is a small unit: Button, Input, Badge, Tabs, Tooltip.</p><p>A section is a composition for a specific task: data table toolbar, settings section, onboarding step, checkout summary.</p><p>This layer helps the agent avoid starting the composition from an empty canvas.</p><p>Instead of saying “draw a dashboard,” you can give it a semantic seed: dashboard screen + table section + filter toolbar + stats cards + active Design Model.</p><p>This changes the quality a lot. The model gets not only style, but also <strong>structure</strong>.</p><p>In Composer, UI blocks can be added to context through the tab or through @mention. They are not a mandatory template, but they work as a semantic hint: “this is the type of block we should use.”</p><p>Under the hood, the composer basically has a built-in UI block auto-detector that it can reuse during an execution run.</p><p>One important detail: <strong>UI Blocks</strong> in the plugin are not a dry Markdown catalog.</p><p>They render in <strong>Preview</strong> right away.</p><p>The user can choose a <strong>primitive</strong> or a <strong>section</strong>, see its structure, variant, state, and visual behavior before the block gets into the prompt or canvas.</p><p>This turns UI Blocks into something more than a library of names. They become a <strong>live semantic inventory</strong>.</p><p>So the agent and the user work with blocks that already have form, role, structure, and an expected way of being used.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vMsMp1gEsjHYMADM_rAGwA.png" /><figcaption>UI Blocks tab and preview sidebar: primitives/sections, selected variant, Add to Chat button.</figcaption></figure><h3>6. User Flows layer</h3><p><strong>User Flows</strong> is the behavioral layer.</p><p>It describes not how one screen looks, but how the user moves through a task.</p><p>For example:</p><ul><li>onboarding;</li><li>sign up;</li><li>sign in;</li><li>permissions;</li><li>settings;</li><li>checkout;</li><li>messaging;</li><li>search;</li><li>paywall;</li><li>referral.</li></ul><p>Each <strong>Flow</strong> contains a goal, steps, required states, risks, and reference patterns.</p><p>This matters because a screen without a flow often becomes decorative.</p><p>When the agent knows we are building onboarding, it should not only think about the welcome screen. It should also consider personalization, permissions, progress, skipped state, error/retry, and the first useful action.</p><p>In the plugin, a Flow can be previewed, added to the chat composer, or exported as Markdown.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4tOw4nz-8RQJbTmCWSuThQ.png" /><figcaption>User Flows tab with categories and preview sidebar for the Onboarding flow, showing steps and states</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x9MBclj8wV7aioUeLmNnpQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ERXyABfFHOIcBz4yvKPW6g.png" /></figure><h3>7. Prompt layer</h3><p><strong>Prompt layer</strong> is not just the user’s text.</p><p>It is an instruction bundle built from several sources:</p><ul><li>base system prompt;</li><li>Figma execution flow prompt;</li><li>active Design Model;</li><li>design execution context;</li><li>connected design systems;</li><li>active skills;</li><li>tool inventory;</li><li>project context;</li><li>write examples for Figma API.</li></ul><p>The order is important.</p><p>If the order is wrong, the model may treat the <strong>design model</strong> as <strong>optional inspiration</strong>. If the order is right, it sees it as a <strong>contract</strong>.</p><p>I also added a conflict hierarchy:</p><ol><li>Safety and tool limitations.</li><li>Explicit user request.</li><li>Active Design Model.</li><li>Connected design system.</li><li>Active skills.</li><li>Model defaults.</li></ol><p>It is a small detail, but it changes the agent’s behavior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TuZxyU3gTPclWAhYFGwUow.png" /><figcaption><strong>Place for image:</strong><em> </em>prompt assembly diagram: base prompt + execution rules + design model + design system context + skills + tool inventory.</figcaption></figure><h3>8. Artifacts layer</h3><p>Not every result should be a chat message.</p><p>If the agent creates an audit, proposal, token update, flow map, or handoff checklist, it should become an artifact.</p><p>An Artifact is a reviewable object.</p><p>It has a title, summary, preview, content, status, and context refs. It can be opened in the side panel, approved, modified, or canceled.</p><p>This is important for UX.</p><p>When the model returns a long audit in chat, it gets lost very quickly. When it creates an artifact, the result becomes part of the project.</p><p>The same goes for change proposals. Before changing shared design-system assets, it is better to create an artifact with before/after, risks, and apply notes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Gs1mT-M5DU8fSfg5aarzg.png" /><figcaption>Chat with an artifact message card and an open Artifact Panel with actions: Approve, Modify, Cancel.</figcaption></figure><p>I designed the plugin around scenarios, not around a list of features.</p><p>It was important to me that every function matched real work done by a designer or design engineer.</p><h4>Scenario 1. Explain the current canvas</h4><p>The user selects a frame or several layers and asks:</p><p>“What is happening here?”</p><p>The plugin reads the selection, ancestors, page name, node types, preview image, and can answer in the project context.</p><p>This is a basic scenario, but it is critical.</p><p>Without it, the agent starts hallucinating.</p><p>I wanted the agent to first understand: this is a frame, component instance, group, button, settings page, or table section. Only then should it answer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3uu7h6B5pWv_tJ1FfY8PmA.png" /><figcaption>Selected frame in Figma and Chat reply where the agent explains the structure of the selection.</figcaption></figure><h4>Scenario 2. Create or change a screen</h4><p>This is the most obvious scenario.</p><p>The user asks:</p><p>“Create a dashboard screen for this project.”</p><p>Or:</p><p>“Redesign this selected frame for mobile.”</p><p>But the important part is not the generation itself.</p><p>The important part is which sources participate in the generation.</p><p>The agent should consider Project, selected platform, Design Model, design-system bindings, UI Blocks, User Flow, attachments, and prompt.</p><p>If a selected frame already exists, a broad redesign should not overwrite it without a reason. A safer option is to create a proposal or a variant next to the original.</p><p>This is a product decision, not a small technical detail.</p><p>In design, it is very easy to lose work. So the default should be conservative.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ySUNsgh4AmQ6w5Port5lCQ.png" /><figcaption>Two frames next to each other: original and generated variant, with labels and the same top alignment.</figcaption></figure><h4>Scenario 3. Review and audit</h4><p><strong>Review mode</strong> starts as read-only.</p><p>The agent should find problems in hierarchy, layout, spacing, accessibility, naming, auto-layout, token usage, and component reuse.</p><p>The result is better as an artifact of type frame_audit.</p><p>It can include severity, affected nodes, issue, and suggested fix.</p><p>This is not “criticism for the sake of criticism.”</p><p>It is a way to make design actionable.</p><p>Especially for handoff.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Rb03hI7TPPMIiiriZ68Rg.png" /></figure><h4>Scenario 4. Work with Design System assets</h4><p>This scenario was one of the main ones.</p><p>Figma design systems already exist in files and team libraries. The plugin should not ignore them. It should use them.</p><p>It can scan local variables, styles, components, and component sets.</p><p>It can work with enabled team libraries through the Figma teamLibrary API.</p><p>It can import variables by key.</p><p>It can bind a variable to selection.</p><p>It can import a component, component set, or style by key.</p><p>It can inspect instance variants and set variant properties.</p><p>This moves AI from “draw something similar” mode into “work with the system” mode.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*00QBmObPokchnmwHNKIczw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tpgI5idvMQ5a54GmyrQB1g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ia_ALubwN2q0RsIm2PDb8g.png" /></figure><h4>Scenario 5. Validate design against Design Model</h4><p>If a project has an active DESIGN.md, the user can ask:</p><p>“Validate this selection against the design model.”</p><p>Here, the result should not be a general opinion.</p><p>It should be structured:</p><ul><li>pass, warn, or fail;</li><li>rule;</li><li>affected node;</li><li>message;</li><li>suggested fix.</li></ul><p>For example:</p><p>“Fill uses raw RGB close to semantic token, but is not bound to a Figma variable.”</p><p>Or:</p><p>“Button-like frame exists while Button component is available.”</p><p>This is the moment when Design Model stops being documentation and becomes a working tool.</p><h4>Scenario 6. Build UI from blocks and flows</h4><p>This is a scenario for fast but controlled design generation.</p><p>The user can choose UI blocks, user flow, platform, and design system, and then write a prompt.</p><p>For example:</p><p>“Create the first three onboarding screens for a B2B SaaS project using this design system.”</p><p>The agent gets:</p><ul><li>project profile;</li><li>Onboarding flow;</li><li>selected UI blocks;</li><li>active Design Model;</li><li>platform target;</li><li>prompt.</li></ul><p>And from that, it builds a screen set.</p><p>This does not guarantee a perfect result on the first try, but it strongly reduces randomness.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o6PuXjNGKAktlFKb0lXsOQ.png" /><figcaption>Composer with selected flow, selected UI blocks, selected platforms, and prompt.</figcaption></figure><h4>Scenario 7. Create an artifact before making a change</h4><p>For many tasks, the correct result is not to immediately change a frame, component, or token.</p><p>The correct result is to create a proposal.</p><p>For example:</p><p>“Normalize token naming for this design system.”</p><p>The agent should not rename variables immediately.</p><p>It should create a tokens_update artifact: what should change, why, what the impact is, what the risks are, and how rollback works.</p><p>Only after approval should it apply the changes.</p><p>This brings the AI workflow closer to a real design systems workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c6_MxbrLFySF4BIWQvTYbw.png" /><figcaption>Artifact approval flow: proposal card -&gt; side panel -&gt; approve -&gt; apply to Figma.</figcaption></figure><h3>Project as a product unit</h3><p>I separated <strong>Project</strong> into its own product concept.</p><p>Because without Project, everything else falls apart.</p><p>If the agent only works inside the current prompt, it does not understand <strong>continuity</strong>. It does not know what product this is, which decisions were already made, which artifacts already exist, or which design system is active.</p><p>Project solves this.</p><p>When the user creates a Project, they go through a small <strong>wizard</strong>:</p><ul><li>Project Category;</li><li>Product Type;</li><li>Domain / Industry;</li><li>Platform;</li><li>Design System.</li></ul><p>These steps look simple, but they create the profile.</p><p>For example:</p><p>“Internal Tool + Operations Platform + Logistics + Desktop Web + IBM Carbon-like system” is a completely different design context than “Consumer App + Lifestyle + iOS + Apple HIG.”</p><p>Project profile affects density, recommended components, interface patterns, and platform assumptions.</p><p>Then Project collects everything around itself:</p><ul><li>chats;</li><li>artifacts;</li><li>project brief;</li><li>thumbnail;</li><li>attachments;</li><li>platform tags;</li><li>active Design Model;</li><li>selected design system;</li><li>related work.</li></ul><p>This way, the plugin becomes not a one-time generator, but a workspace for product design.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Um2AZkozfIpwBGLR7XsPA.png" /><figcaption>New Project Wizard with steps: Category, Product Type, Domain, Platform, Design System</figcaption></figure><h3>Design System: assets, themes, and library context</h3><p><strong>Design System</strong> in this product has two levels.</p><p>The first one is the actual Figma level.</p><p>This is what can be scanned or imported:</p><ul><li>variables;</li><li>variable collections;</li><li>styles;</li><li>components;</li><li>component sets;</li><li>published library assets;</li><li>imported tokens;</li><li>local instances.</li></ul><p>The second one is the semantic level.</p><p>This is how these assets should be used:</p><ul><li>token roles;</li><li>theme behavior;</li><li>component contracts;</li><li>supported platforms;</li><li>density;</li><li>accessibility expectations;</li><li>visual language;</li><li>governance rules.</li></ul><p>That is why the Design Systems tab has not only a list of systems. It also has <strong>Themes</strong> and <strong>Models</strong>.</p><p><strong>Theme</strong> is responsible for the visual direction: palette, typography mood, and surface grammar.</p><p><strong>Model</strong> is responsible for rules and reasoning.</p><p>Design System without a model is inventory.</p><p>Design Model without assets is a declaration.</p><p>Together, they give the agent both material and rules.</p><p>The most powerful part here is <strong>Preview</strong>.</p><p>In <strong>Design Systems</strong>, you can do more than read a system description. You can see how the system behaves across different <strong>product types</strong>: SaaS, AI product, internal tool, e-commerce, dashboard, mobile flow, and so on.</p><p>Preview applies the <strong>Design Model</strong> to a specific product context.</p><p>So the system does not show an abstract set of buttons and cards. It shows examples of how <strong>principles, tokens, components, density, and layout rules</strong> appear in real interface scenarios.</p><p>This matters because a design system without examples often stays just a declaration.</p><p>Here, it becomes a <strong>test surface</strong>.</p><p>You can immediately see how the Design Model interprets the product type, which patterns it brings in, what density it chooses, and how semantic rules turn into UI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ED0XYl-a1fNupDz2mvni3Q.png" /><figcaption>Design Systems three tabs: Design Systems / Themes / Models, with different types of cards.</figcaption></figure><h3>Library tokens</h3><p>A separate problem is Figma libraries.</p><p>The Figma Plugin API does not allow you to simply enable a team library for the user programmatically. The user has to do that in the Figma UI.</p><p>But if the library is already enabled, the plugin can:</p><ul><li>see available library variable collections;</li><li>get variables inside a collection;</li><li>import a variable by key;</li><li>work with local/imported variables;</li><li>bind a compatible variable to selection.</li></ul><p>This changes the role of the agent.</p><p>It does not just say “use primary color.”</p><p>It can say: “Here is the collectionKey, here is the variableKey, here is what needs to be imported, and here is where it should be bound.”</p><p>This is already much closer to design engineering.</p><h3>Design Model and DESIGN.md</h3><p>DESIGN.md is the most important part of the semantic architecture.</p><p>I was inspired by the idea that a design system should live not only in Figma, but also in a textual, versioned, machine-readable format.</p><p>But I did not want to create a token dump.</p><p>A token dump does not explain when and why to use a decision.</p><p>So DESIGN.md in Paradigma is an <strong>operating model</strong>.</p><p>It describes not only values, but decisions.</p><p>For example:</p><ul><li>“Tokens are named decisions.”</li><li>“Use semantic tokens before primitive tokens.”</li><li>“Components are reusable interaction units with anatomy, variants, states, and accessibility behavior.”</li><li>“UI blocks are semantic skeletons.”</li><li>“Screens are workflow-level compositions.”</li><li>“Every pattern must define when to use it, when not to use it, and what to do on small screens.”</li></ul><p>This is very different from normal documentation.</p><p>Normal documentation often explains to a person how the system works.</p><p>Design Model should explain to both the person and the agent how to make design decisions.</p><p>I based the Design Model not on abstract “AI design rules,” but on real guidelines and practices from some of the strongest design systems in the industry: Google Material 3, Apple Human Interface Guidelines, Microsoft Fluent 2, IBM Carbon, Salesforce Lightning Design System 2, and others.</p><p>This allows the model to reason not only at the level of style, but at the level of tested principles: accessibility, platform behavior, component anatomy, semantic tokens, interaction states, responsive patterns, and product UI conventions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*doECRAtqjOcD5lfGKNt_Sg.png" /><figcaption>Fragment of DESIGN.md with frontmatter, principles, token tiers, and component contracts.</figcaption></figure><h3>Design Model structure</h3><p>I included several required parts:</p><ul><li>frontmatter;</li><li>overview;</li><li>foundations;</li><li>token strategy;</li><li>surface, shape, elevation grammar;</li><li>component and UI block model;</li><li>pattern taxonomy;</li><li>key pattern blueprints;</li><li>responsive behavior;</li><li>accessibility;</li><li>do/don’t;</li><li>known gaps.</li></ul><p>Frontmatter gives a short machine-readable contract.</p><p>Body gives reasoning.</p><p>This balance is important.</p><p>If the file is too machine-like, it is hard for a designer to maintain.</p><p>If the file is too human-like, the agent will not be able to extract rules reliably.</p><p>So the format should be human-first, but agent-readable.</p><h3>UI: how the product is organized</h3><p>I wanted the plugin UI to feel like a tool, not like a page with features.</p><p>This is a narrow Figma plugin surface. There is not much space. Every extra block feels heavy.</p><p>So I built the navigation around the main work areas:</p><ul><li>Chat;</li><li>Skills;</li><li>User Flows;</li><li>UI Blocks;</li><li>Design Systems;</li><li>Projects;</li><li>Settings.</li></ul><p>These are not random tabs.</p><p>They match the semantic layers of the product.</p><p>Chat is the current interaction.</p><p>Skills are behavioral instructions.</p><p>User Flows are scenarios and states.</p><p>UI Blocks are structural compositions.</p><p>Design Systems are assets, themes, and models.</p><p>Projects are long-term product context.</p><p>Settings are auth, model, safety, and diagnostics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vrGP_ea78StTbeUAh-U3-w.png" /><figcaption>Main plugin navigation with all tabs and active Chat.</figcaption></figure><h3>Chat</h3><p>Chat is the main workspace.</p><p>But it should not be just a textarea and a list of messages.</p><p>In the header, you can see project selector, artifacts action, model context, and active tags.</p><p>The empty state has suggested actions: Explain, Create, Edit selection, Review, Use as reference.</p><p>This is important for discoverability. The user should not have to guess what the plugin can do.</p><p>But suggested actions should not turn into onboarding text. They should be short actions that start real scenarios.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aMuVkI-1lqikdhhF5hMM1Q.png" /><figcaption>Empty Chat state with suggested actions and composer.</figcaption></figure><h3>Message box</h3><p>The Composer in Figma Design Plugin is a separate product inside the product.</p><p>I wanted it to work as a context assembly surface.</p><p>It has:</p><ul><li>text prompt;</li><li>image/file attachments;</li><li>selected Figma frames;</li><li>skills;</li><li>UI blocks;</li><li>selected flow;</li><li>platform selection;</li><li>model selector;</li><li>reasoning selector;</li><li>execution mode selector;</li><li>suggested actions;</li><li>@mentions for skills, flows, and UI blocks.</li></ul><p>It is not just an input.</p><p>It is the place where the user explicitly assembles context for the agent turn.</p><p>The composer has <strong>internal tabs</strong>: prompt, attachments, selected-frame, skills, ui-blocks, flow.</p><p>When context is added, the composer moves into a contextual state. The user can see exactly what will be sent together with the prompt.</p><p>This reduces the magic.</p><p>And adds control.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HIrbLN-AwvvxUSD-C4pFRQ.png" /><figcaption>Composer in expanded state with tabs: Files, Frame, Skills, UI blocks, Flow.</figcaption></figure><h3>Modes</h3><p>I did not want to make the mode system too rigid.</p><p>So modes in the UI are soft intent presets.</p><p>There are <strong>Auto</strong>, <strong>Screens</strong>, <strong>Library</strong>, <strong>Flow</strong>, <strong>Review</strong>.</p><p><strong>Auto</strong> works for general tasks.</p><p><strong>Screens</strong> is for creating or editing frames.</p><p><strong>Library</strong> is for tokens, variables, styles, and components.</p><p><strong>Flow</strong> is for journeys, diagrams, and prototype logic.</p><p><strong>Review</strong> is for audits, handoff, and suggested fixes.</p><p>But the user can override everything with plain language.</p><p>Mode should not become a cage. It should give the agent a better default for the execution output format.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lWABaoto8A_Dlo3Vscy6dQ.png" /><figcaption>Mode selector in composer with Auto, Screens, Library, Flow, Review.</figcaption></figure><h3>Attachments</h3><p>Attachments can be images, screenshots, Markdown, or text files.</p><p>But the system does not treat all of them the same way.</p><p>An image can be a reference, source screenshot, moodboard, or wireframe.</p><p>Markdown can be a brief, PRD, design doc, or skill.</p><p>The agent should interpret the attachment through context, not copy it blindly.</p><p>In the UI, attachments are visible before sending. They can be removed. Images have a preview.</p><p>This is a small UX detail, but it matters: the user should see what is included in the context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JQHvcAhKfoEswkmScLknPw.png" /><figcaption>attachments drawer with image preview and file attachment.</figcaption></figure><h3>Selected frames</h3><p>Figma selection is one of the strongest context sources.</p><p>If the user selected a frame, that is almost always more important than the general canvas.</p><p>So the composer shows selected frames as a separate context tab.</p><p>There, you can see name, type, and preview. You can remove the frame from context without changing the Figma file itself.</p><p>This lets you say:</p><p>“Use this as reference.”</p><p>Or:</p><p>“Edit this selection.”</p><p>And the agent understands the affected area.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rAyGwMcIhgv2GaWz_plAUQ.png" /><figcaption>Selected frame tab in composer with PNG preview of the selected frame.</figcaption></figure><h3>Skills</h3><p>Skills stayed, but I changed their role.</p><p>In other AI plugins, Skills were one of the main context mechanisms.</p><p>In my Design Plugin, — Skills are a lightweight instruction layer.</p><p>They can be autodetected or passive.</p><p>Autodetected Skills are recognized automatically and added automatically. This can be useful for common reusable actions and workflows.</p><p>Passive skills are connected through @mention.</p><p>A Skill is good for behavior: “do an accessibility audit,” “write concise handoff notes,” “check naming.”</p><p>But a Skill should not replace the Design Model.</p><p>These are different things.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_7_PAt2ctLKsZlP_g71muw.png" /><figcaption>Skills tab with categories, active/passive toggle, and preview sidebar.</figcaption></figure><h3>Artifacts</h3><p><strong>Artifacts</strong> are the second space after <strong>Chat</strong>.</p><p><strong>Chat</strong> is responsible for the dialogue.</p><p>Artifacts are responsible for durable output.</p><p>Types of artifacts:</p><ul><li>tokens update;</li><li>frame audit;</li><li>screen proposal;</li><li>design system doc;</li><li>component proposal;</li><li>flow map;</li><li>handoff checklist;</li><li>figma change preview.</li></ul><p>In Chat, an artifact looks like a card.</p><p>In the side panel, it becomes a full document with actions.</p><p>This is useful for work, even if the MVP is local. It is easier for a designer to review a proposal than to search for a long answer in chat history.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FbQ58TkSCTMfO-J65XW_dg.png" /><figcaption>Artifact Panel with full Markdown content and action footer and Project artifacts list.</figcaption></figure><h3>Technical architecture in brief</h3><p>Technically, this is a Figma plugin with an iframe UI and a sandbox backend.</p><p>The UI is written in Svelte + TypeScript.</p><p>The build goes through Vite for the UI and a separate plugin build script for the Figma sandbox.</p><p>The sandbox has access to the figma global and runs privileged Figma API operations.</p><p>The UI is responsible for state, chat, agent loop, OpenAI/Codex interaction, artifacts, local catalog, and settings.</p><p>The UI and sandbox communicate through typed plugin messages.</p><p>This matters. In products like this, it is easy to end up with chaos around raw postMessage. I wanted the message contract to be explicit.</p><p>The whole codebase was ai-coded in the Codex ecosystem with GPT-5.5.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vucgHkeopoc43TWff-rqyw.png" /><figcaption>Technical diagram: UI iframe &lt;-&gt; plugin sandbox &lt;-&gt; Figma API &lt;-&gt; local broker / Figma service.</figcaption></figure><h3>Agent loop</h3><p>The agent loop is built around the OpenAI Responses API and function tools.</p><p>The flow is:</p><ol><li>Build system instructions.</li><li>Build user input from text and image attachments.</li><li>Call the model with tools.</li><li>If the model returns function calls, execute the tools.</li><li>Return tool outputs back into the loop.</li><li>Repeat until there are no new tool calls.</li><li>Save the final response, transcript, and tool logs.</li></ol><p>The MVP can work non-streaming.</p><p>Later, streaming will give a better UX, but for the first architecture, it was more important to make the tool loop stable and verifiable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZOlJ3F2NAIwZ6IJe47H8YA.png" /><figcaption>Sequence diagram of the OpenAI Responses loop with function_call and function_call_output.</figcaption></figure><h3>Local-first storage</h3><p>Part of the data is stored in figma.clientStorage: settings, chats, skills, design models, bindings, and auth state. The limit is 5 MB.</p><p>For heavier entities, I designed a <strong>local SQLite catalog</strong>.</p><p>It can store:</p><ul><li>UI Primitives;</li><li>UI Sections;</li><li>UI Screens;</li><li>User Flows;</li><li>Skills;</li><li>Design Systems;</li><li>Projects;</li><li>Chats;</li><li>Artifacts.</li></ul><p>This is a local-first approach.</p><p>For me, it was important that the product could work as a local tool without immediately needing complex cloud sync.</p><h3>Auth and integrations</h3><p>I needed OAuth. I have a Pro subscription, so I wanted to fully work not through API tokens, but within the generous limits of my subscription.</p><p>Auth turned out to be more complex than it looked in the PRD.</p><p>At first, I wanted OpenAI OAuth login as the primary UX. But for a standalone Figma plugin, there is no simple public OpenAI API OAuth flow that gives delegated API access to /v1/models or /v1/responses.</p><p>So the MVP architecture has several paths:</p><ul><li>BYOK as a beta fallback for OpenAI API key;</li><li>local Codex broker for experiments with ChatGPT/Codex auth;</li><li>Figma OAuth app for Figma REST API and published library sync;</li><li>hosted Figma service for a public HTTPS callback, because Figma OAuth does not finish cleanly on localhost.</li></ul><p>For Figma, I created a dev app, configured the OAuth callback, and added scopes for current_user:read, file_content:read, library_assets:read, library_content:read, team_library_content:read.</p><p>This is needed not for canvas operations, but for deeper library sync.</p><p>Figma Plugin API covers runtime operations inside the file.</p><p>Figma REST API is needed when you need to sync a published file or team library metadata.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z1L9Vn0QKbdtEAjOgGct5g.png" /><figcaption>Auth architecture: BYOK fallback, Codex local broker, Figma OAuth service on Railway, plugin settings.</figcaption></figure><h3>How I built the product</h3><p>First, I prepared the PRD.</p><p>In it, I described the vision, personas, goals, non-goals, functional requirements, system prompt requirements, storage, security, MVP scope, milestones, and acceptance tests.</p><p>Then I split implementation into parts.</p><p>The first baseline was to create the <strong>core pattern</strong>: UI iframe, plugin sandbox, tool execution, chat, skills, history.</p><p>The second step was to create the <strong>OpenAI Responses loop</strong>.</p><p>The third was to add <strong>Design Model</strong> as a separate domain entity.</p><p>The fourth was to add <strong>Design Systems</strong> and <strong>Figma library context</strong>.</p><p>The fifth was to add <strong>Projects</strong>, <strong>Artifacts</strong>, <strong>UI blocks</strong>, <strong>Flows</strong>, and a more mature UI.</p><p>This order was important. If I had started with a beautiful UI, it would have been easy to build a shell without core behavior.</p><p>But the product stands on the <strong>semantic core</strong>.</p><h3>What came out of it</h3><p>The most important result for me is the change in thinking.</p><p>I stopped thinking about a Figma AI plugin as “a chat that can draw.”</p><p>I started thinking about it as a semantic interpreter for product design.</p><p>This means that result quality depends not only on the model.</p><p>It depends on what context we give to the model and how that context is structured.</p><p>If we give only a prompt, we get prompt-driven design.</p><p>If we give canvas, we get canvas-aware design.</p><p>If we add design system, we get system-aware design.</p><p>If we add DESIGN.md, we get rule-aware design.</p><p>If we add Project, flows, UI blocks, and artifacts, we get a project-oriented design workflow.</p><p>That is the difference.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3zTdDj6_tLHZ0O_oVocjRw.png" /><figcaption>Layered quality ladder: prompt-driven -&gt; canvas-aware -&gt; system-aware -&gt; rule-aware -&gt; project-oriented.</figcaption></figure><h3>What I would improve next</h3><p>There are a few obvious next steps.</p><p>The first one is <strong>streaming</strong>.</p><p>For an agent workflow, it is important to see what is happening in real time: model thinking, tool call, tool result, retry, final answer.</p><p>The second one is <strong>visual diff.</strong></p><p>Before changing existing frames, it would be useful to see before/after not only as text, but visually. The basics are already there. But to make it fully useful, this is still an improvement area.</p><p>The third one is a <strong>stronger validation engine</strong>.</p><p>Right now, Design Model can be used as a prompt contract and a basic validation layer. But long-term, I would like to have more static checks: token binding, detached components, text size, contrast, auto-layout, component misuse.</p><p>The fourth one is <strong>team-shared Design Models</strong>.</p><p>Local-first is good for an indie workflow, but design systems live in teams. They need shared contracts, versioning, and governance.</p><p>The fifth one is a <strong>better bridge between Figma and code</strong>.</p><p>Because the real value is not over only in creating a frame. The value is in making that frame explainable, verifiable, ready for implementation, and able to return back into the system. And it should do that within the standards you actually need.</p><h3>Conclusion</h3><p>I do not think the future of design in Figma is just “press a button and get UI.”</p><p>That is too shallow.</p><p>Design is a system of decisions. And a dynamic one.</p><p>Product design especially.</p><p>Context matters. Constraints matter. The team matters. The design system matters. The user journey matters. The platform matters. The product state matters. Handoff quality matters.</p><p>So AI for design should not work only with pixels.</p><p>It should work with semantics.</p><p>Paradigma is my attempt to design this kind of concept and approach inside Figma.</p><p>Not perfect.</p><p>Not final.</p><p>But clear enough to show the direction:</p><p>AI design tools should be project-aware, system-aware, and contract-aware.</p><p>Then they stop being generators of random screens.</p><p>And start becoming real executors of your thoughts… according to context :)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ssDOSjh5LmAMtq8oQjOqg.png" /></figure><h3>Time spent</h3><p>I worked on the plugin for about 2<strong>–3 weeks/~50–60hrs</strong>.</p><h3>Public access</h3><p>Right now, I have not shared public access to the plugin for a few reasons.</p><p>First, <strong>local OAuth</strong>. The current architecture and installation flow require an additional broker-bridge. The authentication setup also means sharing secrets from both sides: the LLM provider and the Figma account, including the dev app and library keys.</p><p>Second, the plugin is complex. It <strong>still needs solid improvements</strong> on many levels. I like how the app works now, but I also feel there are at least a dozen places where it still needs more polish.</p><p>And yes, somewhere inside I might want to call it kind a “super-app.” But that kind of self-flattery would probably be harmful here. I stopped keeping up with the speed of change in the digital world a long time ago. What I built over weeks can easily lose its value in days.</p><p>That is the era we live in.</p><p>But I also have one stable feeling: absolutely no one is keeping up with this speed anymore :)</p><p>If anyone is interested in having a go with the plugin, and I manage to sort out the security issues and add support for other model providers, as well as fully ensure compatibility with other devices, I will definitely publish this plugin for the community.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3BgwJOj73qe6nLfK.png" /></figure><h4>About me</h4><p>Hey, I’m Max.</p><p>For the last 10 years, I’ve been designing complex B2B and enterprise products. I’m interested in product systems, design architecture, AI-assisted workflows, and the way design context can become structured enough to move closer to implementation.</p><p>In the free time, I also design game-like tools and explore how simulation, systems thinking, and gamification can change the way people work, learn and fun.</p><p>If this article/concepts/plugin was interesting to you, or if you have any questions, write in the comments or find me on <a href="https://www.linkedin.com/in/maxsukach">LinkedIn</a> or visit my <a href="http://www.maxuax.design/">portfolio website</a>.</p><p>I‘ ’ll be happy to chat.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0bd1fe6201d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vibe Coding: Magic without code? Yes — but not so simple.]]></title>
            <link>https://medium.com/@maxsukach/vibe-coding-magic-without-code-yes-but-not-so-simple-b44fdb985039?source=rss-5c62752dc55f------2</link>
            <guid isPermaLink="false">https://medium.com/p/b44fdb985039</guid>
            <category><![CDATA[product-thinking]]></category>
            <category><![CDATA[spec-driven-development]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[context-management]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Max Sukach]]></dc:creator>
            <pubDate>Tue, 13 Jan 2026 08:12:52 GMT</pubDate>
            <atom:updated>2026-01-13T08:12:52.479Z</atom:updated>
            <content:encoded><![CDATA[<h3>Vibe Coding: Magic without code? Yes — but not so simple.</h3><p><strong>A Spec‑driven approach to build complex apps without coding skills.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mxzU78SwqdQOrix7L8XOKw.gif" /></figure><p>This article is for beginners and enthusiasts exploring how to build applications through vibe coding — without writing code themselves.</p><p>It focuses on mindset and context, not on one-click magic. The workflow aims at reaching a properly functioning<strong> MVP</strong>, not the full product lifecycle.</p><h3>The hype around speed, magic and simplicity</h3><p>Lately <a href="https://www.ibm.com/think/topics/vibe-coding"><strong>vibe‑coding</strong></a> has been presented as a new “promised land.” In videos and posts you hear the same message: “<em>agents can can build an app in a minutes, and you never need to code again”</em>.</p><p>Part of this is true — but only for <strong>very shallow prototypes</strong>.</p><p>I want to show something else: <strong>what this process really looks like</strong> if you’re not a developer but you want to create systematic and complex apps.</p><h3>My role</h3><p>I’m a product designer and creator. I’m used to working with concepts, logic, UX flows, user value, systems and constraints.</p><p>I <strong>don’t write code</strong> and <strong>I don’t study programming.</strong></p><p>My job is to <strong>materialize ideas</strong> in the most correct way.</p><p>Vibe‑coding has allowed me to run projects on my own, without extended teams and long dev cycles — but it isn’t a magic button.</p><p>It’s a <strong>set of roles and processes on your own.</strong></p><h3>The main myth of vibe-coding</h3><p>The most common myth is:</p><blockquote><em>“AI agents can do everything themselves.”</em></blockquote><p>The reality is different: code-agents can do a lot, they are multimodal and smart. But only if you give them <strong>good input and context</strong>.</p><p>Without that you get fragile not scalable solutions, conflicting logic and endless clarifications.</p><p>So, — vibe‑coding isn’t about magic — it’s about <strong>managing context</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YnHZSz30BKJFcFz5_myMYg.png" /><figcaption>Context management system</figcaption></figure><h3>Where the real work happens</h3><p>Honestly, I spend most of my time in <strong>GPT chats</strong> and <strong>Notion docs</strong>.</p><p>Not in an IDE and not in code, but in a space of <strong>thinking</strong>, <strong>formulating</strong> and <strong>fixing decisions</strong>.</p><p>At first a project lives in my head, in text, schemes, tables and artifacts — only later does code appear.</p><h3>A project as a system of artifacts</h3><p>When I launch a new project, I create <strong>a dedicated project in ChatGPT</strong>.</p><p>The first chat isn’t “<em>let’s build…</em>”, but a place to shape the core-idea.</p><p>Then other chats appear with different roles. The goal is to <strong>generate and stabilize artifacts</strong>: the main concept, the value and problem statement, mechanics, rules, UX flow, constraints, specifications and finally the roadmap.</p><p>I don’t move to code until the <strong>decisions are fixed in text</strong>.</p><p><em>Note: I translate (transcribe) almost all types of documents into text: tables, graphs, diagrams, illustrations. I strive to provide brief explanations or instructions to every artifact. This reduces the risk of incorrect or ambiguous interpretation by the AI-model.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lFVLmDF1Zr7iBXqJIq-RDw.png" /><figcaption>ChatGPT project example</figcaption></figure><h3>Why “build me an app” doesn’t work</h3><p>If you ask the AI to simply “<em>build me an app</em>”, it will start guessing and simplifying — the result will be like raw-template solutions, chaos or hallucinations.</p><p>I do the opposite: I first <strong>explain what kind of system</strong> needs to come out, and only then ask for implementation.</p><h3>Prompting as an engineering language</h3><p>My main tool is <strong>prompting </strong>(obviously), but not in the sense of clever wording.</p><p>It’s essentially the structure of the request: a description of the current state, the desired result, a list of constraints and rules, a ‘definition of done’ and a list of things to avoid.</p><p>In fact it’s an <strong>engineering and product specification</strong> written for a LLM.</p><p>I act as the <strong>architect and provider of context. Instructor.</strong></p><p>And the model acts as the <strong>executor</strong>.</p><h3>Central source of contex</h3><p><a href="http://www.notion.com/">Notion</a> is my main source of truth. Here I store all artifacts: PDR/PRD, UX flows, tables, databases, versioning, specifications.</p><p>Through the API I can read and update these documents directly from ChatGPT.</p><p>The key idea isn’t that everyone must use Notion, but that you need a <strong>central source of context</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZebRmC896we67muBL_nJzw.png" /><figcaption>Central source of context</figcaption></figure><h3>Moving into the technical phase</h3><p>When the context is ready, I stop generating ideas and become a <strong>translator into technical language</strong>.</p><p>I package the context into structured prompts, prepare PDF specifications, build the roadmap and engineering tasks, and only then open my IDE (<a href="https://en.wikipedia.org/wiki/Integrated_development_environment">ADE</a> — agentic development environment).</p><p>ChatGPT and Notion help me prepare, but real implementation happens in VS Code, GitHub, and services like Firebase or Vercel.</p><p>There is no need to be concerned. Your agent-assistants will help you configure and operate correctly in all of these environments.</p><p>Of course, there is a need to figure things out, especially for the first time. But for the purpose of building an MVP, it will often be basic things.</p><p>So there code-agent reads instructions, writes code and moves along the roadmap, while I <strong>control the process</strong> instead of writing code by hand.</p><h3>When the magic appears</h3><p>The ease doesn’t come <strong>right away</strong>.</p><p>Again, — first you collect context, fix artifacts, write down rules, stabilize logic, set the roadmap and polish your prompts.</p><p>Only then does vibe‑coding start to feel like magic.</p><p>At that point I open the “developer” chat, generate a clear engineering prompt based on my spec, pass it to code-agent and simply say: <strong>“Done. Next!”</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RRq9GjB5LDcbV0ZeFTut2Q.png" /><figcaption>Agentic prompt engineering</figcaption></figure><h3>A mediator, not a coder</h3><p>My role is a <strong>mediator</strong> between a clearly defined system and its technical implementation. I confirm that each stage is ready and allow the AI coder to do its job. And do it well!</p><p>How the magic happens? It’s the result of <strong>solid preparation</strong>.</p><p>If you skip steps you’ll constantly be clarifying and redoing.</p><p>That’s why most effort and time goes into working in ChatGPT and Notion — analyzing, modeling and documenting. Technically —preparing.</p><h3>Fixing is an inevitable stage</h3><p>No project comes together perfectly the first time (for me). Dependency conflicts, failing builds, strange errors and incompatibilities are normal.</p><p>But AI can handle this well: just provide the logs, model analyzes it and suggests targeted fixes.</p><p>The main thing here is to move in small logical steps:</p><blockquote>one prompt → one logical piece.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*acGHwwfQhxyJNaTj755-sg.png" /><figcaption>Vibe coding fixing loop</figcaption></figure><h3>SPEC‑Driven: how it works</h3><h4>What is SPEC‑Driven</h4><p>SPEC‑Driven development is not about bulky documents, it’s about a <strong>living description of the system</strong>, clear instructions and rules.</p><p>I don’t start with code or tools — I start with <strong>clear specifications</strong>. A specification explains what the product is, how it should behave, what rules and constraints exist, what is allowed and what is forbidden. It removes ambiguity and becomes a <strong>contract between me and the AI</strong>.</p><h4>Modus Operandi</h4><p>Let’s wrap it up.</p><p>My SPEC‑Driven Vibe Coding model looks like this:</p><pre>Idea → Context → Artifacts → Specs → Execution → Product → Iteration ⟲</pre><p><strong>0. Setup.</strong> Start a new project: set up the environment, collect the first context, pick your tools.</p><ol><li><strong>Idea.</strong> This is not yet a concept, but a <strong>direction of attention</strong> — the feeling of a problem/solution, unanswered questions, the desire to dig deeper.</li><li><strong>Context &amp; Artifacts.</strong> The idea turns into context, and context into artifacts: shapes, rules, logic, scenarios, constraints, hypotheses, UX flows, decisions, fixed in writing.</li><li><strong>Specification.</strong> The turning point: I stop thinking about <em>what it is</em> and start thinking about <em>how to realize it</em>, but still without coding. Specifications (Product requirements PDR/PRD, Definition of Done, phases, constraints) become fuel for the system.</li><li><strong>Execution.</strong> The magic happens here because all decisions have already been made. <br>Execution is a step-by-step run of the roadmap: <br>one prompt → one controlled logical piece. <br>I don’t code — I confirm stages and changes.</li><li><strong>Product &amp; Iteration.</strong> The application is not the end, but <strong>a mirror</strong>: it shows where context is weak, where assumptions are wrong, and where a new iteration is needed. <br>Then the cycle begins again:</li></ol><pre>test/feedback → updated context → updated specs → new implementation</pre><h3>Conclusion</h3><p>Vibe Coding is not about speed. It’s about <strong>the inertia of preparation</strong>: the better your context and specifications are, the easier and faster the code moves.</p><p>AI doesn’t create magic by itself — it does it for those who <strong>set the stage</strong>. When you apply a spec‑driven approach you stop “making an application” — you simply guide it along the rails you’ve laid.</p><p>This approach doesn’t replace designers or engineers, but gives them <strong>a new level of roles</strong>: to be <strong><em>orchestrators</em></strong> and <strong><em>architects</em></strong> who create and manage context and let systems work.</p><h3>Feedback/resonance</h3><p>This topic is the <strong>high-level overview</strong>. But if this resonates you, — let me know in the comments what you’d like me to dive into next:</p><ul><li>deep dive into <strong>artifacts:</strong> which/where/when (JTBD, User Personas, Value Proposition, Market Signal, Artifact Graph, and tens more…)</li><li>a deeper dive into <strong>spec-driven approach</strong> inside product development workflow (mindset, tools, workflow).</li><li>my <strong>tech IDE/stack (VS Code)</strong> and why I moved away from Cursor / Replit / Lovable / Builder.io (-&gt;I still use it partially — there’s a great hack).</li><li>how I <strong>use agents / co-pilots</strong> (Orchestrator, Researcher, Designer, Engineer, QA…).</li><li>how to use <strong>agentic Skills.</strong></li><li><strong>vibe design</strong> coding with Figma, design systems, tokens, UI-frameworks, Storybook, etc.</li><li>share a bit about the <strong>projects</strong> I’m currently working on.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lXdr5EPaxwEPDOB_vj9-OQ.png" /></figure><p>See ya! Vibe hugs;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b44fdb985039" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Micro-learning needs micro-conclusions]]></title>
            <link>https://medium.com/@maxsukach/micro-learning-needs-micro-conclusions-385d647123f7?source=rss-5c62752dc55f------2</link>
            <guid isPermaLink="false">https://medium.com/p/385d647123f7</guid>
            <category><![CDATA[learning-method]]></category>
            <category><![CDATA[21st-century-learners]]></category>
            <category><![CDATA[andragogy]]></category>
            <category><![CDATA[lifelong-learning]]></category>
            <category><![CDATA[microlearning]]></category>
            <dc:creator><![CDATA[Max Sukach]]></dc:creator>
            <pubDate>Tue, 23 Sep 2025 12:23:29 GMT</pubDate>
            <atom:updated>2025-09-23T16:24:28.246Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FmB5eyXRM_WuVsS5fEUB4g.gif" /></figure><p>Many of us dedicate a few spare minutes each day to learning — watching YouTube lessons, taking mini-courses, reading articles, or asking ChatGPT for advice. But often, after this kind of microlearning, we switch back to other tasks and never draw any conclusions. As a result, the new knowledge stays superficial and is quickly forgotten. How can you avoid this? Below are simple reflection methods to make your short learning sessions (5–20 minutes) much more productive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UV5uqGvPp-O6Di2vdnXXRw.png" /></figure><h4>Why Make Conclusions After Micro-Lessons?</h4><p>A short reflection after learning is not a waste of time — it’s a way to “pause the game” and lock in the information you just received. Learning experts note that inserting small breaks for thinking and self-checking significantly deepens understanding and improves retention. In other words, spending just a few minutes on conclusions helps move new facts from short-term memory into long-term memory and find their place in your personal experience.</p><h3>Effective Methods for Forming Conclusions (for Microlearning)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*90pu9vXjlSoPJyc1Ad344Q.png" /><figcaption><strong>The “What? So What? Now What?” Method</strong></figcaption></figure><ul><li><strong>The “What? So What? Now What?” Method</strong> — a classic mini-reflection. After a lesson or practice, ask yourself: What did I just learn? So what — why is it important? Now what — how will I apply it? For example, after a 10-minute video on time management, ask: <em>“What did I take from it? Why does it matter for my work? And what will I change tomorrow?”</em>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gh-lB5I5hP6gkS7ujIT9rg.png" /><figcaption><strong>One Key Question After Every Piece of Content</strong></figcaption></figure><ul><li><strong>One Key Question After Every Piece of Content.</strong> A very simple trick: after reading an article or watching a video, ask yourself one meaningful question. For example: <em>“How will I apply this idea in my work?”</em> or <em>“What was most unexpected or useful?”</em>. This short pause helps turn passive consumption into active learning.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jnqClGUn4dLh93USEZlOPg.png" /><figcaption><strong>The 3–5 Bullet Point Summary</strong></figcaption></figure><ul><li><strong>The 3–5 Bullet Point Summary.</strong> After each lesson, write down 3–5 main points. This practice works as an exercise in active recall: you force your brain to pull out key ideas from memory. For example, after reading a book chapter, close the text and summarize it in a few sentences — much more effective than simply re-reading. Turn stream into a note.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zg-DaA2X5PtcxRC-g8oq7g.png" /><figcaption><strong>Learning by Explaining to Others</strong></figcaption></figure><ul><li><strong>Learning by Explaining to Others (or Through a Post) <em>(</em></strong><em>such as this, for example!</em>)<strong>.</strong> Try explaining the new idea to a colleague, or write a short social media post about it. This method requires you to structure knowledge and helps you understand it more deeply. Plus, when we teach others, we retain more ourselves.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DB4MGoOZYN1FA4PHrQNgUg.png" /><figcaption><strong>Self-Questioning and Mini Checklists</strong></figcaption></figure><ul><li><strong>Self-Questioning and Mini Checklists.</strong> After a short learning block, give yourself a mini-quiz: <em>“What’s the main idea? How would I apply this? What remains unclear?”</em>. Keep a 3–5 question checklist for such cases. This is like a quick self-exam that shows what you’ve really understood and where the gaps are.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YbsD0sCUSxgc5pK3aL8jmQ.png" /><figcaption><strong>The “One Conclusion per Day” Journal</strong></figcaption></figure><ul><li><strong>The “One Conclusion per Day” Journal.</strong> If you regularly consume learning content, it’s helpful to build a habit of daily reflection. At the end of the day, write down one specific answer to: <em>“What new thing did I learn today?”</em>. In a few weeks, you’ll be surprised how much you’ve absorbed.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z3UebG_pDw16-XoYTiIuOA.png" /><figcaption><strong>Micro-Summaries After Interacting with AI</strong></figcaption></figure><ul><li><strong>Micro-Summaries After Interacting with AI.</strong> If you use ChatGPT or other AI tools, don’t just take the ready-made answer. Write a short summary in your own words. This transforms the information from “just an answer” into part of your own experience and strengthens its practical value. Unprocessed information does not remain with you.</li></ul><h4>Key Takeaways</h4><p>(Remember the bullets, right?!)</p><ul><li>Microlearning works best when paired with <strong>short, deliberate reflection</strong>.</li><li>Even a <strong>single question</strong> (“What will I actually use?”) can turn content into lasting knowledge.</li><li>Writing <strong>3–5 bullet points</strong> after each lesson strengthens memory through active recall.</li><li><strong>Explaining to others</strong> (or posting about it) forces you to structure and internalize ideas.</li><li>Building a <strong>daily conclusion habit</strong> (one insight per day) compounds into big growth over time.</li></ul><h3>In Conclusion</h3><p>Microlearning allows us to grow in small portions, but the depth of learning depends on our activity. Train yourself to make mini-conclusions — in the form of one question, a few bullet points, or a short note. This adds real value to your daily lessons and turns random content consumption into systematic growth.</p><p><strong>Vivat learners!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=385d647123f7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>