repo-scan
by affaan-mrepo-scan is a cross-stack source audit skill that classifies files, detects embedded third-party libraries, and helps you judge what is core, duplicated, or dead weight. It is useful for repo-scan for Code Review, legacy migrations, and refactor planning. See repo-scan install and repo-scan usage guidance in the skill.
This skill scores 74/100, which means it is a usable directory listing for agents that need cross-stack source audit and embedded library detection. It gives users enough to decide on installation, though the workflow is still somewhat sparse outside the main capability description and installation snippet.
- Strong use case definition: cross-stack audit for C/C++, Android, iOS, and Web codebases, with clear when-to-use scenarios.
- Operationally meaningful outputs: file classification, embedded third-party library detection, and four-level verdicts per module.
- A reproducible install path is included, including a pinned commit and explicit review-before-install warning.
- No support files, scripts, or references are provided, so users must trust the SKILL.md workflow without corroborating implementation assets.
- The body is descriptive but not deeply procedural; agents may still need some guesswork on execution details and edge cases.
Overview of repo-scan skill
What repo-scan does
repo-scan is a cross-stack source audit skill that helps you quickly understand how much of a repository is original code, third-party code, or build noise. It is most useful when you need a repo-scan for Code Review, a migration plan, or a refactor decision and do not want to manually skim thousands of files first.
Who should install it
Use the repo-scan skill if you work in legacy codebases, monorepos, or mixed-language repos where ownership is unclear. It is especially relevant for reviewers, platform engineers, and architects who need a structural read on C++, Android, iOS, and web code in one pass.
Why it is different
The main value of repo-scan is not just listing dependencies; it classifies files and produces actionable verdicts that help you decide what to keep, extract, merge, or remove. That makes it more decision-oriented than a generic prompt and more useful than ecosystem-specific dependency tools.
How to Use repo-scan skill
Install repo-scan
Follow the repo-scan install steps in the skill file and keep the pinned commit approach for reproducibility. Install it into your Claude skills directory, then verify you are using the intended source before running it on sensitive code.
Start with the right input
For best repo-scan usage, give the skill a repository path, the audit goal, and the scope boundary. A strong prompt looks like: “Scan this monorepo and identify core assets, embedded third-party code, and likely dead weight before refactoring the payments service.” That is better than “analyze this repo” because it tells the skill what a useful verdict should support.
Read these files first
Begin with SKILL.md, then inspect any repo-level docs that explain conventions or exceptions. If present, read README.md, AGENTS.md, metadata.json, and supporting folders such as rules/, resources/, references/, or scripts/ before you trust the scan output. In this repository, SKILL.md is the only source file exposed, so the installation choice depends mostly on that documented workflow and your own review of the pinned source.
Work the scan into a review flow
Use repo-scan as a first-pass triage tool, then confirm the highest-impact findings with code review or targeted grep. The best workflow is: scan the repo, inspect the flagged modules, validate ownership and embedded libraries, then turn the results into a refactor or cleanup plan.
repo-scan skill FAQ
Is repo-scan only for large repositories?
No. It is most valuable on large or mixed-language repos, but it can also help when a smaller codebase has a lot of vendored code, generated output, or unclear module boundaries. If the repo is already clean and well documented, the payoff is lower.
How is repo-scan different from a normal prompt?
A normal prompt can summarize a repository, but repo-scan is meant to drive a repeatable audit workflow with file classification and verdicts. That makes repo-scan for Code Review stronger when you need consistent inspection criteria instead of a one-off summary.
Is repo-scan beginner friendly?
Yes, if you can provide a clear goal and read the output critically. The skill is more about making a judgment call than teaching source control basics, so beginners should use it with a specific question such as “what can be safely removed?” rather than a broad “analyze everything.”
When should I not use repo-scan?
Do not use it when you only need a high-level product explanation, a package dependency list, or runtime debugging. It is also a poor fit if your repository is tiny or if the important question is behavioral testing rather than code ownership.
How to Improve repo-scan skill
Give tighter audit boundaries
The best way to improve repo-scan results is to define the slice of the repo and the decision you care about. Say whether you want a whole-repo scan, a single service, or only files that might be third-party or dead code. Narrow boundaries reduce noisy verdicts and make the report easier to act on.
Ask for the output you will use
If you need a cleanup plan, ask for modules ranked by risk or effort. If you need a Code Review aid, ask for the places where embedded libraries and generated assets could hide ownership problems. repo-scan works best when the prompt names the downstream decision, not just the repository.
Validate edge cases manually
The common failure mode is over-trusting a first-pass classification on generated files, vendored code, or language-specific build output. After the scan, check the top flagged paths and compare them with repo conventions so you do not remove code that only looks redundant.
Iterate from findings to action
After the first repo-scan output, ask follow-up questions that target the most ambiguous modules. For example: “Which of these flagged directories are safe to archive?” or “Which third-party libraries appear embedded rather than declared?” That keeps repo-scan grounded in concrete next steps and improves the usefulness of the final audit.