Best Practices - Impeccable

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

Run /teach-impeccable first

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

/teach-impeccable

Build initial features

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

Run /critique for feedback

Get design direction and identify major issues.

/critique

Run /normalize if needed

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

/normalize

Add enhancements

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

/colorize
/animate

Run /audit for quality check

Find accessibility, performance, and responsive issues.

/audit

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:

Comprehensive audit

/audit

Review the full report. Prioritize Critical and High severity issues.

Fix design system issues

/normalize

Address theming and consistency problems first.

Harden edge cases

/harden

Fix error handling, i18n, and text overflow issues.

Optimize performance

/optimize

Address any performance bottlenecks identified in audit.

Final polish

/polish

Sweep for alignment, spacing, states, and micro-issues.

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:

Get design critique

/critique

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

Simplify if needed

If critique identifies complexity or clutter:

/distill

Add visual interest

Based on critique findings:

/colorize     # If too monochromatic
/bolder       # If too safe/generic
/quieter      # If too overwhelming

Add motion

/animate

Enhance with purposeful micro-interactions.

Add personality

If brand personality allows:

/delight

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:

Run comprehensive audit

/audit

Get complete picture of quality issues.

Fix critical issues first

Address all Critical and High severity items from audit report.

Harden for production

/harden

Ensure resilience with error handling, i18n, edge cases.

Optimize performance

/optimize

Meet performance targets for launch.

Adapt for mobile

If mobile launch:

/adapt

Final polish pass

/polish

Sweep every detail before shipping.

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:

Quick critique

/critique specific-component

Focus on specific area for targeted feedback.

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

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

Always run /teach-impeccable first

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.

Focus commands on specific areas

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.

Don't skip /audit

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.

Polish last, not first

Don’t run /polish on incomplete features. It’s wasted effort.Right order:

Build functionality
Run /critique or /audit
Fix major issues
Run /polish

Wrong order:

Build half the functionality
Run /polish (wastes time)
Realize you need to change it
Polish again (more wasted time)

Use /critique before /audit

/critique evaluates UX and design effectiveness. /audit checks technical quality.Run critique first to catch fundamental design problems before sweating technical details.

Commit to a direction

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

Scenario: Inherited messy codebase

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

Scenario: Designs look AI-generated

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

Scenario: Performance is terrible

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

Scenario: Interface is too complex

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

Scenario: Mobile experience is broken

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

Scenario: Pre-launch checklist

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

Stage	Priority	Commands
Setup	Highest	`/teach-impeccable`
Quality	High	`/audit`, `/critique`, `/normalize`
Enhancement	Medium	`/colorize`, `/animate`, `/delight`
Simplification	Medium	`/distill`, `/clarify`
Production	High	`/harden`, `/optimize`, `/adapt`
Refinement	Highest	`/polish`
Extraction	Low	`/extract`

Time Investment Guide

Command	Typical Time	When to Use
`/teach-impeccable`	15-30 min	Once per project
`/audit`	5-10 min	Before major changes
`/critique`	5-10 min	When designs feel off
`/normalize`	20-60 min	When inconsistent
`/polish`	30-90 min	Before shipping
`/distill`	20-40 min	When too complex
`/clarify`	10-30 min	When copy is unclear
`/optimize`	30-90 min	When performance is poor
`/harden`	30-60 min	Before production
`/animate`	20-60 min	When too static
`/colorize`	15-45 min	When too monochrome
`/bolder`	30-60 min	When too generic
`/quieter`	20-40 min	When overwhelming
`/delight`	20-60 min	When too functional
`/extract`	20-60 min	When patterns repeat
`/adapt`	30-90 min	Before mobile launch
`/onboard`	40-90 min	New product/feature

Learning Path

Recommended order for learning Impeccable commands:

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.

Week 2: Quality

Add quality-focused commands:

/critique - Design feedback
/normalize - Consistency
/harden - Resilience

Use these to improve existing work.

Week 3: Enhancement

Learn visual enhancement commands:

/colorize - Strategic color
/animate - Purposeful motion
/distill - Simplification

Experiment with different enhancement approaches.

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:

Check you ran /teach-impeccable - Most issues stem from missing context
Provide more specific focus - Use command arguments to target specific areas
Answer questions honestly - When commands ask for clarification, provide details
Review command output - Commands explain their reasoning and suggestions
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

​Command Selection Guide

​When Starting a New Project

​When Fixing Design Issues

​Recommended Workflows

​Quality Assurance Workflow

​Design Enhancement Workflow

​Pre-Launch Workflow

​Rapid Iteration Workflow

​Command Pairing Recommendations

​Complementary Pairs

/audit + /normalize

/critique + /distill

/colorize + /animate

/optimize + /harden

​Command Sequences

​Tips for Best Results

​General Best Practices

​Command-Specific Tips

​When NOT to Use Commands

​Don’t use /polish too early

​Don’t use /bolder on everything

​Don’t use /animate excessively

​Don’t use /distill without context

​Don’t use multiple enhancement commands at once

​Measuring Success

​How to Know Commands Are Working

Audit scores improve

User feedback changes

Lighthouse scores increase

Design feels distinctive

​Metrics to Track

​Common Scenarios

​Avoiding Common Mistakes

​Mistake: Using commands in isolation

​Mistake: Ignoring command questions

​Mistake: Skipping /teach-impeccable

​Mistake: Trying to fix everything at once

​Mistake: Polishing before functionality is complete

​Quick Reference

​Command Priority Matrix

​Time Investment Guide

​Learning Path

​Getting Help

Need More Help?

​Next Steps

Commands Overview

Customization Guide

Command Selection Guide

When Starting a New Project

When Fixing Design Issues

Recommended Workflows

Quality Assurance Workflow

Design Enhancement Workflow

Pre-Launch Workflow

Rapid Iteration Workflow

Command Pairing Recommendations

Complementary Pairs

Command Sequences

Tips for Best Results

General Best Practices

Command-Specific Tips

When NOT to Use Commands

Don’t use /polish too early

Don’t use /bolder on everything

Don’t use /animate excessively

Don’t use /distill without context

Don’t use multiple enhancement commands at once

Measuring Success

How to Know Commands Are Working

Metrics to Track

Common Scenarios

Avoiding Common Mistakes

Mistake: Using commands in isolation

Mistake: Ignoring command questions

Mistake: Skipping /teach-impeccable

Mistake: Trying to fix everything at once

Mistake: Polishing before functionality is complete

Quick Reference

Command Priority Matrix

Time Investment Guide

Learning Path

Getting Help

Next Steps