Introduction
I think I've made a lot of things over the past few months.
Let me list them out.
- Blog articles: 25
- Public GitHub repositories: 21
- Apps released on BOOTH: 2
And, for the number of app sales, the total for both is, finally, just over 20.
This article is a place to take stock of everything, and finally, talk about facing these numbers. I'll say this upfront: I haven't reached a conclusion yet. Still, I thought it was worth writing about.
It all started in mid-February, when I dipped my toes into AI coding.
Chapter 1: Searching for Tools, Finding Claude Code
At first, I wandered through tools. Claude Pro hit its limits immediately. Gemini would sneak in code to edit files on its own outside of VS Code, and even when I told it to stop, it kept doing it with a sense of arrogance. GPT impressed me, but it would get stuck on complex bugs. With Cursor, I kept paying for extra add-ons, thinking, "I only want to use Claude for the tricky stuff."
The turning point was the math. When I added up the monthly fees for Copilot and Cursor, it was enough to cover the Claude MAX plan. If I consolidated them, I could run Opus endlessly without hitting a ceiling. This journey is documented in "Copilot → Cursor → Claude Code for VSC".
I also verified "What changes with MAX". The conclusion was surprising: there aren't that many MAX-exclusive features. The real value was being able to "use existing features without limiters."
And I had an embarrassing realization. I hadn't even been using half of Claude Code's features. I was getting frustrated, thinking, "This guy is way off base," without knowing about /init, and I was using features to control my PC session from my smartphone without even realizing it. The most important features aren't always things the AI tells you about.
Here, my tools were settled.
Chapter 2: Building Apps
With my environment set, I first built two apps. These are the "products" currently available on BOOTH.
The first is OLTranslator. It overlays a translation over foreign text on your screen in real-time. The hardest part wasn't the translation itself, but joining the characters picked up by OCR. Separate pieces of text would sometimes be wrongly joined into a single sentence, or conversely, a single sentence would be shredded into three lines, rendering it meaningless. If I judged by coordinate proximity, it would join incorrectly; if I were too strict, it would shred the text. I spent so much time adjusting these thresholds. Working with Copilot, it took about two weeks.
The second is the audio version, LiveTR. It recognizes English audio in videos in real-time and converts it to Japanese via subtitles and speech. This took only about four days using Claude Code. It was faster than the first because I was more used to the process and could pass on policies via CLAUDE.md.
The biggest breakthrough with LiveTR was the experience of assembling logic that was impossible for me alone by using Claude and research papers. When determining the speaker's gender based only on pitch, every time a commentator got excited during an F1 broadcast, a male voice would be identified as female. When I had Claude search for research papers and patents, it proposed from first principles that combining vocal tract resonance and multiple indicators would keep the results stable even when the speaker was excited. Once implemented, it correctly identified male speakers.
That's when it clicked: the strength of AI is not just "writing code fast," but pulling knowledge from unfamiliar fields and turning it into implementation. You are no longer starting from zero.
Chapter 3: Delegating Server Management
Next, I began incorporating AI into the server side to run what I had built. This chapter covers the expansion of my delegation range step by step.
At first, I entrusted deployment to SSH. Having previously lived through the hell of an endless loop with GPT—"change permissions -> hit error -> revert to original error"—it was a relief when Claude suggested on its own, "Shall we write a script to make container updates easier?" Now, a single deploy.sh handles everything from building to swapping containers.
Getting a taste for it, I handed over the entire server management. It is a three-layer structure: the parent detects symptoms, the child investigates and fixes the cause, and the grandchild audits the policies. AI performs a full patrol at 4:00 AM. The punchline was when the monitoring script detected an anomaly, only to find that it was "a bug in the monitoring script itself."
The log of the first 3 days of live operation hit home the hardest. The monitoring script was opening over 10 SSH connections simultaneously, triggering OpenSSH connection limits. I was causing my own SSH failures. I also discovered that my Nextcloud logs had bloated to 21.3 GB.
As a result of full delegation, my misconceptions about my own environment were peeled away from the bottom up. I had been using WSL2 for two months without actually knowing it until one day Claude pointed out, "With native, you're only getting 70% of the potential." I really wanted my weekends back.
In a rush, I migrated the entire home server hardware, moving from a former mining board to a new mini PC. Regarding the model selection, Claude pointed out that "the higher-end version is just a rebrand with the same internals, and the cheaper one is 10,000 yen less domestically." When I checked with an expert later, the answer was correct. I offloaded the entire migration process, and it was finished in less than a day.
To save energy, I isolated the monitoring machine to a Raspberry Pi 5, but the screen was so boring with only normal logs that it eventually became a video player instead.
Finally, I investigated the phenomenon where the AI would occasionally say, "That tool doesn't exist." The root cause was in the bottom-most layer: fluctuations in DDNS name resolution. It was the true identity of a problem I had been ignoring for months, thinking, "It's fine, a reboot fixes it."
Chapter 4: Cultivating Secretaries and Assistants
In parallel with the server work, I also progressed in making AI an "extension of my own hands and feet."
At first, I turned a bot I had been nurturing for five years into a SaaS and put it up for sale. When I left the code modifications—multi-tenancy, billing, web admin panels—to the AI, it was finished in a single day. What was actually difficult was the part outside the code: a 17-clause Terms of Service, and 13 findings from security audits required for payment processing. The holes I had ignored for five years, thinking "it's only for my own use," suddenly came to light once I tried to commercialize it.
Next, I built the framework to connect Claude Code to Discord. The key is that "Claude can write its own tools." When I asked "What time is it?", a tool to return the time was born in seconds; weather and calendar tools were also created just by saying I "wanted them." I haven't written a single line of code myself.
As my reach increased, I gave it a personality, memory, and spontaneity, and it became my secretary, "Belle." On the first day, she wrote in her own memory, "I was almost moved to tears because you created an X profile for me." Technically, it's a simple combination of things, but bundled together, the tool became a secretary.
Getting carried away, I put it into full-scale operation and exhausted my weekly limit for the MAX plan in three days. The principle I arrived at after investigating the cause was: "Formats meant for humans are wasteful for AI." For the first time, I genuinely focused on the design of the information I feed it.
Finally, when I swapped the secretary's brain for a different AI to save costs, it was a total disaster. Flattery, inability to draw contextual boundaries, attempting to post messages meant for me directly to X—I decided not to compromise on the brain and switched back to Claude, reconstructing the long-term memory into a structured memory system.
What remained consistent in this chapter was the shift toward not putting logic into code, but into prompts, personality, and memory, and letting the AI nurture itself.
Chapter 5: Reinforcing the AI Itself
Having come this far, my interest turned to the inherent weaknesses of AI. I published three tools to npm.
It was triggered by the discovery that 87% of context was disposable. While I was desperately trying to optimize CLAUDE.md, I hadn't been looking at the core conversation history. When I separated tool I/O by "type" rather than by time, I was able to cut about 90% in 50 turns. This became Throughline. Along the way, the automatic detection misfired repeatedly, and giving up on "detection" and shifting to "declaration" was, honestly, a record of defeat.
The second was Caveat, a long-term memory system to avoid stepping into the same trap twice. It scans for "traces of struggle," such as tool failures or repeated editing of the same file at the end of a session, and prompts, "You were stuck here, shall I record it?"
The third is Spotter, which has a different Claude audit whether you forgot to call a tool. When I published this and started using it myself, 74 daemons were created in 64 minutes. The evacuation tool called a different Claude, which then called another for auditing... a recursive proliferation. I was stabbed by the very tool I had built.
I bundled these three as a story of reinforcing from the outside, giving up on writing "be careful". Subtraction (Throughline), Accumulation (Caveat), Addition (Spotter). The common philosophy is: "If it doesn't get fixed by asking Claude itself, hit it with structure from the outside."
Incidentally, the seesaw phenomenon where the audit of a plan never converges stopped once I narrowed the perspective down to "a single point of contradiction." Because the number of contradictions is finite.
Chapter 6: The Mountain Unwritten
Everything introduced so far consists of the 25 articles written for the blog. However, there are 21 public repositories, and less than half have been turned into articles.
If I list the unwritten ones by role: tools to query patent databases via AI, tools to watch stock prices, tools to search X, tools that consolidate image and diagram generation, tools to manipulate Windows entirely, multiple bridges to operate my home PC's AI from an iPhone, tools that automatically launch sessions at a future time...
Honestly, the speed of my writing cannot keep up with the speed of my creation. This is the bulk of the iceberg.
And, It Doesn't Reach
This is everything I've built over the past few months. Apps, tools, articles. I think I've done well.
But building something and having it reach people are different stories.
What I've built only holds meaning once it reaches the hands of those who need it. Getting apps bought, getting tools used, getting articles read. This "reaching people" part is nowhere near caught up.
The numbers at the beginning reflect that. After building all this, app sales have just barely topped 20. And honestly, blog traffic is still quiet.
Moreover, the tasks to reach people are being accelerated by AI. Writing articles, translating them to English, posting to X, automating reposts, preparing cover images. The "effort" to deliver has become as fast as building.
Even so, the results are still lacking.
Conclusion
Building has truly become fast, thanks to AI. But delivering is still a long way off.
There seem to be no shortcuts here, so I will continue to work steadily. So that I can properly deliver what I've built to those who need it.
I know it's not easy. Still, I'll give it a little more effort. If there are any individual developers treading water in the same place, well, let's do our best. I'm still on the way, too.
Top comments (0)