The previous articles covered conceptualization, design, and architecture—all of which address "what to do" and "how to do it." However, there’s another aspect that’s often overlooked during the actual development process: how a toolchain can help you save time and effort. This article focuses on several tools that have significantly boosted my development efficiency.
RTK: A CLI Proxy That Saves Tokens
The most direct cost of developing with Claude Code is token consumption. Every time you run commands like `git status`, `git diff`, or `npm run build`, the raw output is often verbose, but the truly useful information might only be a few lines.
RTK (Rust Token Killer) is a CLI proxy written in Rust that intercepts the output of these commands, filters out unnecessary content, and retains only the key information. In practice, it can reduce token usage by 60–90%.
The most convenient feature is that it runs automatically via Claude Code’s hook mechanism—you simply type `git status` as usual, and the hook automatically rewrites it to `rtk git status`. It’s completely transparent and requires no change to your workflow.
In addition to saving tokens, RTK offers the `rtk gain` command to view cumulative savings and the `rtk discover` command to analyze which frequently used commands haven’t been optimized yet. This allows you to continuously fine-tune your workflow to maximize savings.
context7 MCP: Checking the latest documentation
AI models have a time-bound training dataset, which means they may not be accurate enough for the latest version of a package’s API. For example, if you’re using a new API in Next.js 15, the model’s knowledge might still be stuck on version 14.
context7 MCP solves this problem. It can query the latest package documentation in real time, retrieving API descriptions and sample code for the current version.
It’s simple to use: just specify the package name and the topic you want to look up, and it will return the relevant documentation. In this project, I use it most often to look up Prisma schema syntax, next-intl configuration, and the TipTap Editor API.
This is much faster than opening a browser to look up documentation yourself, and it ensures you’re getting the latest information—so you won’t end up writing deprecated code based on outdated model knowledge.
sequential-thinking MCP: Reasoning Chains for Complex Problems
Some problems cannot be solved in a single step and require step-by-step reasoning. For example, “Why does the ‘series’ page show 0 posts in EN, but works normally in zh-TW?”—this kind of bug involves multiple layers, such as data flow, multilingual logic, and database relationships.
sequential-thinking MCP provides a structured reasoning framework. It doesn’t give you the answer directly; instead, it breaks the problem down into a series of thinking steps, with each step building on the conclusion of the previous one.
In the bug example above, the reasoning process would look something like this:
What is the seriesId queried on the EN series page? → It is the EN series record ID
What is stored in the article’s `seriesId`? → It is always the `zh-TW` series record ID
So, do the EN seriesId and the article’s seriesId match? → No
Solution: The EN series page should first find the zh-TW sibling series, then use its ID to look up the article
This step-by-step reasoning approach is particularly well-suited for handling cross-system bugs, as it forces you to lay out and examine every assumption, ensuring no critical steps are skipped.
Automated Translation System: DeepL + Google Translate
One of the most labor-intensive aspects of a trilingual website is translation. Each article requires three versions: zh-TW, en, and ja. If all of them were translated manually, the workload would be enormous.
This project has established an automated translation system:
Primary Translation Engine: DeepL API, which offers higher translation quality, especially for Chinese-to-English translations
Backup Engine: Google Translate API, which automatically switches when DeepL does not support a language pair (e.g., Chinese to Japanese) or when the API encounters an error
Differential translation: Only translates fields that have changed, rather than translating the entire article every time, saving on API costs
The process in the admin dashboard is simple—after writing the Chinese content, click the "Auto-Translate" button, and the system will translate the title, body, summary, and SEO fields. You can manually fine-tune the translation afterward, but in most cases, the quality is already good enough to use directly.
The greatest value of this system isn’t saving on translation fees, but lowering the psychological barrier to “whether or not to support multiple languages.” Previously, you might have thought, “Adding one more language doubles maintenance costs.” Now, you only need to maintain the Chinese version, and other languages will automatically follow.
The Synergistic Effect of the Toolchain
Taken individually, these tools aren’t earth-shattering, but their combined effect is striking. RTK lets you do more within your token budget; context7 lets you look up documentation without leaving your development environment; sequential-thinking helps you untangle the logic of complex problems; and automatic translation transforms multilingual support from a burden into a nearly zero-cost add-on.
The key isn’t how powerful any single tool is, but how, when these tools form a complete toolchain, they eliminate a significant amount of friction in the development process. You can focus more of your energy on what truly matters: the product itself.
The next post will cover validation and quality—using Playwright MCP for browser automation testing, using the QA skill to systematically find bugs, and using code reviews to ensure code quality.