skills.rest
Rune-kit
Rune-kitOFFICIAL
Explore all skills by this author →
GitHub

autopsy

Analyze codebase complexity, dependencies, dead code, tech debt, git hotspots, and generate prioritized rescue plans.

82|23|Updated Feb 24, 2026
Search Tags:#code quality#code analysis#refactoring#technical debt#legacy code#rescue plan
One-click install
npx skills add https://github.com/Rune-kit/rune --skill autopsy
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: autopsy
Source: https://github.com/Rune-kit/rune/tree/main/skills/autopsy
Command: npx skills add https://github.com/Rune-kit/rune --skill autopsy

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill addresses the challenge of understanding and prioritizing technical debt in legacy codebases, providing a clear roadmap for improvement.

Core Features & Use Cases

  • Comprehensive Codebase Analysis: Assesses complexity, dependencies, dead code, tech debt, and git hotspots.
  • Health Scoring: Generates a quantifiable health score for each module.
  • Prioritized Rescue Plan: Outlines actionable steps to address identified issues.
  • Use Case: When inheriting a large, aging project, use Autopsy to quickly identify the most problematic modules and understand the effort required for refactoring.

Quick Start

Run the autopsy skill to assess the health of the current project's codebase.

Frequently Asked Questions about autopsy

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

FAQPage Schema
How do I assess technical debt in a legacy codebase?▼

To assess technical debt in a legacy codebase, analyze code complexity, dependencies, dead code, and git hotspots to generate a quantifiable health score per module. This pinpoints problematic areas and quantifies the effort required for refactoring.

What is the best way to prioritize refactoring for aging projects?▼

The best way to prioritize refactoring for aging projects is to generate a prioritized rescue plan based on module health scores and git hotspots. This outlines actionable steps to address the most critical code quality issues first.

How do I identify dead code and complexity hotspots using git history?▼

You identify dead code and complexity hotspots by analyzing git history alongside code dependencies. This reveals aging modules with high technical debt and frequent changes, allowing you to target areas needing immediate rescue planning.

Does codebase analysis work without specific dependencies?▼

Yes, codebase analysis works without specific dependencies. It performs a full health assessment directly on your existing project files to evaluate complexity, dependencies, and dead code, requiring no external libraries or setup.

When do I need a rescue plan for legacy code?▼

You need a rescue plan for legacy code when inheriting a large, aging project and needing to quickly identify the most problematic modules. It provides a clear roadmap to understand and prioritize technical debt improvement efforts.

Related Skills

Explore More Software Engineering Skills→
carlosamesarcarlosamesar
1

git-archaeology

Extract blame and commit metadata for specific lines in Git repositories.

Community
Intermediate
iulianditaiuliandita
2

code-slimming

Audit codebases for dead code, redundant logic, and unnecessary wrappers.

Community
Advanced
Rune-kitRune-kit
82

marketing

Generate landing copy, social banners, SEO meta, blog posts, and video scripts.

Official
Advanced
prof-danielcprof-danielc

speckit.checker

Run static analysis tools and aggregate results into a prioritized issue report.

Community
Advanced