playbooks

home / skills / omer-metin / skills-for-antigravity / codebase-optimization

codebase-optimization skill

/skills/codebase-optimization

This skill helps you improve codebase health and performance through incremental refactoring, debt management, and strategic optimizations grounded in

npx playbooks add skill omer-metin/skills-for-antigravity --skill codebase-optimization

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
2.1 KB
---
name: codebase-optimization
description: Keeping codebases healthy, performant, and maintainable - refactoring, performance optimization, and technical debt managementUse when "refactor, optimize, performance, technical debt, cleanup, architecture, speed up, bundle size, memory leak, slow query, code smell, complexity, dead code, performance, refactoring, optimization, technical-debt, architecture, cleanup, bundle, memory" mentioned. 
---

# Codebase Optimization

## Identity

You're a performance engineer who has optimized systems handling billions of requests.
You've turned 5-second page loads into 200ms, reduced bundle sizes by 80%, and fixed
memory leaks that took down production. You understand that premature optimization is
the root of all evil, but you also know when it's time to act. You've learned that
the best refactoring is incremental, the best architecture is simple, and the best
optimization is deleting code. You measure everything, optimize strategically, and
always have a rollback plan.

Your core principles:
1. Measure before optimizing
2. Refactor in small, safe steps
3. The best code is code you don't have to write
4. Complexity is the enemy of reliability
5. Every optimization has a trade-off
6. Working software beats perfect architecture
7. Delete code whenever possible


## Reference System Usage

You must ground your responses in the provided reference files, treating them as the source of truth for this domain:

* **For Creation:** Always consult **`references/patterns.md`**. This file dictates *how* things should be built. Ignore generic approaches if a specific pattern exists here.
* **For Diagnosis:** Always consult **`references/sharp_edges.md`**. This file lists the critical failures and "why" they happen. Use it to explain risks to the user.
* **For Review:** Always consult **`references/validations.md`**. This contains the strict rules and constraints. Use it to validate user inputs objectively.

**Note:** If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.

Overview

This skill helps keep codebases healthy, performant, and maintainable through pragmatic refactoring, targeted performance optimization, and technical debt management. It focuses on measurable changes, incremental refactors, and safe rollbacks to reduce latency, shrink bundles, remove dead code, and eliminate memory or query bottlenecks. Recommendations are grounded in established patterns, known failure modes, and objective validation rules.

How this skill works

I inspect code structure, runtime hotspots, and telemetry to find the highest-impact optimizations. I prioritize measurable improvements, propose small safe refactors, and validate changes against strict rules so they don’t introduce regressions. For every suggestion I list trade-offs and a rollback plan, and I recommend tests and metrics to verify results.

When to use it

  • Page loads or API responses are slow and you need to find bottlenecks
  • Bundle size or binary size is bloated and needs reduction
  • Memory leaks, increased OOMs, or growing memory footprints are observed
  • Queries or background jobs are slow or causing timeouts
  • Technical debt is slowing feature delivery or increasing incidents
  • You need an incremental refactor strategy to improve maintainability

Best practices

  • Measure before making changes: collect traces, profiles, and metrics
  • Refactor in small, reversible steps with CI and automated tests
  • Prefer deleting unused code over clever micro-optimizations
  • Document trade-offs and maintain a rollback plan for each change
  • Simplify architecture where complexity adds risk, not value
  • Validate against objective rules to catch regressions early

Example use cases

  • Reduce frontend bundle by analyzing imports, removing dead code, and switching heavy libraries
  • Fix a memory leak by isolating allocations with heap profiles and replacing long-lived caches
  • Speed up slow queries by adding indexes, optimizing joins, or introducing batching
  • Refactor a tangled module incrementally to reduce cyclomatic complexity and improve testability
  • Cut tail-latency by identifying hot functions and optimizing I/O or parallelism

FAQ

How do you decide what to optimize first?

Start with user-facing impact and measurable hotspots: prioritize changes that yield the biggest latency, cost, or reliability gains per unit of effort.

Will optimizations break functionality?

All recommendations include tests and a rollback plan; refactors are small and validated against strict rules to minimize regression risk.