build-optimization
npx machina-cli add skill NickCrew/claude-cortex/build-optimization --openclawFiles (1)
SKILL.md
3.1 KB
Build Optimization
Expert guidance for optimizing build systems, reducing compilation times, maximizing cache hit rates, and building developer tools that enhance productivity across the development lifecycle.
When to Use This Skill
- Diagnosing slow build times and identifying bottlenecks
- Configuring caching strategies (local, remote, distributed)
- Setting up incremental builds and parallel execution
- Optimizing CI/CD pipeline performance and cost
- Designing or improving bundle splitting and tree shaking
- Building CLIs, plugins, code generators, or IDE extensions
- Configuring monorepo tooling (Nx, Turborepo, Bazel)
- Reducing developer feedback loop times (hot reload, watch mode)
- Managing build artifacts and reproducibility
Quick Reference
| Task | Load reference |
|---|---|
| Compilation, caching, incremental builds, CI/CD optimization | skills/build-optimization/references/build-systems.md |
| Plugin systems, code generation, linting, IDE integration, monorepo tooling | skills/build-optimization/references/developer-tooling.md |
Core Targets
- Build time under 30 seconds for development builds
- Rebuild time under 5 seconds with watch mode
- Cache hit rate above 90% in CI
- Zero flaky builds in production pipelines
- Reproducible builds across environments
Workflow
1. Performance Analysis
Profile the current build before making changes.
- Measure cold build, incremental rebuild, and hot reload times
- Profile CPU, memory, and I/O during builds
- Map the dependency graph and identify bottlenecks
- Evaluate cache hit rates and invalidation patterns
- Review current tool configuration for missed optimizations
2. Optimization
Apply targeted improvements based on profiling data.
- Enable incremental compilation and caching
- Configure parallel execution across available cores
- Set up code splitting and tree shaking
- Optimize module resolution and source transformation
- Implement remote or distributed caching for CI
3. Tooling
Build or configure developer tools for fast feedback loops.
- Configure watch mode and hot module replacement
- Set up clear error messages and progress indicators
- Integrate build analytics and performance dashboards
- Add pre-commit hooks for format, lint, and validation
4. Monitoring
Track build health over time.
- Set up automated build time tracking and alerting
- Monitor cache hit rates and bundle size trends
- Detect performance regressions in CI
- Review and optimize periodically based on data
Common Mistakes
- Optimizing without profiling first
- Disabling caching due to intermittent issues instead of fixing invalidation
- Running full builds when incremental builds would suffice
- Not parallelizing independent build tasks
- Ignoring I/O as a bottleneck (disk speed, network latency)
- Letting bundle sizes grow unchecked without analysis
- Using a single build configuration for development and production
Source
git clone https://github.com/NickCrew/claude-cortex/blob/main/skills/build-optimization/SKILL.mdView on GitHub Overview
This skill helps diagnose and fix slow builds, optimize caching, and enable incremental and parallel builds. It also covers CI/CD optimization, bundle splitting, and developer tooling to speed feedback loops across the development lifecycle.
How This Skill Works
You begin by profiling the current build to measure cold, incremental, and hot-reload times, along with CPU/memory and I/O usage. Then you apply targeted optimizations—enable incremental compilation, configure parallel execution, set up code splitting and tree shaking, and implement remote caching for CI—followed by building developer tooling for fast feedback (watch mode, clear errors, analytics dashboards).
When to Use It
- Diagnosing slow build times and bottlenecks
- Configuring local, remote, and distributed caching
- Setting up incremental builds and parallel execution
- Optimizing CI/CD pipeline performance and cost
- Designing or improving bundle splitting, tree shaking, and monorepo tooling
Quick Start
- Step 1: Profile the current build to measure cold, incremental, and hot-reload times; record CPU/memory/I/O and cache metrics.
- Step 2: Apply optimizations: enable incremental compilation, configure parallelism, and set up code splitting and remote caching for CI.
- Step 3: Build tooling for fast feedback: enable watch mode/HMR, provide clear progress/error indicators, and deploy performance dashboards.
Best Practices
- Profile cold, incremental, and hot rebuilds; measure CPU, memory, and I/O; map the dependency graph.
- Enable incremental compilation and caching; tune cache invalidation and expiration policies.
- Parallelize builds across available cores; configure code splitting and tree shaking to minimize work.
- Use remote or distributed caching for CI; optimize module resolution and source transformation for cache friendliness.
- Monitor build health with dashboards; track cache hit rates, bundle sizes, and regression trends; enforce reproducible builds.
Example Use Cases
- Reduced a large dev build from 60s to 25s by enabling incremental builds and CPU parallelism.
- Implemented remote caching for CI, cutting pipeline times by 40-70% without compromising determinism.
- Added bundle splitting and tree shaking to shrink production bundles while preserving performance.
- Configured Nx/Turborepo monorepo tooling with proper invalidation and watch-mode feedback.
- Built a CLI tool with fast local feedback loops and deterministic, reproducible builds.
Frequently Asked Questions
Add this skill to your agents
