Claude Code's first month — slash commands, MCP, and the agent loop that took over

Four weeks into Claude Code’s existence, by March 31, 2025, the picture was clear: Anthropic had shipped not a feature, but a category. IndyDevDan’s March 31 video on Claude Code’s “most important feature” — custom slash commands — captured the moment when Claude Code crossed from “promising new tool” to “the workflow I’m rebuilding my engineering practice around.”

Three things made March 2025 the inflection month for Claude Code, and they shipped roughly in parallel: the slash-command template system, native Model Context Protocol (MCP) support, and the codebase-architecture patterns the early-adopter community started codifying.

What “slash commands” actually changed

A slash command in Claude Code is a saved prompt template you invoke with /my-command. Dan’s framing: you stop typing the same multi-paragraph context prompts over and over, and start composing your engineering work as a set of named operations.

His examples in the video:

• /review — runs a structured code review against the current diff, flags security, performance, and style issues
• /tdd — generates failing tests for the current feature, then implements until tests pass
• /refactor — applies a specific refactor pattern (extract method, rename, restructure) with a structured plan
• /handover — produces a handover document at the end of a session for the next session to pick up

This isn’t conceptually new — engineers have been writing prompt templates since GPT-3 days. What’s new in Claude Code: the templates are first-class, project-local, version-controllable, and compose with the agent loop. A /review command isn’t just a saved prompt — it’s an entry point into the agent’s tool-use loop, which can read files, run grep, execute tests, all within the template’s specified scope.

Dan’s argument: this is “10x compute per command” because the template loads the full context Claude needs, then the agent loop does the actual work. Without templates, you’re typing the context every time and losing it between sessions.

Why MCP suddenly mattered

Fireship’s March 31 video — “Claude’s Model Context Protocol is here… Let’s test it” — landed the same day. MCP is a protocol Anthropic published in November 2024 for connecting AI assistants to external data sources and tools. For four months it was a niche thing. By end of March 2025, it had become the canonical way to extend Claude Code’s capabilities.

The tutorial walkthroughs through March 2025 (Fireship’s, Anthropic’s own docs, and dozens of community videos) all hit the same beats:

• Build an MCP server in TypeScript (or Python)
• Define tools and resources the server exposes
• Connect Claude Code to the server via local config
• Claude can now call those tools as part of its agent loop

The unlock: anything you can wrap in an MCP server, Claude Code can use as a tool. Database queries, internal APIs, custom file operations, third-party services. The ecosystem of MCP servers exploded through April-May 2025 — but the moment when “MCP became real” was the late-March cluster of tutorials hitting at once.

The codebase architecture patterns

Dan’s March 24 video — “BEST Codebase Architecture for AI Coding and AI Agents” — codified what the early adopters had been figuring out individually: how to structure a codebase so AI agents work well in it.

The pattern, condensed:

• Clear module boundaries with explicit interfaces. Agents work best when “what this file does” is documented or self-evident.
• Small, focused files. Long files confuse the agent’s context budget. Refactor for size.
• README + ARCHITECTURE docs as agent context. The agent reads these to orient itself. Keep them current.
• Test files alongside source. The agent uses tests to verify its own work; co-located tests reduce friction.
• Explicit “agent docs” folder for cross-cutting context — patterns, conventions, anti-patterns specific to the codebase.

These aren’t new principles — clean code, modularity, tests have always been good practice. What’s new: they’re now load-bearing for the agent to work effectively. Codebases that violate these patterns can still ship, but the AI productivity gain is much smaller. The pattern shifted from “good practice” to “the agent’s runtime environment.”

Creator POV vs Reddit dissent

Dan’s POV is consistent across his March content: Claude Code is now the daily driver, the practices around it are codifying, and the engineers who learn this pattern in 2025 will have a multi-year head start.

Fireship’s POV is more product-oriented: MCP is the connecting tissue that makes Claude Code (and any other MCP-compliant client) into a platform rather than a closed product. The protocol’s openness is the strategic asset.

The Reddit dissent splits productively:

• The pro-Claude-Code “100% AI code” thread (2,303 upvotes) echoes Dan’s enthusiasm but with practical methodology: structure first, commit often, write handover docs. This is the “yes, but you have to do it right” position.
• The “context size misunderstood” thread (198 upvotes, but high-signal) — “Why ‘Context Size’ Is Misunderstood — and How Models Really Perform After 8K+ Tokens.” Counterpoint to the hype: Claude Code’s 200K context window doesn’t mean it actually uses 200K well. Performance degrades after ~8-16K tokens in practice for many tasks. The pattern of building large codebase-aware agent loops needs to respect this.

“Context size is a marketing number. What matters is where the model’s attention actually lives.” — top comment in the misunderstood-context thread

The mature take, settling through April-May 2025, was: slash commands + MCP + codebase architecture patterns work, but the model’s effective context is smaller than its advertised context, so the patterns have to be designed around that reality.

What this means for working engineers in late March 2025

Three concrete actions if you’re catching up:

1. Set up project-local slash commands for your common workflows. Even 3-4 commands (/review, /test, /handover) save substantial time over a week.

2. Try one MCP server for your dev workflow. Database, internal API, custom file ops — pick the lowest-hanging fruit and wire it up. The protocol is simple; the gain is large.

3. Audit your codebase for “agent friendliness.” Are the module boundaries clear? Are the files small enough? Is there an ARCHITECTURE doc the agent could read to orient? If no — that’s now a productivity bottleneck, not just code quality.

The honest critique

What’s still rough about Claude Code at end of March 2025:

• Reliability issues persist. File-path hallucinations, monorepo confusion, occasional agent-loop deadlocks. Improving fast but not solved.
• Cost is real for heavy use. API-priced Claude Code via Anthropic’s API for full-day usage runs into real money. Watch your spend.
• The terminal-only ergonomics aren’t for everyone. Engineers who think visually in IDE file trees may genuinely prefer Cursor’s UX even if Claude Code is more capable.
• MCP ecosystem is early. Most MCP servers in March 2025 are experiments. Production-grade servers (well-tested, well-documented, security-audited) are still rare.

For most working engineers reading this in late March 2025: the Claude Code + MCP + slash-commands stack is the new baseline you should at least try. Even if you stay on Cursor or Windsurf, understanding this stack is the leading indicator for where the entire AI-coding tooling category is heading through 2025.