Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

performance

/performance

Optymalizuje wydajność aplikacji: rozmiar paczek, czasy odpowiedzi API, zapytania do bazy, renderowanie Reacta i funkcje serverless, przed wdrożeniem produkcyjnym lub przy wolnych stronach.

Repozytorium
motormetrics ↗
Licencja
MIT
Ostatnia zmiana repozytorium
28.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
5
Przestarzałość

Brak sygnałów. Repozytorium zmienione 28.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Optymalizuje wydajność aplikacji: rozmiar paczek, czasy odpowiedzi API, zapytania do bazy, renderowanie Reacta i funkcje serverless, przed wdrożeniem produkcyjnym lub przy wolnych stronach.

Oryginalny opis (EN)

Optimize application performance - bundle size, API response times, database queries, React rendering, and serverless function performance. Use when investigating slow pages, profiling, load testing, or before production deployments.

Jak działa

  1. Performance Targets
  2. Measure Performance
  3. Bundle Size Optimization
  4. React Performance
  5. Database Query Optimization
  6. Caching
  7. Image Optimization
  8. Vercel Function Optimization
  9. Profiling
  10. Load Testing
Sekcje z nagłówków SKILL.md, w oryginale · 266 linii, 798 słów
Podgląd SKILL.md
---
name: performance
description: Optimize application performance - bundle size, API response times, database queries, React rendering, and serverless function performance. Use when investigating slow pages, profiling, load testing, or before production deployments.
allowed-tools: Read, Edit, Bash, Grep, Glob
---

# Performance Skill

## Performance Targets

**Frontend (Web Vitals):** LCP < 2.5s, FID < 100ms, CLS < 0.1, FCP < 1.8s, TTFB < 600ms
**Backend:** Response time < 500ms (p95), cold start < 2s, error rate < 1%
**Database:** Query time < 100ms, cache hit rate > 80%

## Measure Performance

```bash
# Lighthouse audit
npx lighthouse https://motormetrics.app --view

# Bundle analysis
cd apps/web && ANALYZE=true pnpm build

# Load test with k6
k6 run --vus 100 --duration 5m load-test.js
```

## Bundle Size Optimization

### Dynamic Imports

```typescript
// ❌ Static import (loads immediately)
import { HeavyComponent } from "./heavy-component";

// ✅ Dynamic import (lazy load)
import dynamic from "next/dynamic";
const HeavyComponent = dynamic(() => import("./heavy-component"), {
  loading: () => <div>Loading...</div>,
  ssr: false,
});
```

### Tree Shaking

```typescript
// ❌ Imports entire library
import _ from "lodash";

// ✅ Import only what you need
import uniq from "lodash/uniq";
```

## React Performance

### Prevent Re-renders

```typescript
// useMemo for expensive calculations
const processed = useMemo(() => expensiveOperation(data), [data]);

// useCallback for stable function references
const handleClick = useCallback(() => doSomething(), []);

// React.memo for pure components
const Child = React.memo(function Child({ name }) {
  return <div>{name}</div>;
});
```

### Virtualize Long Lists

```typescript
import { FixedSizeList } from "react-window";

<FixedSizeList height={600} itemCount={items.length} itemSize={100} width="100%">
  {({ index, style }) => <Item style={style} data={items[index]} />}
</FixedSizeList>
```

## Database Query Optimization

### Add Indexes

```typescript
// packages/database/src/schema/cars.ts
export const cars = pgTable("cars", {
  make: text("make").notNull(),
  month: text("month").notNull(),
}, (table) => ({
  makeIdx: index("cars_make_idx").on(table.make),
}));
```

### Avoid N+1 Queries

```typescript
// ❌ N+1 queries
for (const post of posts) {
  post.author = await db.query.users.findFirst({ where: eq(users.id, post.authorId) });
}

// ✅ Single query with relation
const posts = await db.query.posts.findMany({ with: { author: true } });
```

### Select Only Needed Columns

```typescript
// ❌ Selects all columns
const users = await db.query.users.findMany();

// ✅ Select specific columns
const users = await db.select({ id: users.id, name: users.name }).from(users);
```

### Use Pagination

```typescript
const cars = await db.query.cars.findMany({
  limit: 20,
  offset: (page - 1) * 20,
});
```

## Caching

### Redis Caching

```typescript
import { redis } from "@motormetrics/utils/redis";

export async function getCarsWithCache(make: string) {
  const cacheKey = `cars:${make}`;
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached as string);

  const cars = await db.query.cars.findMany({ where: eq(cars.make, make) });
  await redis.set(cacheKey, JSON.stringify(cars), { ex: 3600 });
  return cars;
}
```

### Next.js Caching

```typescript
// Revalidate every hour
export const revalidate = 3600;

// Or use fetch with caching
const data = await fetch(url, { next: { revalidate: 3600 } });
```

## Image Optimization

```typescript
import Image from "next/image";

// ✅ Optimized image with priority for above-fold
<Image
  src="/hero.jpg"
  alt="Hero"
  fill
  sizes="(max-width: 768px) 100vw, 50vw"
  priority
/>
```

## Vercel Function Optimization

```typescript
// API route with optimized config
export const config = {
  maxDuration: 60, // seconds
};

// Use edge functions for low-latency endpoints
export const runtime = "edge";
```

## Profiling

### Performance Middleware

```typescript
// apps/api/src/middleware/performance.ts
export const performanceMiddleware = async (c: Context, next: Next) => {
  const start = performance.now();
  await next();
  const duration = performance.now() - start;

  c.header("X-Response-Time", `${Math.round(duration)}ms`);

  if (duration > 1000) {
    log.warn("Slow request", { path: c.req.path, duration: Math.round(duration) });
  }
};
```

### Query Profiling

```typescript
const start = performance.now();
const result = await db.query.cars.findMany();
const duration = performance.now() - start;

if (duration > 100) {
  console.warn(`Slow query: ${duration}ms`);
}
```

### Vercel Analytics

Check Vercel Dashboard → Analytics for:
- Function execution times
- Edge response times
- Web Vitals metrics
- Request volumes and errors

## Load Testing

```javascript
// load-test.js (k6)
import http from "k6/http";
import { check } from "k6";

export const options = {
  stages: [
    { duration: "2m", target: 100 },
    { duration: "5m", target: 100 },
    { duration: "2m", target: 0 },
  ],
  thresholds: {
    http_req_duration: ["p(95)<500"],
    http_req_failed: ["rate<0.01"],
  },
};

export default function() {
  const res = http.get("https://api.motormetrics.app/api/v1/cars/makes");
  check(res, { "status 200": (r) => r.status === 200 });
}
```

## Performance Checklist

- [ ] Bundle size < 200KB (initial load)
- [ ] LCP < 2.5s, FID < 100ms, CLS < 0.1
- [ ] API responses < 500ms
- [ ] Database queries < 100ms
- [ ] Images optimized (WebP/AVIF)
- [ ] Code splitting implemented
- [ ] Caching strategy in place
- [ ] Long lists virtualized
- [ ] Compression enabled

## Quick Wins

1. **Compression**: Enable gzip/brotli (60-80% size reduction)
2. **Image Optimization**: Use Next.js Image component
3. **Caching**: Cache expensive operations in Redis
4. **Indexes**: Add indexes to frequently queried columns
5. **Code Splitting**: Lazy load heavy components
6. **Memoization**: Use useMemo/useCallback for expensive operations

## References

- Web Vitals: https://web.dev/vitals
- Next.js Performance: https://nextjs.org/docs/app/building-your-application/optimizing
- k6 Load Testing: https://k6.io/docs

Wersje

RepozytoriumWynikLicencja
Ta strona · motormetrics/motormetrics100MIT
ericrisco/rsc-harness100MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
davila7/claude-code-templates100MIT
motormetrics/motormetrics100MIT
event4u-app/agent-config100MIT
arxdsilva/ai-loops100MIT
krzysztofsurdy/code-virtuoso100MIT

Migawka bazy z 13.11.2026 · wersja paczki 556346d14dfe (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100performance-optimization
    Optymalizuje szybkość i skalowalność aplikacji: czas ładowania stron, rozmiar bundle'a, zapytania do bazy, React, lazy loading, cache, dzielenie kodu i profilowanie.
  • 86performance-optimizer
    Optymalizuje wydajność aplikacji Vercel: Core Web Vitals, renderowanie, buforowanie, obrazy, fonty i rozmiar paczek.
  • 100performance-profiler
    Profiluje i optymalizuje wydajność aplikacji: czas ładowania, zużycie pamięci i renderowanie, przy wolnym działaniu lub wyciekach pamięci.
  • 100optimize
    Diagnozuje i naprawia wydajność interfejsu: szybkość ładowania, renderowanie, animacje, obrazy i rozmiar paczki.
  • 90react-optimise
    Optymalizuje wydajność aplikacji React na poziomie aplikacji: React Compiler, rozmiar bundla, renderowanie, pobieranie danych, Core Web Vitals, subskrypcje stanu, profilowanie i zarządzanie pamięcią.
  • 100optimizing-performance
    Analizuje i optymalizuje wydajność aplikacji we frontendzie, backendzie i bazie danych: diagnozuje wolne działanie, skraca czas ładowania, optymalizuje zapytania i zmniejsza paczkę.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.