optimizing-performance

Guides performance optimization, profiling techniques, and bottleneck identification. Use when improving application speed, reducing resource usage, or diagnosing performance issues.

설치로 이동

저장소: CloudAI-X/opencode-workflow
최근 소스 활동: 2026년 1월 10일 13:36
감지된 SKILL.md 언어: 영어
스타: 267
포크: 24

설치 방법

기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.

Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.

직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.

npx skills add https://github.com/CloudAI-X/opencode-workflow --skill optimizing-performance

명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.

로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.

소스 파일 검토

설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.

SKILL.md

소스 지침 · 읽기 전용 미리보기

검색으로 돌아가기 설치로 돌아가기

analyzing-projects

Guides systematic project analysis, codebase exploration, and architecture pattern recognition. Use when understanding new codebases, onboarding to projects, or investigating system structure.

2026-01-10

designing-apis

Guides REST and GraphQL API design, endpoint patterns, request/response schemas, versioning, and API best practices. Use when building APIs, designing endpoints, or reviewing API contracts.

2026-01-10

designing-architecture

Guides software architecture decisions, design patterns, and system design principles. Use when designing systems, choosing patterns, or making architectural decisions.

2026-01-10

이 저장소의 모든 Skills 보기

80% of performance problems come from 20% of the code.

Focus on:
├── Hot paths (frequently executed code)
├── I/O operations (database, network, disk)
├── Memory allocation patterns
└── Algorithm complexity

Type	What It Measures	Tools
CPU Profiling	Time spent in functions	pprof, py-spy, Chrome DevTools
Memory Profiling	Allocation patterns, leaks	Valgrind, memory_profiler, Chrome
I/O Profiling	Disk/network operations	strace, perf, Wireshark
Database Profiling	Query performance	EXPLAIN, slow query log, APM

1. Establish baseline
   └─ Measure current performance with realistic load

2. Identify hotspots
   └─ Profile to find where time/resources are spent

3. Form hypothesis
   └─ Why is this slow? What would make it faster?

4. Implement fix
   └─ Make ONE change at a time

5. Measure again
   └─ Did it help? By how much?

6. Repeat
   └─ Until performance goals are met

# Node.js
node --prof app.js
node --prof-process isolate-*.log > profile.txt

# Python
python -m cProfile -s cumtime app.py
py-spy record -o profile.svg -- python app.py

# Go
go test -cpuprofile cpu.prof -memprofile mem.prof -bench .
go tool pprof cpu.prof

# Database (PostgreSQL)
EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@example.com';

BAD (N+1 queries):
  SELECT * FROM posts;             -- 1 query
  SELECT * FROM users WHERE id=1;  -- N queries
  SELECT * FROM users WHERE id=2;
  ...

GOOD (2 queries):
  SELECT * FROM posts;
  SELECT * FROM users WHERE id IN (1, 2, 3, ...);

BAD:
  SELECT * FROM logs;  -- Returns millions of rows

GOOD:
  SELECT * FROM logs
  WHERE created_at > NOW() - INTERVAL '1 day'
  LIMIT 100;

BAD (blocking):
  result1 = fetch_api_1()  -- Wait 200ms
  result2 = fetch_api_2()  -- Wait 200ms
  return combine(result1, result2)  -- Total: 400ms

GOOD (parallel):
  [result1, result2] = await Promise.all([
    fetch_api_1(),
    fetch_api_2()
  ])  -- Total: ~200ms

BAD (allocates in loop):
  for item in large_list:
      result = []  # Allocates each iteration
      result.append(transform(item))

GOOD (pre-allocate):
  result = []
  for item in large_list:
      result.append(transform(item))

BEST (generator):
  def transform_all(items):
      for item in items:
          yield transform(item)

Technique	When to Use	Impact
Indexing	Slow WHERE/JOIN queries	High
Query optimization	Complex queries	High
Connection pooling	Many short connections	Medium
Read replicas	Read-heavy workloads	High
Caching	Repeated queries	Very High
Denormalization	Complex JOINs	Medium

-- Create index for frequently queried columns
CREATE INDEX idx_users_email ON users(email);

-- Composite index for multiple column queries
CREATE INDEX idx_orders_user_date ON orders(user_id, created_at);

-- Check if index is used
EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@example.com';

Cache-aside pattern:
1. Check cache
2. If miss, query database
3. Store in cache
4. Return result

Technique	When to Use
Object pooling	Frequent allocation of same type
Lazy loading	Large objects not always needed
Streaming	Processing large datasets
Weak references	Cache that can be evicted
Data structure choice	Right structure for access pattern

Loading Performance:
  ☐ Code splitting (lazy load routes/components)
  ☐ Tree shaking (remove unused code)
  ☐ Minification (JS, CSS)
  ☐ Compression (gzip, brotli)
  ☐ Image optimization (WebP, srcset, lazy loading)
  ☐ CDN for static assets

Runtime Performance:
  ☐ Virtualized lists for large data
  ☐ Debounce/throttle event handlers
  ☐ Memoization of expensive computations
  ☐ Avoid layout thrashing (batch DOM reads/writes)
  ☐ Use CSS transforms for animations
  ☐ Web Workers for heavy computation

# Analyze bundle size
npx webpack-bundle-analyzer stats.json
npx source-map-explorer bundle.js

# Identify large dependencies
npx depcheck

Technique	Benefit
Response compression	Reduce transfer size
Pagination	Limit response size
Field selection	Return only needed data
ETags/Caching headers	Reduce redundant requests
Connection keep-alive	Reduce handshake overhead
HTTP/2	Multiplexing, header compression

BAD (multiple requests):
  GET /users/1
  GET /users/2
  GET /users/3

GOOD (batch):
  POST /users/batch
  { "ids": [1, 2, 3] }

Critical (page immediately):
  - Error rate > 5%
  - p99 latency > 5s
  - Service down

Warning (notify during hours):
  - Error rate > 1%
  - p95 latency > 2s
  - Resource utilization > 80%

# Log slow operations
import time
import logging

def timed_operation(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        duration = time.time() - start
        if duration > 1.0:  # Log if > 1 second
            logging.warning(f"{func.__name__} took {duration:.2f}s")
        return result
    return wrapper

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },   // Ramp up
    { duration: '5m', target: 50 },   // Stay at 50 users
    { duration: '1m', target: 0 },    // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],  // 95% under 500ms
    http_req_failed: ['rate<0.01'],    // Error rate < 1%
  },
};

export default function () {
  const res = http.get('https://api.example.com/users');
  check(res, { 'status is 200': (r) => r.status === 200 });
  sleep(1);
}

PROFILING FLOW:
  Measure → Identify → Hypothesize → Fix → Measure → Repeat

COMMON BOTTLENECKS:
  N+1 queries → Eager loading
  Unbounded data → Pagination
  Blocking I/O → Parallelization
  Excessive allocation → Object pooling

DATABASE:
  Index frequently queried columns
  Use EXPLAIN ANALYZE
  Add caching layer

CACHING:
  Cache-aside for general use
  TTL for time-based invalidation
  Invalidate on write for consistency

TARGETS:
  p50 < 100ms
  p95 < 500ms
  p99 < 1s

TOOLS:
  CPU: pprof, py-spy
  Memory: valgrind, memory_profiler
  Load: k6, locust
  DB: EXPLAIN, slow query log

Strategy	Use Case	Invalidation
Cache-aside	General purpose	Manual or TTL
Write-through	Strong consistency	On write
Write-behind	Write-heavy	Async batched
Read-through	Read-heavy	On miss

Metric	Target	What It Measures
LCP (Largest Contentful Paint)	< 2.5s	Load performance
INP (Interaction to Next Paint)	< 200ms	Interactivity
CLS (Cumulative Layout Shift)	< 0.1	Visual stability

Category	Metrics
Latency	p50, p95, p99 response times
Throughput	Requests per second
Errors	Error rate, error types
Saturation	CPU, memory, connections

Tool	Use Case
k6	Modern, scriptable load testing
JMeter	Complex scenarios, GUI
Locust	Python-based, distributed
Artillery	YAML config, easy to start
wrk	Simple HTTP benchmarking

name	optimizing-performance
description	Guides performance optimization, profiling techniques, and bottleneck identification. Use when improving application speed, reducing resource usage, or diagnosing performance issues.
license	MIT
compatibility	opencode
metadata	{"category":"quality","audience":"developers"}

Percentile	Target	User Experience
p50	< 100ms	Fast
p95	< 500ms	Acceptable
p99	< 1s	Tolerable

optimizing-performance

소스 정보

설치 방법

소스 파일 검토

이 저장소의 다른 Skills

이 저장소의 다른 Skills

Optimizing Performance

When to Use This Skill

Performance Optimization Philosophy

The Golden Rules

Optimizing Performance

When to Use This Skill

Performance Optimization Philosophy

The Golden Rules

The 80/20 Rule

Profiling Techniques

Types of Profiling

Profiling Workflow

Common Profiling Commands

Common Bottleneck Patterns

N+1 Query Problem

Unbounded Operations

Synchronous Blocking

Excessive Allocation

Optimization Techniques

Database Optimization

Index Guidelines

Caching Strategies

Memory Optimization

Frontend Performance

Core Web Vitals

Frontend Optimization Checklist

Bundle Optimization

API Performance

Response Time Targets

API Optimization Techniques

Batch Endpoints

Monitoring and Alerting

Key Metrics to Track

Alerting Thresholds

Logging for Performance

Performance Testing

Load Testing Tools

Load Test Example (k6)

Anti-Patterns to Avoid

Quick Reference