<?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 Daniela Gallardo Reyes on Medium]]></title>
        <description><![CDATA[Stories by Daniela Gallardo Reyes on Medium]]></description>
        <link>https://medium.com/@danigallardoreyes?source=rss-267a7bd00ae7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*6OXkYNDSNDBRxzPE.</url>
            <title>Stories by Daniela Gallardo Reyes on Medium</title>
            <link>https://medium.com/@danigallardoreyes?source=rss-267a7bd00ae7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 10:26:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@danigallardoreyes/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[Think before you automate: how I extended the Blueprint Hub into an AI assistant (part 2)]]></title>
            <link>https://www.designsystemscollective.com/think-before-you-automate-how-i-extended-the-blueprint-hub-into-an-ai-assistant-part-2-f058890bffc1?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f058890bffc1</guid>
            <category><![CDATA[framework]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design-operations]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 02:40:11 GMT</pubDate>
            <atom:updated>2026-04-27T07:21:59.199Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article isn’t a definitive guide either. It’s a continuation of a working log: in </em><a href="https://medium.com/design-systems-collective/think-before-you-automate-how-i-extended-the-blueprint-hub-into-an-ai-assistant-part-1-0b1e642ffc57"><em>part 1 I defined a rule</em></a><em>; in this one, I check whether that rule holds when translated into actual instructions.</em></p><p>I wasn’t willing to invest time in something that didn’t make sense.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*iewXbDb1ZlJXeYHk.gif" /><figcaption><em>Sure. Let’s do it properly. — The Office (via GIPHY)</em></figcaption></figure><h3>Start small</h3><p>When you work with complex digital products, the most common mistake isn’t technical: it’s starting too big.</p><p>These are some typical <em>red flags</em> for wasting resources:</p><p>🚩 Trying to automate before you understand. <br>🚩 Building solutions before validating criteria. <br>🚩 Investing time and effort in something you don’t yet know will hold.</p><p>That’s why I decided to start with the <strong>minimum</strong>.</p><p>Not out of fear, or lack of ambition, but to avoid wasted work and to validate — step by step — some critical assumptions:</p><ul><li>How decisions <strong>are made</strong>.</li><li>How requests <strong>are organized</strong>.</li><li>How products <strong>are governed </strong>— products that, if everything goes well, will need to scale and be profitable.</li></ul><p>Before thinking about a full assistant, about flows or automations, I needed to verify one single thing:</p><blockquote><strong>Whether a reasoning rule could survive when it became the behavior of a programmed assistant.</strong></blockquote><p>That was the real starting point.</p><h4>1. Tutorial contract (mini-disclaimer)</h4><p>From here on I get into the practical part. Not as a definitive recipe, but as a starting point: I show the minimum structure, the interface adjustments that matter, and I share the link to the assistant so the world can test it — which means I get feedback and can iterate.</p><p>I’m not going to paste the full instructions here.<br>Out of context they lose meaning, and besides, this V0 will keep evolving.</p><p>What matters is the logic:</p><ul><li><strong>What</strong> do I block?</li><li><strong>What</strong> do I allow?</li><li><strong>What </strong>do I validate before moving forward?</li></ul><h4>2. Scope of this V0</h4><p>This first version of the assistant:</p><ul><li>Implements <strong>a single Blueprint Hub rule</strong>.</li><li>Doesn’t design or propose solutions.</li><li>Doesn’t automate anything.</li><li>Only validates whether a request is clear and governable.</li></ul><p>Nothing more for now.</p><h4>3. Where is GPT Builder? (clear practical step)</h4><p>Go to ChatGPT and look at the <strong>left sidebar</strong>.</p><p>At the very top you’ll see something like: “<strong>Explore GPTs</strong>” Click on it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C04ier1r5skiKnTs.gif" /><figcaption><em>Fig. 1 — Access to GPT Builder from the ChatGPT sidebar. The entry point isn’t in a technical menu or an advanced view: it’s integrated into the normal user flow.</em></figcaption></figure><h4>4. Creating the assistant (V0 setup)</h4><p>Once inside “Explore GPTs,” you’ll see a button in the upper right that says “Create.” When you click it, GPT Builder opens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tFRiRfahlF-kH3Za.gif" /><figcaption><em>Fig. 2 — Entry to GPT Builder from the “Explore GPTs” view, by clicking Create. Before thinking about rules or behavior, you need to know where the assistant is built.</em></figcaption></figure><p>You don’t need:</p><ul><li>An extra account.</li><li>Any installation.</li><li>Anything else.</li></ul><p>It’s all inside ChatGPT.</p><p>The next step is “configuring things” for the V0.</p><h4>5. Deciding what to configure (and what not to) in a V0 assistant</h4><p>Once inside GPT Builder, I moved to the configuration tab.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*-DyZINuB8MUMPBOL.png" /><figcaption><em>Fig. 3 — “Configure” tab in GPT Builder. General view of an assistant’s configuration fields. In this V0, only the elements that define behavior and expectations are touched; no capabilities, tools, or external knowledge are added.</em></figcaption></figure><p>From here on, <strong>every decision was deliberately restrictive</strong>. I only touched the fields that affect the assistant’s behavior and usage expectations.</p><p>I didn’t configure anything related to automation or technical sophistication. In this V0, any extra layer would have hidden whether the rule could hold on its own.</p><p><strong>Assistant Name<br></strong>The name is the first thing someone sees before using the assistant.<br>It’s not marketing. It’s a scope declaration.</p><p>I chose a functional, explicit name: Blueprint Assistant (V0).</p><p>Adding <em>V0</em> is not a minor detail:</p><ul><li>It makes clear this is not a finished solution.</li><li>It doesn’t promise more than it delivers.</li><li>It assumes it will evolve.</li></ul><p>I avoided grandiose or vague names. If the name overpromises, the assistant starts off losing credibility.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*upXiqQ8XHGftcts4.png" /><figcaption><em>Fig. 4 — “Name” field for the assistant in GPT Builder. The name defines scope before any interaction. Adding “V0” makes it explicit that this is a first version, deliberately limited and evolving.</em></figcaption></figure><p><strong>Description<br></strong>The description isn’t there to explain how the assistant works.<br>It’s there to say <strong>when it makes sense to use it</strong>.</p><p>In this V0, the description:</p><ul><li>Narrows down the product type (SaaS, complex digital products)</li><li>Filters out shallow uses</li><li>Aligns expectations before you start</li></ul><p>I didn’t describe rules or processes. Just the context in which this assistant makes sense.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*5d2CS2R3nfAUexY8.png" /><figcaption><em>Fig. 5 — Name and description configuration. The name and description don’t explain how the assistant works — they define what it does and, above all, when it makes sense to use it. In this V0, the description scopes the context (complex digital products) and sets a clear limit: validating the clarity of a request before moving forward, nothing more.</em></figcaption></figure><p><strong>Instructions (core of the assistant)<br></strong>All of the assistant’s behavior, in this V0, is defined in a single place: the Instructions field.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Y7YCXxUNF9etZmg8.gif" /><figcaption>Fig. 6 — Instructions field. In this V0, all rule validation happens here.</figcaption></figure><p><strong>Conversation Starters<br></strong>This field is more important than it looks.</p><p>The starters don’t showcase<em> the best way</em> to use the assistant — they show <em>the most realistic way:</em> incomplete, urgent, or confusing requests, like the ones that show up in real work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*UacFvCcE8ZxZ5yPx.png" /><figcaption><em>Fig. 7 — Conversation starters. These aren’t “well-written” prompts — they’re the kind of real-world chaos that requests actually arrive in.</em></figcaption></figure><p>If the assistant only works with well-written prompts, it doesn’t work in practice.</p><p>Here I aimed to trigger the initial chaos that activates the rule I wanted — and still want — to validate.</p><p><strong>External Knowledge<br></strong>In this version I didn’t load any documents.</p><p>Before teaching the assistant things, I needed to verify that it knew how to behave. Adding knowledge at this stage would have contaminated the test.</p><p>The problem I was validating wasn’t “what it knows” — it was how it decides to move forward.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*vX5Q8LIZPadntpWZ.png" /><figcaption><em>Fig. 8 — External knowledge. No documents loaded in this V0.</em></figcaption></figure><p><strong>Model and Tools<br></strong>For this V0 I needed a model with analytical reasoning capability — not one optimized for speed or creative output.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*k9xCnibMMfVJS0Yg.png" /><figcaption><em>Fig. 9 — GPT-5.2 Thinking model selection (was the latest model by Jan 13th 2026). In this V0, the model doesn’t optimize results: it guarantees the reasoning capacity needed to sustain the clarity rule.</em></figcaption></figure><p>The goal isn’t to “answer well” — it’s <strong>to think in an orderly way</strong>.</p><p>I chose an <strong>analysis-oriented model</strong> because this first Blueprint Hub rule requires:</p><ul><li>Maintaining context.</li><li>Not jumping ahead.</li><li>Holding intermediate clarity states.</li><li>Resisting the urge to propose solutions.</li></ul><p>Here the model isn’t a technical optimization —<strong> it’s a prerequisite for the assistant to behave the way I needed</strong>.</p><p><strong>Capabilities<br></strong>In this V0 I made a deliberate decision about which capabilities could support the rule validation and which couldn’t.</p><p>I enabled the code interpreter and data analysis, because understanding a request in complex digital products isn’t always purely conceptual: sometimes it means reading metrics, tables, structured inputs, or incomplete data that needs to be analyzed before any decision is made.</p><p>This capability reinforces the clarification phase without pushing the assistant to propose solutions.</p><p><strong>I disabled Canvas.<br></strong>Visualizing too early creates a clear temptation: moving forward before you understand. And this V0 exists precisely to block that behavior.</p><p>Other capabilities aren’t part of the behavior I’m validating in this version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*p3jFkc8Cv_gA9SGO.png" /><figcaption><em>Fig. 10 — Capabilities configuration in V0. Data analysis is enabled to support understanding of complex inputs; Canvas is disabled to prevent moving forward without clarity.</em></figcaption></figure><p><strong>Actions<br></strong>In this V0 I didn’t configure any actions.</p><p>Not because they aren’t useful, but because automating or executing anything at this stage would have invalidated the test: the clarity rule has to hold without doing anything beyond thinking.</p><p>For now, actions: none.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*_Tor41nomKcF7tcP.png" /><figcaption><em>Fig. 11 — Actions. Also: absolutely nothing (for now).</em></figcaption></figure><p><strong>Assistant image</strong> (non-critical detail in V0)<br>Although GPT Builder lets you add an image from the start, I decided to treat it as a secondary detail in this first version.</p><p>The image doesn’t define the assistant’s behavior, but it does shape expectations. In a V0 focused on validating a reasoning rule, I chose not to give it more weight than necessary.</p><p>At the time of writing this article, the builder’s image uploader wasn’t working correctly.</p><p>It doesn’t affect the assistant’s functionality or the test I’m trying to validate. I’ll add it when the builder stops fighting me.</p><h3>Publishing the assistant (as-is)</h3><p>With this configuration, I published the assistant exactly as it stands:</p><ul><li>No additions.</li><li>No “improvements.”</li><li>No waiting for it to be perfect.</li></ul><h3>What’s next?</h3><p>The assistant is published and available here: <a href="https://chatgpt.com/g/g-69655eae5ecc8191b29e1261386ba839-blueprint-assistant-v0-1">Blueprint Assistant</a></p><p>It might work well, it might work so-so, it might not work at all. And that’s fine.</p><p>The worst thing you can do with a new tool isn’t using it wrong — it’s never using it at all. If you try it and something doesn’t add up (or adds up too perfectly), let me know. A <a href="https://www.linkedin.com/in/dani-gallardo/">LinkedIn </a>DM is enough.</p><p>I’m not looking for validation. I’m looking for real friction so I can iterate with intent.</p><p>This isn’t about getting it right the first time. It’s about testing, observing, and adjusting with logic.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f058890bffc1" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/think-before-you-automate-how-i-extended-the-blueprint-hub-into-an-ai-assistant-part-2-f058890bffc1">Think before you automate: how I extended the Blueprint Hub into an AI assistant (part 2)</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Think Before You Automate: How I Extended the Blueprint Hub Into an AI Assistant (Part 1)]]></title>
            <link>https://www.designsystemscollective.com/think-before-you-automate-how-i-extended-the-blueprint-hub-into-an-ai-assistant-part-1-0b1e642ffc57?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b1e642ffc57</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[designops]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Mon, 20 Apr 2026 10:28:36 GMT</pubDate>
            <atom:updated>2026-04-27T07:24:12.336Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article is not a definitive guide. It’s a logbook: I think, test, adjust, and document as I build a real assistant.</em></p><figure><img alt="Una mano de marioneta coloca un post-it amarillo con una bombilla dibujada sobre un plano azul tipo blueprint" src="https://cdn-images-1.medium.com/proxy/1*B9nZTLCONK_KfumaO-i3sQ.gif" /><figcaption>GIF “Discuss Sticky Notes” by @masonrystudios, vía GIPHY.</figcaption></figure><h3>Context: Blueprint Hub</h3><p>This all starts with my <a href="https://medium.com/design-systems-collective/blueprint-hub-the-map-for-not-designing-like-a-headless-chicken-part-1-5d10ba678fef">Blueprint Hub</a> — a working framework, a space to think and plan what I’m actually doing, what it’s for, and what resources I have within a design system. Or at least, within the idea of a design system that we were (and still are) trying to build.</p><h3>What triggered creating the assistant?</h3><p>The results of the<em> framework</em> in practice.</p><p>I built the <em>framework</em> (I’ll call it that from here on) because I saw that neither I nor my team had a structure or action plan that could <strong><em>unblock</em></strong> product requests.</p><p>I built it in five days, from a real request, out of pure necessity: I had to understand what was being asked of me and how I could deliver it from a digital factory logic.</p><p>All of this was happening while, at the same time, we were being asked for screens nonstop — but also for a design system that could lay the groundwork, in an orderly and professional way, to eventually<strong> inject AI and automations</strong> “like everyone else.”</p><p>The Blueprint Hub worked. And still works.</p><p>It helped us stop designing blind and collaborate with more intention, even with the design system still under construction.</p><p>But it also made something visible: not everyone arrived at that point of clarity through the same path.</p><h3>The breaking point</h3><p>That’s where my frustration started: some people just couldn’t quite <em>get</em> the framework — and rather than helping, that created more alignment work for me. More governance overhead.</p><p>At that point I started wondering whether the problem could be solved by adding more structure, more control, or even automating part of the onboarding process.</p><p>But I realized the problem wasn’t technical.</p><p>I didn’t need automation. I needed a <strong>catalyst</strong> that could:</p><ul><li><strong>Guide</strong> each step without skipping any.</li><li><strong>Verify</strong> that context and resources are being mapped in an orderly and accurate way.</li><li><strong>Help</strong> establish a shared way of working — a way of working, even if that sounds like WoW — within a digital factory logic.</li></ul><p>Everything else could come later (yes, yes, the famous automations and AI).</p><p>So: first things first. A <strong>Minimum Viable Product</strong> (MVP from here on).</p><h3>MVP: Blueprint Assistant</h3><p>These were my steps — or rather, my objectives — for defining the assistant.</p><h4>1. Write in one sentence what problem it solves and for whom. Nothing more.</h4><p>In other words, answer this structure:</p><blockquote><strong><em>“When __________, my Blueprint Assistant helps me to __________.”</em></strong></blockquote><p>And it came out like this:</p><blockquote><em>“When I receive a product request, my Blueprint Assistant helps me to scope it, evaluate the resources I have, and decide whether to reuse or build something new — giving me a clear execution plan in return.”</em></blockquote><h4>2. Define what the Blueprint Assistant is (and what it isn’t)</h4><p>The next step wasn’t technical and had nothing to do with AI yet.<br>Before thinking about tools, I needed to define what kind of help I wanted to build.</p><p>In other words: what role does this assistant play, and what problems is it not here to solve?</p><p>The Blueprint Assistant<strong> is NOT:</strong></p><ul><li>A senior designer who dictates solutions.</li><li>A UI generator.</li><li>An abstract consultant.</li></ul><p>The Blueprint Assistant<strong> IS:</strong></p><ul><li>A translator of product requests into execution plans, using existing resources (whenever possible).</li></ul><p>In other words: it doesn’t replace thinking or decision-making. <strong>It structures the process that makes it possible to have full clarity — and from there, make one decision or several.</strong></p><p>With that clear, the question was no longer <strong><em>What is the assistant?</em> </strong>but <strong><em>How does it start behaving without betraying this logic?</em></strong></p><h4>3. The Minimum Viable Behavior (MVB) of the Blueprint Assistant</h4><p>There was one rule that couldn’t be broken from the start: if the goal is to help think before designing, the assistant cannot begin by delivering solutions.</p><blockquote>Not every MVP is a feature. <br>Sometimes the MVP is the minimum correct behavior of the system.</blockquote><p><strong>MVB Rule #1: Clarity as a governance condition</strong></p><ul><li>The governance of a request requires the brief to be clear.</li><li>The assistant cannot propose, decide, or move forward until this condition is met.</li></ul><p><strong>How does the assistant verify that the brief is clear?</strong> <br>To consider a brief as clear, the assistant must be able to do all of the following:</p><ul><li>Identify <strong>where the request is coming from</strong></li><li>Understand<strong> what is actually being asked</strong> (beyond how it was phrased)</li><li>Reconstruct a <strong>shared spec</strong> that aligns what the assistant understands with what the person asking understands</li></ul><p>If any of these points fails, the brief is not governable and the assistant must stop at this step.</p><p><strong>Required opening questions<br></strong>The assistant always starts with the origin of the request, because not all requests are born equal — and they don’t all require the same kind of mapping.</p><p><strong>#1 Where is this request coming from?</strong></p><ul><li>Is it a designer-initiated brief (something they spotted but haven’t defined yet)?</li><li>Is it a product request (Functional Analyst, Product Manager)?</li><li>Is it a technical request (engineering or development)?</li><li>Is it a client request?</li></ul><p><strong>#2 What are they actually asking for?</strong> (Not how they asked it — but what need the request is trying to solve.)</p><p><strong>#3 Request spec sheet<br></strong>The assistant rephrases and validates:</p><ul><li>What was requested</li><li>What it’s for</li><li>Where it applies</li><li>What the urgency level is</li><li>What the constraints are (technical, functional, time, and/or budget)</li></ul><p>The goal isn’t to document for documentation’s sake, but to confirm that both parties are on the same page before moving forward.</p><h4><strong>Step exit criterion</strong></h4><p>The step is considered complete only when the assistant can say:</p><p><em>“The brief is clear and governable. I understand its origin, the need behind it, and the boundaries within which it must be addressed. Nothing has been designed yet.”</em></p><p>If it can’t say that → <strong>we don’t move forward</strong>.</p><h3>Before the prompt: think before you delegate</h3><p>All of this brought me to an uncomfortable — but necessary — conclusion. Today everyone wants to <strong>“add AI”</strong> to things: to products, to processes, to decisions.</p><p>But <strong>AI doesn’t create clarity.</strong> It amplifies the state of the system it finds.</p><p>If the context is fuzzy, the objectives are poorly defined, and the resources are unclear — AI won’t sort any of it out. It will generate responses that look correct but are disconnected from the substance.</p><p>That’s especially dangerous: creating a scenario that appears coherent but is conceptually empty generates the illusion of progress when, in reality, it only accelerates the chaos. It doesn’t help build products or digital ecosystems on solid foundations.</p><p>That’s why this exercise didn’t start with the tool, or the prompt, or the automation. It started with one basic rule: <strong>you can’t govern what isn’t clear.</strong></p><p>Even though the Blueprint Hub rests on several rules, the <strong>first step had to be testing whether a single one could hold on its own.</strong></p><p><strong>Defining the minimum behavior</strong> of an assistant is, at its core, a way of <strong>protecting thinking before delegating it</strong>.</p><p>In the next part (<a href="https://www.designsystemscollective.com/think-before-you-automate-how-i-extended-the-blueprint-hub-into-an-ai-assistant-part-2-f058890bffc1">part 2</a>), I document how this rule translates into a real assistant — and what happens when theory meets a genuinely messy request.</p><p><strong><em>Before plugging AI into anything, you had to do this:</em></strong><em> </em><strong><em>think.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*Ben93_kjdnID9-e4.gif" /><figcaption>GIF “Think About It” by <a href="http://twitter.com/Identity">@Identity</a>, vía GIPHY.</figcaption></figure><p>If you work in design systems/operations or B2B product and this resonates, <strong>let’s connect on</strong> <a href="https://www.linkedin.com/in/dani-gallardo/"><strong><em>LinkedIn</em></strong></a>.</p><p>Send me a DM and we’ll set up a virtual coffee ☺️.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b1e642ffc57" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/think-before-you-automate-how-i-extended-the-blueprint-hub-into-an-ai-assistant-part-1-0b1e642ffc57">Think Before You Automate: How I Extended the Blueprint Hub Into an AI Assistant (Part 1)</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Convertí mi metodología en una skill de IA. Y esta vez funcionó.]]></title>
            <link>https://medium.com/@danigallardoreyes/convert%C3%AD-mi-metodolog%C3%ADa-en-una-skill-de-ia-y-esta-vez-funcion%C3%B3-10bfc8609a35?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/10bfc8609a35</guid>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Sun, 19 Apr 2026 19:34:52 GMT</pubDate>
            <atom:updated>2026-04-20T17:40:40.121Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Después de un intento con GPT que se fue de madre, así es como construí una skill real que hace exactamente lo que debe hacer (nada más).</em></p><h3>El problema con el primer intento</h3><p>En los artículos anteriores documenté qué pasó cuando intenté llevar el Blueprint Hub a un asistente de IA. La teoría era sólida. La práctica, no tanto.</p><p>El modelo hacía demasiado. Proponía soluciones antes de entender el problema. Saltaba pasos. Rellenaba huecos con suposiciones en lugar de preguntar. Al final generaba documentación elaborada que no servía para lo que necesitaba: una ficha clara antes de diseñar nada.</p><blockquote><em>“Automatizar un proceso mal instruido solo amplifica el caos. El problema no era la IA, era que las instrucciones no eran lo suficientemente precisas sobre qué NO hacer.”</em></blockquote><p>Así que volví al inicio. En lugar de construir un asistente genérico, construí una <strong>skill</strong>: un bloque de instrucciones específico para un único paso del proceso.</p><blockquote><em>Si no has leído la serie, aquí va el contexto:</em></blockquote><blockquote><strong><em>01 — </em></strong><a href="https://medium.com/@danigallardoreyes/blueprint-hub-el-mapa-para-no-dise%C3%B1ar-como-una-gallina-sin-cabeza-parte-1-7660f2ca4ce2"><strong><em>Blueprint Hub: el mapa para no diseñar como una gallina sin cabeza</em></strong></a><em> — La metodología. Por qué diseñar sin plan solo genera más problemas.</em></blockquote><blockquote><strong><em>02 — </em></strong><a href="https://medium.com/@danigallardoreyes/pensar-antes-de-automatizar-c%C3%B3mo-extend%C3%AD-el-blueprint-hub-a-un-asistente-con-ia-parte-1-23ea35f89e15"><strong><em>Pensar antes de automatizar (parte 1)</em></strong></a><strong><em> </em></strong><em>— El primer intento: extender el Blueprint Hub a un asistente con IA.</em></blockquote><blockquote><strong><em>03 — </em></strong><a href="https://medium.com/@danigallardoreyes/pensar-antes-de-automatizar-c%C3%B3mo-extend%C3%AD-el-blueprint-hub-a-un-asistente-con-ia-parte-2-f3c975084a41"><strong><em>Pensar antes de automatizar (parte 2)</em></strong></a><em> — La ejecución con GPT. El asistente se fue de madre.</em></blockquote><h3>El camino hasta la skill que funciona</h3><figure><img alt="Diagrama vertical con tres etapas numeradas. La etapa 1, sobre fondo beige, presenta el Blueprint Hub como la metodología base: 4 pasos para decidir antes de diseñar, funciona en papel y en Figma. La etapa 2, sobre fondo salmón, describe el intento con GPT que se fue de madre: el modelo proponía, planificaba y asumía demasiado. La etapa 3, sobre fondo amarillo y señalada con un rótulo “estamos aquí”, presenta la Blueprint Hub Trigger Skill como lo que funciona: scope muy definido, solo captura y" src="https://cdn-images-1.medium.com/max/1024/1*raIkkZBASqYKQSIyr0zSxw.png" /><figcaption>La metodología era buena. Faltaba un modelo que la escuchara — tres etapas del proceso: el framework, el intento fallido y la skill que funciona.</figcaption></figure><p>No era solo un problema de instrucciones. Cuando probé esas mismas instrucciones del GPT en Claude Opus 4.6, sin skill, solo como proyecto, la diferencia fue abismal. Donde GPT se saltaba los límites, proponía soluciones y generaba documentos que nadie le había pedido, Claude leyó las instrucciones, las respetó y encima generó un artifact con la ficha estructurada (un artifact es un documento interactivo que Claude genera dentro de la conversación, listo para usar, copiar o descargar). Exactamente el output que yo necesitaba, sin que se lo pidiera dos veces.</p><p>El modelo importa. Pero incluso con un buen modelo, una skill bien definida convierte un resultado bueno en uno que se repite. No es para que funcione la primera vez. Es para que funcione siempre igual.</p><h4><strong>La Trigger Skill: un solo paso, bien hecho</strong></h4><p>El Blueprint Hub tiene cuatro pasos. La skill cubre únicamente el primero.</p><figure><img alt="Diagrama del framework Blueprint Hub con 4 pasos. El paso 1, Trigger, aparece destacado sobre fondo amarillo y marcado como “esta skill”: captura la solicitud, identifica quién pregunta y genera una ficha estructurada. Un puente intermedio, Mapping, conecta con los tres pasos restantes — Scan, Gap Map y Decision Log — que aparecen en gris oscuro marcados como “estas no”, fuera del alcance de esta skill. En el centro, una imagen de John Travolta confundido en Pulp Fiction refuerza la idea del pue" src="https://cdn-images-1.medium.com/max/1024/1*rjdQv3rG4cnqGH0Xn0E5hQ.png" /><figcaption>La Trigger Skill cubre solo el primer paso del Blueprint Hub: capturar la petición con claridad antes de hacer cualquier otra cosa.</figcaption></figure><p>La skill recibe una petición, clara, vaga o directamente copiada de Slack, y hace tres cosas: detecta el perfil de quien pregunta (diseñador, PM, analista funcional), hace las preguntas que faltan <em>de una en una</em>, y genera una ficha estructurada lista para el siguiente paso.</p><p>Lo que <em>no</em> hace: proponer soluciones, evaluar viabilidad, planificar, ni avanzar al paso siguiente. Ese scope tan ajustado es exactamente por qué funciona.</p><h3>Qué es una skill (y por qué no es lo mismo que un chatbot)</h3><p>Una skill no es un asistente que hace de todo. Es un bloque de instrucciones que le dice a Claude cómo comportarse en un contexto muy específico. Tiene límites explícitos. Sabe qué no debe hacer.</p><figure><img alt="Tabla comparativa con dos columnas tituladas “Lo que es…” y “Lo que no es…”, con cinco filas cada una. La columna izquierda (fondo amarillo) describe un skill como: un prompt especializado, una receta reproducible, un scope cerrado, mejores prácticas destiladas y guardrails explícitos. La columna derecha (fondo naranja) aclara que no es: un agente autónomo, un prompt genérico, un sustituto del criterio del usuario, una herramienta nueva ni algo que se autoevalúa." src="https://cdn-images-1.medium.com/max/1024/1*zPKvpHQg5cSOXj5k21gFcA.png" /><figcaption>Anatomía de un Skill — qué es y qué no es un bloque de instrucciones especializadas para Claude.</figcaption></figure><h3>Las pruebas que hizo Claude sobre la skill</h3><p>Antes de dar la skill por buena, la testée con tres casos reales y la comparé contra lo que haría Claude <em>sin</em> ninguna instrucción especial.</p><figure><img alt="Tabla comparativa de benchmark con tres casos de prueba puntuados sobre 5. Un diseñador con petición clara: 5/5 con la skill, 0/5 sin ella. Un PM con petición vaga: 5/5 con la skill, 3/5 sin ella. Un analista con un mensaje de Slack: 4/5 con la skill, 3/5 sin ella. Medias destacadas en amarillo: 93.3% con la skill frente a 40% sin ella." src="https://cdn-images-1.medium.com/max/1024/1*blMPPt6xk2hVtDYCd08waQ.png" /><figcaption>Benchmark — tres peticiones reales probadas con y sin la Trigger Skill. Sin ella, Claude generó 9 documentos para una petición que solo necesitaba una ficha.</figcaption></figure><p>Ese 0/5 sin skill en el primer caso no significa que Claude sea malo. Significa que sin instrucciones precisas, un modelo hace lo que tiene sentido con una petición de producto: ir al fondo, proponer, documentar. Sin skill, Claude generó <strong>9 documentos</strong> para una petición donde solo hacía falta una ficha; specs, checklists, guías de handoff. Útil en otra situación. Completamente fuera de scope para un Trigger.</p><p>La skill existe para redirigir esa energía hacia lo único que importa en este paso: <strong>capturar, no resolver</strong>.</p><h3>Si quieres crear la tuya</h3><p>No necesitas saber programar. Solo necesitas tener un proceso repetitivo que puedas describir con palabras (y ser muy específico sobre sus límites).</p><h4><strong>Cómo crear tu propia skill en 5 pasos</strong></h4><p>Si usas Claude en Cowork, puedes pedirle directamente que te guíe en todo el proceso: desde definir el scope hasta empaquetar el archivo final. Solo tienes que decirle “quiero crear una skill” y te va llevando paso a paso. Pero para que entiendas qué está pasando por debajo, estos son los cinco pasos:</p><p><strong>1. Define un proceso concreto, no un asistente genérico.</strong> Algo como “capturar peticiones” funciona. “Ayudar con diseño” es demasiado vago.</p><p><strong>2. Escribe qué hace Y qué no hace.</strong> Los límites son tan importantes como las instrucciones.</p><p><strong>3. Define el output exacto.</strong> Estructura fija, campos específicos, formato concreto.</p><p><strong>4. Pruébala con casos reales (y caóticos).</strong> Un caso claro, uno vago y uno copiado de Slack. Los caóticos revelan las grietas.</p><p><strong>5. Empaqueta e instala.</strong> Una skill se distribuye como archivo .skill y se puede envolver en un plugin para compartirla con cualquier equipo. Tu proceso, portátil.</p><h3>Si quieres entender cómo funciona Claude por dentro</h3><p>Si te ha parecido interesante lo que puedes hacer con una skill bien construida, <a href="https://anthropic.skilljar.com/claude-101"><strong>Claude 101</strong></a> es el curso oficial de Anthropic. Te explica desde cero cómo funciona el modelo, cómo darle instrucciones que funcionen y cómo sacarle el máximo partido. Es gratuito y vale mucho la pena si quieres ir más allá del chat.</p><p><em>La </em><a href="https://github.com/DanielaGallardoio/blueprint-trigger"><strong><em>Blueprint Hub Trigger Skill</em></strong><em> está disponible para instalar directamente en Claude</em></a><em>. Si esta skill te ahorró tiempo, puedes </em><a href="https://danielagallardo.gumroad.com/coffee"><em>invitarme a un café</em></a><em>. Me ayuda a seguir construyendo el resto de los pasos del Hub.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10bfc8609a35" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blueprint Hub: the map for not designing like a headless chicken (part 1)]]></title>
            <link>https://www.designsystemscollective.com/blueprint-hub-the-map-for-not-designing-like-a-headless-chicken-part-1-5d10ba678fef?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d10ba678fef</guid>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[design-system-operations]]></category>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[digital-product-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Sat, 18 Apr 2026 05:43:59 GMT</pubDate>
            <atom:updated>2026-04-27T15:15:15.494Z</atom:updated>
            <content:encoded><![CDATA[<h3><em>Blueprint Hub: the map for not designing like a headless chicken</em></h3><p><em>Decide before you design, document just enough, and keep delivering value.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*0ybX5LjWaR6mdPk1.gif" /><figcaption>Animation by Carolina Ibáñez (<a href="https://giphy.com/gifs/run-color-chicken-l3JDq3ElUbOv8QV0s">via GIPHY</a>).</figcaption></figure><p>Have you ever been asked to design an urgent component for a digital product, with no finished Design System (DS) and no room to stop and think? It happened to me. Faced with that urgency, I decided to pause and plan better.</p><p>This case is about <strong>clarity and strategy</strong>: useful, shared, and traceable decisions.</p><p>Here’s how we can open up collaboration even when the design system is incomplete, and how each urgent request can end up adding value to the product and the team.</p><p>In this article I <strong>share a tool for thinking before designing</strong>, documenting key decisions, and building processes that keep you on track even when everything feels urgent and messy. Because designing without a plan only creates more problems.</p><h3>No time for the perfect DS: how I activated collaboration on a Headless in progress</h3><p>One ordinary Monday, a specific request landed:</p><blockquote>“We need to design this component. It’s already been sold. The client approved it.”</blockquote><p>In that moment, I understood I couldn’t just dive into designing. The urgency was clear — I had to create a non-standard, non-scalable component. <strong>Not ideal</strong>, but it happens more often than we’d like.</p><p>The key is to approach it with judgment: deliver for this client now, while <strong>leaving a trace so that if this solution is rolled out to other clients in the future, it can become a standard part of the system and the industry.</strong></p><h4>But how do you actually do that?</h4><p>The answer was the <strong>Blueprint Hub; </strong>currently a Figma file where, instead of designing screens, you organize ideas and decisions to avoid chaos and duplicated work. Without that map, you design like a headless chicken.</p><p>With the focus on creating a planning space to activate collaboration with my team, align priorities, and reduce technical debt while the <strong>Headless Design System </strong>is still being built.</p><p>With this framework, we can:</p><ul><li><strong>Validate</strong> whether the request justifies creating a new component or pattern.</li><li><strong>Check</strong> if something already exists in the system that could be adapted.</li><li><strong>Decide</strong> whether to build something new, use a mixed structure, or simply assemble what we already have.</li></ul><p>In essence, the <em>Hub</em> helps us understand what we’re working with, get familiar with the environment, and think critically before we start creating. It’s the map that guides us, the compass that saves us from designing blind.</p><blockquote><em>💡 </em><strong><em>Takeaway</em></strong></blockquote><blockquote><em>The best design starts before you design. If you don’t organize your thinking first, pixels won’t save you after.</em></blockquote><h3>The real case that sparked it</h3><h4>1. Trigger</h4><p>Any request — like the one that came in that Monday — can be the spark that ignites this framework.</p><p>In this case it was a closed request (not ideal, but it happens): <strong>a date range selector</strong> for a planning module (see fig. 1), <strong>a non-standard molecule already sold and approved by the client</strong>.</p><p><strong>My goal:</strong> deliver without building a <em>Frankenstein</em> that’s impossible to maintain, while leaving a trace so that if this solution is rolled out to other clients in the future, it can become a system standard.</p><p>I opened the <strong>Blueprint Hub</strong> to decide before designing (and to avoid getting lost in Figma).</p><p><em>(Yes, nearly 99% of the time the request will never be “by the book”… but starting from real chaos builds your skin as a designer.)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lkoEYmvTrE46p6aOBcz0tw.png" /><figcaption><em>Fig. 1 — Trigger: a white-label template slide that documents the request and helped me map everything in my head (what / where / with what). A 2-for-1: real deliverable and initial WoW base, replicable within the Blueprint Hub.</em></figcaption></figure><p>Request is clear — I’m still not designing anything. <strong>Map first, pixels later.</strong> I call this gesture<em> </em><strong><em>Mapping</em></strong>.</p><h4>1.5 Mapping: from chaos to clarity</h4><p><strong><em>tl;dr</em></strong><em> <br>Map = knowing where the thinking file is and where the files to review are. Once that’s sorted, move on.</em></p><p>Mapping is not a step. It’s literally about orienting yourself and turning the chaos of a request into a clear map.</p><p><strong>1. What libraries am I working with?</strong> <br>Not everything lives in the Design System. To make a good decision, my first move is to locate myself within our ecosystem. An ecosystem that looks something like this:</p><pre>Any org or enterprise account in Figma<br>│<br>├─ Product Team (my turf)<br>│  │<br>│  └─ Colab Factory (where we are now)<br>│     │<br>│     ├─ Blueprint Hub (where I think)<br>│     │<br>│     └─ Incubadora (where components mature)<br>│<br>└─ Design System Team (reference area)</pre><p><strong>2. Where is the source of truth to review?</strong> (DS, inventory, documentation). This question goes beyond the file. It forces me to check where the logic and previously made decisions live, to avoid reinventing the wheel. Your team probably has one. And if not, now would be a good time to build it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*boAJb4m75YazVrOW4Y1MYA.png" /><figcaption><em>Fig. 2 — The slide used to explain: narrowing the scope and removing noise to turn something overwhelming into a clear, actionable decision roadmap.</em></figcaption></figure><h4>2. Scan: from need to evidence</h4><p><strong><em>tl;dr</em></strong><em> <br>The Scan is a quick review of the Design System to see what’s available and understand where (or whether) the resource I need for the request exists.</em></p><p>With <strong><em>Trigger</em></strong> and <strong><em>Mapping</em></strong> done, the <strong><em>Scan</em></strong> is the quick pass we do through the relevant drawers of the ecosystem.</p><p><strong>This is not designing.</strong> It’s confirming what already exists and what I can use.</p><p>In this phase, I look for answers to three key questions:</p><ul><li><strong>Is there something that already works for me? </strong>(Review of existing components and patterns)</li><li><strong>Is there something we could adapt or simply use?</strong> (Similar components that could evolve to meet the current need)</li><li><strong>If it’s something new, what can I rescue from existing material and assets </strong>— foundations, base components, semantic tokens —<strong> to design it more efficiently and consistently?</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uwxr1hhTmyXykAtU_lwWnQ.png" /><figcaption><em>Fig. 3 — The slide I used with the team for the Scan. I broke the request down into components and confirmed what material existed in the inventory. This evidence helped me make an informed decision.</em></figcaption></figure><p>The <strong>result is evidence</strong>. With this information, we can move to the next step: deciding whether the effort is worth it. That’s the <strong><em>Gap Map</em>.</strong></p><h4>3. Gap Map: when urgency meets strategy</h4><p><strong><em>tl;dr</em></strong><em> <br>The Gap Map is the tool for prioritizing the business need and deciding whether the solution will become a contribution to the DS (once “incubated” — we’ll talk about that in another post), or gets ruled out and stays in a product-specific library.</em></p><p>With the <strong><em>Scan </em></strong>evidence in hand, the <strong><em>Gap Map</em></strong> forces me to think from a business perspective.</p><blockquote>My goal is to assess the type of composition being requested and make a judgment call.</blockquote><p><strong>The logic is simple:</strong> urgency doesn’t justify breaking the rules of the system. Instead, we focus on <strong>creating pieces that add value</strong>, avoiding <em>Frankenstein</em> components.</p><p>To do this, we ask:</p><ul><li><strong>What is each part made of?</strong></li><li><strong>Are its parts an industry standard?</strong> (Can they work across any product?)</li><li><strong>Will they contribute to the Design System, or go into a dedicated library?</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q6Sm1nY2-yVmgdrUY2pALw.png" /><figcaption><em>Fig. 4 — The slide I used to explain the </em><strong><em>Gap Map</em></strong><em>: measuring whether creating a new component was worth the effort. The pieces that added to our design ecosystem were classified as MUST, while those that were only useful for the specific case were ruled out for the Design System.</em></figcaption></figure><h4>4. Decision log: the traceable planning of your decisions</h4><p><strong><em>tl;dr</em></strong><em> <br>This is the final step. Here we consolidate the decision made and document it before designing, to ensure traceability.</em></p><p>With the <strong><em>Scan</em></strong> evidence and the <strong><em>Gap Map</em></strong> prioritization in hand, we reach the final decision. This log is where we document it and make it traceable. The goal is for anyone to understand how we arrived at the final conclusion and why.</p><p>Simply put, this process adds an extra layer to the Gap Map: technical and future-friendly. At this point, you have no screens designed yet; instead, you have <strong>the strategic roadmap for the component:</strong> what it is, what states it has, and which library it belongs to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0IeZqV9NoAP89Y-ETvPAxw.png" /><figcaption><em>Fig. 5 — Slide with the roadmap I consolidated for the team. I documented the final decision for each component, defined their states, and ensured full traceability before designing.</em></figcaption></figure><h3>The Blueprint Hub as a method: the end is the beginning</h3><p>The <strong>Blueprint Hub</strong> is not a static process. It’s a thinking tool that evolves. This real date-selector case helped us establish a roadmap, but also validate the complete methodology. The next <strong>Trigger</strong> we receive will be different, but the <strong>Mapping, Scan, Gap Map,</strong> and <strong>Decision Log</strong> will let us face it with the same clarity and strategy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sWc6WMYEtbUzPl-dRoea7g.gif" /><figcaption><em>Fig. 6 — The slide I used to summarize the complete Blueprint Hub methodology. The idea is that this roadmap helps us turn any urgent request into a clear process — with our heads in the game and the business in mind.</em></figcaption></figure><p>In essence, this process proves that strategic design is not a luxury. It’s a necessity. It’s the only way to <strong>turn an urgent request into an asset for your team, your product, and your design system.</strong></p><p><strong><em>Spoiler:</em></strong><em> </em>In Part 2 I’ll share how we’re starting to build — together as a team — components, molecules, organisms, and patterns using the <em>Hub’s outputs</em> as a foundation.</p><p>We’re no longer designing blind: we’re collaborating with intention, even as the system is still being built.</p><p>This is not about having everything figured out.<br>It’s about designing while thinking, and thinking while building.</p><p><em>And if you’re at that same point, activate your own </em><strong><em>Blueprint Hub.</em></strong><em> Thinking before designing changes the game — I promise.</em></p><p>If you’d like to exchange ideas about design systems, strategic design, <em>frameworks</em>, or just want to say 👋 hi, here’s my <a href="https://www.linkedin.com/in/dani-gallardo/">LinkedIn.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d10ba678fef" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/blueprint-hub-the-map-for-not-designing-like-a-headless-chicken-part-1-5d10ba678fef">Blueprint Hub: the map for not designing like a headless chicken (part 1)</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Connect Your Figma to Claude MCP to Test and Organize Things.]]></title>
            <link>https://www.designsystemscollective.com/how-to-connect-your-figma-to-claude-mcp-to-test-and-organize-things-1317dec44cfc?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/1317dec44cfc</guid>
            <category><![CDATA[designops]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ui-ux-design]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Tue, 14 Apr 2026 18:50:46 GMT</pubDate>
            <atom:updated>2026-04-15T16:22:27.149Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>Stop cleaning up the mess alone.</em></strong></p><figure><img alt="Animated GIF of a yellow penguin wearing oversized black sunglasses with green code reflected in the lenses, sticking its tongue out while typing quickly on a keyboard against a dark blue background." src="https://cdn-images-1.medium.com/proxy/1*ihvLaDCaCoaAcQ06gZl_DA.gif" /><figcaption>GIF: <strong>Crypto Penguin</strong> by <strong>@pamcordovamx</strong> on Giphy.</figcaption></figure><p>Your Figma is messy. That’s a fact.</p><p>And that mess slows you down. It makes you slower when you need to decide, drains your energy, and worst of all: it pulls you away from what you truly care about in design.</p><p>Connecting your Figma to Claude MCP is as simple as saying to AI: “read my file and help me understand what I have.” No complex installations. No massive corporate systems. Just you, your Figma, and an assistant that actually understands.</p><p><strong>Best part:</strong> you can try it right now.</p><h3>What really changes when you connect Claude to your Figma.</h3><p>When your file becomes readable by AI, something happens: <strong>you stop being trapped in chaos.</strong></p><p>You stop wasting mental energy searching for things, wondering which component to use, or trying to remember where you put that variable.</p><p>It becomes clear.</p><p>And when that becomes clear, you shift from “I have too many messy things” to “now I can actually think.” Your head is free to do what makes you love design: solve problems, propose solutions, build things that matter.</p><p>It’s not about AI replacing you. It’s about <strong>AI freeing you to do the work only you can do.</strong></p><h3>Connecting the cables: how to set up your environment</h3><p>For Claude to act as your data processor, it needs to “read” your Figma. We use <strong>Figma MCP </strong>(Model Context Protocol), which is basically a local, secure bridge between your laptop and your design file.</p><p>I’ll explain the process in three digestible technical steps for Mac:</p><h4>1. The foundation: Node.js and Claude Desktop</h4><p>The MCP bridge needs an engine to run on your computer, and that engine is Node.js.</p><ul><li>If you don’t have the Claude Desktop app, <a href="https://claude.ai/download">download it</a>.</li><li>Open your Terminal and type node -v. If it returns a version number, you&#39;re good. If you get an error, you&#39;ll need to <a href="https://nodejs.org/">download Node from its official website</a>, or you can install node with Homebrew through the terminal by following these steps:</li></ul><ol><li>If you don’t have homebrew, <a href="https://www.youtube.com/watch?v=P9jhAqpGnnQ">install homebrew.</a></li><li>Run brew update and then brew install node. This installs Node.js from Homebrew and also makes npm and npx available, all under the same management.</li><li>When installation finishes, verify it worked with which node, node -v and npm -v. If everything went well, you should see a Homebrew path — usually /opt/homebrew/bin/node on Macs with Apple Silicon — along with the version installed.</li></ol><figure><img alt="Alt text: Captura de Terminal en macOS mostrando que Node.js quedó instalado correctamente con Homebrew. Se ve la ruta /opt/homebrew/bin/node, la versión v25.8.0 de Node y la versión 11.1.0 de npm." src="https://cdn-images-1.medium.com/proxy/1*eTeaBWSNLqejvH8axTvgfA.png" /><figcaption>Node.js properly installed with Homebrew on macOS, verified in Terminal using which node, node -v, and npm -v.</figcaption></figure><p><strong>You’re ready to continue with Claude Desktop and MCP configuration.</strong> Once Node.js is correctly installed with Homebrew, you have the foundation ready to move forward with the rest of the technical setup. From there, you can continue with MCP server preparation and connecting both parts.</p><h4>2. The keys to the house: Your Figma Token</h4><p>By basic governance and security rules, we never give an external tool more permissions than it needs. We’ll give Claude a strict “read-only” pass.</p><ul><li>In Figma, go to <strong>Settings &gt; Security</strong>.</li><li>Scroll down to <strong>Personal access tokens</strong> and generate a new one (example: “Claude MCP”).</li><li><strong>Pay attention here:</strong> Check only the read boxes. You need file_content:read to read files, and library_assets:read / library_content:read so it understands your Design Systems. Don&#39;t enable write permissions (write).</li><li>Generate the token and copy that long code. Keep it safe because Figma won’t show it to you again.</li></ul><h4>3. Building the bridge: Local configuration</h4><p>Now you need to tell Claude where we put that key, using a text file.</p><ul><li>Open your Terminal, paste this command and press Enter:</li></ul><pre>open -e ~/Library/Application\ Support/Claude/claude_desktop_config.json</pre><ul><li>A blank file will open. Paste this code, replacing the text with your actual token:</li></ul><p>json</p><pre>{<br>  &quot;preferences&quot;: {<br>    &quot;coworkWebSearchEnabled&quot;: true,<br>    &quot;coworkScheduledTasksEnabled&quot;: true,<br>    &quot;sidebarMode&quot;: &quot;task&quot;<br>  },<br>  &quot;mcpServers&quot;: {<br>    &quot;figma&quot;: {<br>      &quot;command&quot;: &quot;/opt/homebrew/bin/figma-develo&quot;,<br>      &quot;args&quot;: [&quot;--stdio&quot;],<br>      &quot;env&quot;: {<br>        &quot;FIGMA_API_KEY&quot;: &quot;PASTE_YOUR_LONG_TOKEN_HERE&quot;,<br>        &quot;PATH&quot;: &quot;/opt/homebrew/bin:/usr/local/bin&quot;,<br>        &quot;NODE_TLS_REJECT_UNAUTHORIZED&quot;: &quot;0&quot;<br>      }<br>    }<br>  }<br>}</pre><p>🛡 <strong>Trench note: The final boss of corporate networks</strong></p><p>If you’re implementing this on your company’s team, you’ll probably run into a dreaded red error when trying to connect Claude: UNABLE_TO_GET_ISSUER_CERT_LOCALLY.</p><p><strong>Why does this happen?</strong> Companies use proxies and firewalls that intercept traffic to protect the network. Node.js (the engine we’re using) is very strict and, since it doesn’t recognize the certificate modified by your company, it blocks the connection.</p><p><strong>How do you solve this in real life?</strong></p><ol><li><strong>The local development path:</strong> Many teams inject the variable &quot;NODE_TLS_REJECT_UNAUTHORIZED&quot;: &quot;0&quot; into the JSON file or install the package globally (npm install -g) to do quick local tests bypassing proxy validation.</li><li><strong>The official path (Recommended):</strong> If you’re scaling this across your team, the right move is to sit down with your IT department so they can provide you with your company’s root certificate and configure it on Node (npm config set cafile). Make friends with your security team — you&#39;ll need them in DesignOps!</li></ol><h3>4. The real test: The moment of truth</h3><p>After saving your JSON file and fully restarting Claude Desktop (make sure to do Cmd + Q, not just close the window), it’s time to check if we’ve built the bridge correctly.</p><p>An important real-world detail: recent versions of Claude sometimes don’t show a giant visual warning or a “plug” icon when the connection is successful. They simply integrate their new superpowers silently.</p><p>So we won’t guess — we’ll ask the machine directly. Open a new chat in Claude and send it this prompt:</p><pre>Can you list all the available tools?</pre><p>If you did everything right, the firewall didn’t block you, and your token is valid, Claude will respond with something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*momK-ZDzmbaDBxruuphiWQ.png" /></figure><p>Bingo! 🎉 When you see Claude recognizing the <strong>figma:get_figma_data</strong> tool, it means AI already has the keys to get in, read the nodes, the components, and most importantly for our mission: the variables and tokens from your file.</p><h3>Now what?</h3><p>The plumbing is done. The bridge is built. Now comes the interesting part: truly understanding what you have in your Figma. What works, what’s broken, where the technical debt is. From there comes the real work to build your own roadmap.</p><p>But here’s the best part.</p><p>Once you can show your file to Claude, you have access to something very few people use yet: Claude skills.</p><h4>What are skills (simple explanation)</h4><p>A skill is basically a special guide that teaches Claude how to do specific things. If Claude is your general assistant, a skill is like saying “when you do this, do it this way.” They’re clear, step-by-step instructions to solve concrete problems.</p><p>In your case, once Claude understands your Figma, you can install skills that help you improve your structure, design, or whatever you need.</p><h4>I recommend starting with Refactoring UI</h4><p>Now that you know what you have in your Figma, the natural next step is improving how you structure it.</p><p>That’s where Refactoring UI comes in — a skill created by Adam Wathan (the same person who invented Tailwind CSS, a framework used by millions of developers) and Steve Schoger, an expert visual designer.</p><p><strong>What does it teach you?</strong></p><p>How to structure your Figma using constraint systems: fixed spacing scales, limited typography, bounded colors. The idea is simple: constraints generate better results. Professional design without needing to be a natural artist.</p><p><strong>[UPDATE NOTE ]</strong></p><blockquote>April 2026 update: The original instructions used text commands that worked in earlier versions of Cowork. A recent update changed how plugins are installed. What you see below is the current process — tested and verified.</blockquote><h4>How to install it in your Cowork</h4><p>Here’s the real process — no commands that no longer work, no surprises.</p><p>First, open the add menu (click the <strong>+</strong> icon) in Cowork chat, go to <strong>Plugins</strong>, then <strong>Add plugin</strong>.</p><figure><img alt="Cowork menu showing the clip icon, Plugins option, and Add plugin in sequence." src="https://cdn-images-1.medium.com/max/1024/1*oVc-vORYA8Fiqq112iGLlQ.png" /><figcaption>Path to add a plugin in Cowork: + icon → Plugins → Add plugin.</figcaption></figure><p>The Directory opens. Go to the <strong>Personal</strong> tab → <strong>Local installs</strong> → click the <strong>+</strong>. Select the option <strong>Add marketplace.</strong></p><figure><img alt="Cowork plugins Directory with Personal tab selected and the plus button to add local installs." src="https://cdn-images-1.medium.com/max/1024/1*YTjr9AN5CTEfhCZJOY2eAg.png" /><figcaption>Cowork Directory screen, Personal tab, with the + button next to Local installs.</figcaption></figure><p>A dialog appears asking for a URL. Type exactly this:</p><pre>wondelai/skills</pre><figure><img alt="Cowork modal for adding a marketplace with the URL field filled in with wondelai/skills and the Sync button visible." src="https://cdn-images-1.medium.com/max/1024/1*ACIMIVbDhy89fq-381lTcA.png" /><figcaption>“Add marketplace” dialog with wondelai/skills entered in the URL field.</figcaption></figure><p>Cowork loads all available Wondel.ai plugins. Find <strong>Ux design</strong> and click <strong>+</strong>.</p><figure><img alt="Cowork Directory showing available Wondel.ai plugins, including Ux design with an install button." src="https://cdn-images-1.medium.com/max/1024/1*HbxaB09H6QDeMHl8Ul58vw.png" /><figcaption>List of available Wondel.ai plugins in the Directory, including Ux design.</figcaption></figure><p>When the icon changes to a gear, it’s installed. It includes Refactoring UI plus other design skills: iOS HIG, UX Heuristics, Hooked, and more.</p><figure><img alt="Cowork plugin card for Ux design showing a gear icon indicating the plugin is installed." src="https://cdn-images-1.medium.com/max/1024/1*klmLT6FD46aNm4Tv7oDj-Q.png" /><figcaption>Ux design plugin from Wondel.ai successfully installed — the gear icon confirms it’s active.</figcaption></figure><p>That’s it. Five steps, no terminal needed.</p><h4>Try it with me</h4><p>I’ve already installed it and will eventually test it with my Figma to see what changes when I use it. If it works, if it opens new questions for me, if it turns out useful, I’ll tell you about it. Because design is a conversation.</p><p>Now it’s your turn. If you’ve never touched the Cowork terminal before, this is the moment to start. It doesn’t have to be perfect — you just need to follow the steps. And if something doesn’t work, DM me. <a href="https://www.linkedin.com/in/dani-gallardo/">I’m here.</a></p><p>What matters isn’t that it sounds complicated. What matters is that you do it. Because in that moment you stop cleaning up alone and start doing real work.</p><h3>Support this content</h3><p>If this article helped you and you want me to keep writing about how to connect design, AI, and real processes, you can support me here:</p><p><a href="https://danielagallardo.gumroad.com/coffee">Buy me a coffee ☕</a></p><p>Every coffee helps me keep creating content so more people can structure their design without going crazy.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1317dec44cfc" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/how-to-connect-your-figma-to-claude-mcp-to-test-and-organize-things-1317dec44cfc">How to Connect Your Figma to Claude MCP to Test and Organize Things.</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cómo conectar tu Figma con Claude MCP para probar y ordenar cosas.]]></title>
            <link>https://medium.com/@danigallardoreyes/c%C3%B3mo-conectar-tu-figma-con-claude-mcp-para-probar-y-ordenar-cosas-d2dd096057ba?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/d2dd096057ba</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[designops]]></category>
            <category><![CDATA[ui-ux-design]]></category>
            <category><![CDATA[figma]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Tue, 14 Apr 2026 18:44:13 GMT</pubDate>
            <atom:updated>2026-04-15T16:29:37.199Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Deja de limpiar el desorden sola.</em></p><figure><img alt="GIF animado de un pingüino amarillo con gafas de sol negras, con reflejos de código verde en los cristales, sacando la lengua mientras teclea rápidamente sobre un teclado frente a un fondo azul oscuro." src="https://cdn-images-1.medium.com/max/480/1*ihvLaDCaCoaAcQ06gZl_DA.gif" /><figcaption>GIF: <strong>Crypto Penguin</strong> by <strong>@pamcordovamx</strong> on Giphy.</figcaption></figure><p>Tu Figma está desordenado. Eso es un hecho.</p><p>Y ese desorden te frena. Te hace más lento cuando tienes que decidir, te quita energía, y lo peor: te aleja de lo que realmente te importa del diseño.</p><p>Conectar tu Figma con Claude MCP es tan simple como decirle a la IA “lee mi archivo y ayúdame a entender qué tengo”. Sin instalaciones complejas. Sin sistemas corporativos gigantes. Solo tú, tu Figma, y un asistente que lee de verdad.</p><p><strong>Lo mejor: </strong>puedes probar ahora mismo.</p><h3><strong>Lo que realmente cambia cuando conectas Claude a tu Figma.</strong></h3><p>Cuando tu archivo es legible por la IA, ocurre algo: <strong>dejas de estar atrapado en el caos</strong>.</p><p>Ya no gastas energía mental buscando cosas, dudando qué componente usar, o intentando recordar dónde pusiste esa variable. Eso se clarifica.</p><p>Y cuando eso se clarifica, pasas de “tengo demasiadas cosas desordenadas” a “ahora puedo pensar de verdad”. Ahora tu cabeza está libre para hacer lo que te enamora del diseño: resolver problemas, proponer soluciones, construir cosas que importan.</p><p>No se trata de que la IA te reemplace. Se trata de que <strong>te libere para hacer el trabajo que solo tú puedes hacer</strong>.</p><h3>Conectando los cables: cómo preparar el entorno</h3><p>Para que Claude actúe como tu procesador de datos, necesita poder “leer” tu Figma. Usamos <strong>Figma MCP</strong> (Model Context Protocol), que es básicamente es un puente local y seguro entre tu portátil y tu archivo de diseño.</p><p>Te explico el proceso en tres bocaditos técnicos para Mac:</p><h4><strong>1. Los cimientos: Node.js y Claude Desktop</strong></h4><p>El puente MCP necesita un motor para funcionar en tu equipo, y ese motor es Node.js.</p><ul><li>Si no tienes la app de <strong>Claude Desktop</strong>, <a href="https://claude.com/download">descárgala</a>.</li><li>Abre tu Terminal y escribe node -v. Si te devuelve un número de versión, estás lista. Si te da error, toca <a href="https://nodejs.org/es">descargar Node desde su web oficial</a>, o bien, puedes instalar node con Homebrew a través de la terminal ejecutando los siguientes pasos:<br><strong>1)</strong> Si no tienes homebrew, <a href="https://youtu.be/WdNetbWngvM?t=20">instala hombrew</a>.<br><strong>2)</strong> Ejecuta brew update y después brew install node. Esto instala Node.js desde Homebrew y deja también disponibles npm y npx, todo bajo la misma gestión.<br><strong>3)</strong> Cuando termine la instalación, comprueba el resultado con which node, node -v y npm -v. Si todo fue bien, deberías ver una ruta de Homebrew —normalmente /opt/homebrew/bin/node en Macs con Apple Silicon— junto con la versión instalada.</li></ul><figure><img alt="Alt text: Captura de Terminal en macOS mostrando que Node.js quedó instalado correctamente con Homebrew. Se ve la ruta /opt/homebrew/bin/node, la versión v25.8.0 de Node y la versión 11.1.0 de npm." src="https://cdn-images-1.medium.com/max/601/1*eTeaBWSNLqejvH8axTvgfA.png" /><figcaption>Node.js instalado correctamente con Homebrew en macOS, verificado desde Terminal con which node, node -v y npm -v.</figcaption></figure><p><strong>Ya puedes continuar con la configuración de Claude Desktop y MCP</strong><br>Una vez que Node.js está correctamente instalado con Homebrew, ya tienes la base lista para seguir con el resto de la configuración técnica. A partir de ahí, puedes continuar con la preparación del servidor MCP y la conexión entre ambas partes.</p><h4><strong>2. Las llaves de la casa: El Token de Figma</strong></h4><p>Por una regla básica de gobernanza y seguridad, nunca le damos a una herramienta externa más permisos de los que necesita. Le daremos a Claude un pase estricto de “solo lectura”.</p><ul><li>En Figma, ve a <strong>Settings &gt; Security</strong>.</li><li>Baja hasta <strong>Personal access tokens</strong> y genera uno nuevo (ej: “Claude MCP”).</li><li><strong>Ojo aquí:</strong> Marca <em>solo</em> las casillas de lectura. Necesitas file_content:read para leer los archivos, y library_assets:read / library_content:read para que entienda tus Design Systems. No actives permisos de escritura (write).</li><li>Genera el token y <strong>copia ese código largo</strong>. Guárdalo bien porque Figma no te lo volverá a mostrar.</li></ul><h4><strong>3. Construyendo el puente: Configuración local</strong></h4><p>Ahora hay que decirle a Claude dónde pusimos esa llave mediante un archivo de texto.</p><ul><li>Abre tu Terminal, pega este comando y presiona Enter: open -e ~/Library/Application\ Support/Claude/claude_desktop_config.json</li><li>Se abrirá un archivo en blanco. Pega este código reemplazando el texto con tu token real:</li></ul><pre>{<br>  &quot;preferences&quot;: {<br>    &quot;coworkWebSearchEnabled&quot;: true,<br>    &quot;coworkScheduledTasksEnabled&quot;: true,<br>    &quot;ccdScheduledTasksEnabled&quot;: true,<br>    &quot;sidebarMode&quot;: &quot;task&quot;<br>  },<br>  &quot;mcpServers&quot;: {<br>    &quot;figma&quot;: {<br>      &quot;command&quot;: &quot;/opt/homebrew/bin/figma-developer-mcp&quot;,<br>      &quot;args&quot;: [&quot;--stdio&quot;],<br>      &quot;env&quot;: {<br>        &quot;FIGMA_API_KEY&quot;: &quot;PEGA_AQUI_TU_TOKEN_LARGO&quot;,<br>        &quot;PATH&quot;: &quot;/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin&quot;,<br>        &quot;NODE_TLS_REJECT_UNAUTHORIZED&quot;: &quot;0&quot;<br>      }<br>    }<br>  }<br>}</pre><p><strong>🛡️ Nota de trinchera: El jefe final de las redes corporativas</strong> <br>Si estás implementando esto en el equipo de tu empresa, es muy probable que al intentar conectar Claude te enfrentes al temido error rojo: UNABLE_TO_GET_ISSUER_CERT_LOCALLY.</p><p><strong>¿Por qué ocurre?</strong> Las empresas utilizan proxies y cortafuegos que interceptan el tráfico para proteger la red. Node.js (el motor que usamos) es muy estricto y, al no reconocer el certificado modificado por tu empresa, bloquea la conexión.</p><p><strong>¿Cómo se soluciona en la vida real?</strong> <br><strong>1. La vía de desarrollo local:</strong> Muchos equipos inyectan la variable &quot;NODE_TLS_REJECT_UNAUTHORIZED&quot;: &quot;0&quot; en el archivo JSON o instalan el paquete de forma global (npm install -g) para hacer pruebas locales rápidas saltándose la validación del proxy.</p><p>2. <strong>La vía oficial (Recomendada):</strong> Si vas a escalar esto en tu equipo, lo correcto es sentarte con tu departamento de TI para que te proporcionen el certificado raíz de la empresa y configurarlo en Node (npm config set cafile). ¡Hazte amiga de tu equipo de seguridad, en <em>DesignOps</em> los vas a necesitar!</p><h4>4. La prueba de fuego: El momento de la verdad</h4><p>Después de guardar tu archivo JSON y reiniciar Claude Desktop por completo (asegúrate de hacer <strong>Cmd + Q</strong>, no solo cerrar la ventana), llega el momento de comprobar si hemos construido bien el puente.</p><p>Un detalle importante de la vida real: las versiones más recientes de Claude a veces ya no muestran un aviso visual gigante ni un icono de un “enchufe” cuando la conexión es exitosa. Simplemente, integran sus nuevos superpoderes en silencio.</p><p>Para sacarnos de dudas, no vamos a adivinar; vamos a preguntarle directamente a la máquina. Abre un chat nuevo en Claude y lánzale este <em>prompt</em>:</p><pre>¿Puedes listar todas las herramientas (tools) externas a las que tienes acceso mediante MCP en este momento? ¿Ves alguna relacionada con Figma?</pre><p>Si hiciste todo bien, el cortafuegos no te bloqueó y tu token es válido, Claude te responderá con algo parecido a esto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*momK-ZDzmbaDBxruuphiWQ.png" /></figure><p>¡Bingo! 🎉 Cuando veas que Claude reconoce tener la herramienta <strong>figma:get_figma_data</strong>, significa que la IA ya tiene las llaves para entrar, leer los nodos, los componentes y, lo más importante para nuestra misión: <strong>las variables y tokens de nuestro archivo</strong>.</p><h3>¿Ahora qué?</h3><p>Se acabó la fontanería. El puente está tendido. Ahora toca lo interesante: entender de verdad qué tienes en tu Figma. Qué funciona, qué está roto, dónde está la deuda técnica. De ahí sale el trabajo real para hacer tu propio roadmap.</p><p>Pero aquí viene lo mejor.</p><p>Una vez que puedas leerle tu archivo a Claude, tienes acceso a algo que muy poca gente usa todavía: <strong>las skills de Claude</strong>.</p><h4>Qué son las skills (explicación simple)</h4><p>Una skill es básicamente una guía especial que le enseña a Claude cómo hacer cosas específicas. Si Claude es tu asistente general, una skill es como decirle “cuando hagas esto, hazlo de esta forma”. Son instrucciones claras, paso a paso, para resolver problemas concretos.</p><p>En tu caso, una vez que Claude entiende tu Figma, puedes instalar skills que te ayuden a mejorar tu estructura, diseño, o lo que sea que necesites.</p><h4>Te recomiendo empezar con Refactoring UI</h4><p>Ahora que sabes qué tienes en tu Figma, el siguiente paso natural es mejorar cómo lo estructuras.</p><p>Para eso existe <strong>Refactoring UI</strong>, una skill creada por <strong>Adam Wathan</strong> (el mismo que inventó Tailwind CSS, un framework que usan millones de desarrolladores) y <strong>Steve Schoger</strong>, un diseñador visual experto.</p><h4>¿Qué te enseña?</h4><p>Cómo estructurar tu Figma usando sistemas de restricción: escalas fijas de espaciado, tipografía limitada, colores acotados. La idea es simple: <strong>los límites generan mejores resultados.</strong> Diseño profesional sin necesidad de ser un artista innato.</p><p><strong>[NOTA DE ACTUALIZACIÓN]</strong></p><blockquote>Actualización abril 2026: Las instrucciones originales usaban comandos de texto que funcionaban en versiones anteriores de Cowork. Una actualización reciente cambió la forma de instalar plugins. Lo que ves abajo es el proceso actual, probado y verificado.</blockquote><h4>Cómo instalarla en tu Cowork</h4><p>Si quieres probarlo aquí va el proceso real sin comandos que ya no funcionan, sin sorpresas.</p><p>Primero, abre el menú añadir (clic en el icono <strong>+</strong>) en el chat de Cowork, ve a <strong>Plugins</strong> y luego a <strong>Añadir plugin</strong>.</p><figure><img alt="Menú de Cowork mostrando las opciones icono +, Plugins y Añadir plugin en secuencia." src="https://cdn-images-1.medium.com/max/1024/0*7jUg3PfvtFo5LcCs.png" /><figcaption>Ruta para añadir un plugin en Cowork: icono + → Plugins → Añadir plugin</figcaption></figure><p>Se abre el Directorio. Ve a la pestaña/tab <strong>Personal</strong> → <strong>Cargas locales</strong> → click en el <strong>+</strong>.<br>Selecciona la opción Añadir marketplace</p><figure><img alt="Directorio de plugins de Cowork con la pestaña Personal seleccionada y el botón más para añadir cargas locales." src="https://cdn-images-1.medium.com/max/1024/0*3Ed77w4zX1fZCbbT.png" /><figcaption>Pantalla del Directorio en Cowork, tab Personal, con el botón + junto a Cargas locales.</figcaption></figure><p>Aparece un modal que pide una URL. Escribe exactamente esto:</p><pre>wondelai/skills</pre><p>Y haz click en <strong>Sincronizar</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*foU-zKdnSHgOT5qN.png" /><figcaption>Modal “Añadir marketplace” cargando depués de darle al botón “Sincronizar” con wondelai/skills escrito en el campo</figcaption></figure><p>Cowork va a cargar todos los plugins disponibles de Wondel.ai. Busca <strong>Ux design</strong> y haz click en el <strong>+</strong>.</p><figure><img alt="Directorio de Cowork mostrando los plugins disponibles de Wondel.ai, entre ellos Ux design con botón de instalación." src="https://cdn-images-1.medium.com/max/1024/0*v2Mea6ttMiVv7nTk.png" /><figcaption>Lista de plugins de Wondel.ai disponibles en el Directorio, incluyendo Ux design.</figcaption></figure><p>Cuando el icono cambie a una ruedita, está instalado. Incluye Refactoring UI junto con otras skills de diseño: iOS HIG, UX Heuristics, Hooked, y más.</p><figure><img alt="Tarjeta del plugin Ux design en Cowork con icono de engranaje indicando que está instalado." src="https://cdn-images-1.medium.com/max/1024/0*dx1o0z1Voca-l51D.png" /><figcaption>Plugin Ux design de Wondel.ai instalado correctamente (el icono de ruedita confirma que está activo).</figcaption></figure><p>Eso es todo. Cinco pasos, sin tocar el terminal.</p><h4>Pruébala conmigo</h4><p>Yo ya instalé lo que tocaba, ahora probaré con mi Figma para ver qué cambia cuando uso la skill. Si funciona, si me abre preguntas nuevas, si me resulta útil, lo voy a contar. Porque el diseño es una conversación.</p><p>Ahora te toca a ti. Si nunca antes tocaste la terminal o el Cowork de Claude, este es el momento para empezar. No tiene que ser perfecto, solo tienes que seguir los pasos. Y si algo no funciona, escríbeme. <a href="https://www.linkedin.com/in/dani-gallardo/">Estoy aquí.</a></p><p>Lo importante no es que suene complicado. Lo importante es que lo hagas. Porque en ese momento dejas de limpiar sola y comienzas a trabajar de verdad.</p><h3>Apoya este contenido</h3><p>Si este artículo te sirvió y quieres que siga escribiendo sobre cómo conectar diseño, IA y procesos reales, puedes apoyarme aquí:</p><p><a href="https://danielagallardo.gumroad.com/coffee"><strong>Cómprame un café ☕</strong></a></p><p>Cada café me ayuda a seguir creando contenido para que más personas puedan estructurar su diseño sin volverse locos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d2dd096057ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pensar antes de automatizar: cómo extendí el Blueprint Hub a un asistente con IA (parte 2)]]></title>
            <link>https://medium.com/@danigallardoreyes/pensar-antes-de-automatizar-c%C3%B3mo-extend%C3%AD-el-blueprint-hub-a-un-asistente-con-ia-parte-2-f3c975084a41?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3c975084a41</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[designops]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Tue, 13 Jan 2026 17:11:15 GMT</pubDate>
            <atom:updated>2026-01-13T17:11:15.030Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Este artículo tampoco es una guía definitiva. Es la continuación de una bitácora: en la <a href="https://medium.com/@danigallardoreyes/pensar-antes-de-automatizar-c%C3%B3mo-extend%C3%AD-el-blueprint-hub-a-un-asistente-con-ia-parte-1-23ea35f89e15">parte 1</a> definí una regla; en esta, compruebo si esa regla se sostiene cuando se traduce a instrucciones reales.</blockquote><p>No estaba dispuesta a invertir tiempo en algo que no tuviera sentido.</p><figure><img alt="Michael Scott applauding slowly, expressing ironic approval before taking action." src="https://cdn-images-1.medium.com/max/480/1*8MfvZdDujeKq38DcP01vbQ.gif" /><figcaption>Sure. Let’s do it properly. — The Office (via GIPHY)</figcaption></figure><h3>Empezar por lo mínimo</h3><p>Cuando trabajas con productos digitales complejos, el error más común no es técnico: es empezar demasiado grande.</p><p>Estas son algunas <em>red flags</em> habituales para perder recursos:</p><ul><li>🚩 Intentar automatizar antes de entender.</li><li>🚩 Construir soluciones antes de validar criterios.</li><li>🚩 Invertir tiempo y esfuerzo en algo que aún no sabes si se sostiene.</li></ul><p>Por eso decidí <strong>empezar por lo mínimo</strong>.</p><p>No por miedo, ni por falta de ambición, sino para no perder trabajo y poder validar, paso a paso, concepciones delicadas:</p><ul><li>Cómo<strong> se toman</strong> decisiones.</li><li>Cómo <strong>se ordenan</strong> peticiones.</li><li>Cómo <strong>se gobiernan</strong> productos que, si todo va bien, deberán escalar y ser rentables.</li></ul><p>Antes de pensar en un asistente completo, en flujos o en automatizaciones, necesitaba comprobar una sola cosa:</p><blockquote><strong>Si una regla de pensamiento podía sobrevivir cuando se convertía en el comportamiento de un asistente programado.</strong></blockquote><p>Ese fue el verdadero punto de partida.</p><h4>1. <strong>Contrato del tutorial (mini-disclaimer)</strong></h4><p>A partir de aquí entro en la parte práctica. No como receta definitiva, sino como punto de partida: muestro la estructura mínima, los ajustes de interfaz que importan y paso el link al asistente para que el mundo lo pruebe, así me entero e itero.</p><p>No voy a pegar aquí las instrucciones completas.<br>Fuera de contexto pierden sentido, y además esta V0 irá cambiando.</p><p>Lo importante es la lógica:</p><ul><li>¿<strong>Qué</strong> bloqueo?</li><li>¿<strong>Qué</strong> permito?</li><li>¿<strong>Qué</strong> valido antes de avanzar?</li></ul><h4>2. Alcance de esta V0</h4><p>Esta primera versión del asistente:</p><ul><li>Implementa <strong>una sola regla</strong> del Blueprint Hub.</li><li>No diseña ni propone soluciones.</li><li>No automatiza nada.</li><li>Sólo valida si un encargo es claro y gobernable.</li></ul><p>Nada más por ahora.</p><h4>3. ¿Dónde está GPT Builder? (paso práctico claro)</h4><p>Entra a ChatGPT y mira la <strong>barra lateral izquierda.</strong></p><p>Arriba del todo verás algo como: <strong>“Explorar GPT”. </strong>Entra ahí.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ejV3HnPkCDEuaQbVxp-fzw.gif" /><figcaption><strong>Fig. 1 — Acceso a GPT Builder desde la barra lateral de ChatGPT.</strong><br> El punto de entrada no está en un menú técnico ni en una vista avanzada: está integrado en el flujo normal de uso.</figcaption></figure><h4>4. Crear el asistente (setup V0)</h4><p>Una vez dentro de <strong>“Explorar GPT” </strong>arriba a la derecha verás un botón que dice: <strong>“Crear”, </strong>cuando haces clic sobre eso se<strong> </strong>abre el <strong>GPT Builder.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ngkftenuEXo5w8Nj6u67IA.gif" /><figcaption><strong>Fig. 2 — Entrada al GPT Builder desde la vista “Explorar GPTs”, al hacer clic en Crear.</strong><br> Antes de pensar en reglas o comportamiento, hay que saber dónde se construye el asistente.</figcaption></figure><p>No necesitas:</p><ul><li>Ni cuenta extra.</li><li>Ni instalación.</li><li>Ni nada más.</li></ul><p>Es todo dentro de ChatGPT.</p><p>El siguiente paso es “configurar cosas” para la V0.</p><h4>5. Decidir qué configurar (y qué no) en un asistente V0</h4><p>Una vez dentro del GPT Builder, pasé a la pestaña de configuración.</p><figure><img alt="Vista de la pestaña “Configurar” del GPT Builder, mostrando los campos de nombre, descripción, instrucciones, iniciadores de conversación, conocimiento, modelo recomendado y funciones disponibles para un nuevo GPT en estado borrador." src="https://cdn-images-1.medium.com/max/1024/1*j2HZfLx2Wp8itq7ucnw-sA.png" /><figcaption><strong>Fig. 3 — Pestaña “Configurar” del GPT Builder.</strong><br> Vista general de los campos de configuración de un asistente. En esta V0, solo se tocan los elementos que definen comportamiento y expectativas; no se añaden capacidades, herramientas ni conocimiento extra.</figcaption></figure><p>A partir de aquí, <strong>todas las decisiones fueron intencionadamente restrictivas</strong>. Sólo toqué los campos que afectan al comportamiento del asistente y a las expectativas de uso.</p><p>No configuré nada relacionado con automatización o sofisticación técnica. En esta V0, cualquier capa extra habría ocultado si la regla se sostenía por sí sola o no.</p><p><strong>Nombre del Asistente<br></strong>El nombre es lo primero que ve alguien antes de usar el asistente.<br>No es marketing. Es una declaración de alcance.</p><p>Elegí un nombre funcional y explícito: <strong>Blueprint Assistant (V0)</strong>.</p><p>Añadir <em>V0</em> no es un detalle menor:</p><ul><li>Deja claro que no es una solución cerrada.</li><li>No promete más de lo que hace.</li><li>Asume que va a evolucionar.</li></ul><p>Evité nombres grandilocuentes o ambiguos. Si el nombre promete demasiado, el asistente empieza perdiendo credibilidad.</p><figure><img alt="Campo “Nombre” del GPT Builder con el nombre “Blueprint Assistant (V0)” introducido durante la configuración del asistente." src="https://cdn-images-1.medium.com/max/960/1*bw8tImVVS-TpgDXXjuHXjQ.png" /><figcaption><strong>Fig. 4— Campo “Nombre” del asistente en el GPT Builder.</strong><br> El nombre define el alcance antes de cualquier interacción. Añadir “V0” explicita que se trata de una primera versión, deliberadamente limitada y en evolución.</figcaption></figure><p><strong>Descripción<br></strong>La descripción no sirve para explicar cómo funciona el asistente.<br>Sirve para decir <strong>cuándo tiene sentido usarlo</strong>.</p><p>En esta V0, la descripción:</p><ul><li>Acota el tipo de producto (SaaS, productos digitales complejos)</li><li>Filtra usos superficiales</li><li>Alinea expectativas antes de empezar</li></ul><p>No describí reglas ni procesos. Sólo el contexto en el que este asistente tiene sentido.</p><figure><img alt="Campo de configuración del GPT Builder mostrando el nombre “Blueprint Assistant (V0)” y la descripción del asistente, que acota su uso a productos digitales complejos y aclara que no propone soluciones, solo valida la claridad del encargo." src="https://cdn-images-1.medium.com/max/1024/1*9zSM2ZJRfg1Zn2jk55mW2w.png" /><figcaption><strong>Fig. 5— Configuración del nombre y la descripción del asistente.</strong><br> El nombre y la descripción no explican cómo funciona el asistente, sino <strong>qué hace y, sobre todo, cuándo tiene sentido usarlo</strong>. En esta V0, la descripción acota el contexto (productos digitales complejos) y fija un límite claro: validar la claridad del encargo antes de avanzar, nada más.</figcaption></figure><p><strong>Instrucciones </strong>(núcleo del asistente)<strong><br></strong>Todo el comportamiento del asistente, en esta V0, se define en un único lugar: el campo de Instrucciones.</p><figure><img alt="Campo de Instrucciones del GPT Builder, donde se define el comportamiento base del asistente sin añadir conocimiento, herramientas ni automatizaciones." src="https://cdn-images-1.medium.com/max/1024/1*u3fB_Nfkn3bGSBsOg_QQxg.gif" /><figcaption><strong>Fig. 6— Campo de Instrucciones.</strong><br> En esta V0, toda la validación de la regla ocurre aquí.</figcaption></figure><p><strong>Iniciadores de conversación<br></strong>Este campo es más importante de lo que parece.</p><p>Los iniciadores no muestran el <strong><em>mejor</em></strong> uso del asistente, sino el <strong>más real</strong>: peticiones incompletas, urgentes o confusas, como las que llegan en el día a día.</p><figure><img alt="Campo de iniciadores de conversación del GPT Builder con ejemplos de peticiones incompletas y ambiguas." src="https://cdn-images-1.medium.com/max/1024/1*XRieS8ktk6EMqjl2QTt92g.png" /><figcaption><strong>Fig. 7— Iniciadores de conversación.</strong><br> No son prompts “bien escritos”, sino el tipo de caos real con el que llegan las peticiones en el día a día.</figcaption></figure><p>Si el asistente sólo funciona con <strong><em>prompts</em></strong> bien escritos, no funciona en la práctica.</p><p>Aquí busqué provocar el caos inicial que activa la regla que quería y quiero validar.</p><p><strong>Conocimiento externo<br></strong>En esta versión no cargué ningún documento.</p><p>Antes de enseñarle cosas al asistente, necesitaba comprobar que sabía <strong>cómo comportarse</strong>. Añadir conocimiento en esta fase habría contaminado la prueba.</p><p>El problema que estaba validando no era “qué sabe”, sino <strong>cómo decide avanzar</strong>.</p><figure><img alt="Campo de Conocimiento del GPT Builder sin documentos cargados, mostrando el botón “Cargar archivos” vacío." src="https://cdn-images-1.medium.com/max/928/1*eTxDnTSJiLaPqNi3oLmuSw.png" /><figcaption><strong>Fig. 8 — Conocimiento externo.</strong><br> Ningún documento cargado en esta V0.</figcaption></figure><p><strong>Modelo y herramientas<br></strong>Para esta V0 necesitaba un modelo con <strong>capacidad de razonamiento analítico</strong>, no uno optimizado para generar resultados rápidos o creativos.</p><figure><img alt="Selector de modelo recomendado en el GPT Builder configurado en “GPT-5.2 Thinking”." src="https://cdn-images-1.medium.com/max/934/1*BcHxRgHt4AJyWPBb6e58yQ.png" /><figcaption><strong>Fig. 9— Selección del modelo GPT-5.2 Thinking.</strong><br> En esta V0, el modelo no optimiza resultados: garantiza capacidad de razonamiento para sostener la regla de claridad.</figcaption></figure><p>El objetivo no es “responder bien”, sino <strong>pensar con orden</strong>.</p><p>Elegí un modelo orientado a <strong>análisis</strong> porque esta primera regla del Blueprint Hub exige:</p><ul><li>Mantener contexto.</li><li>No adelantarse.</li><li>Sostener estados intermedios de claridad.</li><li>Resistir la tentación de proponer soluciones.</li></ul><p>Aquí el modelo no es una optimización técnica, sino <strong>una condición para que el asistente pudiera comportarse como necesitaba.</strong></p><p><strong>Funciones<br></strong>En esta V0 tomé una decisión consciente sobre qué funciones <strong>sí</strong> podían apoyar la validación de la regla y cuáles no.</p><p><strong>Activé el intérprete de código y análisis de datos</strong>, porque entender un encargo en productos digitales complejos no siempre es solo conceptual:<br>a veces implica leer métricas, tablas, inputs estructurados o información incompleta que necesita ser analizada antes de tomar cualquier decisión.</p><p>Esta capacidad refuerza la fase de clarificación sin empujar al asistente a proponer soluciones.</p><p>En cambio, <strong>desactivé el lienzo</strong>.<br>Visualizar demasiado pronto introduce una tentación clara: avanzar antes de entender. Y esta V0 existe precisamente para bloquear ese comportamiento.</p><p>Otras funciones no forman parte del comportamiento que estoy validando en esta versión.</p><figure><img alt="Panel de funciones del GPT Builder con el intérprete de código activado y el lienzo desactivado." src="https://cdn-images-1.medium.com/max/926/1*QAb6txSi2w-YhCa8oxen3Q.png" /><figcaption><strong>Fig. 10— Configuración de funciones en la V0.</strong><br> Se activa el análisis de datos para apoyar la comprensión de inputs complejos y se desactiva el lienzo para evitar avanzar sin claridad</figcaption></figure><p><strong>Acciones<br></strong>En esta V0 no configuré ninguna acción.</p><p>No porque no sean útiles, sino porque automatizar o ejecutar algo en esta fase habría invalidado la prueba: la regla de claridad debe sostenerse sin hacer nada más que pensar.</p><p>Por ahora, acciones: <strong>ninguna</strong>.</p><figure><img alt="Sección “Acciones” del GPT Builder sin ninguna acción configurada, mostrando el botón “Crear una nueva acción”." src="https://cdn-images-1.medium.com/max/915/1*Dpot99o0lgqRA6PkJ-RvEg.png" /><figcaption><strong>Fig. 11— Acciones.</strong><br> También: absolutamente nada (por ahora).</figcaption></figure><p><strong>Imagen del asistente </strong>(detalle no crítico en V0)<strong><br></strong>Aunque el GPT Builder permite añadir una imagen desde el inicio, decidí tratarla como un detalle secundario en esta primera versión.</p><p>La imagen no define el comportamiento del asistente, pero sí condiciona expectativas. En una V0 centrada en validar una regla de pensamiento, preferí no darle más peso del necesario.</p><p>En el momento de escribir este artículo, además, el cargador de imágenes del builder no estaba funcionando correctamente.</p><p>No afecta al funcionamiento del asistente ni a la prueba que me interesa validar. La subiré cuando el builder deje de pelearse conmigo.</p><p><strong>Publicación del asistente</strong> (tal cual)<strong><br></strong>Con esta configuración, publiqué el asistente tal cual está:</p><ul><li>No añadí nada más.</li><li>No lo “mejoré”.</li><li>No esperé a tenerlo perfecto.</li></ul><h3>¿Y ahora qué?</h3><p>El asistente está publicado y se puede usar aquí: <a href="https://chatgpt.com/g/g-69655eae5ecc8191b29e1261386ba839-blueprint-assistant-v0"><strong>Blueprint Assistant</strong></a></p><p>Puede que funcione bien, puede que funcione regular, puede que no funcione en absoluto. <strong>Y está bien.</strong></p><p>Lo peor que se puede hacer con una herramienta nueva no es usarla mal, es <strong>no usarla nunca</strong>. Si la pruebas y algo no cuadra (o si cuadra demasiado), dímelo. Un DM en <a href="https://www.linkedin.com/in/dani-gallardo/">LinkedIn</a> es suficiente.</p><p>No busco validación. Busco fricción real para poder iterar con criterio.</p><p>Esto no va de acertar a la primera. Va de probar, observar y ajustar con lógica.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3c975084a41" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pensar antes de automatizar: cómo extendí el Blueprint Hub a un asistente con IA (parte 1)]]></title>
            <link>https://medium.com/@danigallardoreyes/pensar-antes-de-automatizar-c%C3%B3mo-extend%C3%AD-el-blueprint-hub-a-un-asistente-con-ia-parte-1-23ea35f89e15?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/23ea35f89e15</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[designops]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Tue, 13 Jan 2026 17:07:09 GMT</pubDate>
            <atom:updated>2026-04-17T15:09:04.921Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Este artículo no es una guía definitiva.<br>Es una bitácora: pienso, pruebo, ajusto y documento mientras construyo un asistente real.</blockquote><figure><img alt="Una mano de marioneta coloca un post-it amarillo con una bombilla dibujada sobre un plano azul tipo blueprint" src="https://cdn-images-1.medium.com/max/500/1*B9nZTLCONK_KfumaO-i3sQ.gif" /><figcaption>GIF “Discuss Sticky Notes” por @masonrystudios, vía GIPHY.</figcaption></figure><h3>Contexto: Blueprint Hub</h3><p>Todo esto parte de mi <a href="https://medium.com/@danigallardoreyes/blueprint-hub-el-mapa-para-no-dise%C3%B1ar-como-una-gallina-sin-cabeza-parte-1-7660f2ca4ce2">Blueprint Hub</a>; un marco de trabajo, un espacio para pensar y planificar qué estoy haciendo realmente, para qué y con qué recursos cuento dentro de un sistema de diseño — o al menos, de la idea de sistema de diseño que estábamos y estamos intentando construir.</p><h3>¿Qué gatilló a crear el asistente?</h3><p>Los resultados del framework en la práctica.</p><p>Creé el marco de trabajo (<em>framework</em> desde aquí en adelante)porque vi que ni yo ni mi equipo teníamos una estructura o un plan de acción que “<strong>desparalizara”</strong> las peticiones de producto.</p><p>Lo construí en cinco días, a partir de una petición real, por pura necesidad: tenía que entender qué me pedían y cómo podía cumplir desde una lógica de fábrica digital.</p><p>Todo esto pasaba mientras, en paralelo, se nos pedían pantallas sin parar… pero también un sistema de diseño que sentara bases ordenadas y profesionales para, más adelante, <strong>inyectar IA y automatizaciones</strong> “como todo el mundo”.</p><p>El Blueprint Hub funcionaba y funciona.<br>Nos ayudó a dejar de diseñar a ciegas y a colaborar con más intención, incluso con el sistema de diseño aún en construcción.</p><p>Pero también dejó algo en evidencia: no todo el mundo llegaba a ese punto de claridad por el mismo camino.</p><h3>El punto de quiebre</h3><p>Ahí empezó mi frustración: había personas que no acababan de “pillar” el framework y, lejos de ayudar, me generaba más trabajo de alineación; más carga de gobernanza.</p><p>En ese punto empecé a preguntarme si el problema se resolvía añadiendo más sistema, más control o incluso automatizando parte del proceso de aterrizaje.</p><p>Pero me di cuenta de que el problema no era técnico.</p><p>No necesitaba una automatización. Necesitaba un <strong>catalizador</strong> que:</p><ul><li><strong>Acompañe</strong> los pasos sin saltarse ninguno.</li><li><strong>Verifique</strong> que el contexto y los recursos se están mapeando de forma ordenada y real.</li><li><strong>Ayude</strong> a sentar una manera común de trabajar — una <em>way of working</em>, aunque suene a WoW — dentro de una lógica de fábrica digital.</li></ul><p>Lo demás puede venir después (sí, sí, las famosas automatizaciones y la IA).</p><p>Entonces, primero lo primero: un <strong>Producto Mínimo viable</strong> (<em>MVP</em> desde ahora en adelante).</p><h3>MVP: Blueprint assistant</h3><p>Estos fueron mis pasos, más bien, mis objetivos para plantear el asistente.</p><h4>1. Escribir en una frase qué problema resuelve y para quién. Nada más.</h4><p>En otras palabras responder a esta estructura:</p><blockquote><strong><em>“Cuando __________, mi Blueprint Assistant me ayuda a __________.”</em></strong></blockquote><p>Y salió así:</p><blockquote>“<strong>Cuando</strong> recibo una petición de producto, <strong>mi Blueprint Assistant me ayuda a</strong> aterrizarla, evaluar con qué recursos cuento y decidir si debo reutilizar o construir algo nuevo, devolviéndome un plan claro de ejecución.”</blockquote><h4>2. Definir qué es (y qué no es) el Blueprint Assistant</h4><p>El siguiente paso no fue técnico ni tuvo que ver con IA todavía.<br>Antes de pensar en herramientas, necesitaba definir qué tipo de ayuda quería construir.</p><p>Es decir, desde qué lugar opera este asistente y qué problemas <strong>no</strong> viene a resolver.</p><p>El Blueprint Assistant <strong>NO es</strong>:</p><ul><li>Un diseñador senior que dicta soluciones.</li><li>Un generador de UI.</li><li>Un consultor abstracto.</li></ul><p>El Blueprint Assistant <strong>SÍ es</strong>:</p><ul><li>Un traductor de peticiones de producto a planes de ejecución utilizando recursos existentes (siempre que sea posible).</li></ul><p>En otras palabras, no sustituye el pensamiento ni la toma de decisiones: <strong>estructura el proceso que hace posible que tengas todo claro y que puedas tomar una decisión </strong>(o varias).</p><p>Con esto claro, la pregunta ya no era <strong><em>¿Qué es el asistente?</em></strong>, sino <strong><em>¿Cómo empieza a comportarse sin traicionar esta lógica?</em></strong>.</p><h4><strong>3. El Comportamiento Mínimo Viable (CMV) del Blueprint Assistant</strong></h4><p>Había una regla que no podía romperse desde el inicio: <br>Si el objetivo es ayudar a pensar antes de diseñar, el asistente no puede empezar entregando soluciones.</p><blockquote>No todo MVP es una funcionalidad.<br>A veces el MVP es el comportamiento mínimo correcto del sistema.</blockquote><p><strong>Regla CMV #1: Claridad como condición de gobernanza</strong></p><ul><li>La gobernanza de una petición requiere que el encargo sea claro.</li><li>El asistente no puede proponer, decidir ni avanzar mientras esta condición no se cumpla.</li></ul><p><strong>¿Cómo verifica el asistente que el encargo sea claro? <br></strong>Para considerar un encargo como claro, el asistente debe ser capaz de todo lo siguiente:</p><ul><li>Identificar <strong>de dónde proviene la petición</strong></li><li>Entender <strong>qué se está pidiendo realmente</strong> (más allá de cómo se formuló)</li><li>Reconstruir una <strong>ficha técnica compartida</strong> que alinee lo que entiende el asistente y lo que entiende la persona que consulta</li></ul><p>Si alguno de estos puntos falla, el encargo <strong>no es gobernable</strong> y el asistente <strong>debe detenerse</strong> en este paso.</p><p><strong>Preguntas iniciales obligatorias<br></strong>El asistente siempre empieza por <strong>el origen de la petición</strong>, porque no todas las peticiones nacen igual ni requieren el mismo tipo de mapeo.</p><p><strong>#1 ¿De dónde viene esta petición?</strong></p><ul><li>¿Es una iniciativa del propio diseñador (algo que detectó pero aún no tiene claro)?</li><li>¿Es una petición de producto (Analista funcional, Manager de Producto)?</li><li>¿Es una petición técnica (ingieniería o desarrollo)?</li><li>¿Es una petición de cliente?</li></ul><p><strong>#2 ¿Qué te están pidiendo realmente?</strong><br> (No cómo te lo pidieron, sino qué necesidad intenta resolver la petición.)</p><p><strong>#3 Ficha técnica de la petición</strong><br> El asistente reformula y valida:</p><ul><li>Qué se pide</li><li>Para qué</li><li>Dónde aplica</li><li>Con qué nivel de urgencia</li><li>Con qué restricciones (técnicas, funcionales, de tiempo y/o presupuesto)</li></ul><p>El objetivo no es documentar por documentar, sino <strong>confirmar que ambas partes están en la misma página</strong> antes de avanzar.</p><h4>Criterio de salida del paso</h4><p>El paso se considera completo sólo cuando el asistente puede afirmar:</p><blockquote><em>“El encargo es claro y gobernable.<br>Entiendo su origen, la necesidad que lo motiva y los límites bajo los que debe abordarse.<br>Aún no se ha diseñado nada.”</em></blockquote><p>Si no puede decir eso → <strong>no se avanza</strong>.</p><h3>Antes del prompt: pensar antes de delegar</h3><p>Todo esto me llevó a una conclusión incómoda, pero necesaria. Hoy todo el mundo quiere <strong>“ponerle IA”</strong> a las cosas, a los productos, a los procesos, a las decisiones.</p><p>Sin embargo, <strong>la IA no crea claridad</strong>; amplifica el estado del sistema que encuentra.</p><p>Si el contexto es difuso, los objetivos están mal definidos y los recursos no están claros, la IA no va a ordenar nada. Va a producir respuestas que parecen correctas, pero desconectadas del fondo.</p><p>La creación de un escenario aparentemente coherente, pero conceptualmente vacío, es especialmente peligrosa, genera ilusión de avance cuando, en realidad, sólo acelera el caos. No ayuda a construir productos ni ecosistemas digitales con bases sólidas.</p><p>Por eso este ejercicio no empezó por la herramienta, ni por el prompt, ni por la automatización. Empezó por una regla básica: <strong>no se puede gobernar lo que no está claro</strong>.</p><p>Aunque el Blueprint Hub se apoya en varias reglas, <strong>el primer paso tenía que ser comprobar si una sola podía sostenerse por sí misma.</strong></p><p><strong>Definir el comportamiento</strong> mínimo de un asistente es, en el fondo, una forma de <strong>proteger el pensamiento antes de delegarlo</strong>.</p><p>En la siguiente parte (<a href="https://medium.com/@danigallardoreyes/pensar-antes-de-automatizar-c%C3%B3mo-extend%C3%AD-el-blueprint-hub-a-un-asistente-con-ia-parte-2-f3c975084a41">parte 2</a>), registro cómo esta regla se traduce a un asistente real y qué ocurre cuando la teoría se enfrenta a una petición desordenada de verdad.</p><p>Antes de enchufar IA a nada, había que hacer esto: <strong>pensar.</strong></p><figure><img alt="“Hombre sonríe a cámara y se señala la sien con un dedo, como diciendo ‘piénsalo’.”" src="https://cdn-images-1.medium.com/max/480/0*J7ZkJUUf7K2a0QQF.gif" /><figcaption>GIF “Think About It” por @Identity, vía GIPHY.</figcaption></figure><p>Si trabajas en sistemas/operaciones de diseño o producto B2B y esto te toca, <strong>conectemos en </strong><a href="https://www.linkedin.com/in/dani-gallardo/"><strong>LinkedIn</strong></a>.</p><p>Mándame un DM y coordinamos un café virtual ☺️.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23ea35f89e15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blueprint Hub: el mapa para no diseñar como una gallina sin cabeza (parte 1)]]></title>
            <link>https://medium.com/@danigallardoreyes/blueprint-hub-el-mapa-para-no-dise%C3%B1ar-como-una-gallina-sin-cabeza-parte-1-7660f2ca4ce2?source=rss-267a7bd00ae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/7660f2ca4ce2</guid>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[digital-product]]></category>
            <category><![CDATA[design-system-operations]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[desing-thinking]]></category>
            <dc:creator><![CDATA[Daniela Gallardo Reyes]]></dc:creator>
            <pubDate>Wed, 27 Aug 2025 09:43:21 GMT</pubDate>
            <atom:updated>2025-08-27T09:43:21.050Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Decidir antes de diseñar, documentar lo suficiente y seguir generando valor.</em></p><figure><img alt="Dibujo lineal multicolor de una gallina sin cabeza corriendo sobre fondo negro" src="https://cdn-images-1.medium.com/max/600/1*7Gqoxg2YKQyRcFQBd0cj5g.gif" /><figcaption>Animación de Carolina Ibáñez (<a href="https://giphy.com/gifs/run-color-chicken-l3JDq3ElUbOv8QV0s">vía GIPHY</a>).</figcaption></figure><p>¿Te han pedido alguna vez diseñar un componente urgente para un producto digital, sin un Design System (<em>DS</em>) terminado ni margen para frenar? A mí me pasó, y ante la urgencia decidí parar para planificar mejor.</p><p>Este caso va de <strong>claridad y estrategia:</strong> decisiones útiles, compartidas y trazables.</p><p>Así es como podemos abrir la colaboración incluso cuando el sistema de diseño está incompleto, y cada petición urgente termina aportando al producto y al equipo.</p><p>En este artículo <strong>comparto una herramienta para pensar antes de diseñar</strong>, documentar decisiones clave y construir procesos que mantienen el rumbo aunque todo parezca urgente y desordenado. Porque diseñar sin plan solo genera más problemas.</p><h3>No hay tiempo para el DS perfecto: así activé colaboración en un Headless en progreso</h3><p>Un lunes cualquiera, una petición concreta:</p><blockquote>“Hay que diseñar este componente. Ya lo vendimos. El cliente lo ha aprobado.”</blockquote><p>— En ese momento, entendí que no podía ir directa a diseñar. La urgencia era clara; tenía que crear un componente que no era estándar ni escalable, <strong>no es lo ideal</strong>, pasa más a menudo de lo que quisiéramos.</p><p>La clave está en abordarlo con criterio: cumplir para este cliente ahora, y <strong>dejar trazado que, si en el futuro la solución se lleva a otros clientes, se transforme en algo estándar del sistema y de la industria.</strong></p><h4>Pero ¿cómo cumplir con este criterio?</h4><p>La respuesta fue el <strong>Blueprint Hub; </strong>actualmente es un archivo en Figma, donde no se diseñan pantallas, sino que se ordenan ideas y decisiones para evitar caos y trabajo duplicado. Sin ese mapa, diseñas como una gallina sin cabeza.</p><p>Con el foco puesto en crear un espacio de planificación para activar la colaboración junto a mi equipo, alinear prioridades y reducir la deuda técnica mientras el <strong>Headless Design System</strong> aún está en construcción.</p><p>Con este marco de trabajo, podemos:</p><ul><li><strong>Validar</strong> si la petición justifica la creación de un nuevo componente o patrón.</li><li><strong>Revisar</strong> si ya existe algo en el sistema que se podría adaptar.</li><li><strong>Decidir</strong> si creamos algo nuevo, usamos una estructura mixta o simplemente ensamblamos lo que ya tenemos.</li></ul><p>En esencia, el <em>Hub</em> nos ayuda a saber con qué contamos, a familiarizarnos con el entorno y a pensar con criterio antes de empezar a crear. Es el mapa que nos guía, la brújula que nos salva de diseñar a ciegas.</p><p>💡 <strong>Takeaway </strong><br>El mejor diseño empieza antes de diseñar. Si no ordenas tu cabeza primero, los pixeles no te salvarán después.</p><h3>El caso real que lo detonó</h3><h4>1.Trigger</h4><p>Cualquier petición, en este caso la del lunes, puede ser la chispa que encienda este marco de trabajo.</p><p>En este caso fue una petición cerrada (no es lo ideal, pero pasa): un <strong>selector de rango de fechas</strong> para un módulo de planificación <em>— ver fig. 1 —</em> una <strong>molécula no estándar</strong> ya <strong>vendida y aprobada</strong> por el cliente.</p><p><strong>Mi objetivo:</strong> cumplir sin fabricar un <em>Frankenstein</em> imposible de mantener y, a la vez, dejar trazado que si en el futuro esta solución se lleva a otros clientes, se transforme en algo estándar del sistema.</p><p>Abrí el <strong>Blueprint Hub</strong> para decidir antes de diseñar (y no perderme en Figma).</p><p><em>(Sí, casi el 99% de las veces la petición nunca será “de libro”… pero partir del caos real: te curte la piel de diseñador.)</em></p><figure><img alt="Slide “Caso real = Trigger” del Blueprint Hub: ficha marca blanca de una solicitud de selector de rango de fechas — petición cerrada y urgente, aprobada por cliente; resalta la mezcla no estándar (slider de dos nodos + inputs), con nota resumen, metadata y un wireframe pequeño del slider." src="https://cdn-images-1.medium.com/max/1024/1*vxru80TYcsjhnhsN5SkKhA.png" /><figcaption>Fig. 1 — Trigger: slide tipo (marca blanca) que documenta la petición y <strong>me ayudó a mapear todo en mi cabeza</strong> (qué/dónde/con qué). Un <strong>2×1</strong>: entrega real y <strong>base inicial de WoW</strong> replicable dentro del Blueprint Hub.</figcaption></figure><p>Encargo claro, aún no diseño nada<strong>. Primero mapa, luego píxel.</strong> A este gesto lo llamo <strong>Mapping</strong>.</p><h4>1.5 Mapping: del caos a la claridad</h4><p><strong><em>tl;dr</em><br></strong> <em>Mapa = saber dónde está el archivo para pensar y dónde están los archivos que hay que revisar. Con eso resuelto, siguiente paso.</em></p><p>Mapping no es un paso, es literalmente ubicarse y convertir el caos de la petición en un mapa claro.</p><p><strong>1. ¿Con qué librerías estoy trabajando?</strong> <br>No todo está en el Design System. Para tomar una buena decisión, mi primer paso es ubicarme dentro de nuestro ecosistema. Un ecosistema que se parece a esto:</p><pre>Cualquier cuenta org o enterprise en Figma<br>│<br>├─ Team de Producto (mi cancha)<br>│    │<br>│    └─ Colab Factory (aquí estamos ahora)<br>│        │<br>│        ├─ Blueprint Hub (donde pienso)<br>│        │<br>│        └─ Incubadora (donde maduran los componentes)<br>│<br>└─ Team del Design System (área de consulta)</pre><p><strong>2. ¿Dónde está la fuente de verdad para revisar?</strong> (DS, inventario, documentación). Esta pregunta va más allá del archivo. Me obliga a revisar dónde reside la lógica y las decisiones ya tomadas para evitar reinventar la rueda, seguro tu equipo tiene una y sino, vendría siendo hora de tenerla.</p><figure><img alt="Fig. 2 — Mapping explicado al equipo: pienso en el Blueprint Hub (Product A · Colab Factory) y consulto Theme A del DS — Component Library [solo lectura], A-Dedicated, y Documentación. Si no existe, dejo candidato en Incubator (explicaremos en otro artículo de qué va el incubator)." src="https://cdn-images-1.medium.com/max/1024/1*ClqhQWwetx1GcPdFeR6rbw.png" /><figcaption>Fig. 2 — La slide para explicar: acotar el terreno y quitar ruido para transformar lo abrumador en un <strong>roadmap de decisiones claro y accionable</strong>.</figcaption></figure><h4>2. Scan: de la necesidad a la evidencia</h4><p><strong><em>tl;dr</em></strong><em> </em><br><em>El Scan es una revisión exprés del Sistema de Diseño para ver material disponible y saber dónde está (o si no está) el recurso que me puede ayudar con la petición.</em></p><p>Con el T<em>rigger</em> y el M<em>apping</em> listos, el <em>Scan</em> es la revisión rápida que hacemos en los cajones correspondientes del ecosistema.</p><p><strong>No es diseñar.</strong> Es constatar qué ya existe y me sirve.</p><p>En esta fase, busco respuestas a tres preguntas clave:</p><ul><li><strong>¿Existe algo que ya me sirva?</strong> (Revisión de componentes y patrones existentes)</li><li><strong>¿Hay algo que podamos adaptar o simplemente utilizar?</strong> (Componentes similares que puedan evolucionar a la necesidad actual)</li><li><strong>Si es algo nuevo, qué puedo rescatar del material y assets actuales </strong>— <em>foundations</em>, componentes base, <strong>tokens semánticos </strong>— para diseñarlo de forma más eficiente y consistente.</li></ul><figure><img alt="Diapositiva que muestra el segundo paso de un marco de trabajo, titulado “2. Scan: Notas y comprobaciones”. A la izquierda, un desglose de una solicitud de diseño, donde se especifica que dos componentes de Input de fecha y un Slider de 2 nodos no existen en el inventario. A la derecha, una simulación de un documento con la solicitud original de un selector de rango de fechas y una nota amarilla que resume el resultado del Scan: que la combinación de componentes no existe." src="https://cdn-images-1.medium.com/max/1024/1*mEVBoXwdL4uem01QX8-67A.png" /><figcaption>Fig. 3 — La slide que utilicé con el equipo para el Scan. Desglocé la petición en componentes y constaté qué material existía en el inventario. Esta evidencia me ayudó a tomar una decisión informada.</figcaption></figure><p><strong>El resultado es evidencia.</strong> Con esta información, podemos pasar al siguiente paso: decidir si vale la pena el esfuerzo; el <em>Gap map</em></p><h4>3. Gap Map: cuando la urgencia se encuentra con la estrategia</h4><p><strong>tl;dr<br></strong><em>El </em><strong><em>Gap map </em></strong><em>es la herramienta para priorizar la necesidad del negocio y decidir si la solución se convertirá en un aporte para el DS (una vez “incubada”— hablaremos de esto en otra entrada), o se descarta como tal y se queda en una librería exclusiva del producto.</em></p><p>Con la evidencia del <em>Scan</em> en la mano, el <em>Gap map</em> me obliga a poner la cabeza en el negocio.</p><blockquote>Mi objetivo es sortear el tipo de composición de la solicitud y decidir con criterio.</blockquote><p><strong>La lógica es simple:</strong> una urgencia no justifica romper las reglas del sistema. En su lugar, nos enfocamos en <strong>crear piezas que sumen</strong>, evitando los componentes <em>Frankenstein</em>.</p><p>Para lograr esto, nos hacemos las siguientes preguntas:</p><ol><li><strong>¿De qué va cada una de sus partes?</strong></li><li><strong>¿Sus partes son un estándar en la industria?</strong> (¿Me pueden servir para cualquier producto?)</li><li><strong>¿Serán un aporte al Design System o irán a una librería dedicada?</strong></li></ol><figure><img alt="Diapositiva que muestra el tercer paso de un marco de trabajo, titulado “3. Gap Map: Decidir con criterio, incluso en urgencia”. Una tabla compara tres componentes: “Input pequeño (fecha)”, “Slider de dos nodos” y “Molécula inputs + slider”. La tabla evalúa cada componente según si es un estándar en la industria y si forma parte del Design System. Los dos primeros se clasifican como “Sí” y “MUST”, mientras que la combinación se clasifica como “No” y “WON’T”. Debajo de la tabla, una leyenda expli" src="https://cdn-images-1.medium.com/max/1024/1*ynvU8pEUoPS74h9xYfxNYw.png" /><figcaption>Fig. 4 — La slide que utilicé para explicar el Gap map: medir si valía la pena el esfuerzo de crear un nuevo componente. Las piezas que sumaban a nuestro ecosistema de diseño se clasificaron como MUST, mientras que las que solo eran útiles para el caso puntual se descartaron para el Design System.</figcaption></figure><h4>4. Decision log: el <em>planning</em> trazable de tus decisiones</h4><p><strong><em>tl;dr</em></strong><br><em>Este es el último paso. Aquí consolidamos la decisión tomada y la documentamos antes de diseñar para asegurar la trazabilidad.</em></p><p>Con la evidencia del <em>Scan</em> y la priorización del <em>Gap map</em> en la mano, llegamos a la decisión final. Este <em>log</em> es el paso donde documentamos y hacemos trazable nuestra decisión. El objetivo es que cualquiera pueda entender cómo llegamos a la conclusión final y por qué.</p><p>En simple, este proceso es añadir una capa extra al <em>Gap map</em>, de manera técnica y amigable con el futuro. En este punto, no tienes pantallas diseñadas, sino <strong>la hoja de ruta estratégica del componente</strong>, que te dice qué es, qué estados tiene y a qué librería va a parar.</p><figure><img alt="Diapositiva que muestra el cuarto paso de un marco de trabajo, titulado “4. Decision log: el planning trazable de tus decisiones”. Una tabla detalla las decisiones finales para tres componentes: “Input pequeño (fecha)”, “Slider de dos nodos” y “Molécula inputs + slider”. Para los dos primeros, la decisión final es que se crearán como componentes estándar del Design System. Para la molécula combinada, la decisión es que no formará parte del DS, sino que será un caso puntual en una librería dedica" src="https://cdn-images-1.medium.com/max/1024/1*ATvHFj-qozbUQFjfOzrGzA.png" /><figcaption>Fig. 5— Slide con la hoja de ruta que consolidé para el equipo. En ella documenté la decisión final de cada componente, definí sus estados y aseguré la trazabilidad del proceso antes de diseñar</figcaption></figure><h3>El Blueprint Hub como método: el final es el inicio</h3><p>El Blueprint Hub no es un proceso estático, sino una herramienta de pensamiento que evoluciona. Este caso real del selector de fechas nos sirvió para establecer una hoja de ruta, pero también para validar la metodología completa. El Trigger que recibamos la próxima vez será diferente, pero el Mapping, el Scan, el Gap Map y el Decision Log nos permitirán afrontarlo con la misma claridad y estrategia.</p><figure><img alt="Diagrama de flujo con el título “Blueprint hub → 4 pasos: Del Trigger al GO/NO-GO” que resume la metodología de diseño. El proceso se divide en cuatro círculos azules: 1. Trigger, donde se detecta la necesidad; 2. Scan, donde se comprueba si la petición existe; 3. Gap Map, donde se mide lo que falta para cumplir; y 4. Decision Log, donde se define la ruta del componente." src="https://cdn-images-1.medium.com/max/1024/1*C0MW1F1KsKgXl8Q-PLxsAw.gif" /><figcaption>Fig. 6 — La slide que utilicé para resumir la metodología completa del <strong>Blueprint Hub</strong>. La idea es que esta hoja de ruta nos ayude a convertir cualquier petición urgente en un proceso claro; con la mente en el juego y el negocio.</figcaption></figure><p>En esencia, este proceso es la prueba de que el diseño estratégico no es un lujo, sino una necesidad. Es la única forma de <strong>convertir una petición urgente en un activo para tu equipo</strong>, tu producto y tu sistema de diseño.</p><p><em>Spoiler:</em> En la Parte 2 compartiré cómo estamos empezando a construir — junto al equipo — componentes, moléculas, organismos y patrones usando como base los insumos del <em>Hub</em>.</p><p>No diseñamos más a ciegas: estamos colaborando con intención, aunque el sistema aún esté en construcción.</p><p>Esto no va de tener todo resuelto.<br>Va de diseñar mientras pensamos, y pensar mientras construimos.</p><p><em>Y si estás en ese mismo punto, activa tu propio</em><strong> Blueprint Hub</strong><em>. Te aseguro que pensar antes de diseñar cambia el juego.</em></p><p>Si quieres intercambiar ideas sobre sistemas de diseño, diseño estratégico, <em>frameworks </em>o simplemente pasar a 👋 saludar, aquí está mi <a href="https://www.linkedin.com/in/dani-gallardo/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7660f2ca4ce2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>