Skip to content
Blog

Claude Code Review 2026: An Honest Take From a Design Engineer

A design engineer reviews Claude Code: plan mode, skills, hooks, MCP and CLAUDE.md, where it speeds up UI work, where it falls short, pricing, and a scorecard.

Review 9 min read claude codeai toolsdesign engineeringreview
A dark flat terminal window with prompt lines beside the orange Claude logo.

Most Claude Code reviews I read measure it in tests passed and tickets closed. My job sits in a different place: between a Figma file and a production React screen, where “it works” and “it looks right” are two separate questions.

So this review asks a narrower question. If your work is turning designs into components, keeping a design system consistent, and shipping interfaces that feel finished, is Claude Code worth paying for in late 2026? My short answer is yes, with one condition: you still have to be the person with taste.

What Claude Code is, at the time of writing

Claude Code is Anthropic’s agentic coding tool. It reads your codebase, edits files, runs commands, and works with git. It is not autocomplete. You describe an outcome and it plans, edits across files, and checks its own work by running whatever you let it run.

At the time of writing (November 2026) it runs on several surfaces that share one engine: the terminal CLI, a VS Code extension (which also installs in Cursor), a JetBrains plugin, a desktop app, and the web at claude.ai/code. Your project’s CLAUDE.md, settings and MCP servers carry across all of them, according to the official overview.

The features that matter most for front-end work:

  • Plan mode. Claude reads files and explores, then writes a plan without touching your source. Edits stay blocked until you approve. In the CLI, Shift+Tab cycles permission modes.
  • Permission modes. Beyond plan mode there is default (asks before most actions), acceptEdits, auto (a classifier reviews actions so most run without prompts), dontAsk for locked-down CI, and bypassPermissions for isolated containers. The permission modes docs explain each.
  • CLAUDE.md memory. A markdown file at the project root that Claude reads at the start of every session. It can also read an existing AGENTS.md.
  • Skills. Folders with a SKILL.md that package a repeatable workflow. Claude loads one when the task matches its description, or you call it with a slash command. Custom slash commands have been folded into skills.
  • Subagents. Helpers with their own context window, so a noisy codebase search does not flood your main conversation. Built-in ones include Explore and Plan.
  • Hooks. Shell commands that fire on events, such as after every file edit.
  • MCP. The Model Context Protocol connects Claude Code to outside tools, Figma included.

On models: paid plans default to Opus 5.5 at the time of writing, and you can switch to Sonnet or Haiku with /model. There is also an opusplan alias that uses Opus while planning and Sonnet while executing, which is a sensible cost trade for routine UI work.

Where it earns its keep for a design engineer

Turning a spec into components

This is the headline use, and it is good. With Figma’s official MCP server connected, Claude Code can read frames, variables and component structure instead of guessing from a screenshot. Figma documents the setup for Claude Code in its help center; the remote server is one command:

claude mcp add --transport http figma https://mcp.figma.com/mcp

What you get back is a strong first draft: props, variants, states, and tokens mapped to your Tailwind theme if your instructions say how. It is rarely the final version, for reasons I cover below.

The trick is to start in plan mode. Ask for a component plan first: file locations, prop names, which existing primitives it will reuse. Fixing a wrong prop API in a plan costs one sentence. Fixing it after twelve files have been edited costs an afternoon.

Refactors across a codebase

Renaming a token, swapping an icon library, moving every button to a new variant API: these are the jobs that are boring for a human and easy to get subtly wrong. Claude Code handles them well because it can search the whole repo, edit many files, then run your type checker and lint to confirm.

This is also where subagents pay off. A read-only Explore pass to map every usage before the edit keeps the main session focused on the change itself.

Enforcing design-system rules

This is the part I value most and the part most reviews skip. A design system is mostly a list of rules: which tokens exist, which components to reach for, what is never allowed. Claude Code gives you two places to put those rules.

The soft layer is CLAUDE.md. A few plain lines go a long way:

## UI rules
- Flat design: no shadows, no gradients. Separate surfaces with borders and spacing.
- Colors come from theme tokens only. Never hard-code hex values in components.
- Reuse primitives in src/components/ui before writing a new one.
- Run npm run lint:flat after any UI change.

The hard layer is a script plus a hook. This site, which I build and maintain with AI-assisted tooling, has a small lint:flat script that fails the check on shadows and gradients, whether they come from Tailwind classes or plain CSS, and on inline icons outside the icon folder. A model can forget an instruction in a long session. A failing script it cannot argue with. Wiring that script to a PostToolUse hook, per the hooks reference, means it runs after every edit:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "npm run lint:flat" }]
      }
    ]
  }
}

Instructions tell the agent what you want. Lint tells it what it did. You need both.

This is the same principle behind the design system I built at MedRoyale, which cut design-to-dev handoff time by about 80%: decisions that are written down and checked automatically stop being debated on every screen.

Writing content and microcopy

Empty states, error messages, alt text, MDX drafts, translation passes between English and Indonesian. Because Claude Code sees the component that will render the text, it tends to respect length limits better than a chat window does. You still edit for voice.

Where it falls short

Visual judgement is still yours

Claude Code can now open a browser. The Chrome integration lets it load your local server, read console errors, take screenshots and check a build against a Figma mock. That closes part of the loop, and it catches broken layouts.

It does not replace an eye. Optical alignment, the rhythm of a type scale, whether a hover state feels heavy, whether a dense table is readable at 13 inches: these are judgement calls, and an agent comparing a screenshot to a frame does not reliably make them. Expect “matches the spec” and “feels right” to diverge, and budget time for the second.

Review burden moves, it does not vanish

The tool writes code faster than you can read it. That is the real risk. A diff that touches thirty files and passes type checks can still introduce a second button component, a magic number, or an accessibility regression no lint rule covers.

I treat every session’s output like a pull request from a fast, confident colleague who joined last week. Small scopes, plan mode for anything structural, and a real read of the diff before commit. Skip that, and the time you saved comes back later as bugs.

Cost and limits

Claude Code is not on the Free plan. On the pricing page at the time of writing, it comes with Pro ($20 a month billed monthly, or $17 a month billed annually), Max (from $100 a month), and Team and Enterprise seats. You can also pay per token through an Anthropic Console account.

Subscriptions come with usage limits, and long agentic sessions on the strongest model eat them faster than chat does. For heavy daily use, Pro will feel tight. Picking the model per task, and using opusplan or Sonnet for mechanical refactors, stretches it a lot.

Context discipline is a skill

Long sessions drift: the agent forgets an early decision or keeps a wrong assumption alive. Clearing context between tasks, keeping CLAUDE.md short, and pushing exploration into subagents all help. None of it is automatic, and people who have only used inline autocomplete will feel the learning curve.

Workflow tips that actually help

  1. Plan first for anything with a new API. Approve the plan, then let it execute. Press Ctrl+G to edit the plan in your editor before approving.
  2. Package repeat jobs as skills. “Scaffold a component with story and test” is a good first skill.
  3. Keep scopes small. One component or one refactor per session. Commit between them so rollback is cheap.
  4. Do the visual pass yourself. Use the browser tools to catch breakage, then look at the result with your own eyes at real sizes.

If you are still working out where design engineering ends and frontend begins, I wrote about that in design engineer vs frontend developer. The short version: the more of your value lives in judgement, the more a tool like this helps you, because it takes the typing and leaves you the choices.

Scorecard

Scores are my opinion as a design engineer, out of 5, at the time of writing.

AreaScoreNotes
Spec to component4.5Strong first drafts, especially with Figma MCP. Polish is manual.
Codebase-wide refactors5Searches, edits and verifies across files. Its best use.
Design-system enforcement4.5CLAUDE.md plus hooks plus lint is a sturdy setup.
Content and microcopy4Fast and length-aware. Needs a voice edit.
Visual judgement2.5Browser checks catch breakage, not taste.
Review burden3Output volume makes careful review mandatory.
Cost and limits3.5Fair for daily use on Max; tight on Pro for heavy sessions.
Learning curve3.5Simple to start, slow to master context and permissions.
Overall4Worth it if you keep the taste and the review.

Verdict

Claude Code is the most useful AI tool I have tried for design engineering, because the dull parts of the job (wiring props, mapping tokens, chasing a rename through forty files) are exactly what it does well. It turns a design system from a document people forget into rules the agent reads and a lint step it cannot skip.

Pick it if you own a real codebase, have design-system rules worth enforcing, and are willing to review diffs properly. Skip it, or stay on a lighter plan, if most of your work is visual exploration in Figma, or if you want a tool that will tell you whether a screen looks good. It will not.

For the stack I pair it with, see my stack. For the component layer, I reviewed shadcn/ui separately.

FAQ

Is Claude Code free?

No. At the time of writing it is not on Claude’s Free plan. It comes with Pro, Max, Team and Enterprise plans, or with pay-per-token billing through an Anthropic Console account.

Can Claude Code turn a Figma design into React components?

Yes, and it works best with Figma’s official MCP server connected, so it reads real frames, variables and structure. Expect a solid first draft that still needs a human pass on spacing, states and visual polish.

What is plan mode in Claude Code?

A permission mode where Claude reads and explores your code, then proposes a plan without editing source files. Nothing changes until you approve. It is the safest way to start any structural change.

How do I make Claude Code follow my design system?

Write the rules in CLAUDE.md, then back them with a lint script that fails on forbidden patterns, and run that script from a PostToolUse hook after every edit. Instructions guide it, and the lint check enforces them.

Is Claude Code good for designers who do not code?

It can build working prototypes, but the value grows with your ability to read and judge the code it writes. For designers moving toward code, it is a strong teacher if you read its diffs instead of only accepting them.

Have a project in mind?

I take on a few projects at a time. Tell me about yours.

Get in touch