Kasava
Back to Blog
Engineering

4 Claude Code Tools We Can't Live Without

Ben Gregory-Dec 2, 2025

We've been using Claude Code as our primary development tool for months now. Out of the box, it's incredibly capable--reading files, editing code, running commands, searching codebases. But it has limits. It can't browse the web. It can't control a browser. It can't remember what you were working on yesterday.

Enter MCP.

What is MCP?

MCP--Model Context Protocol--is Anthropic's open standard for connecting AI assistants to external tools and data sources. Think of it as "USB-C for AI." (Although personally I really hate that analogy; it's a standard. Any pattern or industry agreed on standard is just as applicable.)

Anthropic released MCP on November 25, 2024, and the ecosystem exploded. Block, Apollo, Zed, Replit, Codeium, and Sourcegraph were early adopters. Within weeks, dozens of MCP servers appeared for everything from databases to design tools.

After experimenting with plenty of MCP servers and Claude plugins, four tools have become absolutely essential to how we work. Here's why we can't live without them.

1. mgrep: Fast, Multi-Line Code Search That Actually Works

The Problem

You need to find something in your codebase. It could be:

  • A function definition spread across multiple lines
  • A pattern in component props
  • Where a specific API is called
  • How error handling is structured

Standard grep works for simple searches. But modern code is complex. Functions span lines. JSX nests deeply. Configuration objects wrap in ways that break single-line matching.

The Solution

mgrep is a Claude Code plugin built specifically for searching code. It's not just faster grep--it's grep that understands multi-line patterns.

# Find a function definition across multiple lines
mgrep "function.*\n.*return"

# Search specific file types
mgrep "useEffect" --type ts

# Find component patterns
mgrep "const.*=.*\n.*useState"

The key difference: mgrep natively handles patterns that span lines. No regex gymnastics. No piping through multiple commands. Just search that works the way you think.

Why It's Different

Most search tools treat code as text. mgrep treats code as code:

  • Multi-line aware: Patterns that span lines just work
  • Type filtering: Built-in support for languages (ts, js, py, etc.)
  • Fast: Optimized for large codebases
  • Claude-native: Designed specifically for AI agent workflows

The Economics

The mixedbread team (creators of mgrep) ran a 50-task benchmark comparing vanilla Claude Code (using grep) against Claude Code with mgrep. The results were striking:

Cost savings: $0.23 per task vs $0.49 (53% reduction)
Time savings: 82 seconds avg vs 158 seconds (48% faster)
Quality improvement: 76% win rate vs 24% (using LLM-as-judge evaluation)

The key insight: mgrep finds the relevant code snippets in a few semantic queries, so Claude spends its token budget on reasoning instead of scanning through irrelevant results from endless grep attempts. The model gets straight to the answer instead of iterating through partial matches.

At 2x fewer tokens per task, mgrep doesn't just make Claude faster--it makes it cheaper and more accurate. You can try the benchmark yourself.

The Setup

claude plugin install mgrep

That's it. One command. Works immediately.

Why It's Essential

Claude needs to understand your codebase to be useful. Search is how it builds that understanding. mgrep works fast and more accurately than grep. When those results are tokens, accurate results matter.

2. Firecrawl: Web Research Without Leaving Your Terminal

The Problem

Modern development constantly requires looking things up:

  • How does this API work?
  • What's the latest syntax for X?
  • What are other teams doing to solve Y?

Before Firecrawl, this meant context-switching to a browser, searching, reading, copying relevant info back. Every lookup broke flow. And here's the thing--Claude's training data has a cutoff. The documentation you need might have been updated last week.

The Solution

Firecrawl gives Claude the ability to search the web and scrape content directly. No browser. No copy-paste. Just answers.

Me: "What's the current best practice for handling rate limiting in Cloudflare Workers?"

Claude: *searches web, reads multiple sources, synthesizes answer*
"Based on the latest Cloudflare documentation and community patterns, here's the recommended approach..."

The magic isn't just search. Firecrawl can crawl entire sites, extract structured data, and even map a website's URL structure. With 5,000+ GitHub stars and backing from serious infrastructure, it's become the de facto standard for AI web access.

How We Use It

Documentation lookup: When working with unfamiliar APIs, Claude can pull fresh documentation instead of relying on training data that might be outdated.

Competitor research: "How does [competitor] handle their onboarding flow?" Claude can actually go look.

Debugging obscure errors: That Stack Overflow answer from last month? Claude finds it and applies it to our context.

Best practices research: Before implementing a feature, we have Claude research current approaches across multiple sources.

The Setup

// .mcp.json
{
  "mcpServers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "your-api-key"
      }
    }
  }
}

Why It's Essential

Before Firecrawl, Claude's knowledge had a cutoff date. Now it has the entire internet. One user benchmarked it at 50x faster than alternatives. The difference is transformative--especially for fast-moving ecosystems where documentation changes weekly.

3. Beads: Issue Tracking That Lives With Your Code

The Problem

Here's a dirty secret about AI coding agents: they have amnesia. Every session starts fresh. Claude doesn't remember what you worked on yesterday, what's blocked, or where you left off.

We tried everything. Markdown TODO files. GitHub issues. They all had the same problem: they lived outside the code, required manual updating, and Claude couldn't really manage them.

Steve Yegge nailed the problem in his blog post introducing Beads:

"Agents have no memory between sessions. Markdown plans become 'write-only memory' -- agents forget where they are. Work gets lost when agents run out of context."

The Solution

Beads is a git-native issue tracker designed specifically for AI agents. Issues are stored as JSONL in your repo, synced via git, and managed through simple CLI commands.

bd create --title="Add rate limiting to API" --type=feature
bd update kasava-abc --status=in_progress
bd close kasava-abc --reason="Implemented in commit abc123"

The key insight: if issues live in git, they travel with the code. They're versioned. They're distributed. And Claude can read and update them directly.

How We Use It

Session management: At the start of every Claude session, we run bd ready to see what's available to work on. Claude picks up context automatically.

Me: "What should we work on today?"

Claude: *runs bd ready*
"I see 10 issues ready. The top priority is kasava-abc: 'Add rate limiting to API'.
Let me start on that."

*updates issue to in_progress*
*implements feature*
*runs bd close kasava-abc*
*commits everything together*

Dependency tracking: Beads supports four types of dependencies--blocks, related, parent-child, and discovered-from. When one issue depends on another, bd ready won't show it until the blocker is resolved.

Progress tracking: As Claude works, it updates issue status. No manual ticket management.

Atomic commits: Issues close in the same commit as the implementation. Perfect traceability.

The Technical Bits

What makes Beads work for multi-agent workflows:

  • Hash-based IDs: Collision-resistant identifiers that work across machines and branches
  • SQLite cache locally + JSONL in git: Fast local queries, distributed via git
  • No server required: Everything syncs through normal git operations
  • AI-assisted merge conflict resolution: Yes, really

With 3,900 GitHub stars since launching in October 2024, Beads has found its audience. The creator put it well: "After using Beads, going back to markdown TODOs feels like trying to remember a phone number without writing it down."

Why It's Essential

Issue tracking becomes invisible. Claude manages it as part of normal development. No context switching to a web UI. No forgetting to update tickets. Issues and code stay synchronized by design.

The best tools disappear into your workflow. You stop thinking about them. That's Beads.

4. Playwright: Browser Automation for Testing and Research

The Problem

Some things require a real browser:

  • Testing our UI changes
  • Capturing screenshots for documentation
  • Interacting with web apps that require authentication
  • Debugging frontend issues

Before Playwright MCP, this meant manual testing or writing separate automation scripts. And those scripts never quite matched what we actually needed in the moment.

The Solution

Playwright MCP gives Claude direct control of a browser. Navigate, click, fill forms, take screenshots, extract content--all from the conversation.

Me: "Test the login flow"

Claude: *opens browser*
*fills in test credentials*
*clicks login*
*takes screenshot*
"Login successful. Here's what the dashboard looks like after authentication."

This isn't just Playwright with a chat wrapper. Microsoft built this specifically for AI agents. With 23,800 GitHub stars, it's one of the most popular MCP servers out there.

How It's Different

Traditional Playwright requires you to write code. Playwright MCP provides 40+ pre-built tools optimized for AI:

  • Accessibility tree, not screenshots: The AI uses structured accessibility snapshots instead of pixel-based input. Faster and more reliable.
  • No vision models needed: Everything is text-based, which means lower latency and better accuracy.
  • Deterministic tool application: No ambiguity about what "click the blue button" means.

How We Use It

Visual regression testing: After UI changes, Claude can navigate the app and capture screenshots for review.

End-to-end testing: Automate user flows to verify features work correctly.

Design review: We have a custom /design-review command that uses Playwright to navigate our staging site and compare against design specs.

The Setup

// .mcp.json
{
  "mcpServers": {
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest"]
    }
  }
}

That's it. One line to install, works with Chromium, Firefox, and WebKit, supports headed and headless modes.

Why It's Essential

Development doesn't happen in a vacuum. We build web apps, and testing web apps requires a browser. Playwright MCP means Claude can verify its own work, catch visual bugs, and interact with the full application--not just the code.

The Compound Effect

Each tool is powerful alone. Together, they're transformative.

Example: Implementing a New Feature

1. bd ready                         → Claude sees "Add Stripe webhook handler" is top priority
2. bd update kasava-xyz --status=in_progress → Claims the work
3. mgrep "webhook" --type ts        → Find existing webhook patterns
4. Firecrawl searches Stripe's latest webhook documentation for best practices
5. Claude implements the webhook handler
6. Playwright tests the UI components on staging
7. bd close kasava-xyz              → Marks complete
8. Commit includes code + issue closure

No browser tabs. No manual searches for existing code. No manual ticket updates. No separate testing phase. Just continuous development.

The Bottom Line

Claude Code is powerful out of the box. But the right tools turn it from a code assistant into an autonomous development partner.

mgrep gives it code search that actually works. Firecrawl gives it the internet. Beads gives it memory. Playwright gives it eyes.

The real magic isn't in having AI write code--it's in having AI that can search, research, plan, implement, test, and track its own work. These four tools make that possible.

Start with one. See how it changes your workflow. Then add another. Before long, you'll wonder how you ever worked without them.

Building something similar? Want to compare notes? Find me on LinkedIn. Always happy to talk shop about AI-assisted development, MCP integrations, or why despite all this cutting-edge tech, I still can't figure out why my CSS isn't centering that div.