optimize

Original：🇺🇸 English
Translated

Optimize your SaaS app across four dimensions - Speed (page load, API response), Code (unused files, dead code), Database (orphaned data, schema hygiene), and Dependencies (package bloat, bundle size). Use when app feels slow, codebase feels bloated, or after significant development work accumulates. Each path follows AUDIT → CLEAN → PREVENT workflow.

1installs
Sourcewhawkinsiv/claude-code-superpowers
Added on

NPX Install

npx skill4agent add whawkinsiv/claude-code-superpowers optimize

Tags

Translated version includes tags in frontmatter
saas-optimizationperformance-tuningcode-cleanupdatabase-hygienedependency-optimization

SKILL.md Content

View Translation Comparison →

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

MetricGoodBad
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

  • 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:
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:
HeavyLight Alternative
moment.jsdate-fns or dayjs
lodash (full)lodash-es (tree-shakeable)
axiosfetch (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:
  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:
CategoryQuick Win
SpeedAdd caching to slowest API endpoint
CodeDelete obviously dead files
DatabaseAdd indexes to slow queries
DependenciesRemove unused packages

Common Mistakes

MistakeFix
Optimizing before measuringAUDIT first, always
Deleting code without checkingVerify no references before removing
Dropping database columns in productionTest migrations on staging
Updating all packages at onceUpdate one at a time, test each
Premature optimizationWait 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