skills.rest
VKirill
VKirillCOMMUNITY
Explore all skills by this author →
GitHub

refactor-hotspots-craft

Analyze git history to prioritize refactoring targets by change frequency and complexity.

15|2|Updated May 23, 2026
Search Tags:#refactoring#technical debt#git analysis#temporal coupling#code ownership#hotspot detection#incremental decomposition
One-click install
npx skills add https://github.com/VKirill/antigravity-for-claude-code --skill refactor-hotspots-craft
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: refactor-hotspots-craft
Source: https://github.com/VKirill/antigravity-for-claude-code/tree/main/skills/refactor-hotspots-craft
Command: npx skills add https://github.com/VKirill/antigravity-for-claude-code --skill refactor-hotspots-craft

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents wasted refactoring effort by prioritizing code changes based on behavioral evidence from git history rather than surface-level “code smells.”

Core Features & Use Cases

  • Hotspot identification: Ranks files by change frequency and complexity to target the places that actually “cost interest.”
  • Temporal coupling analysis: Finds files that change together to reveal hidden dependencies, shotgun surgery risks, and distributed-monolith boundaries.
  • Social/knowledge map signals: Assesses contributor ownership and fractal value to reduce bus-factor and defect risk during refactors.

Quick Start

Ask your worker-refactor-architect agent to run behavioral hotspot analysis on the repository for refactor prioritization, focusing on change frequency, temporal coupling, and contributor ownership from git history.

Frequently Asked Questions about refactor-hotspots-craft

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

FAQPage Schema
How do I prioritize refactoring targets using git history?▼

Identify true technical-debt hotspots by analyzing git history for change frequency and complexity. This evidence-based prioritization targets files that actually cost interest, preventing wasted refactoring effort on low-signal areas.

What is temporal coupling analysis and how does it find hidden dependencies?▼

Temporal coupling analysis finds files that change together in git history to reveal hidden dependencies and shotgun surgery risks. It validates microservice splits by exposing distributed-monolith boundaries during architecture alignment checks.

How do I reduce bus-factor risk during legacy modernization?▼

Assess contributor ownership and fractal value from git history to build a social knowledge map. This reduces bus-factor and defect risk by highlighting knowledge distribution gaps during legacy modernization refactors.

When should I not use git-based hotspot detection for refactoring?▼

Avoid git-based hotspot detection for greenfield projects or low-signal refactors. The analysis requires substantial git history to extract meaningful change frequency and temporal coupling metrics for evidence-based prioritization.

Can I use behavioral code analysis to validate a microservice split?▼

Yes, behavioral code analysis validates microservice splits by detecting temporal coupling between files that change together. This reveals distributed-monolith boundaries and hidden dependencies, ensuring decomposition aligns with actual architectural behavior.

Related Skills

Explore More Software Engineering Skills→
lis186lis186
46

history-analyzer

Analyze git history to identify hotspots, coupling, and knowledge distribution.

Community
Basic
MatheusrlrMatheusrlr
1

decomposition-planning-roadmap

Generates phased migration roadmaps and tracks decomposition progress for monolithic applications.

Community
Advanced
TheRealSeberTheRealSeber
1

codebase-analysis

Generate cross-referenced Markdown documentation for Java codebases via static analysis.

Community
Advanced
wesuuuwesuuu

tech_debt

Scan backend and frontend code for technical debt patterns and append findings to TECH_DEBT.md.

Community
Advanced