5K

Tool Selection Guide

Maps each task type to a preferred tool: Glob, Grep, and Read to explore, Edit to modify, Bash to verify, and Task with a clear subject to delegate

emerging Updated 2026-10-13 By Nikola Balic (@nibzard) Based on Analysis of 88 Claude conversation sessions (author's own analysis, now offline), Anthropic Claude Code best practices
View .md Edit on GitHub
Add to Pack
or

Saved locally in this browser for now.

Cite This Pattern
APA 
Nikola Balic (@nibzard) (2026). Tool Selection Guide. In *Awesome Agentic Patterns*. Retrieved October 14, 2026, from https://agentic-patterns.com/patterns/tool-selection-guide
BibTeX 
@misc{agentic_patterns_tool-selection-guide,
  title = {Tool Selection Guide},
  author = {Nikola Balic (@nibzard)},
  year = {2026},
  howpublished = {\url{https://agentic-patterns.com/patterns/tool-selection-guide}},
  note = {Awesome Agentic Patterns}
}

Use when

  • Coding agent has file, shell, and delegation tools
  • Agent wastes tokens with wrong tool choices such as Write for small edits
  • Agent skips build checks after code changes

Avoid when

  • Agent has only one or two tools
  • Simple one-off tasks where the workflow adds overhead

Problem

AI agents often struggle to select the optimal tool for a given task, leading to inefficient workflows. Common anti-patterns include:

  • Using Write when Edit would be more appropriate
  • Launching subagents for simple exploration tasks
  • Skipping build verification after code changes
  • Performing sequential exploration when parallel would be faster

These inefficiencies compound across long sessions, resulting in wasted tokens, slower completion, and more user corrections.

Solution

Encode tool selection patterns that emerged from the author's analysis of 88 real-world Claude conversation sessions and that align with Anthropic's published Claude Code guidance (read files before editing, verify changes with shell commands). By matching task type to the right tool, agents can follow proven workflows.

Tool preference patterns from observed usage (session counts come from the author's analysis, whose repository is no longer online — treat them as illustrative, not reproducible):

Task Type Recommended Tool Evidence
Codebase exploration Read → Grep → Glob Consistent pattern across all analyzed projects
Code modification Edit (not Write) Edits far outnumbered Writes in the analyzed sessions
New file creation Write Appropriate use case
Build verification Bash The most frequently used tool in the analyzed sessions
Research delegation Task (with clear subject) Used repeatedly, always with a subject

Key selection criteria:

  1. Exploration tasks (discovering code structure, finding patterns):

    • Start with Glob for file discovery
    • Use Grep for content search (syntax-aware when available)
    • Use Read for targeted file inspection

  2. Code modification tasks (changing existing code):

    • Prefer Edit over Write - preserves existing context and comments, and a partial diff costs far fewer tokens than a full file rewrite
    • Only use Write for brand new files or complete rewrites (with permission)
    • Use Write when changing >50% of a file; otherwise use Edit
    • Always Read the file before editing

  3. Verification tasks (testing, building, checking):

    • Use Bash for build commands, test runners, and linting
    • Run verification after every Edit/Write operation
    • Check for errors/warnings before proceeding

  4. Delegation tasks (parallel exploration):

    • Use Task tool for subagent delegation
    • Always provide clear task subjects (no empty strings)
    • Prefer parallel over sequential for independent exploration
    • Parallel delegation can provide order-of-magnitude speedups for independent tasks (e.g., framework migrations), per the original session analysis
flowchart TD A[Task Type?] --> B[Exploration] A --> C[Modification] A --> D[Verification] A --> E[Delegation] B --> B1[Glob files] B1 --> B2[Grep content] B2 --> B3[Read targets] C --> C1[Read file first] C1 --> C2{New file?} C2 -->|Yes| C3[Write] C2 -->|No| C4[Edit] D --> D1[Bash build/test] D1 --> D2{Errors?} D2 -->|Yes| D3[Fix then retry] D2 -->|No| D4[Proceed] E --> E1[Define clear subject] E1 --> E2{Independent tasks?} E2 -->|Yes| E3[Parallel delegation] E2 -->|No| E4[Sequential delegation] style B fill:#e1f5ff style C fill:#fff4e1 style D fill:#e8f5e9 style E fill:#f3e5f5

How to use it

Before using any tool, mentally categorize the task:

  • "Am I discovering something?" → Exploration toolkit
  • "Am I changing something?" → Edit (after Read)
  • "Am I checking something?" → Bash verification
  • "Am I delegating something?" → Task with clear subject

Anti-pattern prevention:

  • Don't use Write for modifications (use Edit)
  • Don't skip Read before Edit
  • Don't claim work complete without Bash verification
  • Don't use empty task subjects in Task invocations
  • Don't explore sequentially when parallel is possible

Trade-offs

Pros:

  • Grounded in observed sessions and consistent with Anthropic's published guidance
  • Reduces token waste and user corrections
  • Faster workflow completion
  • Clear mental model for tool selection
  • Prevents common anti-patterns

Cons:

  • Requires tool availability (e.g., Bash for verification)
  • Parallel delegation increases cost
  • May feel slower for simple one-off tasks
  • Requires discipline to follow patterns consistently

References