How do I install the Altitude skill?

Run npx skillmds@latest add ronniepinnell/altitude in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Altitude safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Altitude?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Altitude free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Altitude?

ronniepinnell (@ronniepinnell) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Altitude by ronniepinnell — Agent Skill

Name: Altitude
Author: ronniepinnell

Altitude

Right-layer check before coding a fix. Locates which layer a problem actually lives at (data model, storage, API, business logic, UI, process/people) so the fix lands at the cause's layer, not the symptom's. Use before fixing any bug, and whenever the same bug keeps coming back.

ronniepinnell Updated Sep 17, 2026

File contents

/altitude — Fix at the Layer Where the Problem Lives

Most bad fixes are correct code at the wrong altitude: a UI null-check papering over a broken join, an API retry papering over a data race, a cron job papering over a missing constraint. The symptom's layer is where you SEE the problem; it is usually not where the problem IS.

Invocation

/altitude roster page shows blank names
/altitude                               # triage the bug currently under discussion

The ladder (top = where symptoms appear, bottom = where causes live)

L6  Process / people      (who does what, when; missing ownership, missing review)
L5  UI / presentation     (rendering, formatting, client state)
L4  API / transport       (endpoints, contracts, serialization, authz)
L3  Business logic        (rules, calculations, workflows)
L2  Data model / schema   (shapes, constraints, invariants, migrations)
L1  Storage / infra       (DB engine, network, deploy, environment)

Procedure

Name the symptom's layer. Where was the problem observed? (Usually L4–L6.)
Descend with "what would make this impossible?" At each layer below the symptom, ask: is there a change HERE that would make this whole class of bug unrepresentable? A NOT NULL constraint beats a null-check in 40 components. A typed API contract beats defensive parsing in every consumer.
Stop at the lowest layer where the cause is real — not the lowest layer that exists. Descending too far is also a failure mode (rewriting the schema for a typo-level bug). Test: can you state the defect at that layer in one sentence without referencing the layers above it? If yes, that's the layer.
Declare the altitude call, then fix: ALTITUDE: symptom at L5, cause at L2 (missing FK) — fixing at L2, plus L5 guard
- Fix at the cause layer.
- A thin guard at the symptom layer is acceptable ONLY as defense-in-depth, never as the fix, and never silently — name it as a guard.
Recurring-bug override: the same bug fixed 2+ times is conclusive proof the previous fixes were above the cause. The next fix MUST go at least one layer lower, or explain in writing why it can't.

Rules

"Where is it cheapest to patch?" is the wrong question. "Where does the invariant belong?" is the right one.
One-sentence-per-layer discipline: if the descent takes paragraphs, you're investigating, not triaging — go gather facts and come back.
L6 is a real answer. Some bugs are a missing gate/review/owner, and code at any layer will only mask that.

Composes with

/drift — repeated drift at one spot is an altitude smell.
/premortem — premortems catch wrong-altitude designs before they ship.
/refute — refute the fix at the SYMPTOM layer after fixing at the cause layer (proves the fix actually propagated up).
/think — /altitude is decompose specialized for bugs; /think covers the open field.
/verdict — layer verdicts worth remembering are logged there.
/sweep — sweeps use altitude thinking to dedup findings into systemic causes.

---name: altitudedescription: Right-layer check before coding a fix. Locates which layer a problem actually lives at (data model, storage, API, business logic, UI, process/people) so the fix lands at the cause's layer, not the symptom's. Use before fixing any bug, and whenever the same bug keeps coming back.---# /altitude — Fix at the Layer Where the Problem LivesMost bad fixes are correct code at the wrong altitude: a UI null-check paperingover a broken join, an API retry papering over a data race, a cron job paperingover a missing constraint. The symptom's layer is where you SEE the problem;it is usually not where the problem IS.## Invocation```/altitude roster page shows blank names/altitude # triage the bug currently under discussion```## The ladder (top = where symptoms appear, bottom = where causes live)```L6 Process / people (who does what, when; missing ownership, missing review)L5 UI / presentation (rendering, formatting, client state)L4 API / transport (endpoints, contracts, serialization, authz)L3 Business logic (rules, calculations, workflows)L2 Data model / schema (shapes, constraints, invariants, migrations)L1 Storage / infra (DB engine, network, deploy, environment)```## Procedure1. **Name the symptom's layer.** Where was the problem observed? (Usually L4–L6.)2. **Descend with "what would make this impossible?"** At each layer below the symptom, ask: is there a change HERE that would make this whole class of bug unrepresentable? A NOT NULL constraint beats a null-check in 40 components. A typed API contract beats defensive parsing in every consumer.3. **Stop at the lowest layer where the cause is real** — not the lowest layer that exists. Descending too far is also a failure mode (rewriting the schema for a typo-level bug). Test: can you state the defect at that layer in one sentence without referencing the layers above it? If yes, that's the layer.4. **Declare the altitude call, then fix:** `ALTITUDE: symptom at L5, cause at L2 (missing FK) — fixing at L2, plus L5 guard` - Fix at the cause layer. - A thin guard at the symptom layer is acceptable ONLY as defense-in-depth, never as the fix, and never silently — name it as a guard.5. **Recurring-bug override:** the same bug fixed 2+ times is conclusive proof the previous fixes were above the cause. The next fix MUST go at least one layer lower, or explain in writing why it can't.## Rules- "Where is it cheapest to patch?" is the wrong question. "Where does the invariant belong?" is the right one.- One-sentence-per-layer discipline: if the descent takes paragraphs, you're investigating, not triaging — go gather facts and come back.- L6 is a real answer. Some bugs are a missing gate/review/owner, and code at any layer will only mask that.## Composes with- `/drift` — repeated drift at one spot is an altitude smell.- `/premortem` — premortems catch wrong-altitude designs before they ship.- `/refute` — refute the fix at the SYMPTOM layer after fixing at the cause layer (proves the fix actually propagated up).- `/think` — /altitude is `decompose` specialized for bugs; /think covers the open field.- `/verdict` — layer verdicts worth remembering are logged there.- `/sweep` — sweeps use altitude thinking to dedup findings into systemic causes.

Frequently asked questions