Pantheon Logic (Apollo)

Review code for logic errors, edge cases, race conditions, and performance bottlenecks.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/jschulte/pantheon --skill pantheon-logic-apollo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Pantheon Logic (Apollo)
Source: https://github.com/jschulte/pantheon/tree/main/src/skills/pantheon-logic
Command: npx skills add https://github.com/jschulte/pantheon --skill pantheon-logic-apollo

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill identifies and helps fix critical logic errors, edge cases, concurrency issues, and performance bottlenecks within your codebase, ensuring correctness and efficiency.

Core Features & Use Cases

  • Logic Error Detection: Finds off-by-one errors, incorrect boolean logic, null dereferences, and more.
  • Edge Case Analysis: Verifies behavior with boundary values, empty collections, and unexpected inputs.
  • Concurrency & Performance: Detects race conditions, N+1 query patterns, and inefficient algorithms.
  • Use Case: When a feature is behaving unexpectedly or performing poorly, use this Skill to pinpoint the exact lines of code causing the issue and get suggestions for fixes.

Quick Start

Use the Pantheon Logic skill to review the files changed in story 1-3, saving the findings to the sprint artifacts directory.

Frequently Asked Questions about Pantheon Logic (Apollo)

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

FAQPage Schema
How do I find logic errors and race conditions in my code?

To find logic errors and race conditions, perform static code analysis to trace control and data flow. This detects incorrect boolean logic, null dereferences, and concurrency issues by classifying findings into MUST_FIX, SHOULD_FIX, or STYLE categories.

What is the best way to debug performance bottlenecks and N+1 query patterns?

The best way to debug performance bottlenecks involves tracing data flow to detect inefficient algorithms and N+1 query patterns. Static analysis identifies these runtime behavior issues and categorizes them by severity to prioritize fixes.

Can I use static analysis to check edge cases and boundary values in my codebase?

Yes, you can use static analysis to check edge cases by verifying behavior with boundary values, empty collections, and unexpected inputs. This ensures code correctness by identifying unhandled boundary scenarios within your sprint artifact context.

How do I review code logic for off-by-one errors and null dereferences?

Review code logic for off-by-one errors and null dereferences by applying static analysis to trace control flow across specified files. This process identifies incorrect logic and classifies the findings into MUST_FIX, SHOULD_FIX, or STYLE categories.

Does this code review process work for concurrency issues and race conditions?

Yes, this code review process works for concurrency issues and race conditions by statically tracing control and data flow. It detects race conditions and categorizes them alongside logic errors to ensure runtime correctness.

When should I not use static code review for debugging?

You should not use static code review for debugging when you need to analyze runtime environment failures or dynamic memory leaks that require an active execution profile, as this process focuses on tracing control flow and logic correctness.