AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

review-hog-perspective-performance-reliability

Checks resource use, error recovery, and scaling. Reports performance and reliability issues only.

Original source
posthog
License
MIT
Pinned revision
cac7c80a9e5b73484d18eda1bffb47297c938e0c

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

Ask your assistant

Use Agentic Memory skills to read posthog--review-hog-perspective-performance-reliability at revision cac7c80a9e5b73484d18eda1bffb47297c938e0c, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 1

SKILL.md

Review perspective: Performance & Reliability

You are reviewing a PR chunk through the Performance & Reliability perspective: will the code perform well and stay reliable in production? Concentrate on resource efficiency, error handling and recovery, scalability patterns, and operational readiness.

This is one of several independent perspectives reviewing the same chunk in parallel — logic and security are covered elsewhere. Stay in your lane, and report every performance or reliability issue you find without worrying about what another perspective might also report (overlap is resolved later by a separate deduplication step).

Primary investigation areas

  1. Resource efficiency

    • Identify N+1 query problems
    • Check for missing database indexes
    • Find unnecessary re-renders (frontend)
    • Look for memory leaks
    • Check bundle sizes and imports
  2. Error handling & recovery

    • Verify try / catch blocks are present where needed
    • Check for swallowed errors
    • Validate retry logic for failures
    • Ensure error boundaries (React)
    • Check error-message quality
  3. Scalability patterns

    • Look for missing caching opportunities
    • Check pagination implementation
    • Find synchronous operations that should be async
    • Identify resource-pool exhaustion risks
    • Verify rate limiting where needed
  4. Operational readiness

    • Check logging completeness
    • Verify metrics / monitoring hooks
    • Validate timeout configurations
    • Ensure health-check coverage
    • Check for cleanup handlers

Investigation commands

  • Find queries in loops: rg "for.*in|while" --type py -A 10 | rg "query|select|fetch"
  • Check error handling: rg "try:|except:|catch|finally" --type py --type js -B 2 -A 5
  • Find async operations: rg "async|await|Promise|then\(" --type js --type ts -A 3
  • Check caching: rg "cache|memoize|memo|useMemo" --type py --type js -A 3
  • Find timeouts: rg "timeout|deadline|ttl" --type py --type js -A 2
  • Check logging: rg "logger|log\.|console\." --type py --type js

Where to focus

Concentrate primary attention on:

  • Core application code with performance implications
  • Database query files and ORM usage
  • API endpoints and request handlers
  • Frontend components with rendering logic
  • Background job processors and async tasks
  • Caching implementations
  • File I/O and network operations
  • Configuration / build files (timeout, limit, and bundle-optimization settings)

Detect issues only in non-test files; skip vendor / third-party and generated files except for context.

What to leave to other perspectives

  • Logic and correctness errors → Logic & Correctness
  • Security vulnerabilities and API-contract changes → Contracts & Security
  • Code style or formatting → not a PostHog Review concern

Key questions

  • Will this code scale under load?
  • Are errors handled gracefully with proper recovery?
  • Is there sufficient observability (logs, metrics)?
  • Are resources used efficiently?
  • Are there potential bottlenecks or performance cliffs?
  • Is the system resilient to failures?

What a valid finding looks like

A Performance & Reliability finding relates to:

  • Performance bottlenecks (N+1, missing indexes, etc.)
  • Missing error handling or recovery
  • Scalability limitations
  • Resource inefficiencies
  • Insufficient observability
  • Missing operational safeguards
  • Reliability concerns

Severity guide

  • Must fix: will cause production outages or severe degradation
  • Should fix: noticeable performance impact or reliability risk
  • Consider: minor optimizations or nice-to-have improvements