Optimize

Reduce waste and improve efficiency across four dimensions.

Choose Your Path

Speed → Pages slow, APIs timeout, sluggish UX Code → Bloated codebase, unused files, redundant components Database → Orphaned data, unused fields/tables, slow queries Dependencies → Package bloat, large bundles, outdated libraries

When to Optimize

Optimize when:

• App feels slow (Speed)
• Codebase has grown significantly (Code)
• Database has accumulated cruft (Database)
• Bundle size is large or security warnings appear (Dependencies)

Don't optimize when:

• Building MVP
• < 100 users
• Everything works fine

Rule: Make it work, then make it lean.

Speed Optimization

Make your app fast and responsive.

Targets

AUDIT

Identify what's slow.

Tell AI:

Audit app performance:
- Measure page load times
- Log API response times
- Identify slow database queries
- Check bundle size
Report findings with specific numbers.

Quick manual check:

• Chrome DevTools → Network tab → Reload → Check "Load" time
• Chrome DevTools → Network tab → Click action → Check API time

CLEAN

Fix identified issues.

Tell AI:

Optimize these performance issues:
[paste audit findings]

Apply fixes:
- Add caching for slow API calls
- Add database indexes for slow queries
- Optimize/lazy-load images
- Code split large bundles

PREVENT

Stop future slowdowns.

Tell AI:

Add performance monitoring:
- Log API calls > 500ms
- Log database queries > 100ms
- Alert on page load > 3s
- Track bundle size in CI

See PERFORMANCE-CHECKS.md for testing methods. See OPTIMIZATION-PROMPTS.md for specific patterns.

Code Optimization

Remove unused code and reduce complexity.

Signs You Need This

• Files you don't recognize
• Components that aren't used anywhere
• Multiple versions of similar code
• "I'm afraid to delete this"

AUDIT

Find unused code.

Tell AI:

Audit codebase for unused code:
- Find components not imported anywhere
- Find functions never called
- Find files not referenced
- Find duplicate/similar code
- Find commented-out code blocks

List each with file path and last modified date.

What to look for:

• Dead components (created during iteration, never used)
• Orphaned utilities (helper functions nothing calls)
• Abandoned features (half-built, never finished)
• Copy-paste duplication (same logic in multiple places)

CLEAN

Remove identified waste.

Tell AI:

Remove this unused code:
[paste audit findings]

Before deleting:
- Verify nothing imports/calls it
- Check git history for context
- Remove related tests if any

After deleting:
- Run build to verify no breaks
- Run tests to verify no breaks

Safety rule: If unsure, comment out first and test. Delete after confirming nothing breaks.

PREVENT

Stop code accumulation.

Tell AI:

Set up code hygiene practices:
- Add ESLint rule for unused imports
- Add ESLint rule for unused variables
- Configure IDE to highlight unused code
- Add CI check for unused exports

See CODE.md for detailed patterns.

Database Optimization

Clean up data schema and orphaned records.

Signs You Need This

• Tables you don't recognize
• Fields that are always null
• Queries getting slower over time
• "What is this table for?"

AUDIT

Find database waste.

Tell AI:

Audit database for cleanup opportunities:
- Tables with no recent reads/writes
- Columns that are always NULL or empty
- Orphaned records (foreign keys pointing to deleted rows)
- Duplicate data across tables
- Missing indexes on frequently queried fields

List each with table name, row count, and last access if available.

What to look for:

• Abandoned feature tables (feature removed, table remains)
• Legacy columns (renamed but old column kept)
• Orphaned records (user deleted, their data remains)
• Redundant data (same info stored multiple places)

CLEAN

Remove identified waste.

Tell AI:

Clean up database:
[paste audit findings]

Before removing:
- Backup affected tables
- Verify no code references removed tables/columns
- Check for foreign key constraints

Migration steps:
- Create migration to drop unused columns
- Create migration to drop unused tables
- Create script to delete orphaned records
- Add missing indexes

Safety rule: Always backup before schema changes. Test on staging first.

PREVENT

Stop data accumulation.

Tell AI:

Set up database hygiene:
- Add ON DELETE CASCADE for dependent records
- Add NOT NULL constraints where appropriate
- Create cleanup job for soft-deleted records (>90 days)
- Add monitoring for table size growth

See DATABASE.md for detailed patterns.

Dependencies Optimization

Reduce package bloat and bundle size.

Signs You Need This

• npm install takes forever
• Bundle size > 500KB
• Security vulnerability warnings
• "What does this package do?"

AUDIT

Find dependency waste.

Tell AI:

Audit dependencies:
- List packages not imported anywhere in code
- List packages with security vulnerabilities
- List packages with major version updates available
- Analyze bundle size by package
- Find duplicate packages (different versions of same thing)

Report: package name, size impact, last used, and recommendation.

Quick manual check:

# Check bundle size
npm run build

# Check for unused packages
npx depcheck

# Check for vulnerabilities
npm audit

# Check for outdated packages
npm outdated

CLEAN

Remove identified waste.

Tell AI:

Clean up dependencies:
[paste audit findings]

Steps:
- Remove unused packages from package.json
- Update packages with security vulnerabilities
- Replace heavy packages with lighter alternatives
- Remove duplicate package versions

After changes:
- Delete node_modules and package-lock.json
- Fresh npm install
- Run build and tests

Common replacements:

PREVENT

Stop dependency bloat.

Tell AI:

Set up dependency hygiene:
- Add bundle size check to CI (fail if > X KB)
- Add npm audit to CI pipeline
- Configure Dependabot for security updates
- Add depcheck to pre-commit hook

See DEPENDENCIES.md for detailed patterns.

Optimization Priority

When everything needs work:

1. Speed - Users feel this immediately
2. Dependencies - Security vulnerabilities are urgent
3. Database - Affects long-term performance
4. Code - Affects maintainability, not users

Quick wins per category:

Common Mistakes

Success Looks Like

✅ Pages load < 3 seconds ✅ No unused code in codebase ✅ No orphaned data in database ✅ No unused dependencies ✅ Bundle size < 200KB (React apps) ✅ Zero security vulnerabilities ✅ Automated checks prevent future waste