0%
Messay Denbel
messay.ai · Claude Code plugin · v0.3.1 · alpha

See your product the way a design team does.

Coding agents write the code. messay.ai gives them a design team’s judgment, keeps them inside your design system, and remembers every decision.

How it works
  • ●A design team’s judgment
  • ●On your design system
  • ●Accessible by default
  • ●Remembers every decision

● Every edit passes through the core. It comes out on system.

  • /messay:plan
  • /messay:setup
  • /messay:whereami
  • /messay:research
  • /messay:synthesize
  • /messay:problem
  • /messay:clarify
  • /messay:frame
  • /messay:personas
  • /messay:spec
  • /messay:prioritize
  • /messay:backlog
  • /messay:visual
  • /messay:system
  • /messay:ia
  • /messay:flow
  • /messay:blueprint
  • /messay:onboarding
  • /messay:explore
  • /messay:content
  • /messay:figma
  • /messay:think
  • /messay:decide
  • /messay:ship
  • /messay:verify
  • /messay:review
  • /messay:a11y
  • /messay:usability
  • /messay:wrap
  • /messay:retro
  • /messay:promote
  • Affordance and feedback
  • Restraint
  • Self-evident clarity
  • Usability heuristics
  • Goal-directed design
  • Mobile first
  • Design system structure
  • Content design
  • Plain writing, without AI tells
  • Forms and input
  • Trust
  • Data display
  • Web interface guidelines (Vercel)
  • Accessibility, WCAG 2.2 AA
  • UI states in code
  • Trust in AI features
  • Four product risks
  • Opportunity solution tree
  • Validated learning
  • Jobs to be done
  • Service blueprint
  • Research interviews
  • Test-driven development
  • Refactoring
  • Deep modules
  • Use cases
  • Shared domain language
  • Threat modeling
31
commands, from research to retro
28
lenses, from Norman to WCAG
~800
tokens of startup context
0
dependencies in the hooks
01 / The problem

AI gave founders a team’s output. Not a team’s taste.

One person with a coding agent can now ship what used to take a small team. But the team brought more than hands: someone who asked who it's for, someone who sketched three ideas before building one, someone who guarded the design system, and someone who made sure everyone could use it. Without them, you get products that work and feel generic.

02 / Token guard · every file edit

Your design system, enforced on every edit.

Before the agent writes a file, the token guard checks UI code for raw colours, one-off sizes and hard-coded fonts, blocks the edit, and names the token to use. The agent fixes it in the same turn.

bg-[#ff7a00] px-[13px] → bg-primary px-4

Try it / type a raw value and watch the guard
src/components/book-button.tsx
Edit blocked · 5 raw values
  • L2bg-[#ff4800]one-off Tailwind value
  • L2text-[#fff]one-off Tailwind value
  • L2px-[13px]one-off Tailwind value
  • L2py-[9px]one-off Tailwind value
  • L2rounded-[7px]one-off Tailwind value
03 / Where the tokens go

Spend tokens building, not figuring out how to build.

One session’s tokens
36%spent building
  • Re-orienting22%
  • Building the wrong thing20%
  • Design drift12%
  • Late accessibility fixes10%
  • Building36%

Illustrative split of one session, not a benchmark.

Re-orienting

The agent re-reads the repo and you re-explain the product and yesterday's decisions.

Building the wrong thing

The agent commits to its first idea. You reject it and pay for the rebuild.

Design drift

Hardcoded colors, fonts and one-off sizes pile up until a later session spends a pass cleaning them.

Late accessibility fixes

Missing labels and keyboard traps surface in QA, after the code has moved on.

04 / How it works · 31 commands

Say what you’re building. It picks the disciplines.

/messay:planturns one sentence into the chain of steps a design team would take, and skips what’s already done. Every step is also a command you can run on its own.

31 commands / pick a phase
  • /messay:plan

    Say what you're building; get a chain of disciplines.

  • /messay:setup

    Read the repo, find the design tokens, write the rules. Once.

  • /messay:whereami

    Current work, chain, gates and next step in 15 lines.

05 / Guardrails · 4 hooks

Quality that doesn’t depend on remembering to ask.

  • Session startEvery sessionLoads rules, a trimmed brief, status and the last handoff, so nobody re-explains.
  • Token guardEvery file editBlocks raw colors, one-off sizes and hard-coded fonts in UI code, and names the token to use.
  • Commit gateEvery git commitChecks design tokens and accessibility for UI, and tests for logic if you turn them on.
  • Session endEvery closeIf nobody wrapped up, writes a factual handoff from git.
06 / Memory · ~800 tokens

Every session starts where the last one ended.

Rules, a trimmed brief, a few lines of status and the last handoff load at session start: about 800 tokens. Nobody re-explains the product, and nothing is decided twice.

When you correct the agent twice, /messay:promote turns it into a rule every future session follows.

07 / 28 lenses

Review your work through the eyes of the people who wrote the books.

/messay:review looks at any screen, spec or pull request through named lenses, and every finding cites the principle behind it.

Design01 / 28

Affordance and feedback (after Don Norman)

Ask whether a person can tell what to do, do it, and know it worked, without being told.

/messay:review norman-affordance
Hover a lens to look through it
08 / Works where your team works

From the ticket to the canvas and back.

Figma

Directions go into your Figma file, built from your library. Edit by hand; pull the edits back through your tokens.

Jira

Start from a ticket. Triage the backlog for design readiness before developers pick it up.

Azure DevOps

The same, read-only by default. Every write to the tracker is shown and approved first.

Through their official MCP servers, detected when present and never bundled. Every write to a tracker is shown and approved first.

09 / How it was built

Built in two days, with AI. The judgment stayed mine.

Claude Code wrote most of the files. I decided what to build, what was true, and what was good enough to ship. Five moments from the build show how that split works.

  1. 01

    I changed course when research proved me wrong

    My first read of the product that inspired this was shallow. A second look showed it already covered design well, so I rewrote the positioning instead of publishing a false claim.

  2. 02

    I measured instead of claiming

    "Saves tokens" became a number: about 800 tokens of startup context. Measuring also caught a bug that would have deleted long briefs.

  3. 03

    My own guardrails caught me

    The token guard blocked the case study I was building for this site. The exception was approved, visibly, with a reason.

  4. 04

    I curated instead of collecting

    From 914 community skills I adapted about a dozen, credited each one, and rejected the rest.

  5. 05

    Tests found what I'd have missed

    A test caught the contrast checker reporting 7.37:1 for white on black. Fixed, it then found real contrast issues on my own site.

10 / Get started

Give your agent a design team.

Two commands to install, one to set up. Setup reads your repo, finds your design tokens and writes the rules once. Free and open source (Apache 2.0) at launch.

The repository opens at launch. Ask for early access to try it now.

# Add the marketplace and install
/plugin marketplace add messaydesign/messay.ai
/plugin install messay@messay-ai
# Then, in your project
/messay:setup
/messay:plan a booking flow for corporate travel coordinators

Building with AI? Bring a designer who does too.

I design products and the AI workflows that build them. If your team wants both, let’s talk.