making-claude-code-more-agentic - AIXplore

# Making Claude Code More Agentic If you've been following the AI coding assistant space, you've probably noticed an interesting development: Anthropic recently started blocking third-party tools from using Claude Code subscriptions. Tools like OpenCode that were routing through Claude Code authentication now need to use direct API access. The timing is notable. OpenCode had built something genuinely useful: a multi-agent orchestration system where you could assign different models to different tasks, run operations in parallel, and get work done faster. Now that door is closing. But here's what I realized: Claude Code itself has all the capabilities we need. It just doesn't use them aggressively by default. This week I spent time configuring Claude Code to behave more like what I'd gotten used to with OpenCode's oh-my-opencode configuration layer. The results have been excellent. Let me show you how to do the same. --- ## The Problem: Claude Code is Conservative by Default Out of the box, Claude Code tends to work sequentially. Ask it to explore a codebase and then implement a feature, and it will: 1. Explore files one by one 2. Wait for each operation to complete 3. Then start the implementation This is safe but slow. If you've used OpenCode with oh-my-opencode, you know the alternative: launch multiple specialized agents in parallel, have them report back, then synthesize results. Claude Code can do this. It has a Task tool that spawns subagents. It has model selection (haiku, sonnet, opus). It just needs permission and guidance. --- ## The Solution: CLAUDE.md Configuration Claude Code reads a special file called `CLAUDE.md` (or `AGENTS.md`) from your home directory and project directories. This is where you tell it how to behave. Here's the key insight: **you can explicitly tell Claude Code to maximize parallelism and delegate proactively**. ### Step 1: Create Your Global CLAUDE.md Create `~/.claude/CLAUDE.md` with explicit agentic instructions: ```markdown # CLAUDE.md (Global) ## Agentic Execution **MAXIMIZE PARALLELISM** - This is the top priority. **Parallel by Default:** - ALWAYS launch multiple Task tool calls in single message when independent - NEVER wait for one agent to finish before starting another independent one - Default to parallelism for: file searches, research, analysis, reviews - Max 10 concurrent agents; Claude auto-queues excess in batches **Delegation (Proactive):** - Delegate exploration BEFORE making changes - Delegate code review AFTER changes (can parallel with tests) - Delegate debugging when errors occur - Don't wait to be asked - delegate when efficient **Model Routing:** - haiku: Fast ops - routing, lookups, file discovery - sonnet: Core work - implementation, review, testing - opus: Deep thinking - planning, architecture, synthesis ``` The key is being explicit. Claude Code reads these instructions and follows them. If you say "ALWAYS launch multiple Task tool calls," it will. --- ## Step 2: Create Specialized Agents Claude Code supports custom agents in `~/.claude/agents/`. Each agent is a markdown file with YAML frontmatter specifying the model, tools, and system prompt. Here's the pattern that works well, borrowed from oh-my-opencode's model-per-agent approach: ### Speed Tier Agents (haiku) Fast, cheap operations that don't need deep reasoning: ```markdown --- name: parallel-explorer description: Fast parallel file discovery and codebase scanning. tools: Read, Grep, Glob model: haiku --- You are a fast codebase explorer optimized for parallel discovery. Launch multiple search operations simultaneously. Return file lists with brief relevance notes. Never modify files. Speed over depth. ``` ```markdown --- name: quick-router description: Fast task classifier. Routes complex tasks to specialists. tools: Read, Grep, Glob model: haiku --- You are a fast, low-latency assistant. Classify requests by complexity. Route complex tasks to specialized agents. Handle trivial tasks directly. ``` ### Implementation Tier Agents (sonnet) The workhorses for actual coding and content: ```markdown --- name: batch-editor description: Multi-file search-and-replace specialist. tools: Read, Write, Edit, Bash, Grep, Glob model: sonnet --- You are a batch editing specialist for large-scale codebase modifications. Prefer: rg for search, sd for replace, ast-grep for structural edits. Always dry-run first. Show diff preview before bulk apply. ``` ```markdown --- name: incident-responder description: Rapid incident diagnosis and remediation. tools: Read, Write, Edit, Bash, Grep model: sonnet --- You are an incident response specialist. Triage immediately: check processes, logs, ports. Contain first, diagnose second. Document root cause and prevention. ``` ### Reasoning Tier Agents (opus) Reserve expensive opus calls for tasks that genuinely need extended thinking: ```markdown --- name: solution-planner description: High-level planning for complex multi-step tasks. tools: Read, Grep, Glob model: opus --- You are a principal engineer and system architect. Turn vague goals into concrete, staged plans. Produce plans that other agents can execute. Always identify what can run in parallel. Planning only - do not implement. ``` ```markdown --- name: research-synthesizer description: Deep research across multiple sources. tools: Read, Write, Grep, Glob, WebSearch, WebFetch model: opus --- You are a research analyst. Cross-reference sources for consensus vs. outlier views. Always cite sources. Distinguish fact from opinion. Synthesize into actionable insights. ``` --- ## Step 3: Install Fast Tools Claude Code works better when it has fast utilities available. Install these: ```bash # Fast search (Claude Code already uses ripgrep internally) brew install ripgrep fd-find # Safer sed alternative brew install sd # Structural code search/replace brew install ast-grep # Parallel execution brew install parallel ``` Then reference them in your CLAUDE.md: ```markdown ## Fast Tools Prefer these over standard tools: - `rg` over grep (faster, smarter ignores) - `fd` over find (faster, friendlier) - `sd` over sed (safer in-place edits) - `ast-grep` for structural code search/replace - `parallel` for concurrent bash operations ``` --- ## The Results: Before and After ### Before (Default Claude Code Behavior) Ask Claude Code to add a new feature. Watch it: 1. Read file A 2. Wait... 3. Read file B 4. Wait... 5. Search for patterns 6. Wait... 7. Start implementing ### After (Configured for Parallelism) Same request. Watch it: 1. Launch parallel-explorer to map the codebase 2. Launch search-specialist for relevant patterns 3. Launch solution-planner to design approach 4. All three run simultaneously 5. Synthesize results 6. Implement with full context The difference is substantial. Complex tasks that took 10+ back-and-forth exchanges now resolve in 3-4. --- ## What I Actually Tell Claude Code Here's the prompt pattern that triggers the right behavior: ``` For this task, work in parallel where operations are independent: 1. Start with exploration - map relevant files 2. Research any patterns or approaches needed 3. Plan the implementation 4. Execute Delegate to specialized agents. Run independent operations concurrently. Report when you launch parallel tasks. ``` You don't need this every time if your CLAUDE.md is configured well. But it helps for complex tasks. --- ## The Agent Roster I Use After configuration, I have 32 agents organized by model tier: **Haiku (6 agents)** - Fast operations - quick-router, parallel-explorer, search-specialist - morning-briefer, homelab-monitor, cost-guardian **Sonnet (20 agents)** - Implementation - code-reviewer, debugger, test-engineer, batch-editor - incident-responder, communications-specialist, document-generator - Plus language-specific: python-pro, typescript-pro, etc. **Opus (6 agents)** - Deep reasoning - solution-planner, architect-reviewer, research-synthesizer - task-decomposition-expert, weekly-reviewer, database-architect This mirrors the oh-my-opencode pattern of assigning models to tasks based on complexity, not treating every request as needing the most powerful model. --- ## Adapting Oh-My-OpenCode Patterns For those familiar with oh-my-opencode, here's how the patterns translate: | oh-my-opencode | Claude Code Equivalent | |----------------|----------------------| | `agents` config in JSON | `~/.claude/agents/*.md` files | | `model` per agent | YAML frontmatter `model: haiku/sonnet/opus` | | `background_task` concurrency | Task tool with `run_in_background: true` | | `categories` for delegation | Agent descriptions with "Use for:" hints | | Custom commands | `~/.claude/commands/*.md` | The underlying capabilities are similar. The configuration format differs. --- ## Key Takeaways 1. **Claude Code can be highly agentic** - it just needs explicit permission in CLAUDE.md 2. **Model routing matters** - use haiku for speed, sonnet for work, opus for thinking 3. **Parallelism is opt-in** - say "MAXIMIZE PARALLELISM" and Claude Code will 4. **Custom agents are easy** - markdown files with YAML frontmatter in `~/.claude/agents/` 5. **The pattern works** - borrowed from oh-my-opencode, validated in Claude Code The irony of Anthropic blocking third-party tools is that their own tool has these capabilities built in. It just requires configuration. If you've been missing the multi-agent workflows from OpenCode, you can get most of that experience in Claude Code itself. It takes about an hour to set up, and the productivity gains are immediate. --- ## Getting Started 1. Create `~/.claude/CLAUDE.md` with parallelism instructions 2. Create `~/.claude/agents/` directory 3. Add 2-3 specialized agents per tier 4. Install fast tools (`rg`, `fd`, `sd`, `ast-grep`) 5. Test with a complex task and watch the parallel execution The configuration I've shared here is a starting point. Adjust based on your workflow. The goal is making Claude Code work the way modern agentic systems should: parallel by default, delegating proactively, routing to the right model for each task. --- ## Related Articles - [[AI Development & Agents/building-effective-ai-agents|Building Effective AI Agents]] - [[Practical Applications/optimizing-claude-workflows|Optimizing Claude Workflows]] - [[AI Systems & Architecture/multi-agent-architectures|Multi-Agent Architectures]] --- ### Related Articles - [[building-effective-ai-agents-openai-guide|Building Effective AI Agents: Key Insights from OpenAI's Practical Guide]] - [[crct-v7-7-roo-code-adaptation|CRCT: A Technical Overview of the Cline Recursive Chain-of-Thought System]] - [[dspy-programming-language-models-at-scale|DSPy: The Programming Revolution for Language Model Applications]] --- About the Author: Justin Johnson builds AI systems and writes about practical AI development. <a href="https://justinhjohnson.com">justinhjohnson.com</a> | <a href="https://twitter.com/bioinfo">Twitter</a> | <a href="https://www.linkedin.com/in/justinhaywardjohnson/">LinkedIn</a> | <a href="https://rundatarun.io">Run Data Run</a> | <a href="https://subscribe.rundatarun.io">Subscribe</a>