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
| Metric | Good | Bad |
|---|
| Page load | < 3s | > 5s |
| API response | < 500ms | > 1s |
| Time to interactive | < 5s | > 8s |
| Database query | < 100ms | > 500ms |
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
- 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:
bash
# 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:
| Heavy | Light Alternative |
|---|
| moment.js | date-fns or dayjs |
| lodash (full) | lodash-es (tree-shakeable) |
| axios | fetch (built-in) |
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:
- Speed - Users feel this immediately
- Dependencies - Security vulnerabilities are urgent
- Database - Affects long-term performance
- Code - Affects maintainability, not users
Quick wins per category:
| Category | Quick Win |
|---|
| Speed | Add caching to slowest API endpoint |
| Code | Delete obviously dead files |
| Database | Add indexes to slow queries |
| Dependencies | Remove unused packages |
Common Mistakes
| Mistake | Fix |
|---|
| Optimizing before measuring | AUDIT first, always |
| Deleting code without checking | Verify no references before removing |
| Dropping database columns in production | Test migrations on staging |
| Updating all packages at once | Update one at a time, test each |
| Premature optimization | Wait until there's actual waste to clean |
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