cynic-burn

Analyze codebases for orphans, hotspots, giants, and duplicates with actionable verdicts.

2|Updated Jan 14, 2026
One-click install
npx skills add https://github.com/zeyxx/CYNIC-legacy --skill cynic-burn
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: cynic-burn
Source: https://github.com/zeyxx/CYNIC-legacy/tree/main/.crush/skills/cynic-burn
Command: npx skills add https://github.com/zeyxx/CYNIC-legacy --skill cynic-burn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses code complexity by identifying and recommending actions for orphaned files, overly dependent modules, excessively large files, and duplicated code segments, promoting a cleaner and more maintainable codebase.

Core Features & Use Cases

  • Pathology Detection: Identifies Orphans (unimported files), Hotspots (high dependency counts), Giants (large files), and Duplicates (similar code).
  • Actionable Verdicts: Provides clear recommendations like DELETE, MERGE, SPLIT, SIMPLIFY, KEEP, or REVIEW.
  • Use Case: When tasked with reducing technical debt, use this Skill to systematically analyze a project's codebase and pinpoint specific areas ripe for simplification according to the "Don't extract, burn" philosophy.

Quick Start

Analyze the current project for code simplification opportunities.

Frequently Asked Questions about cynic-burn

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

FAQPage Schema
How do I identify technical debt and reduce code complexity in my project?

To reduce code complexity and technical debt, you can analyze your codebase to identify four pathologies: orphaned files, dependency hotspots, oversized giants, and duplicates. This yields actionable verdicts like DELETE, MERGE, SPLIT, or SIMPLIFY for cleaner code.

What is the best way to find duplicated code and unimported files for refactoring?

Finding duplicated code and unimported orphaned files for refactoring involves scanning the codebase to detect similar code segments and unused modules. The process outputs clear recommendations to delete or merge these specific areas to improve maintainability.

How do I simplify code and minimize premature abstraction in a large codebase?

Simplifying code and minimizing premature abstraction requires analyzing overly dependent modules and excessively large files. Instead of extracting logic, you apply a philosophy of burning complexity by splitting or merging components to systematically reduce dependencies.

Can I use this code review approach to systematically handle large files and dependency hotspots?

Yes, this code review approach handles large files and dependency hotspots by analyzing the codebase to pinpoint excessively large files and modules with high dependency counts. It then provides targeted verdicts like SPLIT or SIMPLIFY to resolve these issues.

When should I not use automated codebase simplification recommendations?

Automated codebase simplification recommendations should not be used when your project requires building new abstractions rather than minimizing complexity. The approach strictly adheres to a 'Don't extract, burn' philosophy, so it may not suit architectures needing extensive premature abstraction.

Does cynic-burn require any specific dependencies to analyze code quality?

Cynic-burn does not require any specific dependencies to analyze code quality. It directly analyzes your project's codebase to identify orphans, hotspots, giants, and duplicates, providing actionable verdicts without needing external components.