I Built an AI-Powered Dead Code Detector for VS Code (and It Goes Way Beyond Unused Imports)

function calculateDiscount(price: number, userType: string): number {
  if (userType === "admin") {
    return price * 0;
  }
  return price * 0.9;

  // 💀 Never reached — the return above always fires
  const bonus = price * 0.05;
  console.log("Applying bonus:", bonus);
  return price - bonus;
}

// 💀 Exported but nothing in the codebase ever calls this
export class OldReportGenerator {
  generate(data: any[]) {
    return data.map((d) => JSON.stringify(d)).join("n");
  }
  exportToCsv(data: any[]) {
    return data.join(",");
  }
}

const FEATURE_DARK_MODE = false;    // 🚩 Has been false for 18 months
const USE_NEW_CHECKOUT = true;      // 🚩 Always true — the else branch is dead

if (FEATURE_DARK_MODE) {
  applyDarkTheme(); // 💀 Never runs
}

if (USE_NEW_CHECKOUT) {
  showNewCheckout();
} else {
  showLegacyCheckout(); // 💀 Never runs
  trackLegacyCheckoutEvent();
}

const SYSTEM_PROMPT = `You are an expert static analysis tool specializing in dead code detection. 
Analyze the provided source code and identify:

1. **Unreachable Business Logic** — code after unconditional returns, inside impossible 
   conditions (e.g. if (false), if (1 === 2)), catch blocks that swallow everything, etc.

2. **Unused APIs / Functions** — exported or defined functions/classes/variables that appear 
   to never be called or referenced within the file.

3. **Obsolete Feature Flags** — boolean constants or config checks that are hardcoded to 
   true/false, e.g. const FEATURE_X = false used in conditions.

Respond ONLY with a JSON array (no markdown, no preamble). Each item must have:
{
  "category": "unreachable-logic" | "unused-api" | "obsolete-feature-flag" | "dead-code",
  "message": "Short one-line summary (< 80 chars)",
  "explanation": "2-3 sentences explaining why this is dead/obsolete code",
  "suggestion": "What to do — remove, refactor, or clean up",
  "line": ,
  "severity": "high" | "medium" | "low"
}

Return [] if no issues found.`;

const response = await fetch("https://api.anthropic.com/v1/messages", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
    "anthropic-version": "2023-06-01",
  },
  body: JSON.stringify({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    system: SYSTEM_PROMPT,
    messages: [{ role: "user", content: userMessage }],
  }),
});

const data = await response.json();
const text = data.content
  .filter((b) => b.type === "text")
  .map((b) => b.text)
  .join("");

// Strip possible markdown fences before parsing
const clean = text.replace(/```
{% endraw %}
json|
{% raw %}
```/g, "").trim();
const results = JSON.parse(clean);

function applyDiagnostics(doc: vscode.TextDocument, results: DeadCodeResult[]) {
  const diagnostics = results.map((result) => {
    const line = Math.max(0, (result.line ?? 1) - 1);
    const range = doc.lineAt(Math.min(line, doc.lineCount - 1)).range;
    const diag = new vscode.Diagnostic(
      range,
      `[${result.category}] ${result.message}`,
      vscode.DiagnosticSeverity.Warning
    );
    diag.source = "Dead Code AI";
    diag.code = result.category;
    return diag;
  });

  diagnosticCollection.set(doc.uri, diagnostics);
}

// The webview posts a message back to the extension host
ResultsPanel.currentPanel.webview.onDidReceiveMessage(async (msg) => {
  if (msg.command === "jumpTo") {
    const editor = vscode.window.visibleTextEditors[0];
    const pos = new vscode.Position(Math.max(0, msg.line - 1), 0);
    editor.selection = new vscode.Selection(pos, pos);
    editor.revealRange(
      new vscode.Range(pos, pos),
      vscode.TextEditorRevealType.InCenter
    );
  }
});

# Clone the repo
git clone https://github.com/naimulkarim/dead-code-detector.git
cd dead-code-detector

# Install dependencies
npm install

# Open in VS Code
code .

export ANTHROPIC_API_KEY=sk-ant-api03-...

// .vscode/settings.json or user settings
{
  "deadCode.anthropicApiKey": "sk-ant-...",
  "deadCode.severity": "warning",
  "deadCode.checks": {
    "unreachableLogic": true,
    "unusedApis": true,
    "obsoleteFeatureFlags": true
  }
}

User triggers Cmd+Shift+D
        ↓
extension.ts
  → reads active document text
  → reads enabled checks from config
        ↓
analyzer.ts
  → builds user prompt with language + filename + code
  → POST /v1/messages → Claude Sonnet
  → strips markdown fences, JSON.parse()
  → returns DeadCodeResult[]
        ↓
extension.ts
  → vscode.DiagnosticCollection.set() → squiggles in editor
        ↓
resultsPanel.ts
  → Webview HTML panel with filter buttons + severity cards
  → postMessage() → jump-to-line on click