senior-software-analyst

Audits codebases to map architecture, assess technical debt, and produce structured analysis reports.

4|2|Updated Jan 27, 2026
One-click install
npx skills add https://github.com/Arete-Consortium/ai-skills --skill senior-software-analyst-arete-consortium
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: senior-software-analyst
Source: https://github.com/Arete-Consortium/ai-skills/tree/main/personas/engineering/senior-software-analyst
Command: npx skills add https://github.com/Arete-Consortium/ai-skills --skill senior-software-analyst-arete-consortium

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Understanding an unfamiliar codebase is slow and error-prone when done ad hoc. This Skill provides a disciplined, phased audit framework that maps architecture, traces data flow, and quantifies technical debt before you make any changes. ## Core Features & Use Cases - Phased Codebase Audit: A five-stage framework covering first contact, entry point analysis, architecture mapping, dependency analysis, and configuration/data flow review. - Structured Reporting: Produces a standardized codebase report with component maps, key abstractions, dependency tables, technical debt items, and prioritized recommendations. - Multi-Agent Parallel Analysis: Supports Agent Teams patterns to split large codebases across multiple analysts for frontend, backend, and infrastructure audits. - Use Case: Before contributing to a large Rust or TypeScript project, run this Skill to generate a full architecture map, identify dead code and circular dependencies, and get a prioritized list of technical debt items. ## Quick Start Ask Claude to analyze this unfamiliar codebase and produce a structured architecture and technical debt report using the senior software analyst skill.

Frequently Asked Questions about senior-software-analyst

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

FAQPage Schema
How do I analyze an unfamiliar codebase before making changes?▼

Follow a phased audit: read the README and manifest files, locate the entry point, map the module structure, review dependencies, and trace configuration and data flow. This Skill automates that sequence with concrete grep, find, and build commands.

How to find dead code and technical debt in a project?▼

Run compiler lints such as cargo clippy with dead_code warnings for Rust or ts-prune for TypeScript to surface unused functions and exports. Then flag anti-patterns like god objects, circular dependencies, magic values, and missing error handling.

When should I use codebase analysis instead of code review?▼

Use codebase analysis when you need to understand an entire project's architecture and health before changing anything. Use PR-scoped code review when evaluating a specific diff, since review requires change-focused context rather than full system mapping.

Can this handle large codebases that exceed one context window?▼

Yes, it supports a multi-agent team pattern where separate analysts audit frontend, backend, and infrastructure in parallel. A lead agent then synthesizes the individual results into a unified codebase report.

What are the limitations of automated codebase auditing?▼

The audit relies on static inspection via grep and build checks, so it cannot verify runtime behavior or business logic correctness. Security vulnerability assessment is also out of scope and should be delegated to a dedicated security audit process.