Skip to main content
This guide covers when to use which commands, recommended workflows, and tips for getting the best results from Impeccable.

​
Command Selection Guide

Choosing the right command for your situation:

​
When Starting a New Project

1

Run /teach-impeccable first

Establish design context before doing any design work. This one-time setup makes all other commands more effective.
/teach-impeccable
2

Build initial features

Focus on functionality first. Don’t worry about polish yet.
3

Run /critique for feedback

Get design direction and identify major issues.
/critique
4

Run /normalize if needed

If you have a design system, align everything to it.
/normalize
5

Add enhancements

Use /colorize, /animate, or /delight to add personality.
/colorize
/animate
6

Run /audit for quality check

Find accessibility, performance, and responsive issues.
/audit
7

Run /polish before shipping

Final pass to fix all the little details.
/polish

​
When Fixing Design Issues

Problem: Interface looks generic or AI-generated Solution: 
/critique      # Identify AI slop patterns
/bolder        # Make more distinctive (if appropriate)
/colorize      # Add strategic color
/animate       # Add purposeful motion
Problem: Interface is too complex or cluttered Solution: 
/critique      # Understand what's not working
/distill       # Simplify ruthlessly
/clarify       # Improve unclear copy
/polish        # Refine the simplified version
Problem: Inconsistent design across features Solution: 
/audit         # Document all inconsistencies
/normalize     # Align with design system
/extract       # Pull patterns into reusable components
/polish        # Final consistency pass
Problem: Performance issues Solution: 
/audit         # Identify performance bottlenecks
/optimize      # Fix loading and rendering issues
/harden        # Ensure resilience under load
Problem: Accessibility failures Solution: 
/audit         # Find all accessibility issues
/harden        # Fix edge cases and resilience
/polish        # Ensure all states work correctly
Problem: Interface lacks personality Solution: 
/critique      # Understand what's missing
/colorize      # Add strategic color (if too gray)
/animate       # Add micro-interactions
/delight       # Add moments of joy
/polish        # Refine all the details

​
Recommended Workflows

​
Quality Assurance Workflow

Use this before major releases:
1

Comprehensive audit

/audit
Review the full report. Prioritize Critical and High severity issues.
2

Fix design system issues

/normalize
Address theming and consistency problems first.
3

Harden edge cases

/harden
Fix error handling, i18n, and text overflow issues.
4

Optimize performance

/optimize
Address any performance bottlenecks identified in audit.
5

Final polish

/polish
Sweep for alignment, spacing, states, and micro-issues.
6

Re-audit to verify

/audit
Confirm all issues are resolved.
When to use: Before production deployments, major releases, or quarterly quality reviews.

​
Design Enhancement Workflow

Use this to improve existing interfaces:
1

Get design critique

/critique
Understand what’s working and what’s not from a UX perspective.
2

Simplify if needed

If critique identifies complexity or clutter:
/distill
3

Add visual interest

Based on critique findings:
/colorize     # If too monochromatic
/bolder       # If too safe/generic
/quieter      # If too overwhelming
4

Add motion

/animate
Enhance with purposeful micro-interactions.
5

Add personality

If brand personality allows:
/delight
6

Final refinement

/polish
When to use: When designs are functionally complete but need elevation, or when user feedback indicates designs are boring or forgettable.

​
Pre-Launch Workflow

Use this right before shipping:
1

Run comprehensive audit

/audit
Get complete picture of quality issues.
2

Fix critical issues first

Address all Critical and High severity items from audit report.
3

Harden for production

/harden
Ensure resilience with error handling, i18n, edge cases.
4

Optimize performance

/optimize
Meet performance targets for launch.
5

Adapt for mobile

If mobile launch:
/adapt
6

Final polish pass

/polish
Sweep every detail before shipping.
7

Verify with final audit

/audit
Confirm everything is ready.
When to use: 1-2 weeks before launch, after feature complete, before production deployment.

​
Rapid Iteration Workflow

Use this for quick improvements:
1

Quick critique

/critique specific-component
Focus on specific area for targeted feedback.
2

Apply relevant command

Based on critique, choose one:
/distill component    # If too complex
/clarify component    # If unclear
/bolder component     # If too bland
/animate component    # If too static
3

Quick polish

/polish component
When to use: During active development, for quick iterations on specific components or features.

​
Command Pairing Recommendations

​
Complementary Pairs

These commands work well together:

/audit + /normalize

Why: Audit finds design system inconsistencies, normalize fixes them systematically.Workflow:
/audit          # Find theming and consistency issues
/normalize      # Fix all design system deviations
/audit          # Verify fixes

/critique + /distill

Why: Critique identifies complexity problems, distill solves them.Workflow:
/critique       # "Too many competing actions, unclear hierarchy"
/distill        # Strip to essence, clarify hierarchy
/critique       # Verify improvement

/colorize + /animate

Why: Visual enhancement works better with both color and motion.Workflow:
/colorize       # Add strategic color
/animate        # Add purposeful motion
/polish         # Refine both

/optimize + /harden

Why: Performance and resilience are both production-readiness concerns.Workflow:
/optimize       # Fix performance bottlenecks
/harden         # Handle edge cases and errors
/audit          # Verify both

​
Command Sequences

These commands build on each other: Simplification sequence: 
/distill        # Remove complexity
/clarify        # Improve remaining copy
/polish         # Refine simplified version
Enhancement sequence: 
/normalize      # Ensure consistency first
/colorize       # Add color
/animate        # Add motion
/delight        # Add personality
/polish         # Final refinement
Quality sequence: 
/audit          # Find all issues
/normalize      # Fix design system issues
/optimize       # Fix performance issues
/harden         # Fix resilience issues
/polish         # Final pass
/audit          # Verify

​
Tips for Best Results

​
General Best Practices

This one-time setup provides context that makes every other command more effective. Don’t skip it.Why it matters: Without context, commands make generic assumptions based on AI training data. With context, they understand your users, brand, and design principles.
Most commands accept an optional argument to focus on a specific component, page, or feature.Better:
/audit checkout-flow
/polish header-navigation
/animate dashboard-cards
Less effective:
/audit
/polish
/animate
Focused commands give more detailed, actionable feedback.
Running /audit before other commands helps you understand what needs fixing and prevents wasted effort.Why: You might polish components that need to be removed, or optimize code that’s already fast enough.
Don’t run /polish on incomplete features. It’s wasted effort.Right order:
  1. Build functionality
  2. Run /critique or /audit
  3. Fix major issues
  4. Run /polish
Wrong order:
  1. Build half the functionality
  2. Run /polish (wastes time)
  3. Realize you need to change it
  4. Polish again (more wasted time)
/critique evaluates UX and design effectiveness. /audit checks technical quality.Run critique first to catch fundamental design problems before sweating technical details.
When commands ask questions (like /distill, /animate, /bolder), provide clear answers. Don’t say “whatever you think is best.”Why: Impeccable is opinionated, but it needs your context to make the right choices.

​
Command-Specific Tips

Best practices:
  • Run before major changes to establish baseline
  • Run after major changes to verify quality
  • Focus on specific areas for faster iteration
  • Address Critical and High issues first
  • Don’t ignore Low severity - they compound
Common mistakes:
  • Running audit but not fixing issues
  • Fixing everything at once (triage by severity)
  • Ignoring systemic issues in favor of one-off fixes
Tip: Save audit reports to track improvement over time.

​
When NOT to Use Commands

​
Don’t use /polish too early

Problem: Polishing incomplete features wastes time.Instead: Finish functionality first, then polish.

​
Don’t use /bolder on everything

Problem: Some interfaces need to be calm (dashboards, tools, content platforms).Instead: Use /bolder selectively on marketing pages, landing pages, or hero sections.

​
Don’t use /animate excessively

Problem: Too much animation causes fatigue and hurts performance.Instead: Choose high-impact moments for animation. Not every interaction needs motion.

​
Don’t use /distill without context

Problem: Simplifying without understanding user goals removes necessary features.Instead: Run /teach-impeccable first or answer context questions honestly.

​
Don’t use multiple enhancement commands at once

Problem: Running /colorize, /animate, /bolder, and /delight together can create overwhelming designs.Instead: Choose 1-2 enhancement commands based on what’s missing. Then polish.

​
Measuring Success

​
How to Know Commands Are Working

Audit scores improve

Run /audit before and after. Critical and High severity issues should decrease.

User feedback changes

Users report clarity, speed, or delight improvements after running commands.

Lighthouse scores increase

Performance, accessibility, and best practices scores improve after /optimize and /harden.

Design feels distinctive

After /critique and enhancement commands, designs no longer look AI-generated.

​
Metrics to Track

Technical metrics:
  • Lighthouse scores (Performance, Accessibility, Best Practices, SEO)
  • Core Web Vitals (LCP, FID/INP, CLS)
  • Accessibility audit results (Axe, WAVE)
  • Bundle size and load times
User metrics:
  • Task completion rates
  • Time to complete common workflows
  • Error rates and support tickets
  • User satisfaction scores (NPS, CSAT)
Design metrics:
  • Design system consistency (% components using tokens)
  • Code quality (linting errors, TypeScript strictness)
  • Time from design to ship
  • Number of polish iterations needed

​
Common Scenarios

Situation: You’ve inherited a project with inconsistent designs, hard-coded colors, and no design system.Workflow:
/teach-impeccable    # Establish what it should be
/audit               # Document everything wrong
/normalize           # Fix design system issues
/extract             # Pull patterns into components
/audit               # Verify improvements
/polish              # Final cleanup
Situation: Your designs have all the AI slop tells: purple gradients, glassmorphism, generic fonts.Workflow:
/critique            # Identify specific AI slop patterns
/teach-impeccable    # Establish unique brand direction
/bolder              # Make more distinctive (or /quieter if too loud)
/colorize            # Replace generic color with brand palette
/animate             # Add purposeful motion (not generic effects)
/critique            # Verify no longer looks AI-generated
/polish              # Refine
Situation: Lighthouse scores below 50, users complain about slowness.Workflow:
/audit               # Identify all performance issues
/optimize            # Fix bottlenecks (images, bundles, animations)
/harden              # Ensure resilience under load
/audit               # Verify improvements
Target: LCP < 2.5s, FID < 100ms, CLS < 0.1
Situation: Users report confusion, too many options, unclear hierarchy.Workflow:
/critique            # Understand what's causing complexity
/distill             # Remove unnecessary elements
/clarify             # Improve unclear copy
/normalize           # Ensure remaining elements are consistent
/polish              # Refine simplified version
Situation: Desktop works great, mobile is unusable.Workflow:
/audit               # Find responsive and touch target issues
/adapt               # Fix mobile layouts and interactions
/optimize            # Improve mobile performance
/harden              # Handle mobile edge cases (text overflow, etc.)
/polish              # Final mobile refinement
Situation: Launching in 2 weeks, need to ensure quality.Workflow:
/audit               # Complete quality audit
/harden              # Error handling, i18n, edge cases
/optimize            # Meet performance targets
/adapt               # Ensure mobile works
/polish              # Final pass on all details
/audit               # Final verification

​
Avoiding Common Mistakes

​
Mistake: Using commands in isolation

Problem: Running /colorize without understanding if color is actually what’s needed. Solution: Run /critique first to understand what’s missing, then apply appropriate commands.

​
Mistake: Ignoring command questions

Problem: Commands like /distill, /animate, and /bolder ask context questions, but you say “do whatever.” Solution: Provide specific answers. If you don’t know, run /teach-impeccable first to establish context.

​
Mistake: Skipping /teach-impeccable

Problem: Commands give generic suggestions because they lack project context. Solution: Always run /teach-impeccable once at the start of a project.

​
Mistake: Trying to fix everything at once

Problem: Running all 17 commands on the entire codebase simultaneously. Solution: Triage. Focus on specific areas or high-priority issues first.

​
Mistake: Polishing before functionality is complete

Problem: Spending time perfecting alignment and spacing on features that will change. Solution: Polish only when features are functionally stable.

​
Quick Reference

​
Command Priority Matrix

StagePriorityCommands
SetupHighest/teach-impeccable
QualityHigh/audit, /critique, /normalize
EnhancementMedium/colorize, /animate, /delight
SimplificationMedium/distill, /clarify
ProductionHigh/harden, /optimize, /adapt
RefinementHighest/polish
ExtractionLow/extract

​
Time Investment Guide

CommandTypical TimeWhen to Use
/teach-impeccable15-30 minOnce per project
/audit5-10 minBefore major changes
/critique5-10 minWhen designs feel off
/normalize20-60 minWhen inconsistent
/polish30-90 minBefore shipping
/distill20-40 minWhen too complex
/clarify10-30 minWhen copy is unclear
/optimize30-90 minWhen performance is poor
/harden30-60 minBefore production
/animate20-60 minWhen too static
/colorize15-45 minWhen too monochrome
/bolder30-60 minWhen too generic
/quieter20-40 minWhen overwhelming
/delight20-60 minWhen too functional
/extract20-60 minWhen patterns repeat
/adapt30-90 minBefore mobile launch
/onboard40-90 minNew product/feature

​
Learning Path

Recommended order for learning Impeccable commands:
1

Week 1: Essentials

Start with the most impactful commands:
  • /teach-impeccable - Setup
  • /audit - Find issues
  • /polish - Fix details
Practice these on a small project or component.
2

Week 2: Quality

Add quality-focused commands:
  • /critique - Design feedback
  • /normalize - Consistency
  • /harden - Resilience
Use these to improve existing work.
3

Week 3: Enhancement

Learn visual enhancement commands:
  • /colorize - Strategic color
  • /animate - Purposeful motion
  • /distill - Simplification
Experiment with different enhancement approaches.
4

Week 4: Advanced

Master specialized commands:
  • /optimize - Performance
  • /bolder / /quieter - Visual intensity
  • /delight - Personality
  • /extract - Component patterns
  • /adapt - Responsive design
  • /onboard - User flows
Apply to complete projects.

​
Getting Help

If commands aren’t giving expected results:
  1. Check you ran /teach-impeccable - Most issues stem from missing context
  2. Provide more specific focus - Use command arguments to target specific areas
  3. Answer questions honestly - When commands ask for clarification, provide details
  4. Review command output - Commands explain their reasoning and suggestions
  5. Try command combinations - Some issues need multiple commands to resolve

Need More Help?

Join the community, report issues, or contribute improvements

​
Next Steps

Commands Overview

Complete reference of all 17 commands

Customization Guide

Learn how to customize commands and add project context

Build docs developers (and LLMs) love

Get started for freeTalk to us