
skillcraft
Skills for design, development, and productivity
- version
- 1.1.0
Install
/plugin install skillcraft@skillcraftRun it inside Claude Code after adding the marketplace with /plugin marketplace add manashmandal/claude-skills.
Contents
Discovered from sourceSkills 3
Design Audit
Overview
Quickly identify design issues and provide actionable suggestions for improvement without needing a reference design.
Core principle: Good design follows patterns. Deviations from patterns are often bugs.
When to Use
Use this skill when:
- Reviewing UI during development
- Quick sanity check before PR
- User asks "what's wrong with this design?"
- Accessibility review needed
- User wants "quick feedback on the UI"
- Polishing before demo/launch
Required Inputs
- Screenshot or URL of the frontend to audit
- Context (optional) - Target audience, brand guidelines, purpose
Announce: "I'll perform a quick design audit using design-audit skill."
Audit Process
Phase 1: First Impression (2 seconds)
Capture gut reaction:
- What draws attention first?
- Does hierarchy feel clear?
- Any elements feel "off"?
- Professional or amateur feel?
Phase 2: Systematic Scan
Check each category in order:
1. Visual Hierarchy
- Clear primary action/CTA
- Heading levels make sense
- Important info is prominent
- Secondary items subdued
2. Spacing & Alignment
- Consistent margins/padding
- Grid alignment
- Breathing room between elements
- No orphaned elements
3. Typography
- Max 2-3 font families
- Readable font sizes (min 14px body)
- Sufficient line-height (1.4-1.6)
- Proper font weights
4. Color & Contrast
- WCAG AA contrast (4.5:1 text, 3:1 UI)
- Consistent color palette
- Meaningful color usage
- Not relying on color alone
5. Components
- Buttons look clickable
- Interactive states clear
- Forms properly labeled
- Icons sized consistently
6. Accessibility
- Focus indicators visible
- Touch targets 44px+
- Alt text would make sense
- Keyboard navigation logical
7. Polish
- No pixelated images
- Consistent border radius
- Shadows consistent
- No alignment jitter
Phase 3: Generate Audit Report
Output format:
## Quick Design Audit
### Overall Score: [X/10]
Brief 1-line summary
### Critical Issues (Fix Now)
1. **[Issue]** - [Location]
- Problem: [Description]
- Fix: [Specific actionable suggestion]
- Impact: [Why this matters]
### High Priority Issues (Should Fix)
1. **[Issue]** - [Location]
- Problem: [Description]
- Fix: [Specific actionable suggestion]
### Medium Priority Issues (Consider Fixing)
1. **[Issue]** - [Location]
- Problem: [Description]
- Fix: [Specific actionable suggestion]
### Low Priority Polish (Nice to Have)
1. **[Issue]** - [Location]
- Suggestion: [Improvement idea]
### What's Working Well
- [Positive observation]
- [Another strength]
Issue Priority Matrix
| Impact \ Effort | Low Effort | High Effort |
|---|---|---|
| High Impact | Fix Now | Plan Soon |
| Low Impact | Quick Win | Backlog |
Common Issues & Fixes
Spacing Issues
/* Problem: Inconsistent spacing */
/* Fix: Use spacing scale */
--space-1: 4px;
--space-2: 8px;
--space-3: 16px;
--space-4: 24px;
--space-5: 32px;
Typography Issues
/* Problem: Poor readability */
/* Fix: */
body {
font-size: 16px; /* Not 14px */
line-height: 1.5; /* Not 1.2 */
max-width: 65ch; /* Limit line length */
}
Color Contrast
/* Problem: Low contrast */
/* Fix: Use contrast checker, aim for 4.5:1+ */
/* Bad: #888 on #fff (3.5:1) */
/* Good: #666 on #fff (5.7:1) */
Button States
/* Problem: No hover/focus states */
/* Fix: */
button:hover { background: var(--primary-dark); }
button:focus { outline: 2px solid var(--focus-ring); }
button:active { transform: scale(0.98); }
Severity Definitions
| Severity | Criteria | Examples |
|---|---|---|
| Critical | Blocks usage or accessibility | No focus states, contrast < 3:1, touch targets < 30px |
| High | Impacts usability significantly | Unclear CTA, confusing hierarchy, inconsistent patterns |
| Medium | Noticeable but functional | Minor spacing issues, suboptimal typography |
| Low | Polish items | Pixel alignment, shadow refinement |
Output Actions
After audit, offer:
- Generate CSS fixes - Code snippets to fix issues
- Create ticket list - Formatted for issue tracker
- Deep dive area - Detailed analysis of specific section
- Full report - Use
design-reportfor comprehensive analysis
Red Flags
Stop and clarify if:
- Image is blurry or low resolution
- Cannot determine intended audience
- Multiple distinct UI patterns present
- Unclear what constitutes "done"
Integration
Related skills:
design-compare- When you have a reference designdesign-report- For deep expert analysis
Design Compare
Overview
Compare your frontend implementation against a reference design to identify visual discrepancies, spacing inconsistencies, and structural mismatches.
Core principle: Every pixel matters. Systematic comparison reveals what eyeballing misses.
When to Use
Use this skill when:
- Implementing a design from Figma/Sketch/mockup
- Checking if implementation matches design spec
- Debugging visual differences between design and code
- QA review before handoff
- User says "compare this to the design" or "check against mockup"
Required Inputs
- Reference design - Screenshot, Figma export, or mockup image
- Implementation - Screenshot of current frontend OR URL to capture
Announce: "I'll compare your implementation against the reference design using design-compare."
Comparison Process
Phase 1: Capture and Prepare
-
Obtain reference design
- User provides screenshot/image path
- Read the image using Read tool
- Note dimensions, viewport size
-
Capture implementation
- User provides screenshot OR
- Request user to capture current state
- Match viewport/dimensions to reference
Phase 2: Structural Analysis
Compare these elements systematically:
| Element | Check For |
|---|---|
| Layout | Grid alignment, container widths, flex/grid structure |
| Spacing | Margins, padding, gaps between elements |
| Typography | Font family, size, weight, line-height, letter-spacing |
| Colors | Background, text, borders, shadows |
| Components | Button styles, inputs, cards, icons |
| Hierarchy | Visual weight, heading levels, emphasis |
| Responsive | Breakpoint behavior if applicable |
Phase 3: Generate Comparison Report
Output format:
## Design Comparison Report
### Match Score: [X/10]
### Critical Discrepancies (Must Fix)
- [ ] Issue description | Location | Reference vs Implementation
### Minor Discrepancies (Should Fix)
- [ ] Issue description | Location | Reference vs Implementation
### Acceptable Variations
- Variation description | Reason acceptable
### Pixel-Perfect Elements
- Element that matches exactly
Evaluation Criteria
Spacing (Weight: High)
- Measure in pixels or design tokens
- Flag differences > 4px
- Check consistency across similar elements
Typography (Weight: High)
- Font family must match exactly
- Size tolerance: ±1px
- Weight must match (400 vs 500 matters)
- Line-height tolerance: ±2px
Colors (Weight: Medium)
- Hex values within #02 tolerance per channel
- Check in multiple states (hover, active, focus)
- Gradient direction and stops
Layout (Weight: Critical)
- Container widths must match
- Alignment (left/center/right)
- Element ordering
- White space distribution
Visual Polish (Weight: Medium)
- Border radius consistency
- Shadow values
- Icon sizing and alignment
- Image aspect ratios
Common Discrepancies
| Issue | Impact | Typical Cause |
|---|---|---|
| Inconsistent spacing | High | Missing design tokens |
| Wrong font weight | Medium | Default browser styles |
| Color off by shade | Low | Color space conversion |
| Different line-height | High | Framework defaults |
| Misaligned icons | Medium | Baseline alignment issues |
| Border radius mismatch | Low | Hardcoded values |
Output Actions
After comparison, offer:
- Generate CSS fixes - Output corrected values
- Create issue list - Checklist format for tickets
- Deep dive - Analyze specific element in detail
Red Flags
Stop and clarify if:
- Reference image is low resolution
- Implementation uses different viewport size
- Design has responsive variants not provided
- Component states differ (hover vs default)
Integration
Related skills:
design-audit- For identifying issues without referencedesign-report- For comprehensive expert analysis
Design Report
Overview
Generate comprehensive design evaluation reports from the perspective of a senior product designer with 15+ years at Apple, analyzing every aspect of a frontend interface.
Core principle: Great design is invisible until it's missing. Expert analysis reveals what users feel but can't articulate.
When to Use
Use this skill when:
- Pre-launch design review
- Stakeholder presentation needs
- User requests "expert feedback" or "thorough review"
- Evaluating competitor UI
- Design system audit
- User says "review like an expert" or "Apple designer perspective"
Required Inputs
- Screenshots - Multiple views/states of the interface
- Context document (optional) - Brand guidelines, target users, business goals
- Comparison (optional) - Competitor screenshots for benchmarking
Announce: "I'll conduct a comprehensive design analysis using design-report, evaluating from a senior Apple product designer perspective."
The Apple Design Perspective
Channel these principles throughout analysis:
Core Apple Values
- Clarity - Content is king, chrome is invisible
- Deference - UI helps content, never competes
- Depth - Hierarchy creates understanding
- Consistency - Patterns reduce cognitive load
- Direct manipulation - Objects respond naturally
- Feedback - System state always visible
- Metaphors - Familiar concepts guide interaction
- User control - People initiate, system responds
What Apple Designers Notice
"Most people make the mistake of thinking design is what it looks like. People think it's this veneer — that the designers are handed this box and told, 'Make it look good!' That's not what we think design is. It's not just what it looks like and feels like. Design is how it works." — Steve Jobs
Look for:
- Unnecessary complexity
- Cognitive load reducers
- Moments of delight
- Friction points
- Emotional response triggers
- Details that reveal care (or carelessness)
Report Structure
Executive Summary
One paragraph capturing:
- Overall quality assessment
- Most significant strength
- Most critical issue
- Recommended priority action
Design Quality Score
Rate 1-10 with justification:
| Dimension | Score | Benchmark |
|---|---|---|
| Visual Hierarchy | X/10 | Apple: 9, Average app: 6 |
| Typography | X/10 | Apple: 9, Average app: 5 |
| Color System | X/10 | Apple: 8, Average app: 5 |
| Spacing & Layout | X/10 | Apple: 9, Average app: 5 |
| Interaction Design | X/10 | Apple: 9, Average app: 6 |
| Accessibility | X/10 | Apple: 8, Average app: 4 |
| Polish & Details | X/10 | Apple: 10, Average app: 4 |
| Overall | X/10 | Apple: 9, Average: 5 |
Note: These 1-10 dimension scores provide a quick assessment snapshot. For detailed scoring with weighted criteria totaling 100 points, see
evaluation-criteria.md. A dimension score of 9-10 corresponds to 90-100% in the detailed rubric (Exceptional), 7-8 to 70-89% (Good to Excellent), and so on.
Detailed Analysis
See evaluation-criteria.md for complete checklist.
1. Information Architecture (Weight: Critical)
- Content hierarchy
- Navigation clarity
- Information density
- Progressive disclosure
- Mental model alignment
2. Visual Design (Weight: High)
Typography Analysis:
- Font selection rationale
- Type scale coherence
- Reading comfort
- Emotional tone
Color Analysis:
- Palette harmony
- Semantic usage
- Accessibility compliance
- Mood/brand alignment
Spatial Analysis:
- Grid system
- White space distribution
- Density balance
- Element grouping
3. Interaction Design (Weight: High)
- Affordances
- Feedback mechanisms
- State communication
- Error handling
- Microinteractions
4. Emotional Design (Weight: Medium)
- First impression (gut check)
- Trust signals
- Delight moments
- Personality consistency
- Memorability factor
5. Accessibility (Weight: Critical)
- WCAG compliance level
- Screen reader experience
- Keyboard navigation
- Motor accessibility
- Cognitive accessibility
6. Polish & Craftsmanship (Weight: High)
- Pixel precision
- Animation quality
- Edge cases handled
- Loading states
- Empty states
- Error states
Competitive Analysis (if provided)
- Side-by-side comparison
- Differentiation assessment
- Industry benchmark position
Prioritized Recommendations
Immediate (Before Launch)
- Issue + specific fix + expected impact
Short-term (Next Sprint)
- Issue + specific fix + expected impact
Long-term (Roadmap)
- Issue + strategic recommendation
Appendix
- Detailed measurements
- Accessibility audit results
- Screenshot annotations
Evaluation Approach
The 10-Foot Test
- View interface from across room
- Can you identify: Primary action? Key content? Navigation?
- Squint test: Does hierarchy hold?
The First-Time User Test
- Pretend zero context
- Is purpose immediately clear?
- Can you complete primary task without instructions?
The Return User Test
- Is repeat usage efficient?
- Are shortcuts available?
- Does muscle memory work?
The Accessibility Test
- Zoom to 200%: Still usable?
- Grayscale: Still navigable?
- Keyboard only: All features accessible?
- Screen reader: Makes sense audibly?
The Detail Test
- Zoom to 400%
- Pixel alignment on retina
- Consistent icon sizing
- Border radius consistency
- Shadow uniformity
Output Actions
Report should be:
- PDF-ready formatting
- Executive-friendly summary
- Developer-actionable details
- Visual annotations where helpful
- Quantified metrics where possible
Red Flags
Stop and clarify if:
- Cannot determine target audience
- Purpose of interface unclear
- Multiple conflicting design patterns
- Screenshots are incomplete or low quality
Integration
Related skills:
design-compare- When comparing to specific referencedesign-audit- For quick feedback during development
Supporting documents:
- See
apple-design-principles.mdfor detailed Apple HIG breakdown - See
evaluation-criteria.mdfor complete scoring rubric
Commands 3
Invoke the skillcraft:design-audit skill and follow it exactly as presented to you
Invoke the skillcraft:design-compare skill and follow it exactly as presented to you
Invoke the skillcraft:design-report skill and follow it exactly as presented to you
Agents 4
Design Evaluation Agents
Specialized agent prompts for design evaluation workflows.
Available Agents
design-evaluator-prompt.md
General-purpose design evaluation agent that selects appropriate methodology.
design-comparison-prompt.md
Pixel-level comparison between reference design and implementation.
design-reviewer-prompt.md
Code-review style feedback for UI/UX changes.
Usage
Dispatch agents using the Task tool:
Task tool (general-purpose):
description: "Evaluate design: Homepage"
prompt: [use template from agent prompt file]
Agent Selection Guide
| Scenario | Agent |
|---|---|
| Quick feedback during development | design-evaluator (audit mode) |
| Checking Figma implementation | design-comparison |
| PR with UI changes | design-reviewer |
| Pre-launch comprehensive review | design-evaluator (report mode) |
Design Comparison Agent Prompt Template
Use this template when dispatching an agent to compare implementation against reference design.
Task tool (general-purpose):
description: "Compare design: [component name]"
prompt: |
You are performing pixel-level design comparison analysis.
## Reference Design
Path: [reference image path]
Source: [Figma/Sketch/mockup]
Viewport: [dimensions if known]
## Implementation
Path: [implementation screenshot path]
URL: [if applicable]
Viewport: [dimensions]
## Comparison Focus
Analyze these elements systematically:
| Element | Priority |
|---------|----------|
| Layout & Grid | Critical |
| Spacing | High |
| Typography | High |
| Colors | Medium |
| Components | Medium |
| Visual Polish | Low |
## Your Job
1. **Capture both images** - Note dimensions and viewport
2. **Structural analysis** - Compare layout, grid, spacing
3. **Visual analysis** - Compare typography, colors, shadows
4. **Component analysis** - Compare buttons, inputs, icons
5. **Generate diff report** - List discrepancies by priority
## Output Format
```markdown
## Design Comparison Report
### Match Score: X/10
### Critical Discrepancies (Must Fix)
- [ ] [Issue] | [Location] | Reference: [value] → Implementation: [value]
### Minor Discrepancies (Should Fix)
- [ ] [Issue] | [Location] | Reference: [value] → Implementation: [value]
### CSS Fixes
```css
/* Fix for [issue] */
.selector {
property: correct-value; /* was: wrong-value */
}
```
```
## Red Flags
Stop and ask if:
- Images have different viewport sizes
- Reference is low resolution
- Component states differ (hover vs default)
Design Evaluator Agent Prompt Template
Use this template when dispatching an agent to evaluate frontend design.
Task tool (general-purpose):
description: "Evaluate design: [component/page name]"
prompt: |
You are a design evaluation specialist combining visual analysis with UX expertise.
## Design to Evaluate
[Screenshot path or description of what to evaluate]
## Evaluation Type
Choose the appropriate approach based on context:
**Quick Audit (design-audit):** Use when:
- Development in progress
- Quick feedback needed
- No reference design available
**Comparison (design-compare):** Use when:
- Reference design (Figma/mockup) provided
- Checking implementation fidelity
- QA review
**Expert Report (design-report):** Use when:
- Pre-launch review
- Stakeholder presentation
- Comprehensive analysis needed
## Your Job
1. Identify the appropriate evaluation type
2. Apply the relevant skill methodology
3. Generate actionable findings
4. Prioritize issues by impact
## Output Format
Return a structured evaluation with:
- Overall assessment (score if applicable)
- Critical issues (must fix)
- Important issues (should fix)
- Polish items (nice to have)
- Specific recommendations with CSS/code fixes where applicable
## Context
[Any additional context: target audience, brand guidelines, constraints]
Design Reviewer Agent Prompt Template
Use this template for code-review style design feedback on UI changes.
Task tool (general-purpose):
description: "Design review: [PR/change description]"
prompt: |
You are reviewing UI/UX changes like a senior designer reviews code.
## Changes to Review
[Description of UI changes or diff]
## Before State
[Screenshot or description of previous design]
## After State
[Screenshot or description of new design]
## Review Criteria
**Visual Consistency:**
- Does this match existing design patterns?
- Are spacing/typography/colors consistent?
- Does it follow the design system?
**UX Quality:**
- Is the interaction clear?
- Are states handled (hover, focus, loading, error)?
- Is it accessible?
**Implementation Quality:**
- Are design tokens used (not hardcoded values)?
- Is responsive behavior correct?
- Are animations smooth?
## Your Job
1. Compare before/after states
2. Identify regressions or improvements
3. Check consistency with existing UI
4. Provide actionable feedback
## Output Format
```markdown
## Design Review
### Summary
[1-2 sentence assessment]
### Approved / Changes Requested / Blocked
### Strengths
- [What's done well]
### Required Changes
- [ ] [Specific change needed] | [Why]
### Suggestions (Optional)
- [ ] [Nice-to-have improvement]
### Screenshots/Annotations
[Reference specific areas if needed]
```
## Review Principles
- Be specific (not "spacing looks off" but "16px gap should be 24px")
- Provide solutions, not just problems
- Distinguish required vs optional changes
- Consider accessibility always
Hooks 1
Sponsors
Details
- Marketplace
- manashmandal/claude-skills
- Author
- Manash Mandal
- Category
- Community