General Relativity Skills

Why General Relativity?

General Relativity describes how mass curves spacetime and how objects follow geodesics (shortest paths) through curved space. In software architecture:

GR Concept	Software Architecture Analogue
Spacetime curvature	Technical debt warping the “shape” of the codebase
Geodesic	Optimal refactoring path through a curved codebase
Event horizon	Point of no return in system complexity
Gravitational lensing	Indirect dependencies that distort the apparent structure
Gravitational waves	Propagating breaking changes across module boundaries
Frame dragging	Accumulated context pulling decisions away from their optimal path
Escape velocity	Minimum refactoring effort needed to escape a debt gravity well
Singularity	Non-refactorable legacy core

These are precise architectural metaphors — the GR mathematics (metric tensors, geodesic equations, Ricci curvature) provide quantitative measures of code health.

Skills

Skill ID	Description	Model Class
`gr-spacetime-debt-metric`	Measures technical debt as spacetime curvature; produces a debt “mass” score per module	`strong`
`gr-event-horizon-detector`	Identifies modules approaching the event horizon (complexity point of no return)	`strong`
`gr-geodesic-refactor`	Finds the minimal-cost (geodesic) path through a refactoring decision space	`strong`
`gr-gravitational-lensing-tracer`	Traces indirect dependency paths that distort the apparent module structure	`strong`
`gr-gravitational-wave-propagator`	Models how a breaking change propagates as gravitational waves through module boundaries	`strong`
`gr-frame-dragging-correction`	Detects and corrects for accumulated context drift pulling decisions off their optimal path	`strong`
`gr-escape-velocity-calculator`	Computes the minimum refactoring effort needed to escape a debt gravity well	`strong`
`gr-singularity-detector`	Identifies irreducible complexity cores (singularities) that cannot be refactored away	`strong`
`gr-black-hole-evaporator`	Gradual extraction strategy for code locked in a singularity (inspired by Hawking radiation)	`strong`
`gr-metric-tensor`	Computes the full curvature tensor for a codebase — a multi-dimensional debt map	`strong`
`gr-redshift-analyser`	Measures how architectural decisions become increasingly distorted over long maintenance cycles	`strong`
`gr-tidal-force-splitter`	Identifies modules under extreme tidal stress (pressure from multiple incompatible requirements)	`strong`
`gr-wormhole-linker`	Finds non-obvious connections between distant modules that could reduce refactoring distance	`strong`
`gr-penrose-process`	Extracts usable work (reusable code) from a rotating complexity well	`strong`
`gr-hawking-decomposer`	Decomposes a monolithic black hole into incrementally extractable components	`strong`

Orchestration Pattern

gr-* request
  1. Claude Sonnet 4.6   → GR mathematical analysis
  2. GPT-5.4             → back-translation to refactoring/architecture guidance

When to Use

GR skills are best for:

Quantifying technical debt in large codebases (gr-spacetime-debt-metric, gr-metric-tensor)
Planning major refactoring campaigns (gr-geodesic-refactor, gr-escape-velocity-calculator)
Legacy modernisation strategies (gr-hawking-decomposer, gr-black-hole-evaporator)
Understanding indirect dependency impact (gr-gravitational-lensing-tracer)
Breaking-change impact analysis (gr-gravitational-wave-propagator)

Instructions That Invoke These Skills

physics-analysis — primary consumer; selects GR skills based on the architectural problem shape
refactor — uses gr-geodesic-refactor + gr-escape-velocity-calculator for large-scale refactoring decisions