From a39753e5e2ce50d21f9ea0764520a67b62ad2ac5 Mon Sep 17 00:00:00 2001 From: Meherzi Zied Date: Wed, 27 Aug 2025 10:08:55 +0100 Subject: [PATCH 1/4] Update README.md Made the readme beginner friendly --- README.md | 560 +++++++++++++++++++----------------------------------- 1 file changed, 198 insertions(+), 362 deletions(-) diff --git a/README.md b/README.md index ccb6532..4ff59aa 100644 --- a/README.md +++ b/README.md @@ -1,444 +1,280 @@ -# How to Build a Coding Agent - Workshop - -A hands-on workshop for learning how to build AI agents with progressively increasing capabilities. This repository contains six different agent implementations that demonstrate the evolution from a simple chat interface to a fully capable agent with file system access, code search, and tool execution. - -Refer to the blog post at https://ghuntley.com/agent/ to learn more. - -## 🎯 Learning Objectives - -By working through this workshop, you will learn: - -- How to integrate with the Anthropic Claude API -- The fundamentals of tool-calling and function execution -- How to build a robust agent event loop -- Progressive enhancement of agent capabilities -- Error handling and logging in agent systems -- Schema generation for tool parameters - -## 🏗️ Architecture Overview - -All applications share a common architecture pattern with a central event loop that handles user input, sends messages to Claude, processes tool calls, and returns results. - -```mermaid -graph TB - subgraph "Agent Architecture" - A[Agent] --> B[Anthropic Client] - A --> C[Tool Registry] - A --> D[getUserMessage Function] - A --> E[Verbose Logging] - end - - subgraph "Shared Event Loop" - F[Start Chat Session] --> G[Get User Input] - G --> H{Empty Input?} - H -->|Yes| G - H -->|No| I[Add to Conversation] - I --> J[runInference] - J --> K[Claude Response] - K --> L{Tool Use?} - L -->|No| M[Display Text] - L -->|Yes| N[Execute Tools] - N --> O[Collect Results] - O --> P[Send Results to Claude] - P --> J - M --> G - end - - subgraph "Tool Execution Loop" - N --> Q[Find Tool by Name] - Q --> R[Execute Tool Function] - R --> S[Capture Result/Error] - S --> T[Add to Tool Results] - T --> U{More Tools?} - U -->|Yes| Q - U -->|No| O - end +# 🧠 Build Your Own Coding Agent – Step-by-Step Workshop + +Welcome! 👋 This workshop will guide you through building your own **AI-powered coding assistant** — starting from a basic chatbot, and adding powerful tools like file reading, shell command execution, and code searching. + +You don’t need to be an AI expert. Just follow along and build step-by-step! + +🌐 **Want a detailed overview?** Check out the blog post: [ghuntley.com/agent](https://ghuntley.com/agent/) + +--- + +## 🎯 What You'll Learn + +By the end of this workshop, you’ll understand how to: + +✅ Connect to the Anthropic Claude API +✅ Build a simple AI chatbot +✅ Add tools like reading files, editing code, and running commands +✅ Handle tool requests and errors +✅ Build an agent that gets smarter with each step + +--- + +## 🛠️ What We're Building + +You’ll build 6 versions of a coding assistant. Each version adds more features: + +1. **Basic Chat** — talk to Claude +2. **File Reader** — read code files +3. **File Explorer** — list files in folders +4. **Command Runner** — run shell commands +5. **File Editor** — modify files +6. **Code Search** — search your codebase with patterns + +You’ll end up with a powerful local developer assistant! + +--- + +## 🧱 How It Works (Architecture) + +Each agent works like this: + +1. Waits for your input +2. Sends it to Claude +3. Claude may respond directly or ask to use a tool +4. The agent runs the tool (e.g., read a file) +5. Sends the result back to Claude +6. Claude gives you the final answer + +We call this the **event loop** — it's like the agent's heartbeat. + +
+📈 Click to view a simplified diagram + +``` +User → Agent → Claude → Tools → Claude → Agent → You ``` -## 📚 Application Progression - -The workshop is structured as a progression through six applications, each building upon the previous one's capabilities: - -```mermaid -graph LR - subgraph "Application Progression" - A[chat.go
Basic Chat] --> B[read.go
+ File Reading] - B --> C[list_files.go
+ Directory Listing] - C --> D[bash_tool.go
+ Shell Commands] - D --> E[edit_tool.go
+ File Editing] - E --> F[code_search_tool.go
+ Code Search] - end - - subgraph "Tool Capabilities" - G[No Tools] --> H[read_file] - H --> I[read_file
list_files] - I --> J[read_file
list_files
bash] - J --> K[read_file
list_files
bash
edit_file] - K --> L[read_file
list_files
bash
code_search] - end - - A -.-> G - B -.-> H - C -.-> I - D -.-> J - E -.-> K - F -.-> L +
+ +--- + +## 🚀 Getting Started + +### ✅ Prerequisites + +* Go 1.24.2+ or [devenv](https://devenv.sh/) (recommended for easy setup) +* An [Anthropic API Key](https://www.anthropic.com/product/claude) + +### 🔧 Set Up Your Environment + +**Option 1: Recommended (using devenv)** + +```bash +devenv shell # Loads everything you need ``` -### 1. Basic Chat (`chat.go`) -**Purpose**: Establish the foundation - a simple chat interface with Claude +**Option 2: Manual setup** -**Features**: -- Basic conversation loop -- User input handling -- API integration with Anthropic -- Verbose logging support +```bash +# Make sure Go is installed +go mod tidy +``` -**Key Learning**: Understanding the core conversation pattern and API integration. +### 🔐 Add Your API Key + +```bash +export ANTHROPIC_API_KEY="your-api-key-here" +``` + +--- + +## 🏁 Start with the Basics + +### 1. `chat.go` — Basic Chat + +A simple chatbot that talks to Claude. -**Usage**: ```bash go run chat.go -go run chat.go --verbose # Enable detailed logging ``` -### 2. File Reading Agent (`read.go`) -**Purpose**: Add the first tool - file reading capability +➡️ Try: “Hello!” +➡️ Add `--verbose` to see detailed logs + +--- + +## 🛠️ Add Tools (One Step at a Time) -**Features**: -- Everything from `chat.go` -- `read_file` tool for reading file contents -- Tool definition and schema generation -- Tool execution and result handling +### 2. `read.go` — Read Files -**Key Learning**: How to implement and register tools, handle tool calls from Claude. +Now Claude can read files from your computer. -**Usage**: ```bash go run read.go -# Try: "Read the contents of fizzbuzz.js" ``` -### 3. File Listing Agent (`list_files.go`) -**Purpose**: Expand file system access with directory listing +➡️ Try: “Read fizzbuzz.js” + +--- -**Features**: -- Everything from `read.go` -- `list_files` tool for directory exploration -- Multiple tool registration -- File system traversal with filtering +### 3. `list_files.go` — Explore Folders -**Key Learning**: Managing multiple tools and file system operations. +Lets Claude look around your directory. -**Usage**: ```bash go run list_files.go -# Try: "List all files in this directory" -# Try: "What files are available and what's in fizzbuzz.js?" ``` -### 4. Bash Command Agent (`bash_tool.go`) -**Purpose**: Add shell command execution capabilities +➡️ Try: “List all files in this folder” +➡️ Try: “What’s in fizzbuzz.js?” -**Features**: -- Everything from `list_files.go` -- `bash` tool for executing shell commands -- Command output capture -- Error handling for failed commands +--- + +### 4. `bash_tool.go` — Run Shell Commands -**Key Learning**: Safe command execution and output handling. +Allows Claude to run safe terminal commands. -**Usage**: ```bash go run bash_tool.go -# Try: "Run git status" -# Try: "List all .go files using bash" ``` -### 5. Full File Editing Agent (`edit_tool.go`) -**Purpose**: Complete agent with file modification capabilities +➡️ Try: “Run git status” +➡️ Try: “List all .go files using bash” + +--- -**Features**: -- Everything from `bash_tool.go` -- `edit_file` tool for modifying files -- File creation and directory creation -- String replacement with uniqueness validation +### 5. `edit_tool.go` — Edit Files -**Key Learning**: File manipulation, validation, and comprehensive agent capabilities. +Claude can now **modify code**, create files, and make changes. -**Usage**: ```bash go run edit_tool.go -# Try: "Create a simple Python hello world script" -# Try: "Add a comment to the top of fizzbuzz.js" ``` -### 6. Code Search Agent (`code_search_tool.go`) -**Purpose**: Powerful code search capabilities using ripgrep +➡️ Try: “Create a Python hello world script” +➡️ Try: “Add a comment to the top of fizzbuzz.js” + +--- -**Features**: -- Everything from `list_files.go` and `bash_tool.go` -- `code_search` tool for finding code patterns -- Ripgrep integration for fast searching -- File type filtering and case sensitivity options -- Pattern matching with regex support +### 6. `code_search_tool.go` — Search Code -**Key Learning**: Code discovery, pattern matching, and search optimization. +Use pattern search (powered by [ripgrep](https://github.com/BurntSushi/ripgrep)). -**Usage**: ```bash go run code_search_tool.go -# Try: "Find all function definitions in Go files" -# Try: "Search for TODO comments in the codebase" -# Try: "Find where the Agent struct is defined" ``` -## 🛠️ Tool System Architecture - -The tool system uses a consistent pattern across all applications: - -```mermaid -classDiagram - class Agent { - +client: *anthropic.Client - +getUserMessage: func() (string, bool) - +tools: []ToolDefinition - +verbose: bool - +Run(ctx Context) error - +runInference(ctx Context, conversation []MessageParam) (*Message, error) - } - - class ToolDefinition { - +Name: string - +Description: string - +InputSchema: ToolInputSchemaParam - +Function: func(input json.RawMessage) (string, error) - } - - class ReadFileInput { - +Path: string - } - - class ListFilesInput { - +Path: string - } - - class BashInput { - +Command: string - } - - class EditFileInput { - +Path: string - +OldStr: string - +NewStr: string - } - - class CodeSearchInput { - +Pattern: string - +Path: string - +FileType: string - +CaseSensitive: bool - } - - Agent --> ToolDefinition : uses - ToolDefinition --> ReadFileInput : read_file - ToolDefinition --> ListFilesInput : list_files - ToolDefinition --> BashInput : bash - ToolDefinition --> EditFileInput : edit_file - ToolDefinition --> CodeSearchInput : code_search -``` +➡️ Try: “Find all function definitions in Go files” +➡️ Try: “Search for TODO comments” -## 🚀 Setup +--- -### Prerequisites -- [devenv](https://devenv.sh/) (recommended) or Go 1.24.2+ -- Anthropic API key +## 🧪 Sample Files (Already Included) -### Environment Setup +* `fizzbuzz.js`: for file reading and editing +* `riddle.txt`: a fun text file to explore +* `AGENT.md`: info about the project environment -1. **Using devenv (recommended)**: -```bash -devenv shell # Enters development environment with all dependencies -``` +--- -2. **Manual setup**: -```bash -# Ensure Go 1.24.2+ is installed -go mod tidy -``` +## 🐞 Troubleshooting -### API Key Configuration -```bash -export ANTHROPIC_API_KEY="your-api-key-here" -``` - -## 📖 Usage Examples +**API key not working?** -### Basic Chat -```bash -$ go run chat.go -Chat with Claude (use 'ctrl-c' to quit) -You: Hello! -Claude: Hello! How can I help you today? -``` +* Make sure it’s exported: `echo $ANTHROPIC_API_KEY` +* Check your quota on [Anthropic’s dashboard](https://www.anthropic.com) -### File Operations -```bash -$ go run edit_tool.go -Chat with Claude (use 'ctrl-c' to quit) -You: What files are in this directory? -tool: list_files({}) -result: [".devenv.flake.nix",".gitignore","AGENT.md","bash_tool.go"...] -Claude: I can see several files in this directory, including Go source files for different agent implementations... - -You: Read the riddle.txt file -tool: read_file({"path":"riddle.txt"}) -result: I have a mane but I'm not a lion... -Claude: This is a riddle! The answer is "a horse"... -``` +**Go errors?** -### Code Search Operations -```bash -$ go run code_search_tool.go -Chat with Claude (use 'ctrl-c' to quit) -You: Find all function definitions in Go files -tool: code_search({"pattern":"func ","file_type":"go"}) -result: edit_tool.go:20:func main() { -edit_tool.go:58:func NewAgent( -edit_tool.go:323:func ReadFile(input json.RawMessage) (string, error) { -Claude: I found several function definitions across the Go files... - -You: Search for TODO comments -tool: code_search({"pattern":"TODO","case_sensitive":false}) -result: No matches found -Claude: There are no TODO comments in the current codebase. -``` +* Run `go mod tidy` +* Make sure you’re using Go 1.24.2 or later -### Debugging with Verbose Mode -```bash -$ go run edit_tool.go --verbose -# Provides detailed logging of: -# - API calls and timing -# - Tool execution details -# - File operations -# - Error traces -``` +**Tool errors?** -## 🧪 Test Files +* Use `--verbose` for full error logs +* Check file paths and permissions -The repository includes sample files for testing: +**Environment issues?** -- **`fizzbuzz.js`**: A JavaScript FizzBuzz implementation for reading/editing -- **`riddle.txt`**: A simple riddle for content analysis -- **`AGENT.md`**: Development environment documentation +* Use `devenv shell` to avoid config problems -## 🔧 Development Environment +--- -This project uses [devenv](https://devenv.sh/) for reproducible development environments with: +## 💡 How Tools Work (Under the Hood) -- Go toolchain -- Node.js and TypeScript -- Python environment -- Rust toolchain -- .NET Core -- Git and common development tools +Tools are like plugins. You define: -The environment automatically sets up all dependencies and provides helpful scripts: +* **Name** (e.g., `read_file`) +* **Input Schema** (what info it needs) +* **Function** (what it does) -```bash -devenv shell # Enter development environment -devenv test # Run environment tests -hello # Custom greeting script -``` +Example tool definition in Go: -## 🎓 Workshop Flow - -### Phase 1: Understanding the Basics -1. Start with `chat.go` to understand the conversation loop -2. Examine the API integration and response handling -3. Experiment with verbose logging - -### Phase 2: Adding Tools -1. Progress to `read.go` to see tool integration -2. Understand schema generation and tool definitions -3. Practice with file reading operations - -### Phase 3: Building Complexity -1. Explore `list_files.go` for multiple tool management -2. Test directory traversal and file system operations -3. Learn about tool combination strategies - -### Phase 4: System Integration -1. Use `bash_tool.go` to see command execution -2. Understand error handling and output capture -3. Practice with system integration - -### Phase 5: Full Agent Capabilities -1. Master `edit_tool.go` for complete file operations -2. Understand validation and safety measures -3. Build complete agent workflows - -### Phase 6: Advanced Code Discovery -1. Use `code_search_tool.go` for powerful code searching -2. Learn ripgrep integration and pattern matching -3. Practice efficient code discovery and analysis - -## 🔍 Key Concepts Demonstrated - -### Event Loop Pattern -All agents use the same core event loop that: -1. Accepts user input -2. Maintains conversation history -3. Calls Claude API with tools -4. Processes tool use requests -5. Executes tools and collects results -6. Returns results to Claude for final response - -### Tool Definition Pattern ```go var ToolDefinition = ToolDefinition{ - Name: "tool_name", - Description: "What the tool does", - InputSchema: GenerateSchema[InputStruct](), - Function: ToolFunction, + Name: "read_file", + Description: "Reads the contents of a file", + InputSchema: GenerateSchema[ReadFileInput](), + Function: ReadFile, } ``` -### Schema Generation -Automatic JSON schema generation from Go structs using reflection and jsonschema tags. +Schema generation uses Go structs — so it’s easy to define and reuse. -### Error Handling -Consistent error handling across all tools with proper logging and user feedback. +--- -### Progressive Enhancement -Each application builds upon the previous one, demonstrating how to gradually add capabilities to an agent system. +## 🧭 Workshop Path: Learn by Building -## 🚦 Common Issues and Solutions +| Phase | What to Focus On | +| ----- | ------------------------------------------------ | +| **1** | `chat.go`: API integration and response handling | +| **2** | `read.go`: Tool system, schema generation | +| **3** | `list_files.go`: Multiple tools, file system | +| **4** | `bash_tool.go`: Shell execution, error capture | +| **5** | `edit_tool.go`: File editing, safety checks | +| **6** | `code_search_tool.go`: Pattern search, ripgrep | -### API Key Issues -- Ensure `ANTHROPIC_API_KEY` is set in your environment -- Check that your API key has sufficient credits +--- -### Tool Execution Errors -- Use `--verbose` flag to see detailed error logs -- Check file permissions for file operations -- Verify paths are relative to the working directory +## 🛠️ Developer Environment (Optional) -### Environment Issues -- Use `devenv shell` for consistent environment -- Run `go mod tidy` if dependencies are missing -- Check Go version compatibility (1.24.2+) +If you use [`devenv`](https://devenv.sh/), it gives you: -## 🎯 Next Steps +* Go, Node, Python, Rust, .NET +* Git and other dev tools -After completing this workshop, consider exploring: +```bash +devenv shell # Load everything +devenv test # Run checks +hello # Greeting script +``` + +--- -- Adding more specialized tools (web scraping, API calls, etc.) -- Implementing tool chaining and workflows -- Adding persistent memory and state management -- Building web interfaces for your agents -- Integrating with other AI models and services +## 🚀 What's Next? + +Once you complete the workshop, try building: + +* Custom tools (e.g., API caller, web scraper) +* Tool chains (run tools in a sequence) +* Memory features (remember things across sessions) +* A web UI for your agent +* Integration with other AI models --- -This workshop provides a solid foundation for understanding agent architecture and tool integration. Each application demonstrates key concepts that are essential for building production-ready AI agents. +## 📦 Summary + +This workshop helps you: + +* Understand agent architecture +* Learn to build smart assistants +* Grow capabilities step-by-step +* Practice using Claude and Go together + +--- + +Have fun exploring and building your own AI-powered tools! 💻✨ + +If you have questions or ideas, feel free to fork the repo, open issues, or connect with the community! From 23e6734b40e2f90c00a41f299519f03d4dcaf87b Mon Sep 17 00:00:00 2001 From: Geoffrey Huntley Date: Wed, 27 Aug 2025 19:47:06 +1000 Subject: [PATCH 2/4] Update README.md --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 4ff59aa..858972c 100644 --- a/README.md +++ b/README.md @@ -12,11 +12,11 @@ You don’t need to be an AI expert. Just follow along and build step-by-step! By the end of this workshop, you’ll understand how to: -✅ Connect to the Anthropic Claude API -✅ Build a simple AI chatbot -✅ Add tools like reading files, editing code, and running commands -✅ Handle tool requests and errors -✅ Build an agent that gets smarter with each step +- ✅ Connect to the Anthropic Claude API +- ✅ Build a simple AI chatbot +- ✅ Add tools like reading files, editing code, and running commands +- ✅ Handle tool requests and errors +- ✅ Build an agent that gets smarter with each step --- From 25be23e76bef781a9e3ba3c766866c6219e90a0c Mon Sep 17 00:00:00 2001 From: Geoffrey Huntley Date: Wed, 27 Aug 2025 19:54:32 +1000 Subject: [PATCH 3/4] Update README.md --- README.md | 105 +++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 80 insertions(+), 25 deletions(-) diff --git a/README.md b/README.md index 858972c..b429d09 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,9 @@ By the end of this workshop, you’ll understand how to: ## 🛠️ What We're Building -You’ll build 6 versions of a coding assistant. Each version adds more features: +You’ll build 6 versions of a coding assistant. + +Each version adds more features: 1. **Basic Chat** — talk to Claude 2. **File Reader** — read code files @@ -31,7 +33,35 @@ You’ll build 6 versions of a coding assistant. Each version adds more features 5. **File Editor** — modify files 6. **Code Search** — search your codebase with patterns -You’ll end up with a powerful local developer assistant! +```mermaid +graph LR + subgraph "Application Progression" + A[chat.go
Basic Chat] --> B[read.go
+ File Reading] + B --> C[list_files.go
+ Directory Listing] + C --> D[bash_tool.go
+ Shell Commands] + D --> E[edit_tool.go
+ File Editing] + E --> F[code_search_tool.go
+ Code Search] + end + + subgraph "Tool Capabilities" + G[No Tools] --> H[read_file] + H --> I[read_file
list_files] + I --> J[read_file
list_files
bash] + J --> K[read_file
list_files
bash
edit_file] + K --> L[read_file
list_files
bash
code_search] + end + + A -.-> G + B -.-> H + C -.-> I + D -.-> J + E -.-> K + F -.-> L +``` + +At the end, you’ll end up with a powerful local developer assistant! + + --- @@ -48,17 +78,42 @@ Each agent works like this: We call this the **event loop** — it's like the agent's heartbeat. -
-📈 Click to view a simplified diagram - -``` -User → Agent → Claude → Tools → Claude → Agent → You +```mermaid +graph TB + subgraph "Agent Architecture" + A[Agent] --> B[Anthropic Client] + A --> C[Tool Registry] + A --> D[getUserMessage Function] + A --> E[Verbose Logging] + end + + subgraph "Shared Event Loop" + F[Start Chat Session] --> G[Get User Input] + G --> H{Empty Input?} + H -->|Yes| G + H -->|No| I[Add to Conversation] + I --> J[runInference] + J --> K[Claude Response] + K --> L{Tool Use?} + L -->|No| M[Display Text] + L -->|Yes| N[Execute Tools] + N --> O[Collect Results] + O --> P[Send Results to Claude] + P --> J + M --> G + end + + subgraph "Tool Execution Loop" + N --> Q[Find Tool by Name] + Q --> R[Execute Tool Function] + R --> S[Capture Result/Error] + S --> T[Add to Tool Results] + T --> U{More Tools?} + U -->|Yes| Q + U -->|No| O + end ``` -
- ---- - ## 🚀 Getting Started ### ✅ Prerequisites @@ -99,8 +154,8 @@ A simple chatbot that talks to Claude. go run chat.go ``` -➡️ Try: “Hello!” -➡️ Add `--verbose` to see detailed logs +* ➡️ Try: “Hello!” +* ➡️ Add `--verbose` to see detailed logs --- @@ -114,7 +169,7 @@ Now Claude can read files from your computer. go run read.go ``` -➡️ Try: “Read fizzbuzz.js” +* ➡️ Try: “Read fizzbuzz.js” --- @@ -126,8 +181,8 @@ Lets Claude look around your directory. go run list_files.go ``` -➡️ Try: “List all files in this folder” -➡️ Try: “What’s in fizzbuzz.js?” +* ➡️ Try: “List all files in this folder” +* ➡️ Try: “What’s in fizzbuzz.js?” --- @@ -139,8 +194,8 @@ Allows Claude to run safe terminal commands. go run bash_tool.go ``` -➡️ Try: “Run git status” -➡️ Try: “List all .go files using bash” +* ➡️ Try: “Run git status” +* ➡️ Try: “List all .go files using bash” --- @@ -152,8 +207,8 @@ Claude can now **modify code**, create files, and make changes. go run edit_tool.go ``` -➡️ Try: “Create a Python hello world script” -➡️ Try: “Add a comment to the top of fizzbuzz.js” +* ➡️ Try: “Create a Python hello world script” +* ➡️ Try: “Add a comment to the top of fizzbuzz.js” --- @@ -165,16 +220,16 @@ Use pattern search (powered by [ripgrep](https://github.com/BurntSushi/ripgrep)) go run code_search_tool.go ``` -➡️ Try: “Find all function definitions in Go files” -➡️ Try: “Search for TODO comments” +* ➡️ Try: “Find all function definitions in Go files” +* ➡️ Try: “Search for TODO comments” --- ## 🧪 Sample Files (Already Included) -* `fizzbuzz.js`: for file reading and editing -* `riddle.txt`: a fun text file to explore -* `AGENT.md`: info about the project environment +1. `fizzbuzz.js`: for file reading and editing +1. `riddle.txt`: a fun text file to explore +1. `AGENT.md`: info about the project environment --- From bbf3476fe228ca923de77133147ef1a0c0303605 Mon Sep 17 00:00:00 2001 From: Geoffrey Huntley Date: Wed, 27 Aug 2025 19:54:57 +1000 Subject: [PATCH 4/4] Update workshop title for clarity --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b429d09..99f4927 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# 🧠 Build Your Own Coding Agent – Step-by-Step Workshop +# 🧠 Build Your Own Coding Agent via a Step-by-Step Workshop Welcome! 👋 This workshop will guide you through building your own **AI-powered coding assistant** — starting from a basic chatbot, and adding powerful tools like file reading, shell command execution, and code searching.