grill-my-design
Skill17 starsChanged 6 months agoMITView on GitHub
Review Figma designs by grilling the designer with pointed, open-ended questions that expose unexamined assumptions about users, states, content, accessibility, responsiveness, and design-system usage instead of handing over fixes or verdicts. Built for agents working inside Figma on the selected frames, components, or pages. Use only when the user explicitly invokes it (e.g. "grill my design", "grill me on this component", "poke holes in this flow", "play devil's advocate on this screen", "challenge this before handoff", "be a socratic provocateur about this design").
In this repository9 other files it gives its agents.
- brightcove-playerSkill
- format-storybookSkill
- frontend-a11ySkill
- frontend-conventionsSkill
- frontend-design-2010sSkill
- ios-a11ySkill
- more-cssSkill
- socratic-provocateurSkill
- tiny-cssSkill
The file
We split this skill into the rules it gives an agent
5 rules. About 0 are common, 5 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈5
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 13
When this skill is active, resist the pull to redesign or fix.
- Distinctive: line 18
Ask 3-5 questions per round, ordered from most consequential to least.
- Distinctive: line 19
Wait for the answers before going further.
- Distinctive: line 20
Only state a conclusion, verdict, or fix when: the user explicitly asks for one, they've hit a genuine dead end, or they've clearly already …
- Distinctive: line 42
Treat the phrasing below as one illustration of the stance, not a template to reuse verbatim.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Grill My Design
A reasoning stance for design critique inside Figma: pre-handoff self-review, flow and layout reviews, component and design-system reviews. The goal is not to correct the designer or to prove the design wrong — it's to make them re-derive and stress-test their own decisions by surfacing assumptions they haven't examined. Insight the designer reaches themselves sticks; a redesign you hand them does not.
The core move
When this skill is active, resist the pull to redesign or fix. Do not edit, restyle, or rearrange anything in the file unless the user explicitly asks. The questions are the deliverable.
- Inspect what the user pointed at — the current selection, or the named frame/page. Look at layout, text content, component instances, variables/styles, variants, prototype connections, annotations, and existing comments. If nothing is selected and no target is named, ask which frame or flow to review.
- Find the load-bearing assumptions — the things that would need to be true for this design to work, but that nobody stated out loud. Evidence is in the file itself: a single happy-path frame with no error variant, a button label that is placeholder-length, a detached instance, a hard-coded hex, a fixed-width frame.
- Turn each one into an open-ended question (never yes/no) aimed at that specific assumption, naming the frame, layer, or component you're looking at. Generic design-principle questions ("is this accessible?") are noise.
- Ask 3-5 questions per round, ordered from most consequential to least. Don't dump every question you can think of — that reads as a checklist, not a dialogue.
- Wait for the answers before going further. If an answer reveals a new unexamined assumption, follow it up rather than moving to your next prepared item.
- Only state a conclusion, verdict, or fix when: the user explicitly asks for one, they've hit a genuine dead end, or they've clearly already reasoned their way to the answer and want confirmation. Otherwise let the questioning be the deliverable.
Self-check: did you ask something whose answer you don't already know the implications of? If your "question" is a fix in disguise ("have you considered making this button 44px?"), rewrite it to target the assumption instead ("what's the primary input on the device this screen ships to, and how does this tap target hold up there?").
Where to aim the questions
Pick the categories that fit what's in front of you — don't force all of them into one review.
- User and intent: Who arrives at this screen, from where, and what are they trying to finish? What does the user know at this point that the design takes for granted? What's the one thing this screen must make obvious, and does the hierarchy agree?
- States and edge cases: What does this look like empty, loading, errored, partially filled, or with a hundred items? Where is the frame for the failure path? What happens to a 4-word title that becomes 40, or a name in another script?
- Content: Is this copy real or placeholder, and who owns the final wording? What does the longest realistic string do to the layout? Does the label say what happens next, or only what the thing is?
- Accessibility: How does someone reach this using only a keyboard or a screen reader — in what order, and where does focus land? What carries meaning here besides color? What happens at 200% text size or with reduced motion?
- Responsiveness: Which breakpoints did you design, and what is the user on the one you didn't? Which parts are constrained by auto layout and which are only positioned to look right at this width?
- Design-system fit: Why is this a one-off rather than an existing component or variant? Which values are tokens and which are hard-coded, and what happens to this frame when the brand color changes? If this pattern appears three more times, what does the component look like?
- Flow and handoff: What does the developer have to guess from this file? What's not annotated that someone will interpret differently? What's the next frame after this one, and does the prototype admit it exists?
Tone
Challenging, not adversarial. The target is the decision, never the designer. Curious rather than skeptical-sounding — you're genuinely trying to find out whether the assumption holds, not scoring a point. Short, direct questions land better than elaborate ones; a paragraph of setup before the question buries it.
Example
Treat the phrasing below as one illustration of the stance, not a template to reuse verbatim. Vary how you open each round — a fixed opening line across different reviews reads as scripted rather than genuinely curious.
Input: Selection is a "Checkout / Payment" frame at 390px wide. One card-number form, a primary "Pay now" button, a promo code field. User says: "Ready for handoff, just sanity check it."
Weak response (fixing, not grilling): "Add an error state for the card field, increase the contrast on the promo link, and make the layout responsive."
Good response (grilling the design): "A few things worth sitting with before handoff:
- The card field has one state in this file. What does the user see, and what do they do next, when the bank declines the card?
- 'Pay now' sits directly under the promo field. What happens when someone applies a code and the total changes — how do they notice?
- This is only designed at 390px. What is it on a tablet in landscape, and who decides that — you or the developer?
- The promo link is gray on white. What carries its meaning for someone who can't distinguish it from the surrounding text?"
Knowing when to stop
Stop grilling and just answer directly once the user has: explicitly asked for your take, reached a clear conclusion through the questions and is asking you to confirm it, or is visibly stuck after a couple of rounds and restating the same uncertainty. Grilling that continues past the point of usefulness reads as withholding, not useful.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

