vp-q02-performance

Detect N+1 queries, missing indexes, and blocking operations across code paths.

1|Updated Jan 16, 2026
One-click install
npx skills add https://github.com/velesar/alpha-zero-review- --skill vp-q02-performance
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: vp-q02-performance
Source: https://github.com/velesar/alpha-zero-review-/tree/main/skills/vp-q02-performance
Command: npx skills add https://github.com/velesar/alpha-zero-review- --skill vp-q02-performance

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires vp-s02-layer-architecture, vp-s04-entity-model, vp-s06-dependency-graph.

What problem does it solve?

Performance bottlenecks across code paths hinder latency and scalability; this skill provides a structured approach to identify hotspots using a mental-model-driven workflow.

Core Features & Use Cases

  • Stepwise hotspot prioritization based on dependencies and hotspots from the mental model.
  • Detection of N+1 queries, missing indexes, expensive queries, and async blocking issues.
  • Use Case: apply to multi-layered applications (API, DB, ORM) to surface performance hotspots and guide targeted optimizations.

Quick Start

Identify the top three performance hotspots in the codebase and document findings.

Frequently Asked Questions about vp-q02-performance

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find N+1 queries and performance bottlenecks across multiple code paths?

To find performance bottlenecks across code paths, apply a mental-model-driven workflow to detect N+1 queries, missing indexes, expensive queries, and async blocking operations in multi-layered applications. It prioritizes hotspots based on dependency mappings.

What is the best way to profile expensive queries and blocking operations in a multi-layered application?

Profiling expensive queries and blocking operations involves mapping findings to predefined mental-model constraints across API, DB, and ORM layers. This surfaces hotspots and guides targeted optimizations for latency and scalability issues.

How do I detect missing database indexes causing scalability issues in my codebase?

Detect missing indexes by applying mental-model constraints to your codebase with multiple data access layers. The workflow identifies these performance hotspots and maps them to the corresponding dependencies for prioritized optimization.

Do I need architecture and entity model dependencies to analyze codebase concurrency and performance?

Yes, you need layer architecture, entity model, and dependency graph dependencies to analyze concurrency and performance. These dependencies are required to map detected performance hotspots to the corresponding code paths and structural layers.

Can I use this performance analysis workflow on a simple single-layer API without complex concurrency?

This performance analysis workflow is designed for codebases with multiple data access layers, APIs, and concurrency. Applying it to a simple single-layer API without complex concurrency may not yield meaningful hotspot prioritization or mapping results.

Why does async blocking happen and how can I identify it during code path analysis?

Async blocking happens when concurrent operations are mismanaged across data access layers. You can identify it by applying predefined mental-model constraints during code path analysis to surface these specific performance hotspots.