qualia-framework 2.1.0

package/framework/scripts/voice-hotkey.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+Voice-to-text hotkey listener for Razer Basilisk V3 35K mouse button.
+Press forward button to start recording. Stops automatically after
+1.5s of silence. Pastes transcription and presses Enter.
+"""
+
+import subprocess
+import sys
+import os
+import signal
+import json
+import threading
+import time
+import struct
+import wave
+
+try:
+    import evdev
+    from evdev import ecodes
+except ImportError:
+    print("Install evdev: pip install evdev")
+    sys.exit(1)
+
+# Config
+ELEVEN_API_KEY = os.environ.get("ELEVEN_API_KEY", "sk_7ed98c8dfe85842183561244ebc3e7120ac291b7005ec0ca")
+MOUSE_NAME = "Razer Razer Basilisk V3 35K"
+TARGET_BUTTON = 276  # BTN_EXTRA = mouse forward button
+AUDIO_FILE = "/tmp/voice-input.wav"
+MIC_DEVICE = "plughw:1,0"  # USB Condenser Microphone
+
+# Silence detection
+SILENCE_THRESHOLD = 500    # RMS amplitude below this = silence
+SILENCE_DURATION = 1.5     # Seconds of silence before auto-stop
+CHECK_INTERVAL = 0.2       # How often to check audio level
+
+recording_proc = None
+is_recording = False
+lock = threading.Lock()
+
+
+def notify(msg, timeout=2000):
+    subprocess.Popen(["notify-send", "-t", str(timeout), "Voice Input", msg],
+                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def get_rms(audio_file):
+    """Get RMS of the last chunk of recorded audio."""
+    try:
+        size = os.path.getsize(audio_file)
+        if size < 1000:
+            return 0
+        # Read last 0.2s of audio (16000 Hz * 2 bytes * 0.2s = 6400 bytes)
+        chunk_size = 6400
+        with open(audio_file, "rb") as f:
+            # Skip WAV header area, read from near end
+            read_start = max(44, size - chunk_size)
+            f.seek(read_start)
+            data = f.read(chunk_size)
+
+        if len(data) < 100:
+            return 0
+
+        # Parse as 16-bit signed samples
+        samples = struct.unpack(f"<{len(data)//2}h", data[:len(data) - len(data) % 2])
+        if not samples:
+            return 0
+        rms = (sum(s * s for s in samples) / len(samples)) ** 0.5
+        return rms
+    except Exception:
+        return 0
+
+
+def silence_monitor():
+    """Background thread: monitors audio level and stops recording on silence."""
+    global is_recording
+    silence_start = None
+
+    # Wait a bit before starting to monitor (let user start speaking)
+    time.sleep(0.8)
+
+    while is_recording:
+        time.sleep(CHECK_INTERVAL)
+        if not is_recording:
+            break
+
+        rms = get_rms(AUDIO_FILE)
+
+        if rms < SILENCE_THRESHOLD:
+            if silence_start is None:
+                silence_start = time.time()
+            elif time.time() - silence_start >= SILENCE_DURATION:
+                # Silence long enough — stop and transcribe
+                with lock:
+                    if is_recording:
+                        is_recording = False
+                        stop_and_transcribe()
+                return
+        else:
+            silence_start = None
+
+
+def start_recording():
+    global recording_proc, is_recording
+
+    with lock:
+        if is_recording:
+            return
+        is_recording = True
+
+    notify("Recording...")
+    recording_proc = subprocess.Popen(
+        ["arecord", "-D", MIC_DEVICE, "-f", "S16_LE", "-r", "16000", "-c", "1", AUDIO_FILE],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    )
+
+    # Start silence monitor in background
+    t = threading.Thread(target=silence_monitor, daemon=True)
+    t.start()
+
+
+def stop_and_transcribe():
+    global recording_proc, is_recording
+
+    if recording_proc:
+        try:
+            recording_proc.terminate()
+            recording_proc.wait(timeout=2)
+        except Exception:
+            pass
+        recording_proc = None
+
+    is_recording = False
+
+    if not os.path.exists(AUDIO_FILE):
+        notify("No audio recorded")
+        return
+
+    if os.path.getsize(AUDIO_FILE) < 10000:
+        notify("Recording too short")
+        try:
+            os.unlink(AUDIO_FILE)
+        except OSError:
+            pass
+        return
+
+    notify("Transcribing...")
+
+    try:
+        result = subprocess.run(
+            ["curl", "-s", "-X", "POST", "https://api.elevenlabs.io/v1/speech-to-text",
+             "-H", f"xi-api-key: {ELEVEN_API_KEY}",
+             "-F", f"file=@{AUDIO_FILE}",
+             "-F", "model_id=scribe_v1"],
+            capture_output=True, text=True, timeout=30
+        )
+        os.unlink(AUDIO_FILE)
+
+        response = json.loads(result.stdout)
+        text = response.get("text", "").strip()
+
+        if not text:
+            notify("No speech detected")
+            return
+
+        # Copy to clipboard, paste, then press Enter (wtype = Wayland-native, no daemon)
+        subprocess.run(["wl-copy", text], check=True)
+        time.sleep(0.1)
+        # Ctrl+V (paste)
+        subprocess.run(["wtype", "-M", "ctrl", "v", "-m", "ctrl"], check=True)
+        time.sleep(0.15)
+        # Enter (send)
+        subprocess.run(["wtype", "-k", "Return"], check=True)
+
+        notify(text[:100])
+
+    except Exception as e:
+        notify(f"Error: {str(e)[:80]}")
+        try:
+            os.unlink(AUDIO_FILE)
+        except OSError:
+            pass
+
+
+def find_device():
+    """Find the Razer mouse event device."""
+    devices = [evdev.InputDevice(path) for path in evdev.list_devices()]
+    for dev in devices:
+        if MOUSE_NAME in dev.name:
+            caps = dev.capabilities(verbose=True)
+            for (etype, _), codes in caps.items():
+                for code_info in codes:
+                    if isinstance(code_info, tuple):
+                        _, code_val = code_info
+                        if code_val == TARGET_BUTTON:
+                            return dev
+                    elif code_info == TARGET_BUTTON:
+                        return dev
+    for dev in devices:
+        if MOUSE_NAME in dev.name and "Keyboard" not in dev.name:
+            return dev
+    return None
+
+
+def main():
+    global is_recording
+
+    dev = find_device()
+    if not dev:
+        print(f"Could not find '{MOUSE_NAME}' input device.")
+        print("Available devices:")
+        for path in evdev.list_devices():
+            d = evdev.InputDevice(path)
+            print(f"  {path}: {d.name}")
+        sys.exit(1)
+
+    print(f"Listening on: {dev.name} ({dev.path})")
+    print(f"Press mouse forward button to record. Auto-stops on {SILENCE_DURATION}s silence.")
+
+    for event in dev.read_loop():
+        if event.type == ecodes.EV_KEY and event.code == TARGET_BUTTON and event.value == 1:
+            if not is_recording:
+                start_recording()
+
+
+if __name__ == "__main__":
+    main()

package/framework/scripts/voice-input.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# Voice-to-text: Record mic → ElevenLabs STT → paste into focused app
+# Usage: Bind to a hotkey. Press once to start recording, press again to stop & transcribe.
+# Requires: arecord, curl, wl-copy, wtype, notify-send
+# Requires: ELEVEN_API_KEY env var
+
+set -euo pipefail
+
+ELEVEN_API_KEY="${ELEVEN_API_KEY:-sk_7ed98c8dfe85842183561244ebc3e7120ac291b7005ec0ca}"
+LOCKFILE="/tmp/voice-input.lock"
+AUDIO_FILE="/tmp/voice-input.wav"
+
+# Toggle: if already recording, stop; otherwise start
+if [ -f "$LOCKFILE" ]; then
+    # === STOP RECORDING ===
+    PID=$(cat "$LOCKFILE")
+    kill "$PID" 2>/dev/null || true
+    rm -f "$LOCKFILE"
+
+    notify-send -t 2000 "Voice Input" "Transcribing..."
+
+    # Send to ElevenLabs STT
+    RESPONSE=$(curl -s -X POST "https://api.elevenlabs.io/v1/speech-to-text" \
+        -H "xi-api-key: $ELEVEN_API_KEY" \
+        -F "file=@$AUDIO_FILE" \
+        -F "model_id=scribe_v1")
+
+    # Extract text from JSON response
+    TEXT=$(echo "$RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('text',''))" 2>/dev/null || echo "")
+
+    rm -f "$AUDIO_FILE"
+
+    if [ -z "$TEXT" ]; then
+        notify-send -t 3000 "Voice Input" "No speech detected"
+        exit 0
+    fi
+
+    # Copy to clipboard and paste via wtype (Wayland-native, no daemon needed)
+    echo -n "$TEXT" | wl-copy
+    sleep 0.1
+    wtype -M ctrl v -m ctrl
+
+    notify-send -t 2000 "Voice Input" "$TEXT"
+else
+    # === START RECORDING ===
+    notify-send -t 2000 "Voice Input" "Recording... Press hotkey again to stop"
+
+    # Record from USB mic (card 1), 16kHz mono WAV (optimal for STT)
+    arecord -D plughw:1,0 -f S16_LE -r 16000 -c 1 "$AUDIO_FILE" &
+    echo $! > "$LOCKFILE"
+fi

package/framework/skills/animate/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: animate
+description: Review a feature and enhance it with purposeful animations, micro-interactions, and motion effects that improve usability and delight.
+user-invokable: true
+args:
+  - name: target
+    description: The feature or component to animate (optional)
+    required: false
+---
+
+Analyze a feature and strategically add animations and micro-interactions that enhance understanding, provide feedback, and create delight.
+
+## MANDATORY PREPARATION
+
+### Read DESIGN.md (Authoritative Source)
+
+Before any context gathering, check for the project's design decisions file:
+
+```bash
+cat .planning/DESIGN.md 2>/dev/null
+```
+
+**If DESIGN.md exists:** This is the authoritative source for all design decisions in this project. Use its palette, typography, spacing, component, and motion decisions as your foundation. Do NOT override these decisions unless the user explicitly asks. Reference specific DESIGN.md decisions in your output (e.g., "Per DESIGN.md, the primary color is...").
+
+**If DESIGN.md does not exist:** Proceed with normal context gathering below. Consider suggesting the user run `/qualia:discuss-phase` to establish design decisions.
+
+### Context Gathering (Do This First)
+
+You cannot do a great job without having necessary context, such as target audience (critical), desired use-cases (critical), brand personality/tone (playful vs serious, energetic vs calm), and performance constraints.
+
+Attempt to gather these from the current thread or codebase.
+
+1. If you don't find *exact* information and have to infer from existing design and functionality, you MUST STOP and STOP and call the AskUserQuestionTool to clarify. whether you got it right.
+2. Otherwise, if you can't fully infer or your level of confidence is medium or lower, you MUST STOP and call the AskUserQuestionTool to clarify. clarifying questions first to complete your context.
+
+Do NOT proceed until you have answers. Guessing leads to inappropriate or excessive animation.
+
+### Use frontend-master skill
+
+Use the frontend-master skill for design principles and anti-patterns. Do NOT proceed until it has executed and you know all DO's and DON'Ts.
+
+---
+
+## Assess Animation Opportunities
+
+Analyze where motion would improve the experience:
+
+1. **Identify static areas**:
+   - **Missing feedback**: Actions without visual acknowledgment (button clicks, form submission, etc.)
+   - **Jarring transitions**: Instant state changes that feel abrupt (show/hide, page loads, route changes)
+   - **Unclear relationships**: Spatial or hierarchical relationships that aren't obvious
+   - **Lack of delight**: Functional but joyless interactions
+   - **Missed guidance**: Opportunities to direct attention or explain behavior
+
+2. **Understand the context**:
+   - What's the personality? (Playful vs serious, energetic vs calm)
+   - What's the performance budget? (Mobile-first? Complex page?)
+   - Who's the audience? (Motion-sensitive users? Power users who want speed?)
+   - What matters most? (One hero animation vs many micro-interactions?)
+
+If any of these are unclear from the codebase, STOP and call the AskUserQuestionTool to clarify.
+
+**CRITICAL**: Respect `prefers-reduced-motion`. Always provide non-animated alternatives for users who need them.
+
+## Plan Animation Strategy
+
+Create a purposeful animation plan:
+
+- **Hero moment**: What's the ONE signature animation? (Page load? Hero section? Key interaction?)
+- **Feedback layer**: Which interactions need acknowledgment?
+- **Transition layer**: Which state changes need smoothing?
+- **Delight layer**: Where can we surprise and delight?
+
+**IMPORTANT**: One well-orchestrated experience beats scattered animations everywhere. Focus on high-impact moments.
+
+## Implement Animations
+
+Add motion systematically across these categories:
+
+### Entrance Animations
+- **Page load choreography**: Stagger element reveals (100-150ms delays), fade + slide combinations
+- **Hero section**: Dramatic entrance for primary content (scale, parallax, or creative effects)
+- **Content reveals**: Scroll-triggered animations using intersection observer
+- **Modal/drawer entry**: Smooth slide + fade, backdrop fade, focus management
+
+### Micro-interactions
+- **Button feedback**:
+  - Hover: Subtle scale (1.02-1.05), color shift, shadow increase
+  - Click: Quick scale down then up (0.95 → 1), ripple effect
+  - Loading: Spinner or pulse state
+- **Form interactions**:
+  - Input focus: Border color transition, slight scale or glow
+  - Validation: Shake on error, check mark on success, smooth color transitions
+- **Toggle switches**: Smooth slide + color transition (200-300ms)
+- **Checkboxes/radio**: Check mark animation, ripple effect
+- **Like/favorite**: Scale + rotation, particle effects, color transition
+
+### State Transitions
+- **Show/hide**: Fade + slide (not instant), appropriate timing (200-300ms)
+- **Expand/collapse**: Height transition with overflow handling, icon rotation
+- **Loading states**: Skeleton screen fades, spinner animations, progress bars
+- **Success/error**: Color transitions, icon animations, gentle scale pulse
+- **Enable/disable**: Opacity transitions, cursor changes
+
+### Navigation & Flow
+- **Page transitions**: Crossfade between routes, shared element transitions
+- **Tab switching**: Slide indicator, content fade/slide
+- **Carousel/slider**: Smooth transforms, snap points, momentum
+- **Scroll effects**: Parallax layers, sticky headers with state changes, scroll progress indicators
+
+### Feedback & Guidance
+- **Hover hints**: Tooltip fade-ins, cursor changes, element highlights
+- **Drag & drop**: Lift effect (shadow + scale), drop zone highlights, smooth repositioning
+- **Copy/paste**: Brief highlight flash on paste, "copied" confirmation
+- **Focus flow**: Highlight path through form or workflow
+
+### Delight Moments
+- **Empty states**: Subtle floating animations on illustrations
+- **Completed actions**: Confetti, check mark flourish, success celebrations
+- **Easter eggs**: Hidden interactions for discovery
+- **Contextual animation**: Weather effects, time-of-day themes, seasonal touches
+
+## Technical Implementation
+
+Use appropriate techniques for each animation:
+
+### Timing & Easing
+
+**Durations by purpose:**
+- **100-150ms**: Instant feedback (button press, toggle)
+- **200-300ms**: State changes (hover, menu open)
+- **300-500ms**: Layout changes (accordion, modal)
+- **500-800ms**: Entrance animations (page load)
+
+**Easing curves (use these, not CSS defaults):**
+```css
+/* Recommended - natural deceleration */
+--ease-out-quart: cubic-bezier(0.25, 1, 0.5, 1);    /* Smooth, refined */
+--ease-out-quint: cubic-bezier(0.22, 1, 0.36, 1);   /* Slightly snappier */
+--ease-out-expo: cubic-bezier(0.16, 1, 0.3, 1);     /* Confident, decisive */
+
+/* AVOID - feel dated and tacky */
+/* bounce: cubic-bezier(0.34, 1.56, 0.64, 1); */
+/* elastic: cubic-bezier(0.68, -0.6, 0.32, 1.6); */
+```
+
+**Exit animations are faster than entrances.** Use ~75% of enter duration.
+
+### CSS Animations
+```css
+/* Prefer for simple, declarative animations */
+- transitions for state changes
+- @keyframes for complex sequences
+- transform + opacity only (GPU-accelerated)
+```
+
+### JavaScript Animation
+```javascript
+/* Use for complex, interactive animations */
+- Web Animations API for programmatic control
+- Framer Motion for React
+- GSAP for complex sequences
+```
+
+### Performance
+- **GPU acceleration**: Use `transform` and `opacity`, avoid layout properties
+- **will-change**: Add sparingly for known expensive animations
+- **Reduce paint**: Minimize repaints, use `contain` where appropriate
+- **Monitor FPS**: Ensure 60fps on target devices
+
+### Accessibility
+```css
+@media (prefers-reduced-motion: reduce) {
+  * {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+  }
+}
+```
+
+**NEVER**:
+- Use bounce or elastic easing curves—they feel dated and draw attention to the animation itself
+- Animate layout properties (width, height, top, left)—use transform instead
+- Use durations over 500ms for feedback—it feels laggy
+- Animate without purpose—every animation needs a reason
+- Ignore `prefers-reduced-motion`—this is an accessibility violation
+- Animate everything—animation fatigue makes interfaces feel exhausting
+- Block interaction during animations unless intentional
+
+## Verify Quality
+
+Test animations thoroughly:
+
+- **Smooth at 60fps**: No jank on target devices
+- **Feels natural**: Easing curves feel organic, not robotic
+- **Appropriate timing**: Not too fast (jarring) or too slow (laggy)
+- **Reduced motion works**: Animations disabled or simplified appropriately
+- **Doesn't block**: Users can interact during/after animations
+- **Adds value**: Makes interface clearer or more delightful
+
+Remember: Motion should enhance understanding and provide feedback, not just add decoration. Animate with purpose, respect performance constraints, and always consider accessibility. Great animation is invisible - it just makes everything feel right.

package/framework/skills/bolder/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: bolder
+description: Amplify safe or boring designs to make them more visually interesting and stimulating. Increases impact while maintaining usability.
+user-invokable: true
+args:
+  - name: target
+    description: The feature or component to make bolder (optional)
+    required: false
+---
+
+Increase visual impact and personality in designs that are too safe, generic, or visually underwhelming, creating more engaging and memorable experiences.
+
+## MANDATORY PREPARATION
+
+### Read DESIGN.md (Authoritative Source)
+
+Before any context gathering, check for the project's design decisions file:
+
+```bash
+cat .planning/DESIGN.md 2>/dev/null
+```
+
+**If DESIGN.md exists:** This is the authoritative source for all design decisions in this project. Use its palette, typography, spacing, component, and motion decisions as your foundation. Do NOT override these decisions unless the user explicitly asks. Reference specific DESIGN.md decisions in your output (e.g., "Per DESIGN.md, the primary color is...").
+
+**If DESIGN.md does not exist:** Proceed with normal context gathering below. Consider suggesting the user run `/qualia:discuss-phase` to establish design decisions.
+
+### Context Gathering (Do This First)
+
+You cannot do a great job without having necessary context, such as target audience (critical), desired use-cases (critical), brand personality/tone, and everything else that a great human designer would need as well.
+
+Attempt to gather these from the current thread or codebase.
+
+1. If you don't find *exact* information and have to infer from existing design and functionality, you MUST STOP and STOP and call the AskUserQuestionTool to clarify. whether you got it right.
+2. Otherwise, if you can't fully infer or your level of confidence is medium or lower, you MUST STOP and call the AskUserQuestionTool to clarify. clarifying questions first to complete your context.
+
+Do NOT proceed until you have answers. Guessing leads to generic AI slop.
+
+### Use frontend-master skill
+
+Use the frontend-master skill for design principles and anti-patterns. Do NOT proceed until it has executed and you know all DO's and DON'Ts.
+
+---
+
+## Assess Current State
+
+Analyze what makes the design feel too safe or boring:
+
+1. **Identify weakness sources**:
+   - **Generic choices**: System fonts, basic colors, standard layouts
+   - **Timid scale**: Everything is medium-sized with no drama
+   - **Low contrast**: Everything has similar visual weight
+   - **Static**: No motion, no energy, no life
+   - **Predictable**: Standard patterns with no surprises
+   - **Flat hierarchy**: Nothing stands out or commands attention
+
+2. **Understand the context**:
+   - What's the brand personality? (How far can we push?)
+   - What's the purpose? (Marketing can be bolder than financial dashboards)
+   - Who's the audience? (What will resonate?)
+   - What are the constraints? (Brand guidelines, accessibility, performance)
+
+If any of these are unclear from the codebase, STOP and call the AskUserQuestionTool to clarify.
+
+**CRITICAL**: "Bolder" doesn't mean chaotic or garish. It means distinctive, memorable, and confident. Think intentional drama, not random chaos.
+
+**WARNING - AI SLOP TRAP**: When making things "bolder," AI defaults to the same tired tricks: cyan/purple gradients, glassmorphism, neon accents on dark backgrounds, gradient text on metrics. These are the OPPOSITE of bold—they're generic. Review ALL the DON'T guidelines in the frontend-master skill before proceeding. Bold means distinctive, not "more effects."
+
+## Plan Amplification
+
+Create a strategy to increase impact while maintaining coherence:
+
+- **Focal point**: What should be the hero moment? (Pick ONE, make it amazing)
+- **Personality direction**: Maximalist chaos? Elegant drama? Playful energy? Dark moody? Choose a lane.
+- **Risk budget**: How experimental can we be? Push boundaries within constraints.
+- **Hierarchy amplification**: Make big things BIGGER, small things smaller (increase contrast)
+
+**IMPORTANT**: Bold design must still be usable. Impact without function is just decoration.
+
+## Amplify the Design
+
+Systematically increase impact across these dimensions:
+
+### Typography Amplification
+- **Replace generic fonts**: Swap system fonts for distinctive choices (see frontend-master skill for inspiration)
+- **Extreme scale**: Create dramatic size jumps (3x-5x differences, not 1.5x)
+- **Weight contrast**: Pair 900 weights with 200 weights, not 600 with 400
+- **Unexpected choices**: Variable fonts, display fonts for headlines, condensed/extended widths, monospace as intentional accent (not as lazy "dev tool" default)
+
+### Color Intensification
+- **Increase saturation**: Shift to more vibrant, energetic colors (but not neon)
+- **Bold palette**: Introduce unexpected color combinations—avoid the purple-blue gradient AI slop
+- **Dominant color strategy**: Let one bold color own 60% of the design
+- **Sharp accents**: High-contrast accent colors that pop
+- **Tinted neutrals**: Replace pure grays with tinted grays that harmonize with your palette
+- **Rich gradients**: Intentional multi-stop gradients (not generic purple-to-blue)
+
+### Spatial Drama
+- **Extreme scale jumps**: Make important elements 3-5x larger than surroundings
+- **Break the grid**: Let hero elements escape containers and cross boundaries
+- **Asymmetric layouts**: Replace centered, balanced layouts with tension-filled asymmetry
+- **Generous space**: Use white space dramatically (100-200px gaps, not 20-40px)
+- **Overlap**: Layer elements intentionally for depth
+
+### Visual Effects
+- **Dramatic shadows**: Large, soft shadows for elevation (but not generic drop shadows on rounded rectangles)
+- **Background treatments**: Mesh patterns, noise textures, geometric patterns, intentional gradients (not purple-to-blue)
+- **Texture & depth**: Grain, halftone, duotone, layered elements—NOT glassmorphism (it's overused AI slop)
+- **Borders & frames**: Thick borders, decorative frames, custom shapes (not rounded rectangles with colored border on one side)
+- **Custom elements**: Illustrative elements, custom icons, decorative details that reinforce brand
+
+### Motion & Animation
+- **Entrance choreography**: Staggered, dramatic page load animations with 50-100ms delays
+- **Scroll effects**: Parallax, reveal animations, scroll-triggered sequences
+- **Micro-interactions**: Satisfying hover effects, click feedback, state changes
+- **Transitions**: Smooth, noticeable transitions using ease-out-quart/quint/expo (not bounce or elastic—they cheapen the effect)
+
+### Composition Boldness
+- **Hero moments**: Create clear focal points with dramatic treatment
+- **Diagonal flows**: Escape horizontal/vertical rigidity with diagonal arrangements
+- **Full-bleed elements**: Use full viewport width/height for impact
+- **Unexpected proportions**: Golden ratio? Throw it out. Try 70/30, 80/20 splits
+
+**NEVER**:
+- Add effects randomly without purpose (chaos ≠ bold)
+- Sacrifice readability for aesthetics (body text must be readable)
+- Make everything bold (then nothing is bold - need contrast)
+- Ignore accessibility (bold design must still meet WCAG standards)
+- Overwhelm with motion (animation fatigue is real)
+- Copy trendy aesthetics blindly (bold means distinctive, not derivative)
+
+## Verify Quality
+
+Ensure amplification maintains usability and coherence:
+
+- **NOT AI slop**: Does this look like every other AI-generated "bold" design? If yes, start over.
+- **Still functional**: Can users accomplish tasks without distraction?
+- **Coherent**: Does everything feel intentional and unified?
+- **Memorable**: Will users remember this experience?
+- **Performant**: Do all these effects run smoothly?
+- **Accessible**: Does it still meet accessibility standards?
+
+**The test**: If you showed this to someone and said "AI made this bolder," would they believe you immediately? If yes, you've failed. Bold means distinctive, not "more AI effects."
+
+Remember: Bold design is confident design. It takes risks, makes statements, and creates memorable experiences. But bold without strategy is just loud. Be intentional, be dramatic, be unforgettable.