Skip to main content
skill CX Codex

code-necromancer — Claude Code skill: what it does, how to install

The code-necromancer skill maps an inherited or dormant codebase, helps get it running, and lays out a modernization plan. It starts by examining the system before changing it.

MIT 187 installs ★ 274 updated 2026-10-30

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add curiositech/some_claude_skills --skill code-necromancer -a claude-code
Open on GitHub

What code-necromancer does

The workflow has three stages: archaeology, resurrection, and rejuvenation. First, the skill guides repository cataloging and creates dependency and architecture maps. Next, it checks packages, environment variables, and infrastructure, then calls for integration tests and a record of launch blockers.

The final stage covers security recommendations and a prioritized upgrade roadmap with effort estimates. The package also includes report templates and guides for identifying frameworks, dependencies, and infrastructure. Its sequencing matters: the skill flags running npm install before examining the code as premature.

This workflow targets neglected or poorly documented systems, not greenfield work or routine fixes in maintained projects. It includes sample commands for gh, npm, pip, go, and grep; choose those that match the project’s stack.

What it helps with

  • catalog inherited repositories and identify their technologies
  • map links between repositories and external dependencies
  • find the environment variables and credentials needed to run a system
  • trace blockers that prevent services from starting or communicating
  • plan incremental upgrades while preserving existing features

Example prompts for the agent

  • Inspect this inherited project with no documentation; start by mapping its repositories and dependencies.
  • Help me bring this dormant service up: check its environment, infrastructure, and launch blockers.
  • Draft a modernization roadmap for this project, including security work and effort estimates.

How to install code-necromancer

1Skills CLI (Vercel)

npx skills add curiositech/some_claude_skills --skill code-necromancer -a claude-code

2Manually: put the files in place

~/.claude/skills/code-necromancer/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/code-necromancer/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about code-necromancer

How do I install code-necromancer in Claude Code?

Run npx skills add curiositech/some_claude_skills --skill code-necromancer -a claude-code. The skill file is at ~/.claude/skills/code-necromancer/SKILL.md.

What does code-necromancer do?

It guides codebase investigation, getting a legacy system running in development, and planning upgrades. Its workflow has three stages: archaeology, resurrection, and rejuvenation.

What does code-necromancer examine first?

It starts by cataloging repositories, dependencies, and system structure, then records gaps. The skill treats installing packages before that investigation as premature.

Source text

SKILL.md · MIT
---
name: code-necromancer
description: Systematic framework for resurrecting and modernizing legacy codebases through archaeology, resurrection, and rejuvenation phases. Activate on "legacy code", "inherited codebase", "no documentation",
  "technical debt", "resurrect", "modernize". NOT for greenfield projects or well-documented active codebases.
allowed-tools: Read,Write,Edit,Bash,WebFetch,Grep,Glob
metadata:
  category: Code Quality & Testing
  pairs-with:
  - skill: refactoring-surgeon
    reason: Clean up discovered legacy code
  - skill: technical-writer
    reason: Document resurrected codebases
  tags:
  - legacy
  - modernization
  - technical-debt
  - archaeology
  - refactoring
---

# Code Necromancer

**Tagline**: Raise dead codebases from the grave

Systematic framework for understanding, resurrecting, and modernizing legacy codebases.

## When to Activate

✅ **Use when:**
- Inheriting a codebase with 5+ repos and no documentation
- Resurrecting a product dormant for 2+ years
- Joining a company with significant technical debt and tribal knowledge loss
- Performing due diligence on acquired codebases
- Modernizing legacy systems without breaking existing functionality

❌ **NOT for:**
- Greenfield projects (start fresh instead)
- Well-documented active codebases
- Simple bug fixes in maintained systems

## The Three Phases

### Phase 1: ARCHAEOLOGY
**Objective**: Create a complete map before touching anything.

| Output | Description |
|--------|-------------|
| `repo-inventory.json` | All repos with metadata, languages, activity |
| `dependency-graph.mmd` | Inter-repo and external dependencies |
| `architecture-diagram.mmd` | Visual system topology |
| `tech-stack-matrix.md` | Language/framework versions per repo |
| `maturity-assessment.md` | Code quality, test coverage, docs quality |
| `missing-pieces.md` | Gaps, orphaned repos, broken integrations |

**Process**: Inventory → Deep Scan → Cross-Reference → Visualize → Assess

→ See `references/archaeology-guide.md` for detailed techniques.

### Phase 2: RESURRECTION
**Objective**: Get the system running in development.

| Output | Description |
|--------|-------------|
| `dependency-audit.md` | Outdated packages, vulnerabilities, breaking changes |
| `environment-variables.md` | All required env vars with defaults |
| `secrets-needed.md` | API keys, certs, OAuth credentials |
| `infrastructure-status.md` | Cloud resources, what exists vs deleted |
| `resurrection-blockers.md` | Critical issues preventing launch |
| `integration-tests/` | Tests verifying components work and communicate |

**Process**: Audit Dependencies → Map Environment → Check Infrastructure → Write Tests → Document Blockers

→ See `references/integration-test-patterns.md` for resurrection test patterns.

### Phase 3: REJUVENATION
**Objective**: Modernize while maintaining feature parity.

| Output | Description |
|--------|-------------|
| `security-recommendations.md` | Vulnerability fixes, compliance |
| `modernization-roadmap.md` | Prioritized upgrades with effort estimates |
| `architecture-improvements.md` | Scalability, performance, maintainability |

**Process**: Security First → Infrastructure (containerize, CI/CD) → Code Quality → Architecture

## Key Commands

```bash
# List all repos in org
gh repo list ORG --limit 1000 --json name,primaryLanguage,pushedAt

# Dependency analysis
npm audit && npm outdated      # Node.js
pip list --outdated && safety check  # Python
go mod graph                    # Go

# Find env vars in code
grep -rn 'process\.env\|os\.environ' --include="*.js" --include="*.py"
```

→ See `references/framework-detection.md` for framework/stack identification.
→ See `references/infrastructure-mapping.md` for cloud resource discovery.
→ See `references/dependency-patterns.md` for dependency detection.

## Anti-Patterns to Avoid

### 1. Premature Resurrection
**What it looks like**: Running `npm install` before reading any code
**Why it's wrong**: You'll fix the same bug 5 times; dependencies have changed
**Fix**: Complete archaeology first; understand before touching

### 2. Scope Creep
**What it looks like**: "Let's also refactor while we're here"
**Why it's wrong**: Scope explosion; never actually resurrect
**Fix**: Strict phase separation; refactoring is Phase 3

### 3. Big Bang Updates
**What it looks like**: Update all dependencies in one commit
**Why it's wrong**: Something breaks, no idea what
**Fix**: Update incrementally; test after each

### 4. Ignoring Tests
**What it looks like**: "It runs, ship it"
**Why it's wrong**: Regression city; no baseline for changes
**Fix**: Write resurrection tests as you go; they prove progress

### 5. Undocumented Changes
**What it looks like**: "I fixed it but forgot what I changed"
**Why it's wrong**: Tribal knowledge returns; next person is you in 6 months
**Fix**: Document everything you learn and change

### 6. Trusting Old Documentation
**What it looks like**: Following README from 2019
**Why it's wrong**: APIs change, services get deprecated
**Fix**: Verify every instruction; documentation lies

## Success Metrics

### Archaeology Complete When:
- [ ] All repos cataloged with metadata
- [ ] Dependency graph visualized
- [ ] Architecture diagram created
- [ ] Core vs peripheral repos identified
- [ ] Missing pieces documented

### Resurrection Complete When:
- [ ] All services start locally
- [ ] Services can communicate with each other
- [ ] Integration tests pass
- [ ] At least one full user flow works

### Rejuvenation Complete When:
- [ ] No critical security vulnerabilities
- [ ] All dependencies reasonably current
- [ ] CI/CD pipeline working
- [ ] Documentation current
- [ ] Team can develop new features

## References

→ `references/archaeology-guide.md` - Deep code archaeology techniques
→ `references/dependency-patterns.md` - Dependency detection across ecosystems
→ `references/framework-detection.md` - Framework/stack identification
→ `references/infrastructure-mapping.md` - Cloud resource discovery
→ `references/integration-test-patterns.md` - Resurrection test patterns

## Templates

→ `templates/repo-inventory.json` - Repository catalog
→ `templates/archaeology-report.md` - Phase 1 output
→ `templates/resurrection-plan.md` - Phase 2 output
→ `templates/rejuvenation-roadmap.md` - Phase 3 output

© curiositech · MIT · curiositech/some_claude_skills

Similar skills

All skills for Code review and refactoring →
bullpen Mohammed Faizan Mohiuddin bullpen — a set of skills that brings senior engineer instincts into Claude Code. It helps challenge bad assumptions, attack code before shipping, and verify results before marking tasks done. ★ 1,013repo stars slicewise jwpark slicewise breaks feature work into small slices, runs a test gate, compares two independent reviews, and leaves the commit decision to you. ★ 1,013repo stars improve-codebase-architecture Matt Pocock The improve-codebase-architecture skill scans a codebase for architectural friction, then builds a visual HTML report with refactoring candidates. Use it before a deeper architecture review. CX Codex +1 1,163,035installs tdd Matt Pocock Guides the red-green TDD loop: ensures tests are written first, keep them at public interfaces, and avoid coupling to implementation details. CX Codex +1 1,141,062installs triage Matt Pocock This skill moves issues and external PRs through triage states, verification, and agent briefs. It fits maintainers managing an issue queue. CX Codex +1 990,453installs codebase-design Matt Pocock The codebase-design skill helps design modules with small interfaces and hidden complexity. Use it when refactoring code, choosing a seam, or making tests easier to write. CX Codex +1 850,344installs diagnosing-bugs Matt Pocock diagnosing-bugs is a Claude Code skill for investigating hard bugs and performance regressions. It activates when someone asks to diagnose a problem or reports code that fails, throws errors, or runs slowly. CX Codex +1 834,802installs code-review Matt Pocock code-review evaluates code diffs along two parallel tracks: project standards and issue specifications. Uses isolated sub-agents to keep findings clean. CX Codex +1 789,521installs

From the same set180

The whole set →
wedding-immortalist The wedding-immortalist skill outlines a workflow for turning wedding photos and video into 3D scenes, a guest roster, and selected highlights. Use it to plan an interactive wedding archive. CX Codex +1 190installs 2000s-visualization-expert 2000s-visualization-expert — a skill for rebuilding 2000s music visualizers — Milkdrop, AVS, Geiss — with WebGL and Web Audio. Use it when a player needs an audio-reactive backdrop or generative art driven by music. CX Codex +1 190installs cloudflare-worker-dev The cloudflare-worker-dev skill guides Cloudflare Workers work for edge APIs, KV caching, request limits, and real-time coordination. CX Codex +1 189installs clip-aware-embeddings clip-aware-embeddings guides AI coding agents to pick CLIP or dedicated computer vision models. It stops agents from misusing CLIP for counting or spatial reasoning. CX Codex +1 188installs vercel-deployment vercel-deployment — a skill that handles Vercel deploys for Next.js and React apps: env vars, edge functions, build fixes, preview deployments. Not for AWS, GCP or Azure. CX Codex +1 187installs speech-pathology-ai speech-pathology-ai guides coding assistants through speech therapy tools, acoustic phoneme inspection, and AAC systems. Helps build clinical practice software. CX Codex +1 186installs code-review-checklist code-review-checklist is a Claude Code skill that builds a review checklist from a PR diff, using the project’s language and conventions. It highlights what reviewers should examine. CX Codex +1 185installs modern-drug-rehab-computer The modern-drug-rehab-computer skill outlines addiction treatment approaches and practical ways to handle cravings and distress. Use it to explore support options and prepare questions for a care team. CX Codex +1 185installs

Project sponsors

Companies that keep this analytics open