code-review-altitude-dimension

Analyze code changes for implementation depth versus superficial fixes.

7|Updated Mar 8, 2026
One-click install
npx skills add https://github.com/mkusaka/ccskills --skill code-review-altitude-dimension
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-review-altitude-dimension
Source: https://github.com/mkusaka/ccskills/tree/main/skills/code-review-altitude-dimension
Command: npx skills add https://github.com/mkusaka/ccskills --skill code-review-altitude-dimension

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This skill helps identify if each code change is integrated deeply enough, reducing the risk of creating brittle and fragile solutions.

Core Features & Use Cases

  • Check Implementation Depth: Ensures changes affect the right part of the code, not just a band-aid fix.
  • Prevent Fragility: Encourages generalizing underlying mechanisms to improve the robustness of fixes.
  • Use Case: If a new feature needs to be implemented and you want to make sure it is integrated into the existing codebase in a way that won't cause issues in the future.

Quick Start

Run the 'code-review-altitude-dimension' skill on your codebase to check for depth and robustness of your changes.

Frequently Asked Questions about code-review-altitude-dimension

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

FAQPage Schema
How do I check if a code change is a deep fix or just a band-aid patch?

To check if a code change is a deep fix or a band-aid patch, analyze whether the modification impacts the appropriate architectural level or merely applies superficial low-level patchwork. This verifies implementation depth and prevents brittle solutions.

What is implementation depth in code review?

Implementation depth in code review measures how deeply a modification is integrated into the codebase. It ensures changes affect the correct architectural level and generalize underlying mechanisms rather than relying on superficial fixes.

How do I prevent brittle and fragile solutions when adding new features?

To prevent brittle and fragile solutions when adding new features, ensure changes are integrated deeply enough at the correct architectural level. Generalizing underlying mechanisms during code review improves overall software robustness.

Does code review for implementation depth require in-depth knowledge of the codebase?

Yes, code review for implementation depth requires in-depth knowledge of the codebase. Reviewers need the ability to discern architectural level fixes versus low-level patchwork to accurately maintain software integrity.

When should I review code changes for architectural altitude and robustness?

You should review code changes for architectural altitude and robustness when implementing new features. This ensures modifications are integrated into the existing codebase in a way that maintains software integrity and prevents future issues.