Summary: This is a work note about connecting my website’s brand tokens to Claude Design in June 2026. What remains useful is the judgment involved in defining the synchronization scope, reviewing permissions, and accepting the result. The interface, commands, and plan from that time are not a fixed guide to the product today. Importing design data also does not establish that every output follows the brand.

Halfway through the process, I was looking at a permission confirmation in the terminal, my finger hovering above Enter. I only wanted to synchronize colors, typefaces, and spacing, yet the dialog referred to a seemingly unrelated subdirectory.

At that moment, I decided to stop and read what the tool was preparing to do.

I retain this experience because whether a tool can perform an action and whether I should allow it to do so are different questions. No single command can replace that judgment.

Connecting Design Data Still Requires Checking the Output

In a product article published on June 17, 2026, Claude introduced design-system imports and design-sync, describing ways to bring existing design data into a workflow. What attracted me was the possibility of giving generation a more concrete basis instead of describing a brand verbally every time.

Reading a specification does not guarantee a correct result. A tool may have the right color reference and still use it in the wrong context. Having typeface data does not establish that hierarchy, spacing, and readability are appropriate.

An import supplies a design reference; the finished work still needs to be checked item by item.

What I wanted to test was how far this connection could go on my own website. This essay records the scope of that work, not a compatibility test for every project.

An Entry Point Used Then Is Not a Permanent Product Boundary

For that synchronization, I chose Claude Code and used a separate design workspace to inspect the contents. That explains what I did at the time. It does not establish that only Code can use Design or that Chat can never participate.

The official getting-started documentation reviewed for this revision describes access through conversations, Artifacts, and Claude Code, and says that Design shares usage with other activity under the plan. The original claim that Design had a separate weekly allowance that did not affect Chat or Code should not be presented as a current rule.

Historical operations and current product documentation need to be read separately.

Nor is this a promise about availability for any particular account. Before beginning, a user still needs to check the applicable plan, administrative settings, tool version, and current interface. There is no need to follow an old command merely to recreate my experience.

Decide What to Move Before Deciding How to Run the Command

At the time, I chose to synchronize only brand tokens: foundational specifications such as colors, typefaces, and spacing, rather than complete components. The original work note records ten files and a validate result of exit 0. Those were results from that work, not evidence that this revision ran the process again.

When I was working with the Astro project, component synchronization was outside that delivery scope. I therefore chose the smaller scope. That is not an official conclusion that Claude Design can never support Astro, nor does it guarantee that a tokens-only synchronization cannot fail.

Define the synchronization scope first, so the acceptance check knows what to examine.

I also created a new project rather than mixing website-specific data into a potentially shared design system. That was my choice in that situation, not the only arrangement everyone should use.

The /update and /design-sync commands, tokens-only option, and .design-sync/ name mentioned in the original essay should be read as names from the work note at that time. Tools change, so anyone repeating the work needs to read the current documentation.

Read the Permission Dialog as a Complete Action and Path

During that work, I traced a prompt involving an unrelated worker subdirectory back to the choice of working directory. That was my understanding of this particular incident, not a guarantee that every similar prompt has the same cause.

The reusable practice is to compare the requested authorization with the task in front of me. Which data will it read? Which files will it change? Will it connect to an external service? Does the permission apply only once, or remain in effect afterward?

A command’s name alone cannot prove that it only reads and never writes.

For example, the behavior of sed depends on its complete arguments and how it is combined with other operations. The absence of a > character does not mean that writing is impossible. A sandbox may provide specific boundaries, but the phrase “inside a sandbox” does not by itself establish that every data access and action is appropriate.

If the displayed scope goes beyond the requirement I understand, I stop to clarify or reduce it. What needs to be judged is the actual action, not how confidently the tool presents it.

Reading the File Is More Reliable Than Either Side’s Memory

During the synchronization, I thought the brand data lived under src/, while the tool found the source under public/styles/. I retain that detail as an instance in which my memory was corrected, not as a path that every current version of the website should copy.

The important point is not which side remembered more accurately. It is whether we returned to the file and checked. After finding a file, I still need to confirm that it is the version and source intended for the present task. Its mere existence does not make it authoritative.

After locating a file, confirm its purpose and version.

The same principle applies to publication. During that work, I assumed that pushing the code would trigger deployment and then returned to the project’s rules to verify the actual process. Synchronizing version control and formally publishing the website are separate outcomes.

Exit 0 Answers Only the Question That Was Checked

A validate command returning exit 0 may indicate that the specified check passed under the rules in effect at the time. Its meaning depends on what the validation actually examined. It cannot be expanded into proof that the entire design system is correct.

I also opened Cowork at the time and compared the source with the synchronized output, including color values. That was the acceptance arrangement recorded in the original note. A separate window does not naturally possess independent judgment merely because it is separate. A reviewer needs access to the original data, knowledge of the criteria, and may still share blind spots with the executor.

The value of a second set of eyes lies in checking the evidence and criteria again.

An executor’s self-check remains useful. For an important delivery, a reviewer who did not participate in producing it may add another perspective. I no longer describe self-verification as no verification at all.

This comparison covered tokens. It did not establish that every generated screen, component, mobile layout, and accessibility requirement had passed. An acceptance record should state both what was confirmed and what remained outside its scope.

Commits, Synchronization, and Publication Have Different Endpoints

The original work note recorded a commit, aligned mirrors, and a closeout without force. Those are version-control descriptions from that time. They are not evidence that the website content went live, nor should they become instructions for pushing directly to main from an arbitrary working directory.

Under the site’s current shared rules, changes intended for main are integrated in the primary checkout and synchronized there with git sync. Deployment uses its separate established process. After synchronization succeeds, the content served from the production domain still needs to be checked.

Preserving a version, synchronizing mirrors, and publishing a website each require separate confirmation.

Readers do not need to copy my combination of tools. The more useful lesson is to agree on the delivery scope first, then choose acceptance and publication methods that fit it.

Four-panel comic: Historical operations and current product documentation need to be read separately. Define the synchronization scope first, so the acceptance check knows what to examine. A command's name alone cannot prove that it only reads and never writes. The value of a second set of eyes lies in checking the evidence and criteria again. Preserving a version, synchronizing mirrors, and publishing a website each require separate confirmation. An import supplies a design reference; the finished work still needs to be checked item by item.

Before Pressing Enter, Know What You Are Allowing

This experience made three practices more important to me: define the scope first, verify the source at the time of use, and accept the result against stated criteria. They do not guarantee an error-free process, but they make a claim of “complete” easier to understand and examine.

This continues the line of thought in my writing on multi-model collaboration and on taste and judgment. The work is not finished merely because execution has been handed over. Purpose, permissions, and results still need to remain connected.

The next time a confirmation appears, I still want to ask first: what, exactly, am I allowing it to change?