New Dev Tools tab

Author: ofriw

scripts/output/podcasts/manifest.json

@@ -31,9 +31,9 @@
   },
   "practical-techniques/lesson-7-planning-execution.md": {
     "scriptPath": "practical-techniques/lesson-7-planning-execution.md",
-    "size": 19597,
-    "tokenCount": 4821,
-    "generatedAt": "2025-11-10T08:26:48.551Z"
+    "size": 11291,
+    "tokenCount": 2745,
+    "generatedAt": "2025-12-07T19:20:22.116Z"
   },
   "practical-techniques/lesson-8-tests-as-guardrails.md": {
     "scriptPath": "practical-techniques/lesson-8-tests-as-guardrails.md",

scripts/output/podcasts/practical-techniques/lesson-7-planning-execution.md

@@ -0,0 +1,203 @@
+---
+title: Modern CLI Tools
+sidebar_position: 3
+---
+
+# Modern CLI Tools for Multi-Agent Workflows
+
+Managing parallel agent sessions, rapid context switching across worktrees, and quick file edits without breaking flow—modern CLI tools eliminate friction that accumulates across dozens of daily operations. These tools complement agent workflows with better defaults, richer information, and ergonomic interfaces.
+
+**Four categories:** Text editing (micro), file navigation (eza, yazi, fzf), and git operations (lazygit) address the most frequent CLI tasks in multi-agent development workflows.
+
+## Text Editing
+
+### micro
+
+[**micro**](https://micro-editor.github.io/) is a Go-based terminal text editor that brings GUI-like keybindings to the command line. Single binary, no dependencies, cross-platform support.
+
+**Key differentiators:** Ctrl+S to save, Ctrl+Q to quit, Ctrl+F to find—no modal editing or memorization required. Syntax highlighting for 130+ languages out of box. Multi-cursor support (Sublime-style) for parallel editing. Lua plugin system for extensibility. Integrated terminal and mouse support for hybrid keyboard/mouse workflows.
+
+**Best suited for:** Developers needing quick edits in agent context without switching to IDE. Engineers who find Vim's modal editing overhead for one-line changes. Users wanting terminal editing with familiar modern editor keybindings (coming from VSCode, Sublime, or similar GUI editors).
+
+**Trade-offs:** Feature-minimal compared to IDEs—no LSP integration, limited refactoring tools, basic navigation. Not as powerful as Vim/Neovim for complex multi-file operations or advanced text object manipulation. For large files (1000+ lines) or deep code exploration, IDE remains superior tool choice.
+
+**vs Vim:** No modal editing learning curve enables instant productivity. Trade: less powerful for macro operations and text object manipulation at scale.
+
+**vs Nano:** More sophisticated feature set—multi-cursor editing, plugin ecosystem, better syntax highlighting for code. Better suited for actual development work rather than simple config edits.
+
+**Installation:**
+
+```bash
+# macOS
+brew install micro
+
+# Linux (binary)
+curl https://getmic.ro | bash
+
+# Cross-platform (Go)
+go install github.com/zyedidia/micro/cmd/micro@latest
+```
+
+Requirements: None (static binary). Optional: clipboard support via xclip/xsel on Linux.
+
+## File Navigation
+
+### eza
+
+[**eza**](https://eza.rocks/) is a Rust-based ls replacement, actively maintained fork of the unmaintained exa project. Fast, feature-rich, with better defaults than traditional ls.
+
+**Key differentiators:** Colors for file types and permissions by default. Git integration shows per-file status (`--git`) or per-directory repository state (`--git-repos`). Human-readable file sizes in long format without flags. Tree view (`--tree`), icons support (`--icons`), and hyperlink support for terminal emulators. Fixes Grid Bug from exa that caused rendering issues.
+
+**Best suited for:** Developers working across git worktrees who need instant branch status visibility. Engineers wanting better ls defaults without heavy configuration overhead. Users comfortable with modern Rust tooling ecosystem and willing to install additional dependencies.
+
+**Trade-offs:** More dependencies than ls (Rust binary, optional Nerd Fonts for icons). Some features need configuration (icon support requires compatible fonts). Slightly longer learning curve for advanced options, though defaults work well immediately.
+
+**vs ls:** Colors, git status visibility, human-readable sizes by default. Better information density without memorizing flags.
+
+**vs exa:** Actively maintained (exa development stopped), security patches, bug fixes (Grid Bug), feature parity plus hyperlinks and bright color support.
+
+**Installation:**
+
+```bash
+# macOS
+brew install eza
+
+# Cargo (Rust)
+cargo install eza
+
+# Linux package managers
+sudo apt install eza      # Debian/Ubuntu
+sudo pacman -S eza        # Arch
+```
+
+Requirements: None (static binary). Optional: Nerd Fonts for icon support (`--icons`).
+
+### yazi
+
+[**yazi**](https://yazi-rs.github.io/) is a Rust-based terminal file manager with full asynchronous I/O and multi-threaded CPU task distribution. Currently in public beta, suitable as daily driver.
+
+**Key differentiators:** Full asynchronous architecture keeps UI responsive during heavy operations (large directories, remote filesystems). Rich preview support for images (Kitty, Sixel, iTerm2, WezTerm protocols), videos, PDFs, archives, and code with syntax highlighting via built-in integration. Lua-based plugin system with package manager for extensibility. Vim-like keybindings with visual mode, multi-tab support, and auto-completion. Client-server architecture with pub-sub model enables cross-instance communication. Integrates with ripgrep, fd, fzf, and zoxide for enhanced workflows.
+
+**Best suited for:** Developers navigating complex directory structures who need rich file previews without leaving terminal. Engineers working with remote filesystems where responsiveness matters (async I/O prevents UI freezing). Users wanting Vim-like file management with extensive customization (Lua plugins, themes, custom previewers).
+
+**Trade-offs:** Currently in public beta—stable enough for daily use but evolving rapidly. More complex than simpler tools like nnn (which is tiny, nearly 0-config). Learning curve for Vim keybindings if coming from traditional file managers. Lacks "undo" feature that Vifm provides.
+
+**vs Ranger:** Significantly faster (Rust vs Python architecture). Asynchronous I/O prevents UI freezing on heavy operations.
+
+**vs lf:** Both fast and async-capable (lf written in Go). Yazi offers richer built-in preview support and plugin ecosystem.
+
+**vs nnn:** nnn is smaller, faster to start, nearly 0-config. Yazi trades simplicity for rich features (previews, plugins, advanced async task management).
+
+**Installation:**
+
+```bash
+# macOS
+brew install yazi
+
+# Cargo (Rust)
+cargo install --locked yazi-fm yazi-cli
+
+# Linux package managers
+sudo pacman -S yazi       # Arch
+```
+
+Requirements: None (static binary). Optional: Überzug++ or similar for advanced image preview, ffmpegthumbnailer for video thumbnails, fd/ripgrep/fzf/zoxide for enhanced integration.
+
+### fzf
+
+[**fzf**](https://junegunn.github.io/fzf/) is a Go-based fuzzy finder that processes millions of items instantly. Single binary, 11+ years mature (since 2013), widely adopted as the standard fuzzy CLI tool.
+
+**Key differentiators:** Shell integration provides Ctrl+R (history search), Ctrl+T (file search), Alt+C (directory navigation), and `**<TAB>` (fuzzy completion for any command). Vim/Neovim integration via fzf.vim and fzf-lua plugins. Tmux integration via fzf-tmux wrapper for popup windows. Preview window support shows file contents or git diffs during selection. Highly customizable via environment variables (FZF_DEFAULT_OPTS, FZF_DEFAULT_COMMAND). Pipe-friendly architecture works with any command output.
+
+**Best suited for:** Developers navigating large codebases who need instant file/symbol location without IDE context switches. Engineers with heavy shell usage for command history search and script selection. Users wanting fuzzy selection everywhere—git branches, docker containers, kubernetes pods, process lists.
+
+**Trade-offs:** Requires shell setup script for full power (Ctrl+R, Ctrl+T, `**<TAB>` bindings). Learning curve for advanced customization (environment variables, preview commands, custom key bindings). Power comes from integration with other tools—standalone usage provides limited value.
+
+**vs traditional find/grep:** Interactive visual feedback with instant results. Fuzzy matching reduces need for exact pattern specification.
+
+**Installation:**
+
+```bash
+# macOS
+brew install fzf
+$(brew --prefix)/opt/fzf/install  # Shell integration
+
+# Git clone
+git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
+~/.fzf/install
+
+# Linux package managers
+sudo apt install fzf      # Debian/Ubuntu
+sudo pacman -S fzf        # Arch
+```
+
+Requirements: None (static binary). Shell integration script essential for full functionality.
+
+:::tip fzf Shell Integration
+Full fzf power requires shell integration. After installation, run:
+
+```bash
+$(brew --prefix)/opt/fzf/install  # macOS Homebrew
+~/.fzf/install                     # Git installation
+```
+
+Enables: Ctrl+R (history), Ctrl+T (files), Alt+C (cd), `**<TAB>` (completion)
+:::
+
+## Git Operations
+
+### lazygit
+
+[**lazygit**](https://github.com/jesseduffield/lazygit) is a Go-based Git TUI (terminal user interface) for visual branch management, interactive staging, and commit navigation. Cross-platform with extensive customization options.
+
+**Key differentiators:** Visual branch tree shows repository topology without command memorization. Interactive staging supports hunk selection and individual line staging. Commit navigation browses history with inline diffs. Customizable keybindings via YAML config. Mouse support for clicking to select, scrolling through commits. Multi-worktree awareness for parallel branch development.
+
+**Best suited for:** Developers managing multi-worktree workflows who need visual branch context. Engineers doing complex interactive rebases, cherry-picks, and merges. Users wanting git discoverability via menu-driven interface instead of command memorization.
+
+**Trade-offs:** Performance degrades on massive repositories (Linux kernel: 57s load time, 2.6GB RAM usage). Not a replacement for all git commands—some operations faster via raw CLI. Learning curve for keybindings, though discoverable via built-in help menu.
+
+**vs raw git:** Visual interface reduces command memorization burden. Complex operations (rebase, cherry-pick) easier with interactive UI.
+
+**vs gitui:** More mature ecosystem (plugins, community integrations) but slower on massive repos. gitui benchmarks: 24s load time, 0.17GB RAM on Linux kernel.
+
+**vs tig:** Significantly faster (57s vs 4m20s on Linux kernel). More interactive—tig focuses on browsing, lazygit enables full git workflows.
+
+**Installation:**
+
+```bash
+# macOS
+brew install lazygit
+
+# Go
+go install github.com/jesseduffield/lazygit@latest
+
+# Windows
+scoop install lazygit
+
+# Linux package managers
+sudo apt install lazygit     # Debian/Ubuntu
+sudo pacman -S lazygit       # Arch
+```
+
+Requirements: git. Optional: custom config in `~/.config/lazygit/config.yml`.
+
+## Philosophy: Mix CLI and UI Tools
+
+Don't be dogmatic about terminal-only or GUI-only workflows. IDEs remain the best tools for code navigation, symbol search, and viewing large files. CLI excels at quick edits, git operations, and managing parallel sessions.
+
+**Use the best tool for each task:**
+
+- **Code navigation and exploration:** IDE (VS Code, IntelliJ, etc.) - superior symbol search, go-to-definition, call hierarchies
+- **Quick edits in agent context:** CLI (micro, vim) - faster than switching to IDE for one-line changes
+- **Git operations across worktrees:** CLI (lazygit, raw git commands) - better visibility into multiple branches
+- **Reading large files or complex logic:** IDE - better syntax highlighting, folding, and navigation
+
+Pragmatism beats purism. These are all just tools—choose based on efficiency, not ideology.
+
+---
+
+**Related Course Content:**
+
+- [Lesson 7: Planning & Execution](/docs/practical-techniques/lesson-7-planning-execution) - Multi-worktree workflows leveraging these CLI tools
+- [Developer Tools: Terminals](/developer-tools/terminals) - Terminal recommendations for running these CLI tools efficiently
+- [Developer Tools: MCP Servers](/developer-tools/mcp-servers) - Extend CLI agents with code research and web grounding

website/developer-tools/cli-tools.md

@@ -0,0 +1,153 @@
+---
+title: MCP Servers
+sidebar_position: 4
+---
+
+# MCP Servers
+
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) extends CLI agents with specialized capabilities—code research, web grounding, browser automation. While IDE-based assistants (Cursor, Windsurf) often include these features built-in, CLI agents (Claude Code, Copilot CLI, Aider) rely on MCP servers to add functionality beyond basic file operations.
+
+These three MCP servers address the critical gaps in AI-assisted development workflows.
+
+## Code Research
+
+### ChunkHound
+
+[ChunkHound](https://chunkhound.github.io) provides semantic code search and structured sub-agent research for large codebases.
+
+**What it does:**
+
+- Multi-hop semantic search through code relationships
+- Hybrid semantic + symbol search (conceptual discovery, then exhaustive regex)
+- Map-reduce synthesis with architectural relationships and `file:line` citations
+
+**When to use it:**
+
+- **10,000-100,000 LOC:** Valuable when repeatedly connecting components across the codebase
+- **100,000+ LOC:** Highly valuable as autonomous agents show incomplete findings
+- **1,000,000+ LOC:** Essential—only approach with progressive aggregation at extreme scale
+
+**Key trade-off:** Higher token cost (1-2x) vs autonomous search, but maintains first-iteration accuracy through context isolation.
+
+**Installation:**
+
+```bash
+uv tool install chunkhound
+```
+
+Requires Python 3.10+ and the uv package manager. See [ChunkHound on GitHub](https://github.com/chunkhound/chunkhound) for API key configuration and setup details.
+
+**Learn more:** [Lesson 5: Grounding](/docs/methodology/lesson-5-grounding#deep-dive-chunkhound-architecture) covers ChunkHound's architecture, pipeline design, and scale guidance in detail.
+
+## Web Research
+
+### ArguSeek
+
+[ArguSeek](https://github.com/ArguSeek/arguseek) is a web research sub-agent with isolated context and semantic state management.
+
+**What it does:**
+
+- Google Search API (quality vs Bing/proprietary alternatives)
+- Query decomposition—3 concurrent variations per query (docs + community + security advisories)
+- Semantic subtraction—follow-up queries skip covered content and advance research
+- Bias detection—flags vendor marketing, triggers counter-research
+
+**When to use it:**
+
+- Researching best practices and competing approaches
+- Finding security advisories and CVEs
+- Learning new technologies with current (post-training) information
+- Multi-source research (processes 12-30 sources per call, scales to 100+ sources per task)
+
+**Key advantage:** Maintains state across queries—builds on previous research instead of re-explaining basics, keeping your orchestrator context clean.
+
+**Installation:**
+
+```bash
+brew install arguseek
+```
+
+Requires Go 1.23+ and Google API credentials. See [ArguSeek on GitHub](https://github.com/ArguSeek/arguseek) for detailed setup instructions and configuration options.
+
+**Learn more:** [Lesson 5: Grounding](/docs/methodology/lesson-5-grounding#deep-dive-arguseek-architecture) explains ArguSeek's architecture, semantic subtraction, and research patterns.
+
+## Browser Automation
+
+Two major options for browser automation—both provide comprehensive tooling, differ in maturity and optimization approach.
+
+### Playwright MCP
+
+[Playwright MCP](https://github.com/microsoft/playwright-mcp) is the official browser automation server from Microsoft, built on the Playwright testing framework. Most popular MCP server on GitHub for browser automation.
+
+**What it does:**
+
+- Accessibility tree approach (not screenshots)—LLM-friendly structured data from the DOM
+- Full browser automation via Playwright—navigate, click, type, extract data
+- Automated testing and exploration—generate tests, reproduce bugs, validate UX from natural language
+- Self-verifying workflows—agents modify code, launch browser, interact with UI, confirm expected behavior
+
+**When to use it:**
+
+- Mature ecosystem preference—established Playwright foundation with broad community support
+- Testing-focused workflows—leverages Playwright's end-to-end testing patterns
+- Accessibility-first automation—semantic DOM structure over visual parsing
+
+**Key advantage:** High popularity and mature testing ecosystem. Accessibility tree provides clean, structured text that LLMs interpret reliably without visual processing overhead.
+
+**Installation:**
+
+```bash
+npx @playwright/mcp@latest
+```
+
+Requires Node.js 18+. See [Playwright MCP on GitHub](https://github.com/microsoft/playwright-mcp) for MCP client configuration.
+
+### Chrome DevTools MCP
+
+[Chrome DevTools MCP](https://github.com/ChromeDevTools/chrome-devtools-mcp) is the official browser automation server from the Google Chrome team, purpose-built for MCP workflows with context optimization.
+
+**What it does:** (26+ professional tools)
+
+- Performance analysis—run traces, extract LCP, blocking time, actionable metrics
+- Advanced debugging—analyze network requests (CORS, failed loads), inspect console logs, take DOM snapshots
+- Reliable automation—simulate user interactions (click, type, navigate) via Puppeteer
+- Emulation—CPU throttling, network speed, viewport size for testing under constraints
+
+**When to use it:**
+
+- Performance-focused workflows—deep Chrome DevTools integration for profiling and optimization
+- Context-optimized preference—newer tool designed specifically for MCP agent use cases
+- Chrome-specific features—leverage proprietary DevTools Protocol capabilities
+
+**Key capability:** Closes the "write code → run → verify" loop—agents test their changes in the browser and iterate based on actual behavior.
+
+**Installation:**
+
+```bash
+npx chrome-devtools-mcp@latest
+```
+
+See [Chrome DevTools MCP on GitHub](https://github.com/ChromeDevTools/chrome-devtools-mcp) for MCP client configuration.
+
+### Choosing Between Them
+
+**Playwright MCP:** More popular with broader GitHub community, mature testing ecosystem, established Playwright foundation. Best for standard testing workflows and accessibility-first automation.
+
+**Chrome DevTools MCP:** Newer and purpose-built for MCP, context-optimized by the Chrome team, performance analysis focus. Best for Chrome-specific debugging and profiling workflows.
+
+Both provide comprehensive browser automation with similar scope (~26 tools). The choice depends on ecosystem preference and whether you prioritize maturity (Playwright) or MCP-specific optimization (CDP).
+
+:::tip Run Browser Automation in Sub-Agents
+Browser automation generates high token volumes—DOM snapshots (5,000-15,000 tokens), screenshots (3,000-8,000 tokens), network traces (2,000-10,000 tokens). Multiple operations quickly fill your context window.
+
+**Best practice:** Delegate browser tasks to sub-agents. The sub-agent processes DOM data and screenshots in its isolated context, then returns a concise synthesis: "Button at selector `.submit-btn` clicked, form submitted successfully, redirected to `/dashboard`" (50 tokens instead of 15,000-token DOM dump).
+
+See [Lesson 5: Sub-Agents for Context Isolation](/docs/methodology/lesson-5-grounding#solution-2-sub-agents-for-context-isolation) for architecture details.
+:::
+
+---
+
+**Related Course Content:**
+
+- [Lesson 5: Grounding](/docs/methodology/lesson-5-grounding) - Detailed architecture and use cases for ChunkHound and ArguSeek
+- [Lesson 7: Planning & Execution](/docs/practical-techniques/lesson-7-planning-execution) - Multi-agent workflows that leverage MCP capabilities