If you’ve used any coding agent, you know that it’s becoming increasingly common to have AI writing more and more of code that would take you hours or days to complete, now, just a spec away. The value you could add by writing code, can now be added x10 by focusing on the “opposite side of the spectrum”: your tickets? Make them crystal clear. Your bug reports? Add stack traces and line numbers and relevant call hierarchies to them. Your design docs? Version control them. Embed as much business and product knowledge inside your codebase.
This is a much better way of adding value because, in a typical scenario, your business and core decisions will probably outlive your lines of code. So, the knowledge you embed in the codebase becomes the foundation for doing real work with specs and/or coding agents.
Within agents, agentic IDEs, LLMs and everything in-between, opinions are still the main topic: this model beats that one, if you don’t use GPT-5 on high you’re missing out, ONLY use Opus 4.1, etc, etc. The cure?
Just focus on shipping useful stuff and stick to a single stack/combination that works for you, for your team, for your codebase and tech stack.
In my case, that’s turning out to be Claude Code, powered by Sonnet 4.5, that’s it, nothing else. YMMV.
Slash commands recap
In a previous post on this series of exploring Claude Code, I briefly looked at slash commands, and concluded that they are a step up above the (already excellent) out of the box experience of the “vanilla Claude Code”.
With custom slash commands, you effectively turn CC into a “smart agent” (pun intended!) that can actually absorb and adapt your codebase’s patterns, which is critical for basically any enterprise product codebase.
After all, there’s always going to be those nice in-house micro frameworks embedded inside larger ones. You know, how you always need to instantiate `DockerContainerJavaIT` class before writing an integration test? Or you need to register all your repository methods in that special class to add logging to see the SQL queries?
Every single codebase is “the same but different” in the sense that these patterns will emerge everywhere with different levels of strictness.
Slash commands ARE powerful because you can essentially give CC explicit instructions that get codified inside the agent workflow:
/refactor @FileA.javawhere `/refactor` is a custom command that will:
--- refactor.md
You always refactor the code to have public methods annotated with `@OurLoggingFramework` and ensure queries always return a DTO.
You always work TDD style and operate on the file given as argument $1.The power here is reusability of templates, where your own preferred flows become embedded inside the agent. But, what if we can go further?
Enter Sub-agents
How can one go even further than the above? Slash commands FEEL like the ultimate hack when you first use them, because, if you are just levelling up your agentic code skills, they actually ARE! You realize that you don’t need to always type “the same classic prompt that yields good results over and over”, because you transform it into a reusable pattern.
You start collecting some of these patterns, and, before you know it, you have a highly tailored setup that does wonders in your particular codebase and project.
However, besides this, before agents, before GenAI, before all the hype, especially if you have had some “old programming experience”, you developed some habits for yourself. Some habits in how you yourself LIKE to work, habits that allow you to move very efficiently in a given tech stack and context because you know exactly what to do and how.
Well, what if you COULD make Claude Code embed your own habits while combining it with the super skill of the LLM itself?
Feels like a dream? Well, let the fever run high, and enter sub-agents.
In fact, you might have seen it popping up as a tip during a session:
In fact, following the suggestions is probably the best way to learn!
So, I decided to dive deep and took it for a spin:
Then, the agent gets created and CC internally gives it its own guiding prompt and dedicated set of tools it can use, a system prompt, examples of usage and a few more interesting things.
It’s all available via, you guessed it, `/agents` command.
With this in place, CC will now invoke your agent when it needs it for a given task:
Once an agent finishes its work task, it will compile a summary of what it has achieved in its “internal loop” and pass it to the main agentic loop to summarize it for you and finish the task.
Obviously all the advice from prompt engineering and best software development practices applies here, and it’s even more critical: do not create endless sub-agents and ensure each agent has a clear set of well-defined instructions and does one thing very well instead of many things superficially.
Conclusion
All the experience you’ve accumulated by using normal agents, writing rule files, creating custom slash commands, honing your own programming skill habits and strengths over years, months, decades or weeks, can ALL add together to give you a fertile ground for creating highly effective agents that allow you to do more by embedding more of your own beliefs and practices into the agentic loops that drive the underlying LLMs. This means it stays more aligned with your own way of working, you can do more, iterate more, debug more and also, build more!!
Keep agenting!!!