home / skills / duc01226 / easyplatform / scout

scout skill

/.claude/skills/scout

This skill quickly locates relevant codebase files across large projects to jumpstart feature work spanning multiple directories.

npx playbooks add skill duc01226/easyplatform --skill scout

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.8 KB
---
name: scout
version: 1.0.0
description: Fast codebase file discovery for task-related files. Use when quickly locating relevant files across a large codebase, beginning work on features spanning multiple directories, or before making changes that might affect multiple parts. Triggers on "find files", "locate", "scout", "search codebase", "what files".
infer: false
allowed-tools: Glob, Grep, Read, Task, TodoWrite
---

# Scout - Fast Codebase File Discovery

Fast codebase search to locate files needed for a task. Token-efficient, parallel execution.

**KEY PRINCIPLE**: Speed over depth. Return file paths only - no content analysis.

---

## When to Use

- Quickly locating relevant files across a large codebase
- Beginning work on features spanning multiple directories
- Before making changes that might affect multiple parts
- Mapping file landscape before investigation or implementation
- Finding all files related to an entity, feature, or keyword

**NOT for**: Deep code analysis (use `feature-investigation`), debugging (use `debugging`), or implementation (use `feature-implementation`).

---

## Quick Reference

| Input               | Description                                         |
| ------------------- | --------------------------------------------------- |
| `USER_PROMPT`       | What to search for (entity names, feature keywords) |
| `SCALE`             | Number of parallel agents (default: 3)              |

---

## Workflow

### Step 1: Analyze Search Request

Extract keywords from USER_PROMPT to identify:
- Entity names (e.g., TextSnippet, Employee)
- Feature names (e.g., authentication, notification)
- File types needed (backend, frontend, or both)

### Step 2: Execute Parallel Search

Spawn SCALE number of `Explore` subagents in parallel using `Task` tool.

#### Agent Distribution Strategy

- **Agent 1 - Backend Core**: `src/Backend/*/Domain/`, `src/Backend/*/Application/UseCaseCommands/`, `src/Backend/*/Application/UseCaseQueries/`
- **Agent 2 - Backend Infra**: `src/Backend/*/Application/UseCaseEvents/`, `src/Backend/*/Api/Controllers/`, `src/Backend/*/Application/BackgroundJobs/`
- **Agent 3 - Frontend**: `src/Frontend/apps/`, `src/Frontend/libs/apps-domains/`, `src/Frontend/libs/platform-core/`

### Step 3: Synthesize Results

Combine results into a **numbered, prioritized file list**.

---

## Search Patterns by Priority

```
# HIGH PRIORITY - Core Logic
**/Domain/Entities/**/*{keyword}*.cs
**/UseCaseCommands/**/*{keyword}*.cs
**/UseCaseQueries/**/*{keyword}*.cs
**/UseCaseEvents/**/*{keyword}*.cs
**/*{keyword}*.component.ts
**/*{keyword}*.store.ts

# MEDIUM PRIORITY - Infrastructure
**/Controllers/**/*{keyword}*.cs
**/BackgroundJobs/**/*{keyword}*.cs
**/*Consumer*{keyword}*.cs
**/*{keyword}*-api.service.ts

# LOW PRIORITY - Supporting
**/*{keyword}*Helper*.cs
**/*{keyword}*Service*.cs
**/*{keyword}*.html
```

---

## Results Format

```markdown
## Scout Results: {USER_PROMPT}

### High Priority - Core Logic
1. `src/Backend/.../Domain/Entities/{Entity}.cs`
2. `src/Backend/.../UseCaseCommands/{Entity}/Save{Entity}Command.cs`
...

### Medium Priority - Infrastructure
10. `src/Backend/.../Api/Controllers/{Entity}Controller.cs`
...

### Frontend Files
30. `src/Frontend/apps/.../features/{entity}/{entity}-list.component.ts`
...

**Total Files Found:** {count}

### Suggested Starting Points
1. `{most relevant file}` - {reason}
2. `{second most relevant}` - {reason}
```

---

## See Also

- `feature-investigation` skill - Deep analysis of discovered files
- `feature-implementation` skill - Implementing features after scouting
- `planning` skill - Creating implementation plans from scouted files

---

**IMPORTANT Task Planning Notes (MUST FOLLOW)**
- Always plan and break work into many small todo tasks
- Always add a final review todo task to verify work quality and identify fixes/enhancements

Overview

This skill finds task-related files quickly across large C# codebases. It prioritizes speed and returns a concise, numbered list of file paths so you can start work or plan changes without deep code analysis. Use it to map the file landscape before investigation or implementation.

How this skill works

I extract keywords from your prompt (entity names, feature keywords, file types) and run parallel explore agents across backend and frontend directories. Each agent searches high-, medium-, and low-priority patterns and returns matching file paths. I then synthesize results into a prioritized, numbered file list with suggested starting points.

When to use it

  • Quickly locate files related to an entity or feature before coding
  • Begin work on a feature that spans multiple directories
  • Identify files that might be affected by a refactor or change
  • Map relevant backend and frontend files before deeper investigation
  • Find candidate files to feed into a deeper analysis or implementation workflow

Best practices

  • Provide clear keywords or entity names in the prompt (e.g., TextSnippet, Employee, authentication)
  • Specify scope if needed (backend, frontend, or both) to reduce noise
  • Use scale to increase parallel agents for larger repos (default 3)
  • Run a follow-up with a deep-analysis skill for code content review or debugging
  • Break follow-up work into small TODOs and include a final review task

Example use cases

  • Locate all files related to the Employee entity across backend and frontend
  • Find controller, use-case, and domain files before implementing a feature
  • Quickly gather files touched by an upcoming API contract change
  • Scout relevant UI components and store files when updating a frontend feature
  • Collect candidate files to pass to a deeper investigation or implementation workflow

FAQ

What does the skill return?

It returns only file paths, organized by priority and numbered; no file contents or analysis are provided.

How many parallel searches run by default?

Three parallel agents by default (backend core, backend infra, frontend); you can increase the scale for larger codebases.