# Analyze

> Deep codebase analysis with extended thinking — use for complex tasks that may lead to implementation

- Skill: `eddmann/analyze` (Agent Skill)
- Install (CLI): `npx skillmds@latest add eddmann/analyze`
- Raw SKILL.md: https://api.skillmd.com/api/skills/eddmann/analyze/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: eddmann (https://skillmd.com/u/eddmann)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/eddmann/analyze

---


ultrathink: Gather deep context and analyze the following request with extreme thoroughness. Do NOT begin planning until you have built a comprehensive mental model of the relevant code.

## Request

$ARGUMENTS

## Context

- Current directory: !`pwd`
- Git branch: !`git branch --show-current 2>/dev/null || echo "not a git repo"`
- Recent commits: !`git log --oneline -10 2>/dev/null || echo "no commits"`

## Phase 1: Broad Context Gathering (MANDATORY — do this FIRST)

Before forming ANY opinions or plans, gather context aggressively:

1. **Map the project structure** — use Glob to understand the directory layout, then read project config files (CLAUDE.md, AGENTS.md, package.json, Cargo.toml, Makefile, tsconfig.json, or equivalent). This tells you the conventions.
2. **Launch Explore agents** (set to "very thorough") in parallel to map all code areas relevant to the request. Cast a wide net.
3. **Read ALL files** that might be relevant — err on the side of reading MORE, not less. Read files in parallel batches. If you're unsure whether a file matters, read it.
4. **Read tests** to understand expected behavior, test patterns, and edge cases already covered.
5. **Check git history** (`git log --oneline --all -- <relevant paths>`) if it helps understand design decisions or recent changes.

**You should have read 10+ files before moving to Phase 2.** If you haven't, you haven't read enough. Spend real effort here — this is where the quality comes from.

## Phase 2: Resolve Ambiguity

If the request is ambiguous or there are meaningful choices that affect the approach (e.g., which library, what scope, performance vs simplicity), use `AskUserQuestion` to resolve them NOW — before committing to any direction. Don't guess at intent.

## Phase 3: Deep Analysis

Now think deeply about what you've learned:

1. **Consider multiple approaches** — don't settle on the first idea
2. **Identify tradeoffs** — performance, maintainability, complexity, risk
3. **Think about edge cases** and failure modes
4. **Consider how changes fit** with existing patterns and conventions
5. **Anticipate problems** that might arise during implementation

## Phase 4: Output

Decide whether this request is an **implementation task** or **pure analysis**.

**If implementation:** Use `EnterPlanMode`. Do any remaining exploration there, write the plan to the plan file with specific file:line references, then use `ExitPlanMode` for approval. Once approved, proceed with implementation directly.

**If pure analysis:** Output findings directly. Include file:line references. No plan mode needed.