Claude Code Tools Deep Dive

When you ask Claude to perform a task, you're often hoping it figures out the right approach. But Claude Code provides a specific set of built-in tools with well-defined inputs, outputs, and behaviors. Understanding these tools thoroughly—like learning a standard library or framework primitives—gives you fine-grained control over what Claude can do.

This course is an exhaustive overview of Claude's built-in tools. You'll learn exactly how each tool works, what it can and cannot do, and how to combine them into reliable, reproducible workflows. With this knowledge, you can build custom skills and hooks that leverage these tools precisely, intercept and modify their behavior, and create predictable automation instead of guessing what will happen.

What You'll Learn

This course provides a comprehensive reference to every built-in tool and how to use them as building blocks:

• File Tools: Read, Write, Edit—their exact behavior, permissions, and when to use each
• Search Tools: Glob vs Grep—understanding their different pattern syntaxes, performance characteristics, and use cases
• Bash Tool: How commands execute, sandboxing behavior, timeouts, and output handling
• Web Tools: WebFetch and WebSearch—their capabilities, limitations, and permission models
• Agent Tools: Task (subagents) and TodoWrite—how they work and when to use them programmatically
• Permission System: The exact rules for allowed-tools, deny patterns, and how they're evaluated
• Hook System: PreToolUse and PostToolUse—intercepting tool calls, validating inputs, and modifying behavior
• Settings Precedence: How user, project, local, and enterprise settings combine and override

Course Philosophy

Understanding the tools is like understanding React hooks or the Node.js standard library. Once you know the inputs, outputs, and behavior of each primitive, you can:

• Build Predictable Workflows: Chain tools together with confidence in the outcome
• Create Precise Skills: Reference specific tools in your skill definitions instead of relying on agent inference
• Implement Custom Controls: Use hooks to intercept tools and enforce your own validation rules
• Debug Effectively: Know exactly which tool is being called and why
• Design Reproducible Automation: Get the same results every time instead of variability from AI reasoning

The focus is on:

• Complete Understanding: Knowing exactly how each tool works, not just what it does
• Reproducibility: Building workflows that produce consistent, predictable results
• Control: Choosing the exact tool and parameters instead of hoping Claude picks correctly
• Composition: Combining tools, skills, and hooks to create custom automation primitives

Course Structure

Each lesson covers a specific tool or system in detail, explaining its exact behavior, parameters, edge cases, and how to use it in skills and hooks.

Core Tool Series

1. Read Tool - File reading behavior, line offsets, limits, permissions, and when Read is preferred over Bash
2. Write vs Edit - Understanding when to create new files vs modify existing ones, and the critical requirement to Read before Write
3. Glob Patterns - Pattern syntax, performance characteristics, and using Glob for file discovery
4. Grep Tool - Regex patterns, output modes, context lines, and when to use Grep vs Glob
5. Bash Tool - Command execution, timeouts, background processes, and the BashOutput tool

Permission & Security Series

6. Permission Rules - Exact evaluation order of allow, ask, and deny rules
7. Working Directories - How additionalDirectories works and filesystem access boundaries
8. Sandboxing - Sandbox modes, excluded commands, and network restrictions
9. Deny Patterns - Protecting sensitive files with glob patterns in permission rules

Hooks & Interception Series

10. PreToolUse Hooks - Intercepting tool calls before execution, reading tool context, and blocking with exit codes
11. PostToolUse Hooks - Reacting to tool results, triggering follow-up actions
12. Hook Matchers - Targeting specific tools and patterns with matcher syntax
13. Hook Security - Avoiding infinite loops and understanding settings inheritance in hooks

Advanced Tools & Patterns

14. WebFetch - URL fetching, prompt-based content extraction, and permission patterns
15. WebSearch - Search queries, domain filtering, and working with search results
16. Task Tool (Subagents) - When to use subagents, model selection, and passing context
17. TodoWrite - Programmatic task management and using todos in skills

Settings & Configuration Series

18. Settings Precedence - Understanding the hierarchy from enterprise to local settings
19. Environment Variables - Using the env key and understanding variable scope
20. Model Configuration - Overriding default models for main agent and subagents
21. Hook Configuration - Defining hooks in settings.json with matchers and commands

Prerequisites

To get the most out of this course, you should have:

• Familiarity with the command line and shell commands
• Understanding of file system concepts (paths, directories, permissions)
• Claude Code installed and configured
• Basic knowledge of JSON syntax
• Experience using Claude Code for at least a few tasks (so you understand the basic interaction model)

How to Use This Course

This course is structured as a comprehensive reference. You don't need to go through it sequentially:

• If you're building skills: Start with the Core Tool Series to understand which tools to reference in your allowed-tools
• If you're securing Claude: Jump to the Permission & Security Series to understand deny rules and sandboxing
• If you're building automations: Check out the Hooks & Interception Series to learn how to modify tool behavior
• If you're configuring teams: Focus on the Settings & Configuration Series for enterprise policies

Each lesson is self-contained with complete examples, so you can jump directly to the tool or concept you need to understand.