skills.rest
cwilliams5
cwilliams5COMMUNITY
Explore all skills by this author →
Website𝕏@codywilliamsGitHub

review-outside-box

Analyzes entire codebases for systemic performance, bug, and anti-pattern issues.

1|Updated Jan 12, 2026
Search Tags:#architecture#code review#performance#refactoring#design patterns#systemic issues
One-click install
npx skills add https://github.com/cwilliams5/Alt-Tabby --skill review-outside-box
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: review-outside-box
Source: https://github.com/cwilliams5/Alt-Tabby/tree/main/.claude/skills/review-outside-box
Command: npx skills add https://github.com/cwilliams5/Alt-Tabby --skill review-outside-box

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill identifies systemic patterns of performance bottlenecks, bugs, and anti-patterns that are often missed by targeted reviews, leading to significant codebase improvements.

Core Features & Use Cases

  • Architectural Analysis: Examines data flow, call patterns, and resource usage across the entire codebase.
  • Pattern Identification: Detects systemic issues like inefficient data transformations, redundant computations, and suboptimal resource management.
  • Use Case: Discover if the entire application is using a slow regex parsing method where a faster JSON parser would be orders of magnitude more efficient, or identify if expensive operations are being performed within hot loops.

Quick Start

Initiate a comprehensive review of the codebase to identify systemic performance and design issues.

Frequently Asked Questions about review-outside-box

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

FAQPage Schema
How do I find systemic performance bottlenecks across an entire codebase?▼

Architectural code review identifies systemic issues by examining data flow, call patterns, and resource usage across the entire codebase. It targets high-level design smells and inefficient approaches rather than isolated function-level errors.

Can architectural analysis detect inefficient design patterns and anti-patterns?▼

Architectural analysis detects anti-patterns by examining inter-module communication and resource utilization. It identifies systemic issues like redundant computations and suboptimal resource management that targeted reviews often miss.

What is the best way to review code for systemic issues instead of isolated bugs?▼

Reviewing for systemic issues requires a broad analysis of code structure and inter-module communication. This targets high-level design smells and inefficient systemic approaches, catching problems like expensive operations within hot loops.

Does systemic code review work for identifying slow data parsing methods application-wide?▼

Systemic code review works for identifying slow data parsing methods by analyzing data flow and call patterns application-wide. It can discover if an entire application uses inefficient parsing where a faster alternative would be orders of magnitude more efficient.

When should I use systemic code review instead of targeted function-level checks?▼

Use systemic code review when targeted reviews miss broad architectural issues. It is necessary for discovering application-wide patterns of performance bottlenecks, bugs, and anti-patterns across inter-module communication and resource utilization.

Related Skills

Explore More Software Engineering Skills→
bketelsenbketelsen
1

architecture-extract

Analyze project structure to derive module boundaries, data flows, and service relationships.

Community
Intermediate
stephanjstephanj
9

database-optimizer

Analyze slow database queries and execution plans for PostgreSQL and MySQL.

Community
Advanced
rortan134rortan134
26

find-bugs-diff

Identify bugs, security vulnerabilities, and code quality issues in source code changes.

Community
Advanced
inbharataiinbharatai
22

code-reviewer

Analyzes code for bugs, security vulnerabilities, performance bottlenecks, and style violations.

Community
Advanced