Editor’s Brief
The story of Jason, a 36-year-old former import-export trader who transitioned into software engineering and created CC Switch, an open-source utility that reached 20,000 GitHub stars and 1.3 million downloads. The project solves a specific friction point for users of Claude Code by providing a GUI to manage and switch between different API providers and configurations.
Key Takeaways
- Solving Personal Friction:** CC Switch was born from the frustration of manually editing configuration files to switch API providers for Claude Code.
- Technical Evolution:** The project underwent three major refactors, including a significant move from Electron to Tauri to reduce the app's footprint from 80MB to 7MB.
- AI-Assisted Craftsmanship:** Jason advocates for using AI as a partner but maintains a strict rule: never commit code you do not fully understand.
- Pragmatic Marketing:** Despite being a solo developer, Jason actively marketed the tool by "piggybacking" on the launches of new LLM providers, proving that visibility is as vital as code quality.
Introduction
The following content is compiled by VIPSTAR in combination with X/social media public content and is for reading and research reference only.
focus
- If you use Claude Code, you have most likely used CC Switch.
- Invite the author to live broadcast today to learn the story behind the tool (the following content is generated by AI)
Remark
For parts involving rules, benefits or judgments, please refer to the original expression and latest official information of Sunny Arbor.
Editorial comments
This article “X Import: Xiangyangqiao – 1.3 million downloads, 20,000 Star open source project CC Switch, the first work of 36-year-old programmer Jason” comes from the X social platform and is written by Xiangyangqiao. Judging from the completeness of the content, the density of key information given in the original text is relatively high, especially in the core conclusions and action suggestions, which are highly implementable. If you use Claude Code, you have most likely used CC Switch. The author is invited to live broadcast today to learn the story behind the tool (the following content is generated by AI). In January 2026, an open source project called CC Switch exceeded 20,000 stars on GitHub. Behind this number is a story written by an older career changer in six months. The project author, Jason, used to do import and export trade, and only started to teach himself programming last year… For readers, its most direct value is not “knowing a new point of view”, but being able to quickly see the conditions, boundaries and potential costs behind the point of view. If you break this content down into verifiable judgments, it would at least include the following levels: If you use Claude Code, you have most likely used the software CC Switch. ;Today, the author is invited to live broadcast to learn the story behind the tool (the following content is generated by AI). Among these judgments, the conclusion part is often the easiest to disseminate, but what really determines the practicality is whether the premise assumptions are established, whether the sample is sufficient, and whether the time window matches. We recommend that readers, when quoting this type of information, give priority to checking the data source, release time and whether there are differences in platform environments, to avoid mistaking “scenario-based experience” for “universal rules.” From an industry impact perspective, this type of content usually has a short-term guiding effect on product strategy, operational rhythm, and resource investment, especially in topics such as AI, development tools, growth, and commercialization. From an editorial perspective, we pay more attention to “whether it can withstand subsequent fact testing”: first, whether the results can be reproduced, second, whether the method can be transferred, and third, whether the cost is affordable. The source is x.com, and readers are advised to use it as one of the inputs for decision-making, not the only basis. Finally, I would like to give a practical suggestion: If you are ready to take action based on this, you can first conduct a small-scale verification, and then gradually expand investment based on feedback; if the original article involves revenue, policy, compliance or platform rules, please refer to the latest official announcement and retain the rollback plan. The significance of reprinting is to improve the efficiency of information circulation, but the real value of content is formed in secondary judgment and localization practice. Based on this principle, the editorial comments accompanying this article will continue to emphasize verifiability, boundary awareness, and risk control to help you turn “visible information” into “implementable cognition.”
If you use Claude Code, you have most likely used CC Switch.
Invite the author to live broadcast today to learn the story behind the tool (the following content is generated by AI)
In January 2026, an open source project called CC Switch exceeded 20,000 stars on GitHub.
Behind this number is a story written by an older career changer in six months.
The project author Jason used to do import and export trade, and only started to teach himself programming last year.
It took him three months to learn the basics from TypeScript to React, Nodejs, and Rust, and then made his first formal project.
I have no background in computer science and no experience in a major manufacturer. I have only a simple starting point:
Make a satisfactory project and prove yourself that there is no failure in changing careers.
Pain points are products
Domestic users of Claude Code know that the official subscription threshold is high, and everyone relies more on transfer stations or domestic models.
However, switching between different suppliers requires manual changes to environment variables or configuration files, which is cumbersome and error-prone.
There were already some script tools on the market at that time, but they were all command line operations and not friendly enough to ordinary users.
Jason happened to be contributing code to the open source project Cherry Studio and learned the Electron framework, so he came up with an idea:
Create a visual interface to make switching simple and intuitive.
The first version was completed in less than a week.
The function is very basic, which is to switch by modifying the suffix name of the configuration file, and only supports Claude Code.
But this simple tool solves a real need.
Jason’s design philosophy is clear: minimally intrusive.
Even if you uninstall CC Switch, it will not affect the user’s normal use.
Your application will always have a provider enabled, so even if you delete the tool, the configuration will still work.
This meticulous consideration of user experience runs throughout from the first version.
The difficult evolution from toys to products
The real test comes later.
As the number of users grew, Jason began to receive feedback and feature requests.
GitHub’s Issue area quickly accumulated hundreds of suggestions.
He needs to choose among these needs, not only to maintain the core advantages of the product, but also to meet the actual needs of different users.
The core of the product has always been ease of use, something Jason emphasizes repeatedly.
No matter what functions are added, they cannot destroy the experience of “filling in an API Key to import and switching with one click”.
Such restraint is not easy.
For a while, he added shortcut switches for local proxy and failover on the main interface.
This function was originally designed for transfer station users, especially public welfare station users, whose services are very unstable and require frequent switching.
However, many users who did not need these functions turned them on when they saw the buttons, which resulted in a series of problems. In the end, Jason had to move these switches to the settings and hide them by default.
He said it was a “very bitter lesson” that violated core principles of ease of use and added extra complexity.
The bigger challenge comes from the technical level.
In order to make the software lighter and start faster, Jason decided to refactor the entire project from Electron to Tauri.
The problem with Electron is that it encapsulates the entire Chrome runtime in it. Even if only one page is written, the basic size is about 80MB, and the memory usage is large.
Too heavy for a tool that only implements supplier management and switching.
But refactoring means moving from TypeScript to Rust.
The programming language has changed, and the existing TypeScript and Python libraries in the AI field can no longer be used.
The most painful part of the refactoring process was the local proxy functionality.
This feature was originally intended to support hot switching and failover, because Claude Code did not have hot switching before version 2.49, and the provider must restart the terminal for the change to take effect.
This is a necessity for transit station users who need to switch frequently.
As a result, before the development was completed, Claude Code officially supported hot switching.
But the agent function has been half completed, so we can only continue.
Because the language has been changed, many ready-made libraries cannot be used, so we can only write them from scratch in Rust.
After the reconstruction was completed, the software size was reduced from 80MB to 6-7MB on Mac. The memory usage is almost negligible, and it can be opened in a few tenths of a second after clicking.
Jason said that overall, this reconstruction is still necessary.
Choose Electron or Tauri, depending on your project positioning.
If it is a large and comprehensive project like Cherry Studio, Electron is a wise choice, but if it is a small tool, Tauri is lightweight enough.
The bloody lessons of configuration management
CC Switch has undergone three major reconstructions.
The first time is switching from configuration files to writing and reading JSON.
The second time was from Electron to Tauri.
The third time was purely to clean up technical debt, split large files, and unify the way components are used.
But the most painful lessons come from iterating on configuration management strategies.
Initially, Jason adopted a full replacement strategy: when switching suppliers, the entire configuration file was overwritten instead of just replacing the API Key and request address.
This was done because at that time, Claude Code’s configuration fields had to change in almost every minor version, and the software update speed could not keep up.
And some providers have unique fields, such as limiting the maximum request token, which may limit performance for another provider.
So he designed a “general configuration” function: extract the common fields of different suppliers (such as plug-in configuration, disabling signatures, disabling automatic updates, etc.), and you can choose whether to write these common fields when creating a new supplier.
The problem is that many users don’t see this option, or don’t understand what it means. After creating a new supplier, they find that all the configurations are missing, and they start to curse.
This question was asked so many times for a while that it even made Jason mentally broken.
He began to wonder, is it better to replace key fields? So during the Spring Festival this year, the entire logic was restructured into key field replacement.
As a result, it overturned just one day after it was released.
Because some users require custom fields, key field replacement cannot pass these fields.
What’s even worse is that the configuration file format of Claude Code is very special. It is in TOML format instead of JSON, and some fields cannot be written at all.
Jason worked overtime yesterday and struggled for two more days today. After repeated analysis, he found that full replacement with common configuration is a safer solution.
The afternoon version rolled back the logic again.
Fortunately, he did not change the data structure during reconstruction, so the two versions are fully compatible and no data will be lost.
Learning Methodology in the AI Era
Jason’s career change experience has been an inspiration to many.
His method is not mysterious: go through the basic concepts first, then do actual projects and learn from positive feedback.
He emphasized that although AI can do most things in the AI era, basic concepts cannot be skipped.
You have to know that this thing exists before you can let AI do it, and the learning process will not take too long, it will be very fast.
When he was learning TypeScript, he wrote a script to scan the auction house of “World of Warcraft”, which could earn game currency.
When he was learning React and Next.js, he built a game catalog website. Useful things were produced at every stage. This sense of accomplishment supported him to continue.
He said that all learning is like this. Simply typing is boring. You have to try to do something and get positive feedback.
With the help of AI, it’s easy.
But he also has an important principle: Don’t submit code you don’t understand.
After the AI generates the code, it must not only understand every detail, but at least understand what these codes are doing.
This is a very important bottom line for novices in the AI era.
Many people are worried about the gap between engineers. The traditional intermediate process from novice to senior seems to have been replaced by AI.
Jason feels that novices should observe the working process of AI.
He saw many experts opening several windows at the same time and working on multiple WorkTree in parallel, but he suggested that novices should focus on one task and observe the thinking process of AI, which can learn a lot.
And when there is a problem with the AI’s thinking, you can interrupt and correct it in time.
Practical tips for AI programming
Regarding AI programming, Jason shared a complete methodology:
- Use the right model
If you are not an experienced programmer, just use the best model.
Because you may not have a strong enough ability to judge code quality, using the best model can reduce the probability of errors.
For example, if you want to plan or execute, use Opus 4.6 (currently 4.5). If you want to debug or read code, use Codex 5.3 or GPT 5.2. For important tasks, just use the strongest one.
- Plan Mode is the key
Before starting a feature, analyze and plan how to do it. Claude Code itself has Plan Mode.
If it is a very complex task, a separate document must be maintained.
This document clearly states how many steps the entire large task requires, what each step is, what its purpose is, and what its baseline is.
Of course, this document can also be produced together with AI.
Before starting a small task each time, read the task from this document.
After you are done, write the results in it.
You can manually maintain this document and make additions, deletions, or modifications.
- Context management is core
From the earliest Copilot, to the later Cursor, to the current Claude Code, they are essentially advancements in context management.
Provide the most efficient and needed context to the AI model as much as possible.
Concrete operation:
- If you know where the problem is, just tell the AI where to look for it.
- If you know which file the task is concentrated in, tell it directly that it is mainly in this file.
- This can save context very much
The context of the current model has not advanced for a long time.
Although the Sonnet series has a 1M version, it is not very practical, and most of them still use the 200K version.
So control the context, compress it when it needs to be compressed, and open it when it needs to be newly opened.
Jason’s experience is:
- If the next question is closely related to the previous context, continue the original conversation
- If it is not so relevant but is somewhat relevant, you can compress it before continuing.
- If it doesn’t matter at all, just open a new conversation
Try not to let it trigger automatic compression.
If the tasks are divided well, unless it is a particularly large task or copywriting work, it will generally not go to the step of automatic compression.
- Control the amount of code
Code is a liability, not an asset. This statement becomes even more important in the age of AI.
Never pursue how many lines you wrote today.
It is a better choice to implement functions with as few lines as possible and with the simplest possible structure.
AI will not reject you. If you go to a programmer, he might say it’s too complicated to do.
But even if AI may not be able to achieve it, it will help you achieve it. In this way, it is possible to implement a simple function through a very complex path.
Jason once received an 8,000-line PR just to test whether the server was available, and the entire project was only 6,000 lines at the time.
In the early days of Claude-3.5 or 4.0, I liked writing defensive code very much. I had the urge to deepen the complexity and cover all kinds of boundary conditions, resulting in a lot of code.
- Clear technical debt in a timely manner
When a project reaches a certain scale, technical debt must be cleared in a timely manner.
Whether it’s a leftover problem or a single relatively large file.
Try to keep a file within 1,000 lines, preferably five to six hundred lines.
This is not said casually. Claude Code’s default read tool only reads the first 2,000 lines of code. If it is longer, the grep tool will be used.
If a file has 5,000 lines, it will reduce the probability that the AI will read the target code, it will not be able to obtain accurate context, and it will be filled with context quickly, money will be lost, and the effect is not good.
Jason mentioned a detail: OpenClaw has a front-end file with 50,000 lines.
This project is very fun, but it is still far away from real production-level software.
If you want to use it at production level in the future, these technical debts must be cleared.
- Do a good job in architectural design
You need to do a good architectural design before doing it.
You can’t let the AI start writing features directly.
You need to figure out what functions to implement, what pages should be there, how to interact with the front and back ends, and how to design the architecture. This needs to be planned before implementation begins.
After the project volume and code volume increase, it is really troublesome and time-consuming to reconstruct it, even with the help of AI.
- Required to use Git
Novices don’t need to learn other technologies, but they must learn Git. Otherwise, you really can’t get it back if it’s damaged.
the power of language
Jason has an interesting point: he doesn’t really like the word “Vibe Coding”.
He said that language is powerful. It not only affects the people who hear you speak, but also affects yourself.
If you say “This project belongs to me Vibe Coding”, it is easy for yourself to relax your requirements for product code quality.
Therefore, he generally does not participate in discussions on topics such as “Vibe Coding”.
This kind of self-discipline is only used to ask for yourself, not others.
But this reminder is important.
Motoko added that Wittgenstein said “language is hell”, and the language we use has already given us some hints.
In the AI era, maintaining respect for code quality is more important than anything else.
secrets of growth
The growth curve of CC Switch is interesting.
Significant growth began in January 2026, with nearly 7,000 stars added in a single month.
This is directly related to the popularity of Claude Code in China.
Jason observed that since the end of last year, there seemed to be a huge wave of AI programming suddenly becoming popular.
Coupled with the popularity of ClaudeCode and OpenClaw this year, CC Switch has also followed the trend.
Moreover, almost all domestic open source models natively support Anthropic’s Messages API format and can be directly connected to Claude Code.
This card point is particularly good.
Jason also did some promotion in the early stages.
For example, when a domestic manufacturer releases a new model, he will take advantage of it and say, “To use my tool, you only need to fill in a Key and import it into Claude for use.”
He said that if you are making your own products, especially in the current AI era where products are developing rapidly, it is still necessary to do marketing or gain popularity.
If you come from a technical background, there is no need to feel embarrassed about doing marketing or trying to gain popularity. You must be brave enough to do so.
What advantages does your software have and what problems can it solve? Speak it out and let everyone know about it.
CC Switch has been downloaded about 1.3 million times right now.
This is based on click download statistics from GitHub. The actual number of users is unknown because the software does not collect any data.
Trivia about APIs
Jason popularized a piece of knowledge that many people don’t know: Claude’s official API is divided into three types.
The first is the most serious official API, which comes from the official website, Amazon Cloud or Microsoft Cloud.
The price of this API is very high, 7 RMB is equal to 1 USD. But it can be used anywhere, including Cursor SDK, OpenClaw, and various Chatbots.
The second is an API reversed from Claude Max subscription.
This can only be used in Claude Code, not anywhere else.
Because the official detects that you are using it in a non-Claude place, your account will be banned.
Therefore, the forwarder will also restrict that this API can only be used in Claude.
The third type is reverse-engineered API, such as reverse-engineering from tools such as Cursor and kiro.
This can be used anywhere, just like the first one.
However, the performance will be worse because some default prompt words will be included after reverse, and third-party applications may not provide complete context in order to save costs.
But the third type is very cheap, incredibly cheap.
One hundred million tokens a day is fine. If you use the first method, you will have to burn thousands of dollars a day.
This also explains why the API quality of some transfer stations is poor, mainly depending on which of the three types it is.
The power of open source
CC Switch adopts the MIT license, and anyone can fork and modify it themselves.
Now there is a terminal version (CLI version), a plug-in version, and some people even have an intelligent prediction function that can automatically determine which model is needed for a task.
Jason said that the CLI version made by netizen Fork is very cool, and he didn’t know that the TUI (Terminal User Interface) could be so cool.
source
author:Sunny Arbor
Release time: February 28, 2026 23:17
source:Original post link
Editorial Comment
The narrative of the "self-taught developer" is often dismissed as survivorship bias, but Jason’s success with CC Switch offers a more grounded blueprint for the current era of software development. At 36, transitioning from trade to tech, he didn't set out to build a platform; he built a shim. In the modern stack, where complex tools like Claude Code are becoming central to the workflow, the most valuable real estate often lies in the friction between those tools and the user.
What makes this story stand out isn't just the download count—it’s the technical discipline Jason applied while using AI. We are currently seeing a surge in "Vibe Coding," a term Jason notably rejects. His refusal to adopt the label is telling. It suggests that while AI can generate the bulk of the logic, the responsibility for the architecture, the performance, and the "technical debt" remains firmly with the human. His transition from Electron to Tauri is a prime example. A "vibe coder" might have settled for an 80MB utility that works "well enough." A software engineer recognizes that a configuration switcher shouldn't consume more resources than the IDE it supports. By rewriting the tool in Rust/Tauri, Jason demonstrated a level of craftsmanship that separates a "project" from a "product."
His experience with configuration management—specifically the "all-or-nothing" vs. "key-only" replacement—is a classic lesson in user experience. Developers often assume users want granular control, but Jason found that users actually want predictability. When he tried to make the tool "smarter" by only replacing specific fields, it broke for users with custom setups. Reverting to a "full replacement with shared defaults" strategy was a humbling realization that in utility software, stability beats cleverness every time.
From an editorial perspective, the most actionable takeaway here is Jason’s approach to "context management" when working with AI. He treats the LLM's context window as a finite resource that must be managed, not a bottomless pit. By manually maintaining a task document and feeding the AI only the necessary files, he avoided the "hallucination spiral" that many beginners fall into. He treats the AI like a highly capable but easily distracted intern. You give it a clear plan, you watch its "thinking" process, and you intervene the moment it veers off-track.
Finally, we have to talk about the "growth" aspect. Many open-source developers believe that if the code is good, the stars will follow. Jason’s success proves the opposite: you have to "ride the waves." By positioning CC Switch as the bridge for every new "Claude-compatible" model launch from Chinese providers, he turned every industry announcement into a marketing event for his own tool. It’s a reminder that in a crowded ecosystem, being the "useful tool next to the giant" is a highly effective strategy for gaining traction.
Jason’s journey suggests that the barrier to entry for building high-utility software has collapsed, but the barrier to building *good* software remains as high as ever. AI can write the functions, but it can't decide to refactor for performance, it can't empathize with a frustrated user, and it certainly can't navigate the politics of a GitHub Issue tracker. That remains the domain of the engineer.