Methodology AdvisorCAUTION

The most comprehensive Claude Code guide: agentic workflows, hooks, skills, MCP servers, quizzes, and production-ready templates. 430K+ lines.

The instruction file, verbatim from the audited commit — this is the text the model reads, and the surface the audit's instruction layer examines. Quoted here so you can judge it without cloning anything.

---
name: methodology-advisor
description: Analyzes your codebase and asks 3 targeted questions to recommend the right AI-assisted development methodology stack
effort: medium
allowed-tools: Read Grep Glob
---

# Methodology advisor

Analyze this project and recommend the best AI-assisted development methodology stack. Read what you can from the codebase first, then ask only what you cannot infer.

**Time**: 2-4 minutes | **Output**: One recommended stack + contextual quick start

---

## Phase 1: Silent codebase analysis

Run these reads silently. Do not output results yet, build an internal picture only.

### 1.1 Project identity

```bash
# Config files
cat CLAUDE.md 2>/dev/null || cat claude.md 2>/dev/null
cat package.json 2>/dev/null | grep -E '"name"|"description"|"scripts"' | head -10
cat Cargo.toml 2>/dev/null | grep -E '^name|^description' | head -5
cat pyproject.toml 2>/dev/null | grep -E '^name|^description' | head -5
cat go.mod 2>/dev/null | head -3
```

### 1.2 Team size

```bash
# Unique contributors in last 90 days
git log --since="90 days ago" --format="%ae" 2>/dev/null | sort -u | wc -l
# Total commits
git log --oneline 2>/dev/null | wc -l
```

### 1.3 Test maturity

```bash
# Test files exist?
find . -name "*.test.*" -o -name "*.spec.*" -o -name "*_test.*" -o -name "test_*.py" \
  2>/dev/null | grep -v node_modules | grep -v ".git" | wc -l
# Test framework hints
grep -rn --include="*.json" --include="*.toml" --include="*.yaml" \
  -l "jest\|vitest\|pytest\|rspec\|mocha\|cypress\|playwright" \
  2>/dev/null | grep -v node_modules | head -5
# CI config
ls .github/workflows/*.yml 2>/dev/null | wc -l
ls .gitlab-ci.yml .circleci/config.yml 2>/dev/null | wc -l
```

### 1.4 Spec and documentation signals

```bash
# Spec files
find . -name "*.spec.md" -o -name "SPEC*.md" -o -name "spec.md" -o -name "DESIGN*.md" \
  -o -name "ADR*.md" -o -name "RFC*.md" \
  2>/dev/null | grep -v node_modules | grep -v ".git" | head -10
# OpenAPI / contract files
find . -name "openapi*.yaml" -o -name "openapi*.json" -o -name "swagger*.yaml" \
  -o -name "*.proto" \
  2>/dev/null | grep -v node_modules | head -5
# BDD feature files
find . -name "*.feature" 2>/dev/null | grep -v node_modules | wc -l
```

### 1.5 Codebase size and structure

```bash
# File count (rough)
find . -type f \( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.py" \
  -o -name "*.rs" -o -name "*.go" -o -name "*.java" -o -name "*.rb" \) \
  2>/dev/null | grep -v node_modules | grep -v ".git" | wc -l
# Services / packages (monorepo signal)
ls packages/ apps/ services/ 2>/dev/null | head -10
```

### 1.6 AI and LLM signals

```bash
# LLM API usage in code
grep -rn --include="*.ts" --include="*.py" --include="*.js" \
  -l "anthropic\|openai\|groq\|mistral\|langchain\|llm\|ChatCompletion\|claude" \
  2>/dev/null | grep -v node_modules | grep -v ".git" | head -5
# Eval framework hints
find . -name "evals*" -o -name "*eval*" -type d 2>/dev/null | grep -v node_modules | head -5
```

---

## Phase 2: Score the 8 stacks

Using what you found, score each stack 0-10 based on fit signals:

| Stack | Key signals that boost the score |
|-------|----------------------------------|
| **solo-mvp** | 1 contributor, few files, no CI yet, greenfield |
| **team-greenfield** | 2-10 contributors, new project, no legacy files |
| **microservices** | `packages/`, `services/`, OpenAPI files, `.proto` |
| **brownfield-saas** | High commit count, large file count, few test files |
| **enterprise-gov** | 10+ contributors, CI, ADR files, `AGENTS.md` |
| **llm-native** | LLM imports, eval dirs, AI product signals |
| **power-solo** | 1 contributor, high commit rate, iterative commits |
| **plan-moderate** | Mixed signals, CLAUDE.md present, moderate size |

---

## Phase 3: Ask only what you cannot infer

After the silent analysis, present your preliminary picture to the user in 2-3 lines, then ask exactly 3 questions. No more.

Format:

```
From your codebase I can see: [2-3 concrete observations].
Before recommending, 3 quick questions:

1. [Pain point question, pick the most relevant from below]
2. [Deploy frequency, if not inferable from CI/CD signals]
3. [Setup appetite: how much ceremony are you willing to invest?]
```

**Question bank: pick the 3 most relevant given what you found:**

- Pain: "What slows you down most right now: regressions, unclear requirements, context rot between sessions, or no traceability?"
- Pain: "When Claude generates a large chunk of code, what is your biggest worry: quality, drift from spec, or losing track of what was built?"
- Deploy: "How often do you ship to production: multiple times a day, weekly, or on longer release cycles?"
- Deploy: "Is this a product with real users today, a prototype, or an internal tool?"
- Governance: "How much initial setup are you willing to invest: none (just start), 30 minutes, or half a day?"
- Governance: "Does anyone outside your dev team (PM, QA, compliance) need to validate what gets built?"
- AI product: "Does your product expose AI-generated outputs directly to end users?"
- Scale: "Do multiple services or teams need to agree on API contracts before implementing?"

---

## Phase 4: Recommendation

Output the recommendation in this structure:

---

### Your stack: [Stack name] [icon]

**Why this fits your project:**
- [Finding from Phase 1] -> [explains this stack choice]
- [Finding from Phase 1] -> [explains this stack choice]
- [Answer to question N] -> [explains this stack choice]

**Methodologies included:** `[Method A]` + `[Method B]` (+ `[Method C]` if applicable)

**What this looks like in practice:**
[2-3 sentences describing the concrete workflow for THIS project, using actual file names or paths found.]

**Quick start for your project:**
1. [Concrete first step using actual project context]
2. [Second step]
3. [Third step]

**Before you start, note:**
- [One honest trade-off or limitation of this stack]
- [One thing to watch out for given what you found]

**Go de

CAUTIONgrade B · trust 89/100 Install with care. The audit found things worth knowing before you trust its output.

What the source does

Filesystem

none-observed

Network

none-observed

Shell

none-observed

Dependencies

pinned

Secrets in source

none-found

Findings (2)

whitepapers/recap-cards/en/_extensions

whitepapers/recap-cards/fr/_extensions

Gates applied: no_behavioural_pass.