I've spent a lot of time staring at browser tabs, switching between Figma, Jira, and my IDE, trying to verify if the padding on a button matches what is written in the CSS. It's a low-value, high-friction task that kills flow. When we talk about 'AI agents' today, most people focus on them writing code or summarizing text. But the real productivity leap isn't just having an agent write a component; it's having an agent audit your design layers against your implementation without you ever leaving Cursor.
This is what happens when you bridge the gap with the Lanhu MCP server.
The context-switching tax
If you are working in a high-performance team, design handoff is usually where momentum goes to die. A designer makes a change in Lanhu, leaves a comment about a color tweak, and then... nothing happens until you manually notice the notification, open the web interface, find the layer, and translate that back into code.
If you are using an agent like Claude or Cursor, that agent is currently blind to your design source of truth. It only knows what you copy-paste into it. You can paste a screenshot, sure—but screenshots don't give you the structural metadata. They don't tell you if a group is named btn-primary-container or just Group 452.
By using the Lanhu MCP server (available at https://vinkius.com/mcp/lanhu), you are essentially giving your agent a structural view of your design workspace.
Beyond the screenshot: Structural Auditing
The magic isn't in 'seeing' the design; it's in querying it. When I looked at the toolset available in this Lanhu implementation, one specific thing stood out that most people skimming documentation would miss: the list_layers and get_file tools.
Most developers think of MCP as a way to 'show' an image to an LLM. That is trivial. The real power lies in retrieving node structures and metadata. With list_layers, your agent can recursively traverse the hierarchy of a Lanhu file.
You can prompt your agent: "Check the layers in the 'checkout-v1' file. Are there any hardcoded hex values that deviate from our design tokens?"
The agent doesn't just look at a picture; it parses the tree. It sees the nodes, identifies the properties, and compares them against the context you've provided in your codebase. This turns an AI agent from a simple coder into a Design Ops auditor.
What you can actually automate
Based on the tools available in this server, we aren't just talking about viewing files. We are talking about orchestration:
-
Automated Component Audits: Using
list_layersandget_file, an agent can verify if your React component props match the design specifications (e.g., checking if a padding value in Lanhu matches your Tailwind config). -
Comment-Driven Development: The
get_commentstool is massive. Instead of hunting for feedback, you can ask: "Summarize all recent designer feedback on the 'Mobile Wallet' project and create a checklist of tasks in my editor." -
Project Discovery: If you are part of multiple teams, use
list_teamsandlist_project_filesto let the agent find the relevant assets for the feature you are currently building.
The Security Reality
Here is where we need to be honest: giving an AI agent access to your design workspace—which often contains sensitive product roadmap info—is a massive security risk. If you're running a custom MCP script on your local machine, what happens if that script has an SSRF (Server-Side Request Forgery) vulnerability? Or what if the agent starts leaking team member details through list_members?
When I built Vinkius, this was my primary obsession. We don't just run these tools; we run them in isolated V8 sandboxes. Every execution context has eight distinct governance policies—including DLP (Data Loss Prevention) and HMAC audit chains. When your agent calls get_comments, it's happening within a controlled environment that prevents the agent from using that connection to probe your internal network.
If you are building production-grade workflows, 'it works on my machine' isn't enough. You need an execution layer that handles the heavy lifting of security and auth so you can focus on the prompt engineering.
Getting started
The setup is intentionally stripped of friction. I hate the moment a developer has to configure complex OAuth callbacks just to test a tool.
- Subscribe to the Lanhu server on Vinkium.
- Grab your Lanhu Access Token (found in your [User Settings] → [Access Token]).
- Paste the connection token into Claude or Cursor.
That's it. No heavy lifting, no broken dependencies.
You can find the full catalog and setup instructions here: https://vinkius.com/mcp/lanhu
We are moving toward a world where the IDE is the center of all engineering truth—not just code, but design, documentation, and project management. The MCP protocol is the glue that makes this possible. Stop manual checking; start orchestrating.
MCPs are the music of AI Agents. We built the catalog. Discover Vinkius MCP Catalog.
Top comments (0)