It works incredibly well for rapidly building new applications. This, of course, is very useful for any programming task, whether you're working on an existing legacy application or a new codebase.
However, from personal experience, I feel that coding agents like Claude Code are very powerful for completely new codebases because of how effectively they can go from 0 to 1.
This ability to quickly build an app is incredibly useful for creating highly personalized products, such as internal tools. In this article, I'll show you how I use Claude Code to quickly build custom apps, which used to take weeks to build but now can be built in less than an hour.
Why build internal tooling
Internal use has always been useful. It is usually created by engineers within the company to facilitate repetitive processes. This, of course, is very useful as it makes these repetitive processes more efficient because they can be used in one or the same script. This has two main advantages:
- You can complete the process more effectively with internal tools than external
- In-house tools make the catch more decisive unlike a developer who comes up with a custom solution to a problem every time.
However, it usually takes time to build this internal streaming (especially if you don't have access to a recording agent). This time has prevented you from building internal tools for any task that isn't repetitive enough or doesn't take enough time.
However, this game has completely changed with the release of Coding Agents. The cost of building internal tools has dropped significantly, allowing you to build more internal tools for greater efficiency.
I would argue that since the cost of building internal tools is so low, you should definitely spend time building internal systems that will make you and others in your company more efficient. It is also good for making processes more decisive. If two different engineers were asked to solve a particular task, they would probably come up with somewhat different solutions. However, if you already have internal tools to solve this task, the result is naturally deterministic because it is handled by a piece of code. This increases the number of internal tools even more.
Internal construction method of tools
If you've come this far, I hope you know why you should have internal tools. It's simply a way to make you and others in your company more efficient, and ensure that cases are handled decisively.
However, you still need to know how to build internal tooling. I have divided this section into two main parts, which I believe are the pillars of interior design:
- Find out when you need to build a tool
- Creating a reusable tool that is easily accessible to everyone and that everyone knows. You can build a single script to your advantage, but making it reusable, complete, and available to everyone can be a big challenge.
Finding the need for a tool
The first step is always finding the need for a tool. You can probably find this everywhere throughout your company. You have to look for bottlenecks, processes that take too much time and hinder your growth. An internal tool should also be designed for repetitive tasks.
If you have a process that comes up over and over again, you should definitely build an internal hardware for it. This could be:
- Checks if document processing is complete
- Automatically sends customer requests to the right person
- Documentation for your API.
These are all routines that are often repeated several times a week and you don't want to do them yourself all the time.
You should always be on the lookout for these types of jobs. Tasks that you do over and over again, and tasks that a piece of software can easily solve. Of course, some jobs require a human touch. For example, answering emails or responding to bug reports.
However, you should try to open your mind to what kind of tasks can be solved automatically. With the issuance of LLMs, many jobs can be automated. You can have smart systems like OpenClaw, which automatically handle incoming requests or similar, and can do an incredible amount of work automatically.
I just urge you to keep an open mind where tasks can be automated, and always keep it in the back of your mind, as we see coding agents getting smarter and more automated.
Building a reusable tool
After finding the need for a tool, which you should be able to do a few times a week at this point because of how coding agents work, it's time to build a reusable tool.
When I build a reusable tool, I try to keep the following things in mind:
- It should be general, so it should not only apply to your specific problem but also to other types of it.
- It should be easily accessible to everyone (for example, via a shared GitHub repository)
- Everyone should be aware of it.
The last part can be more complicated than you think. If you have built many internal tools, it is not possible for every task to follow all available tools.
That's why I always try to update files like CLAUDE.MD, AGENTS.MD, WARP.MD, or similar, to make sure that the agents themselves are able to use the tools.
The tools should, therefore, be available through a shared GitHub repository that every agent has access to and knows about.
If you follow these steps, you're already a long way from building a reusable, effective internal tool.
Another very important part that is difficult to achieve in my opinion, is to create a standard tool. Sure, you can build a tool that solves the exact problem you're working on right now, which is relatively simple.
However, the often most challenging part is building a tool that handles the diversity of the problem and is highly customizable. It can be widely used by many people for any problem similar to your original problem.
The reason this is difficult is that you never really know the variety of problems that can arise. However, an easy fix for this is to have the LLM create an internal tool to think about the different variables you may encounter and discuss them with the LLM.
I highly recommend using the heavy usage of program mode to discuss with LLM the problem you are facing, how to solve it, and how to solve its different variations to make your text as normal as possible. In most cases, simply telling LLM about this will create a better script that can be used for many different types of problem you're dealing with and will make the tool reusable.
Some tools I've built
It's good to know how to find problems that require a tool and to know how to build a tool. And I think it's very important to know about certain tools to better understand how to build your own tools.
I believe that the best tool you can build is one that is highly customized to your needs, which means it's hard to suggest to others what kind of tools they should build. However, I will provide examples of tools I have built as inspiration.
Examples:
- A bot that checks my emails and calendar and gives me a daily report. It also automatically reads emails that I have trained it to ignore, so that I only read relevant emails.
- GitHub's review bot notifies me every time I receive a review request, providing a description of the pull request. Well explained the way I want it to be explained
- Document processing test documents
The way I came up with these scripts is just to think about what my main issues are or the things I spend the most time on. For everything I spend a lot of time on, I then start thinking about how this can be fully replaced with a tool. Or at least done very effectively using the tool.
In some use cases, this will not be possible. Some things, like writing a specific piece of code or working with different stakeholders, are difficult to outsource to an internal tool. However, in some use cases, it can be easily simplified using the tool.
A tool that checks my email and calendar reports to me, for example, is a simple setup of an OpenClaw model with a cron job that runs every day before I come to work. This was an easy thing to come up with since I usually spend time in the morning reading emails or checking if I need anything to prepare my calendar. And I thought this could easily be automated.
With GitHub's review bot, I also noticed that I started spending more time getting and reviewing pull requests. Considering how much code is written with coding engines now, reviewing pull requests has become a bigger part of my day than I would have liked.
Another simplification was to get an alert in Slack every time I was tagged in a pull request and create a special summary explaining the pull request. I also made the agent look for common errors I found in previous pull requests by scanning my GitHub revision history. This setup has already saved me about 50% of the time I spent reviewing survey requests, where some requests would be automatically approved, as long as it's a simple change and I pass all my tests that I set the agent to run. Although some, usually large survey requests, I still had to review, the reviews worked better when I was given a descriptive summary of the review request and knew what parts of the code to look for.
The conclusion
In this article, I have discussed how to create effective tools for internal use using Claude Code or any other code agent. Coding agents have made it much easier to build internal equipment to be more efficient. While previously you were forced to build internal tools only for repetitive problems that took a lot of time, the bar has now been lowered so you can build internal tools for less important problems. This has the amazing advantage that it will save you a lot of time. Every time you notice any problem that you think will repeat itself, you can create internal tools, make it available to everyone in your team, and thus make everyone more successful. Internal tools have the potential to be incredibly powerful, and you should always keep in mind how to solve a problem by building internals that will handle the diversity of the problem you are solving.
👉 My Free eBook and Webinar:
🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)
📚 Get my free ebook Vision Language Models
💻 My webinar on Vision Language Models
👉 Find me on social media:
💌 Stack
🐦 X / Twitter
