Generic coding agents hit a limit, custom agents go past it
Claude Code, Cursor and Gemini CLI are built for the average codebase. Teams that scale with agents move from better agents to more agents to custom agents built for their own domain.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 21 October 2025 Updated: 3 min read
Most teams are hitting the limits of Claude Code, Cursor, and Gemini CLI.
The problem isn’t the tools. It’s that they’re built for everyone’s codebase, not yours.
Generic agents are tuned for the average codebase
Out-of-box agents are incredible for general work. But they’re optimized for the average codebase, not your domain-specific problems.
The cost shows up in three places:
- Hundreds of hours debugging mismatched suggestions
- Millions of tokens wasted on irrelevant context
- Agents that don’t understand your edge cases
The alpha in engineering isn’t in the easy problems that any agent can solve. It’s in the hard, specific problems that most agents can’t handle out of the box. That’s where custom agents shine.
A new system prompt makes a new product
When you change the system prompt, you’re not modifying Claude Code anymore. You’re creating a completely new product.
Take a simple Pong agent with a 3-line system prompt:
You are a pong agent.
Always respond exactly with: pong
That's it.
No matter what you prompt, it only responds with “pong.” That’s the power of system prompts. All the work that went into making a great general agent is replaced by your specific purpose.
Your system prompt multiplies every single user prompt your agent runs.
A custom agent is a small build
Building a custom agent isn’t rocket science:
- A 150-line Python script
- A system prompt in a markdown file
- Optional custom tools for domain logic
- The Claude Code SDK, which handles the complexity
You’re not building from scratch. You’re composing specialized intelligence from established components.
Better agents, then more agents, then custom agents
After helping teams at several retailers scale from single agents to multi-agent systems, I’ve watched one pattern repeat: better agents, then more agents, then custom agents.
Every successful agentic engineering journey I have seen follows this path.
- Better agents: optimize your prompts, context, and pipelines with existing tools.
- More agents: scale compute by running multiple specialized agents in parallel.
- Custom agents: build domain-specific intelligence for your hardest problems.
Three levels of custom agents
Level 1: custom system prompts
Your system prompt defines everything. Change it, and you’ve created a completely new product.
Level 2: custom tools
Out-of-box agents have 15+ generic tools. Most specialized agents need exactly 1 to 3 domain-specific tools. Build custom MCP servers and reduce context noise.
Level 3: multi-agent orchestration
This is where custom agents become systems. One real example is a micro-SDLC agent system:
- A planner agent analyzes the task and creates the spec.
- A builder agent implements the changes.
- A reviewer agent validates quality.
- The change ships automatically when all pass.
One prompt starts the complete pipeline, and it runs outside the loop. I’ve watched this pattern ship production code in 45 minutes that used to take 4 hours.
When to build a custom agent
Use out-of-box agents when you are:
- doing general development work
- exploring new codebases
- working on tasks that benefit from broad capabilities
Build custom agents when you are:
- repeating specialized pipelines constantly
- solving domain-specific problems with unique constraints
- at the point where context management becomes critical for quality
- running multi-step pipelines that need isolation
This is how the best engineering teams are deploying AI: not by using the same tools as everyone else, but by building agents that understand their specific domain, constraints, and edge cases.
Agent coding isn’t about what we can do anymore. It’s about what we can teach our agents to do.
Where are you on the journey: better, more, or custom?
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Coding agent setup
- Use subagents as researchers, not implementers Subagents that implement directly lose context between sessions. Subagents that research, write their plans to the file system and leave the implementation to the main agent work in production.
- A swarm of subagents is not throughput Coordinators that fan out to thousands of subagents measure merged pull requests, which is output. The limit on fan-out is how much a team can check well enough that what lands is what customers need.
- An agent is a loop, and the loop is what you debug A coding agent perceives, decides, acts and observes, then repeats. Naming which of the four steps failed turns a mystery into a fix.
Scaling needs named owners
Coding agents scale across teams when named people own the platform, the team practice, the guardrails, and the measurement. Rollout & scale is where that ownership is built and handed to internal owners, in your stack.
Training on this topic: Agentic Engineering for Developers and QAWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check