Skip to content
Skills Library
Programming · Review & audit

performance

/performance

Keep app loads and interactions responsive as data grows. Use when a page feels slow, jumps, or lags, or when changing a data read, list, polling path, startup path, or performance-sensitive UI.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Keep app loads and interactions responsive as data grows. Use when a page feels slow, jumps, or lags, or when changing a data read, list, polling path, startup path, or performance-sensitive UI.

Original author description

Keep app loads and interactions responsive as data grows. Use when a page feels slow, jumps, or lags, or when changing a data read, list, polling path, startup path, or performance-sensitive UI.

How it works

  1. Load only what the current view needs
  2. Keep repeated work cheap
  3. Protect startup and the first paint
  4. Keep interactions responsive
Original SKILL.md headings · 72 lines, 607 words
SKILL.md preview
---
name: performance
description: >-
  Keep app loads and interactions responsive as data grows. Use when a page
  feels slow, jumps, or lags, or when changing a data read, list, polling path,
  startup path, or performance-sensitive UI.
scope: dev
---

# Performance

Find the cost that users actually wait on, then reduce it without weakening
the result. A slow screen may be waiting on the server, moving too much data,
serial reads, repeated computation, or browser rendering; measure before adding
caches or extra complexity.

## Load only what the current view needs

- Shape list reads around the fields the list displays. Keep large document
  bodies, histories, rendered output, and other rarely viewed data on a detail
  or on-demand path. Return a small preview when the list needs one.
- Paginate or window unbounded histories and activity feeds. Start with the
  recent or visible range and load more as the user asks for it.
- Batch related reads instead of issuing one query per row. Compute counts and
  other aggregates in the database when the result can be much smaller than
  the source rows.
- Start independent reads together. Do not make the first useful content wait
  for unrelated settings, below-the-fold panels, or secondary details.
- Index fields used by frequent filters, joins, and sorts when the data and
  observed query cost justify it. Keep indexes aligned with real query shapes.

For action-backed screens, shape the action response for the screen's current
need and keep the UI on the app's existing action and query hooks. Do not add a
second fetch path that duplicates the same read.

## Keep repeated work cheap

- Keep list and frequently refreshed reads inexpensive. Avoid parsing,
  reformatting, or rebuilding large values on every read when the result can be
  prepared once or computed only for the view that needs it.
- Use the app's existing live-update path when fresh data must reach an open
  screen. Poll only when needed, and keep polled reads bounded and cheap.
- Keep large file contents and long records out of list responses. Load them
  when the user opens the relevant item rather than sending them on every list
  refresh.
- Defer nonessential data and expensive child views until after the main
  content is usable. Window a rendered list when rendering all rows makes
  scrolling or updates slow.

## Protect startup and the first paint

- Keep migrations, backfills, data scans, aggregations, provider handshakes,
  and cache warming out of module evaluation and application startup. Hosted
  serverless instances can restart, so startup work can repeat on user
  requests. Use the app's deliberate migration, job, or on-demand path.
- Keep optional heavy runtimes out of modules loaded by ordinary page requests.
  Load a browser, media processor, or other large dependency only in the
  feature or job that needs it, and inspect the deployed bundle when adding
  one.
- Keep the server-rendered shell public and independent of a visitor's session.
  Resolve user-specific state after the shell loads through the app's
  authenticated client data path. Reads that must reflect a recent mutation
  should not depend on cached server-rendered loader data.
- Give loading placeholders the final content's basic geometry. Reserve space
  for content whose size is known; avoid showing a temporary layout that shifts
  the user's reading position when data arrives.

## Keep interactions responsive

Show that an interaction registered as soon as it happens, aiming for 100 ms.
If the work needs the network or takes longer, acknowledge it before waiting
and show a focused pending state within 400 ms. Use an optimistic update when
it is safe, then confirm or roll back on failure.

When investigating a slow experience, separate server response time, data
transfer, serial waits, rendering, layout movement, and long interaction work.
Use representative data and the production build when development tooling
changes the cost. Verify that the user-visible action completed before
comparing timings or memory.

Versions

RepositoryScoreLicence
This page · builderio/agent-native90MIT
ericrisco/rsc-harness100MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
davila7/claude-code-templates100MIT
motormetrics/motormetrics100MIT
motormetrics/motormetrics100MIT
event4u-app/agent-config100MIT
arxdsilva/ai-loops100MIT

Identical content appears in 30 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version d38fea0ed146 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100conventions-perf
    Apply when adding or changing a route, screen, endpoint, MCP tool, mutation, live event, background job or polling loop, or when a performance guard fails.
  • 90Android Performance
    Measure and improve Android app performance on the phone: startup time, jank, memory, baseline profiles, R8 and main-thread work. Use when the app feels slow or the user asks for optimization.
  • 100conventions-perf
    Apply when adding or changing a route, screen, endpoint, MCP tool, mutation, live event, background job or polling loop, or when a performance guard fails.
  • 100performance-audit
    Identify performance bottlenecks — rendering, startup, memory, and I/O — across any stack. Use when the app is slow, before perf-sensitive releases, or when the user mentions latency, jank, or memory growth.
  • 100web-performance
    Measures and improves web page speed using Core Web Vitals (LCP, INP, CLS) with field and lab data - fixes slow loading, slow interactions and layout shifts, cuts JavaScript, image and font weight, sets caching headers, and adds performance budgets to CI. Use when a site or web…
  • 90design-editor-performance
    What each screen costs on Design's canvas, the budgets that bound it, and how to prove a change keeps them. Use when changing culling, previews, live editors, zoom/pan/drag, DesignEditor hooks or caches, or when Design lags, flashes, or grows memory.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.