Code is incredibly good at converting natural language prompts into fully working code. If you ask simple queries or for simple implementations, Claude Code typically one-shots it without you having to do any subsequent queries or tests to make sure everything is working as intended. However, once you start asking for more complex tasks and implementations, Claude Code struggles with the one-shotting.
In these cases, you have to spend a lot of time testing the implementation of Claude Code, seeing how well it works, and whether it adheres to your preferences. Then, when you find deviations, you have to prompt Claude Code to fix it, make sure it understands your intent fully, and continue like this until the implementation is exactly as you want it.
This infographic highlights the main contents of this article and discusses how to make your Claude Code more efficiently able to perform one-shot implementations using three specific techniques. Image by Gemini
Naturally, this is a time-consuming process, which is why I have written this article where I discuss how to make Claude Code better at one-shotting the implementations that you want to build. I’ll cover specific techniques I utilize to make Claude Code run for longer, test implementations, and thus be more efficient at implementing your ideas without requiring iterations.
Why one-shot implementations with Claude Code
First, I want to cover why you should want to achieve more one-shotting with Claude Code. The simple reason is that a one-shot implementation saves you time. Instead of having to test and iterate on implementations with Claude Code, which is a very time-consuming process because you have to wait for Claude Code to finish its work, you simply get the fully ready implementation right away.
Thus, the main reason you want to do this is simply to save time. This opens up more time, which you can spend on performing other implementations, bug fixes, or, in general, other work, which in turn makes you even more efficient. How efficiently you can implement solutions is the most critical factor in how good or how proficient you are as an engineer.
How to make Claude Code better at one-shotting
In this section, I’ll cover a few techniques that I use on a daily basis to make my Claude Code instance better able to handle one-shot implementations that I wanted to make. I’ll keep it as specific as possible, and I’ll keep it to the exact technique that I use for my own use cases. Of course, this might not apply exactly to your use cases. However, I think you can easily generalize these techniques and try to apply them to your specific application areas.
Discussing your implementation with an LLM
The first tip I provide is based on aligning your idea of the implementation with LLM’s idea of the implementation. What you want to implement is, of course, a thought that you have in your mind and not something super concrete. Converting this into code is a bit of a challenge because there could be ambiguous elements to your thought of the implementation or other factors that are not entirely clear. Thus, it’s incredibly important to discuss with an LLM what you’re trying to implement, to clarify anything that is unclear, and to make the LLM understand exactly what it should implement.
Thus, before you start implementing anything, you should typically have a full discussion with an LLM on:
- Exactly what you’re trying to implement
- What you should think about when implementing
- What context is needed to efficiently implement
And so on. I can have this conversation multiple times for my own implementations.
If I’m implementing something that I know requires doing a lot of web searches and researching something online, I’ll typically have an initial discussion with Gemini Deep Research Pro Mode.
This is because Gemini is, in my opinion, the best online research agent and the one where I get the best results. I’ll then chat back and forth with Gemini and have it create a final product, being a report or an outline slash plan for what I want to implement, including everything to think about during the implementation, and feed it into my coding agent, which currently is ClaudeCode, but which can of course be any coding agent of your preference
In other cases, I simply use plan mode in Claude Code and discuss directly with Claude what I should do and how I should do it. When doing planning, I explicitly instruct the model to ask me questions when anything is unclear or ambiguous. This makes the model more prone to asking questions where it needs more context, which helps me better align with my coding agent exactly what I’m trying to implement.
Note that Claude Code can also do online web searches, so you could, in theory, do it if you want to search the web as well.
Giving the LLM testing permissions
When the LLM has a super clear plan, which we will have made given the last section I described, it’s now time for the LLM to implement the plan it created with you.
When the LLM does this implementation, it typically takes quite a while because you’re using the best LLMs, which will be slower. An example of one of the best LLMs is Claude Opus 4.6.
Because the implementation takes quite a while, it’s incredibly important to make the LLM self-sufficient and able to test its own implementation before it gets back to you. This will save you a lot of time because the LLM can test its own work instead of having to ask you to test it.
To set this up, you should give your LLM browser access. How you do this differs for different IDs or CLIs that you use to do your coding. However, in Claude Code, you can spin up Claude Code with dash-dash Chrome and install the Playwright MCP.
This gives Claude Code browser access, and the Playwright MCP is a very powerful tool to make Claude Code better at using the browser. It does sacrifice a bit of speed for quality, but in general, I think this is a worthwhile tradeoff with everything to do with coding. Using faster but lower-quality models doesn’t actually increase speed, because it just makes the implementations worse, and you have to do more iterations, which in the long run takes more time.
Store your preferences
My last tip will be on storing your preferences from previous sessions. The first sessions you have with Claude Code will be less effective because Claude Code doesn’t exactly understand your preferences and how you like the code. Thus, it’s incredibly important that after each session you have with Claude Code, you make it memorize what it’s learned from the session, Key takeaways that it wishes it knew before the session, and if it were to start a new session, it would appreciate having this knowledge.
There are multiple ways of achieving this. I personally have a generalized knowledge command, which I run after every session I have with Claude Code, where it stores relevant project knowledge in the project claude.md file and relevant user knowledge in the user level claude.md file.
I find that Claude is very good at judging which content should be stored in which file, and I usually trust it to store the relevant user knowledge into the user file and project knowledge into the project file. In my opinion, it’s equally good as I in determining where the content or which file the content belongs to.
If you do this in every session, the latter sessions will be more effective because Claude Code will automatically understand your intent and preferences better and automatically adapt its implementations to that.
If you have a specific frontend styling preference, you don’t have to ask about how to design the frontend of the website. It can simply read the Claude.md file describing your preference and immediately implement that without having to ask clarifying questions or even without having to first implement something. Then the user is unhappy with the implementation and has to re-implement stuff.
Conclusion
In this article, I’ve discussed why you want to make your Claude Code more efficient at one-shotting implementations. Briefly explained, it will simply save you a lot of time if Claude Code is better at understanding your intent and immediately implementing that without you having to iterate on the implementation. I covered three specific techniques on how you can achieve this. And I believe that improving your cloud code instance like this will give you a major advantage over all other coding agent users. This is about customizing your coding agent to make it more efficiently able to implement the thoughts you have in your mind into actual code. It will be incredibly important for the future
👉 My free eBook and Webinar:
🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)
📚 Get my free Vision Language Models ebook
💻 My webinar on Vision Language Models
👉 Find me on socials:
💌 Substack
🐦 X / Twitter
