New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Performance Check

by ZeroDeng01 in ZeroDeng01/sublinkPro

Checklist for reviewing code changes that touch queries, APIs, rendering, caching or algorithms for performance, scalability and resource-usage problems.

MITAuto-check passedDevelopment

Install Performance Check

skills CLI
$ npx skills add ZeroDeng01/sublinkPro --skill performance-check -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install ZeroDeng01/sublinkPro performance-check --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/ZeroDeng01/sublinkPro.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/performance-check .claude/skills/performance-check && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
performance-check
GitHub stars
1.7k
Token cost
~1.8k tokens
SKILL.md length
634 words
Files
9 (incl. references)
Skills in repo
8
Repo updated
First seen
Licence
MIT

At a glance

Checklist for reviewing code changes that touch queries, APIs, rendering, caching or algorithms for performance, scalability and resource-usage problems.

  • Works in 4 steps: Use profiler to locate actual… → Measure before optimizing (benchmarks,… → Focus on hot paths (90/10 rule - 90% of… → …
  • Reviewing a pull request that adds or changes list or search endpoints
  • SKILL.md covers Performance Check Checklist, Performance Testing, Performance Monitoring and Fallback Strategy, plus 2 more sections
  • Calls go

What it does

The skill gives the agent a checkbox review across several areas: database queries (N+1 loading, missing indexes, selecting every column, queries inside loops, pagination, eager loading), API responses (payload size, filtering, compression, cache headers, partial responses), frontend rendering (needless re-renders, virtualized long lists, bundle splitting, image loading, debouncing) and caching (hot data, invalidation, expiry).

Each area links to a longer guide in the references folder covering algorithm complexity, APIs, caching, concurrency, databases, the frontend, memory and the network. Those guides include code examples such as memoization and a load-testing sample. The skill is meant for changes that can affect performance and is not for simple config changes.

When your agent uses it

  • Reviewing a pull request that adds or changes list or search endpoints
  • Checking new database queries for N+1 loading and missing indexes
  • Auditing a React component for needless re-renders
  • Reviewing a recursive algorithm before it is merged

Example prompts

  • “Review this branch for performance problems before I open the pull request.”
  • “Check whether the new order-list endpoint paginates and avoids queries inside loops.”
  • “The search results component feels slow. Go through the performance checklist for it.”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Use profiler to locate actual bottlenecks (pprof, Chrome DevTools)
  2. Measure before optimizing (benchmarks, load tests)
  3. Focus on hot paths (90/10 rule - 90% of time in 10% of code)
  4. Don't guess - profile and measure

What it can do on your machine

Read from SKILL.md and the folder at commit 11479da. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • github.com
    • react.dev
    • gorm.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Performance Check loads about 1.8k tokens when it runs, and up to ~10k if it reads all its reference files. Until then it costs about 51 tokens; SKILL.md has 634 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~51
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~10k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from ZeroDeng01/sublinkPro at commit 11479da, republished under its MIT licence (© ZeroDeng01). 634 words, ~1,777 tokens.

Download SKILL.mdSave it as .claude/skills/performance-check/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
performance-check
description
Performance review checklist for optimization, scalability, and resource usage. Use when changes affect queries, APIs, rendering, caching, or algorithms. Not for simple config changes.
version
1.0.0
author
SublinkPro Team
user-invocable
true

Performance Check Skill

This skill provides a comprehensive performance review checklist for code changes that may impact application performance, scalability, or resource usage.

When to use: When making changes to:

  • Database queries and models
  • API endpoints (especially list/search operations)
  • Frontend rendering logic
  • Background jobs and scheduled tasks
  • Caching mechanisms
  • Large data processing
  • File operations
  • Network requests
  • Recursive algorithms

Performance Check Checklist

🗄️ 1. Database Query Optimization

Check for:

  • N+1 query problem: Are related records loaded efficiently?
  • Missing indexes: Are frequently queried columns indexed?
  • **Select ***: Are only needed columns selected?
  • Unnecessary joins: Are all joins necessary?
  • Query in loop: Are queries executed inside loops?
  • Pagination: Are large result sets paginated?
  • Eager loading: Are associations preloaded when needed?

Detailed guide: references/database-optimization.md (includes code examples)

⚡ 2. API Response Optimization

Check for:

  • Response size: Are responses minimized (exclude unnecessary fields)?
  • Pagination: Are large lists paginated?
  • Filtering: Are list endpoints filterable to reduce data?
  • Compression: Is gzip compression enabled?
  • Caching headers: Are appropriate cache headers set?
  • Partial responses: Can clients request only needed fields?

Detailed guide: references/api-optimization.md (includes load testing example)

🎨 3. Frontend Rendering Optimization

Check for:

  • Unnecessary re-renders: Are components optimized with React.memo/useMemo/useCallback?
  • Large lists: Are large lists virtualized (>100 items)?
  • Heavy computations: Are expensive calculations memoized?
  • Bundle size: Are large dependencies code-split?
  • Image optimization: Are images lazy-loaded and properly sized?
  • Debouncing/Throttling: Are frequent events (scroll, input) debounced?

Detailed guide: references/frontend-optimization.md (includes memoization example)

💾 4. Caching Strategy

Check for:

  • Cache frequently accessed data: Are hot paths cached?
  • Cache invalidation: Is stale data properly invalidated?
  • Cache TTL: Are appropriate expiration times set?
  • Cache key design: Are cache keys unique and predictable?
  • Memory limits: Is cache size bounded to prevent memory exhaustion?

Detailed guide: references/caching-strategies.md

🔄 5. Concurrency & Parallelization

Check for:

  • Blocking operations: Are long operations executed asynchronously?
  • Parallel processing: Can independent tasks run concurrently?
  • Goroutine leaks: Are goroutines properly cleaned up?
  • Race conditions: Are shared resources protected with mutexes?
  • Channel buffering: Are channels sized appropriately?

Detailed guide: references/concurrency-guide.md (includes goroutine pool pattern)

📦 6. Memory Management

Check for:

  • Memory leaks: Are resources (connections, files, goroutines) released?
  • Large allocations: Are large objects (slices, maps) pre-allocated when size is known?
  • Pointer vs value: Are large structs passed by pointer?
  • String concatenation: Is strings.Builder used for building large strings?
  • JSON marshaling: Are large objects streamed instead of loaded entirely?

Detailed guide: references/memory-management.md

Show full SKILL.md (253 more words)Show less
🌐 7. Network & HTTP Optimization

Check for:

  • Connection pooling: Are HTTP clients reused (not created per request)?
  • Timeouts: Are reasonable timeouts set on all network requests?
  • Keep-alive: Are persistent connections used?
  • Request batching: Can multiple requests be combined?
  • Retry logic: Are failed requests retried with exponential backoff?

Detailed guide: references/network-optimization.md

🔍 8. Algorithm Complexity

Check for:

  • Time complexity: Is the algorithm O(n²) or worse for large n?
  • Space complexity: Does the algorithm use excessive memory?
  • Redundant work: Are results computed multiple times?
  • Early exit: Can loops exit early when condition is met?

Detailed guide: references/algorithm-complexity.md

Performance Testing

Backend Benchmarks
bash
# Run benchmark tests
go test -bench=. -benchmem ./services/

# Profile CPU and memory
go test -cpuprofile=cpu.prof -memprofile=mem.prof -bench=.
go tool pprof cpu.prof
API Load Testing
bash
# Apache Bench
ab -n 1000 -c 10 http://localhost:8000/api/v1/nodes

# k6 (see assets/load-test.js)
k6 run assets/load-test.js
Frontend Performance

Run Lighthouse in Chrome DevTools (F12 → Lighthouse tab):

  • First Contentful Paint (FCP): < 1.8s
  • Largest Contentful Paint (LCP): < 2.5s
  • Time to Interactive (TTI): < 3.8s
  • Cumulative Layout Shift (CLS): < 0.1

Performance Monitoring

Backend Instrumentation
go
import "time"

func (s *Service) CriticalOperation() error {
    start := time.Now()
    defer func() {
        log.Infof("Operation duration: %v", time.Since(start))
    }()
    // ... work ...
}
Database Query Monitoring

Enable slow query logging in development:

go
db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{
    Logger: logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), logger.Config{
        SlowThreshold: 200 * time.Millisecond, // Log queries > 200ms
        LogLevel:      logger.Warn,
    }),
})

Fallback Strategy

If performance issues are unclear:

  1. Use profiler to locate actual bottlenecks (pprof, Chrome DevTools)
  2. Measure before optimizing (benchmarks, load tests)
  3. Focus on hot paths (90/10 rule - 90% of time in 10% of code)
  4. Don't guess - profile and measure

Exit Criteria

  • All performance issues identified and addressed
  • Benchmark tests pass with acceptable performance
  • No database queries in loops (or justified and documented)
  • Large lists are paginated/virtualized
  • Performance implications documented in PR (if significant)
  • Monitoring/logging added for new critical paths

References

Codebase
  • services/mihomo/mihomo.go - Core performance-critical service
  • services/scheduler/speedtest_task.go - Concurrent node testing example
  • webs/src/views/nodes/ - Frontend list rendering patterns
External

© ZeroDeng01, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 8 other files (references) in .agents/skills/performance-check of ZeroDeng01/sublinkPro.

  • SKILL.md
  • references/algorithm-complexity.md
  • references/api-optimization.md
  • references/caching-strategies.md
  • references/concurrency-guide.md
  • references/database-optimization.md
  • references/frontend-optimization.md
  • references/memory-management.md
  • references/network-optimization.md

Open the folder on GitHubat commit 11479da

Compare with similar skills

Performance Check next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Performance Check compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Performance Check this skillZeroDeng01/sublinkPro1.7k—~1.8kAutomated safety check: PassMIT
Performance OptimizationThibautBaissac/rails_ai_agents665—~1.2kAutomated safety check: NotesMIT
WordPress Code GuardamElnagdy/guard-skills1.3k—~2.4kAutomated safety check: PassMIT
React Code Reviewgiuseppe-trisciuoglio/developer-kit355—~2.6kAutomated safety check: NotesMIT
Keybase RPC Log Analysiskeybase/client9.3k—~3kAutomated safety check: PassBSD-3-Clause
Wp Performance Reviewelvismdev/claude-wordpress-skills2341 repos~4.5kAutomated safety check: PassMIT

Similar skills

  • Performance Optimization

    ThibautBaissac/rails_ai_agents

    Identifies and fixes Rails performance issues including N+1 queries, slow queries, and memory problems.

    665 GitHub stars~1.2k tokensUpdated 4 mo ago
    DevelopmentAuto-check: notes

  • WordPress Code Guard

    amElnagdy/guard-skills

    Reviews WordPress plugin, theme and block code after an agent writes or edits it, catching missing escaping, nonces, capability checks and unprepared queries.

    1.3k GitHub stars~2.4k tokensUpdated 3 mo ago
    DevelopmentAuto-check passed

  • React Code Review

    giuseppe-trisciuoglio/developer-kit

    Provides comprehensive code review capability for React applications, validates component architecture, hooks usage, React 19 patterns, state management, performance optimization, accessibility…

    355 GitHub stars~2.6k tokensUpdated 27 days ago
    Frontend & DesignAuto-check: notes

  • Keybase RPC Log Analysis

    keybase/client

    Captures a clean Keybase service log and analyzes it for redundant, duplicated or looping RPCs, then checks whether a caching fix reduced the calls.

    9.3k GitHub stars~3k tokensUpdated today
    DevelopmentAuto-check passed

  • Wp Performance Review

    elvismdev/claude-wordpress-skills

    WordPress performance code review and optimization analysis.

    234 GitHub starsUsed in 1 repo~4.5k tokens
    Business, Finance & HRAuto-check passed

  • Eviction Policy Regret Audit

    ben-manes/caffeine

    Searches synthetic workloads for cases where Caffeine's adaptive eviction policy falls short of its achievable hit rate, then classifies each gap by cause.

    18k GitHub stars~16k tokensUpdated yesterday
    DevelopmentAuto-check: notes

More from ZeroDeng01/sublinkPro

All 8 skills in this repo

  • Security Review Checklist

    ZeroDeng01/sublinkPro

    Checklist-driven security review for changes to authentication, authorization, MFA, secrets, input validation and other security-critical code.

    1.7k GitHub stars~2.3k tokensUpdated 2 days ago
    Auto-check passed

  • SublinkPro Manager

    ZeroDeng01/sublinkPro

    Manages a SublinkPro proxy subscription server through natural language, adding nodes, building subscriptions and share links, and editing templates and tags.

    1.7k GitHub stars~7.2k tokensUpdated 2 days ago
    Auto-check passed

  • Post-Development Workflow

    ZeroDeng01/sublinkPro

    A required checklist for after code changes: validate each changed layer, check that docs and other layers stay in sync, and test before committing or opening a PR.

    1.7k GitHub stars~4.4k tokensUpdated 2 days ago
    Auto-check passed

  • Documentation Sync Check

    ZeroDeng01/sublinkPro

    Checklist for keeping README, feature, configuration, install and API docs in step with code changes in the same PR, including the Chinese copies.

    1.7k GitHub stars~2.6k tokensUpdated 2 days ago
    Auto-check passed

  • Pre-Commit Check Gate

    ZeroDeng01/sublinkPro

    Blocking checklist that runs formatting, lint and test commands for changed Go and frontend files before any git add, commit or pull request.

    1.7k GitHub stars~2.9k tokensUpdated 2 days ago
    Auto-check: notes

  • Theme Adaptation Checklist

    ZeroDeng01/sublinkPro

    A checklist for UI changes that touch colors, surfaces or theme code, making sure light and dark modes, devices, states and layering all still work.

    1.7k GitHub stars~1.4k tokensUpdated 2 days ago
    Auto-check passed

Works with

Categories

Questions about Performance Check

What does Performance Check do?

Checklist for reviewing code changes that touch queries, APIs, rendering, caching or algorithms for performance, scalability and resource-usage problems. The skill gives the agent a checkbox review across several areas: database queries (N+1 loading, missing indexes, selecting every column, queries inside loops, pagination, eager loading), API responses (payload size, filtering, compression, cache headers, partial responses), frontend rendering (needless re-renders, virtualized long lists, bundle splitting, image loading, debouncing) and caching (hot data, invalidation, expiry).

When should I use Performance Check?

Performance Check fits situations like: reviewing a pull request that adds or changes list or search endpoints; checking new database queries for N+1 loading and missing indexes; auditing a React component for needless re-renders; reviewing a recursive algorithm before it is merged.

How do I install Performance Check in Claude Code?

Run `npx skills add ZeroDeng01/sublinkPro --skill performance-check -a claude-code`. Or copy the skill folder (.agents/skills/performance-check in ZeroDeng01/sublinkPro) into .claude/skills/performance-check in your project. Claude Code loads it when a task matches its description.

How do I install Performance Check in Codex?

Run `npx skills add ZeroDeng01/sublinkPro --skill performance-check -a codex`. Or copy the skill folder (.agents/skills/performance-check in ZeroDeng01/sublinkPro) into .agents/skills/performance-check in your project. Codex loads it when a task matches its description.

Can I use Performance Check in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ZeroDeng01/sublinkPro --skill performance-check -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/performance-check, .gemini/skills/performance-check, .github/skills/performance-check and .opencode/skills/performance-check in your project.

What does Performance Check need to run?

Going by SKILL.md and its folder, Performance Check needs the command-line tools its instructions call (go).

Does Performance Check access the network?

SKILL.md names 3 domains. As links in the text: github.com, react.dev and gorm.io. This is read from the text; nothing was executed.

Is Performance Check safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Performance Check use?

Performance Check is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Performance Check use?

About 1.8k tokens (SKILL.md is roughly 7.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 8.4k tokens, read only when the agent opens those files.

What are the alternatives to Performance Check?

Skills that share tags, products or a category with Performance Check: Performance Optimization (ThibautBaissac/rails_ai_agents, 665 stars), WordPress Code Guard (amElnagdy/guard-skills, 1.3k stars), React Code Review (giuseppe-trisciuoglio/developer-kit, 355 stars) and Keybase RPC Log Analysis (keybase/client, 9.3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Performance Check?

ZeroDeng01 (a GitHub user) maintains it in ZeroDeng01/sublinkPro, which has 1,665 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on October 5, 2026.

Source: ZeroDeng01/sublinkPro on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.