AGENT SKILL

ams-figma-pro-dev

暂无简介

License 许可
MIT
所属仓库
TanNhatCMS/jarvis
最近更新
2026-11-07
Stars
★ 0
Forks
1

03 SKILL.md 正文

Figma Pro (Dev)

Overview

For developers, Figma is the source of truth for what to build — and the collaboration surface with designers. Professional Figma usage from the dev side means: extracting specs efficiently (dev mode), consuming design tokens as code, implementing components to match the design system's intent (not just pixels), and giving designers feedback that improves the handoff both ways.

The through-line: implement the system, not the screenshot — tokens, components, and behaviors, not one-off pixel values.

When to use

  • Implementing UI from Figma designs.
  • Extracting design tokens (colors, type, spacing) into code.
  • Reviewing designs for implementability before building.
  • Setting up design-token pipelines (Style Dictionary, Tokens Studio).
  • Giving designers developer-friendly feedback.

Core concepts

  • Dev Mode as the interface. Inspect mode: measurements, colors, typography, assets export, and code snippets (CSS/iOS/Android). Compare designs vs implementation (visual diffing); focus on tokens and components, not copying generated CSS verbatim.
  • Design tokens, not hex codes. Colors, typography scales, spacing, radii, shadows defined as named tokens in Figma Variables — exported to code (Style Dictionary, Tokens Studio) as the single source of truth. Hardcoded #3B82F6 in code while Figma says color/primary/600 is drift waiting to happen.
  • Components map to components. Figma components (with variants, auto-layout, properties) should correspond 1:1 with code components (props = Figma properties). Mismatched granularity — Figma has 3 button variants, code has 12 — signals a broken handoff conversation.
  • Auto-layout ≈ flexbox. Figma's auto-layout maps directly to flexbox concepts (direction, gap, padding, alignment). Designs built with auto-layout translate to responsive code naturally; absolutely-positioned-everything designs fight responsiveness — flag it early.
  • Behaviors, not just visuals. Hover/focus/disabled/error/loading states, responsive behavior at breakpoints, animation specs (duration, easing), and content edge cases (long names, empty states). A design without states is a spec with holes — ask before assuming.
  • Two-way feedback. Developers reviewing designs for: implementability (custom vs system components), accessibility (contrast, focus, touch targets), and edge cases. Designers need this input before final sign-off, not after implementation starts.

Practical workflow

  1. Before building: review the design. Check: tokens used (not raw values)? components from the library (not one-offs)? all states designed? responsive behavior specified? If not, ask — assumptions now are rework later.
  2. Set up the token pipeline. Export Figma Variables → transform (Style Dictionary) → code tokens (CSS custom properties, Tailwind theme, platform resources). Automated, versioned, and the only way colors/type/spacing enter the codebase.
  3. Map components 1:1. For each Figma component: the code component, its props (matching Figma properties/variants), and its states. Build the mapping explicitly for design-system work; it becomes the contract.
  4. Implement from tokens + components. Compose screens from the component library using tokens; new one-off styles are a design-system conversation, not a solo decision.
  5. Verify visually. Screenshot/snapshot tests for components; side-by-side review with the designer for key screens; check responsive breakpoints and states, not just the happy-path desktop frame.
  6. Close the loop. Implementation discoveries (a state nobody designed, a breakpoint that breaks) go back to the designer and into the design system. Handoff is a conversation, not a handover.

Token pipeline sketch:

Figma Variables (color/primary/600, spacing/4, radius/lg, ...)
   → Tokens Studio / Variables export (JSON)
   → Style Dictionary transform
   → code: CSS custom props / Tailwind @theme / SwiftUI / Compose resources
   → consumed by components; CI verifies no raw values (lint rule)

Dev checklist per screen:

[ ] All colors/type/spacing from tokens (no raw values)
[ ] Components from the library (props match Figma variants)
[ ] All states implemented (hover, focus, disabled, loading, error, empty)
[ ] Responsive behavior verified at defined breakpoints
[ ] Assets exported at right sizes/formats (SVG for icons, right densities)
[ ] Accessibility: contrast, focus order, touch targets (44px+)

Common pitfalls

  • Pixel-copying screenshots. Measuring pixels from a static frame instead of using tokens and components — brittle, unresponsive, and drifts from the system on the next design update.
  • Raw values in code. Hardcoded hex/spacing "to match the design" while tokens exist. Lint against it; tokens are the contract.
  • Ignoring states. Building only the default state — hover, focus, error, empty, and loading get invented during implementation (inconsistently). Demand state coverage in design review.
  • One-off components. Building bespoke components for what the design system already covers (or should). Every one-off is design-system debt — route it through the system conversation.
  • No responsive spec. Desktop frame only, "we'll figure out mobile later." Later is rework. Auto-layout-first designs + breakpoint specs before implementation.
  • Copying generated code. Pasting Figma's generated CSS verbatim — absolute positioning, magic numbers, no responsiveness. Generated code is a reference, not an implementation.
  • Silent divergence. Implementation drifting from design with no conversation (or design changing without telling devs). Regular design-engineering syncs; the mapping is a living contract.

04 同仓库更多 Skills

TanNhatCMS
TanNhatCMS/jarvis

web-scrape

Turn web pages into LLM-ready markdown via the Firecrawl API (renders JS, anti-bot handling). Use when browser_open/fetch fails on JS-heavy pages, or when you need clean markdown/structured extraction from a site. Requires FIRECRAWL_API_KEY.

★ 0
TanNhatCMS
TanNhatCMS/jarvis

design-taste-frontend

tasteskill v2, the anti-slop frontend skill. Art direction for websites, distilled from a study of 247 curated gallery sites (One Page Love, Awwwards Sites of the Day). Deals researched directions (idea, composition, type, palette, photographs, section blueprints) from a library, enforces a strict no-slop house style with a real-browser inspector, and runs a look-and-fix loop on screenshots. Use this whenever you build, design, redesign, restyle, polish or review a landing page, marketing site, portfolio, product page, one-pager, hero or any public-facing web page, in any stack (HTML/CSS, React, Next.js, Vue, Svelte, Astro, Tailwind) — also when the user says a page looks generic, templated, "AI-made", sloppy, or asks to make it look designed, premium, award-level or less like every other site. Not for dashboards or app screens.

★ 0
TanNhatCMS
TanNhatCMS/jarvis

test-driven-development

Use when implementing any feature or bugfix, before writing implementation code

★ 0
TanNhatCMS
TanNhatCMS/jarvis

systematic-debugging

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

★ 0
TanNhatCMS
TanNhatCMS/jarvis

requesting-code-review

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

★ 0
TanNhatCMS
TanNhatCMS/jarvis

brainstorming

You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).

★ 0