I built a custom Claude Code launcher, then outgrew it
A while ago I started working on a custom launcher for Claude Code that'd let me run the harness with 3rd party providers (models like DeepSeek, Kimi from Moonshot AI, GLM from Z.ai, providers like OpenRouter etc.) and features like Remote Control easily.
Today I'm releasing the latest version of it and probably also stopping work on it for the foreseeable future.
Let me bring you up to speed with all of the details and write a post-mortem of sorts.
Some brief background
Funnily enough, an adjacent blog post about the tool where I complained about how Apple makes releasing software difficult ended up on the front page of Hacker News, which brought a lot of traffic to the blog:
I'm not sure why the most random posts that I write sometimes end up there, the one titled "Never Update Anything" is still haunting me sometimes - the stuff I could have written better, alongside the blog post itself having a few updates, which is funny (though the argument made in that post was purposefully absurdist, not literal). But here we are.
The fact that the tool itself wasn't ready for the time when the blog post got a bunch of eyes on it is what you'd call a pretty big blunder. After building what I wanted to use myself, it occurred to me that there's no way in hell I'm managing to do actual marketing myself, that's just not what I'm comfortable with, at least not enough right now to become proficient at it.
Up front, the tool got a few hundred views with no marketing anywhere, alongside about a hundred downloads and with no sales so far.
It is available for anyone who wants to take a look and is free to download and use, albeit you can pay for it as well:
I even made a barebones logo and borrowed the color scheme for some elements from Anthropic (since you probably aren't copyrighting a bunch of colors, especially because the "3rd party" bit is front and center anyway), I think at least the tagline says what it is clearly:
Some of you might know Itch.io as that site where you primarily get indie games, but apparently you can host and buy/download software there as well, I'll explain my reasoning for putting the tool there in a bit (and also why it might not have been the best of ideas), alongside why I still ended up making my own homepage in addition to the Itch.io page.
In case you're curious, the source for the tool is available (it's written in Go), but it's not open source in the proper sense.
The development was heavily AI assisted and along the way some changes on Anthropic’s side broke my ability to use Remote Control with 3rd party providers. I made a bug report about it, but nobody as much as acknowledged it, so it got automatically closed. Instead, I just ended up writing a local Anthropic API compatible proxy, that later got reused to allow dynamic model switching within existing sessions.
I can also assure you that it wouldn't have materialized as a real thing with my workload, if not for LLMs. I'd also say that it shouldn't exist, but only because Anthropic should be more forthcoming with their harness, and 3rd party models should be supported without any weird environment variable setting, but work more like OpenCode. It's obvious to me that that's not their business model, same as how Codex doesn't really push you in that direction, while other harnesses like ZCode don't have an issue with offering that sort of configuration out of the box.
In other words, the overall development was plagued by occasional issues that pushed the scope of the work upwards and I've been sitting on the latest version for a while before just deciding to get it out the door and largely move on to other, more approachable harnesses:
This should maybe explain why it took a few months to get here. Let's take a step back and let me tell you about the tool, the features, as well as the experience of using Itch.io and some quick lessons from building something that I used myself for a while but didn't earn a dollar from.
The tool I built
The idea of the tool was quite simple.
Normally you'd launch Claude like so:
claude
That opens it in its default configuration, often with your subscription credentials. Even though their UI doesn't expose it well enough, you can configure the model to use anything you want, as long as it supports the Anthropic API format. For example, the DeepSeek docs show us how to integrate with their models.
For Linux and Mac:
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=<your DeepSeek API Key>
export ANTHROPIC_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash
export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash
export CLAUDE_CODE_EFFORT_LEVEL=max
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=786432
For Windows:
$env:ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN="<your DeepSeek API Key>"
$env:ANTHROPIC_MODEL="deepseek-v4-pro[1m]"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-v4-pro[1m]"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-v4-pro[1m]"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-v4-flash"
$env:CLAUDE_CODE_SUBAGENT_MODEL="deepseek-v4-flash"
$env:CLAUDE_CODE_EFFORT_LEVEL="max"
$env:CLAUDE_CODE_AUTO_COMPACT_WINDOW="786432"
In a word, this sucks. Obviously you could set up an alias like deepcode or something similar but then you'd eventually have like a bunch of different aliases for the different profiles.
My idea was simpler, what if you could have a tool that'd allow you to swap between the different providers on a whim, each having its own profile:
# Setup the profiles after installing the tool
ccode init-config
ccode edit-config zed
# Can also choose the default profile from the CLI
ccode profiles
ccode set-default-profile deepseek
# Launch Claude Code with the default profile
ccode
# Launch with other custom profiles
ccode --bedrock
ccode --deepseek
ccode --openrouter
ccode --openrouter-preset
ccode --zai
ccode --kimi
ccode --qwen
ccode --minimax
ccode --some-other-custom-profile
Here's what it looks like when you use the tool:
Not only that, but other Claude Code features like Remote Control are also supported:
For example, here's a DeepSeek session running inside of Claude Desktop:
Bet you didn't know that's possible! That's the feature that they broke and I had to do some hacking around to keep it working in the recent versions, but that doesn't seem like a deliberate thing on their part, and instead just how the variables get passed around. So in other words, they broke a feature that they don't support but also don't seem to forbid.
This also means that the other features of the harness and its tools work, for example you can get any model running with the dynamic workflows feature Claude has. Most harnesses have sub-agents, but I've still found these workflows to be some of the better ways to do long form work:
I've had way fewer instances of an LLM telling me "Hey, here's what shipped so far" and stopping its work at 2 AM when it's been explicitly instructed to keep going until everything is done. Nowadays you'd use the /goal command or an equivalent to achieve something similar even with regular sub-agents, though the problem there is that OpenCode for example doesn't support such a command, while something like ZCode and Claude Code do.
Here's an example of a simple workflow in progress:
Similarly, here's an example of DeepSeek in Claude Code using the web search tools:
I'm actually not sure how these are billed/rate-limited, because with the GLM Coding Plan I got a bunch of their MCP tools which have their own usage caps, but I've never seen anything like that being limited on my Anthropic subscription, at least not in a way where I'd run into those limits because of not using the tools so much.
Also, as long as you have an environment that speaks the Anthropic API, like OpenRouter for example (I didn't bother to set up a local Anthropic <--> OpenAI translation feature for the proxy, though I've done so for other projects in the past with some success), you can even do things like running OpenAI models inside of Claude Code with few to no issues:
For the most part the tool I wrote is also just a CLI wrapper, that sits around Claude Code and doesn't try to integrate with it that much more, merely configures it and launches it, also handling permissions and remote control if desired by you:
Eventually I had to add support for a dynamic proxy to add support for switching models mid-session (across providers), but for the most part you'd probably just pass them in as invocations at start, based on what profiles you configure:
Here's an example of the Kimi models in Claude Code (I did use the older K2.7 for sub-agents because it's cheap and probably less overloaded):
And also here's an example of the GLM models (though very recently GLM 5.3 Flash came out, which I might put in the config instead):
Here's a quick example of running with the GLM setup, Claude Code does see the model names, but obviously the details it makes up itself as far as I'm aware (for example when the model says just ccode in the dynamic profile mode, it cannot answer with confidence itself):
Here's the dynamic proxy, e.g. when I start with ccode --dynamic it will route requests to a local endpoint that names a generic ccode model and then based on the active session configuration route it to the real provider, be it your Anthropic subscription, DeepSeek, Kimi, GLM or anything else. The idea is that the harness no longer directly knows what model it's running (though it can still have multiple different slots), but rather that part is handled by the proxy process:
Once you have that, you can also have a simple TUI or CLI for switching the active model on such a proxy, per session
And also some basic stats gathering:
At this point it probably should be clear that while the tool started out very simple, as time went on it got more and more features that I needed. There's also importing configuration from files and split config setups for storing the profiles in the project directory but credentials in the user directory and some other things, feel free to take a look at the docs site to learn more.
I still suspect that if I posted it to Hacker News, I'd probably get the reaction of:
This could have just been a shell script.
though with the proxying and all the other stuff I'm not so sure anymore. For what it's worth, Go led to some great and mostly environment-independent functionality and feels like a nice way to write and ship software nowadays. At the same time, I'm tired of the idea of having to maintain this and do further releases.
Somewhere along the way, I discovered that outside of Anthropic most other providers give you more leeway in what harness to use and frankly I like OpenCode even more than Claude Code, despite their desktop app being quite bad. On the desktop app side though, there is ZCode and the folks behind Zed also seem to be working on their own thing.
Whereas if I want to interact with the models inside of OpenCode, I can also just automate it, with tools like Kepler or Paseo. Personally, I think that Kepler keeps changing their UI in confusing ways while not having a good sub-agent viewer, whereas Paseo has one of the more polished UIs but at the same time doesn't really let you interact with OpenCode sub-agents, in case one of them gets stuck.
I will be honest, I haven't found any rock solid tools in this space, like Agent Orchestrator felt even more messy and vibe coded, and most of them seem to struggle from trying to ship a bunch of features ASAP. There was Junie which I quite liked, but it was very vendor-specific and I've also since cancelled their subscription - since work won't pay for a license for me and I use almost entirely Zed nowadays either way.
Either way, slightly awkward combinations of those tools still felt better at the end of the day when compared to the idea of me using just Claude Code and nothing else, especially since I've cancelled my subscription with them due to the writing of the models being unbearable slop and them being annoying about writing exploits and continuously messing with the harness and limits and so much more other stuff. At this point it's better for me to set up OpenCode and Paseo and just run with Kimi and GLM.
The things surrounding the software
Not everything was such an uphill battle, though. For example, Itch is actually a lovely option for releasing software and I'm not sure why more people don't do that! You see, they give you the ability to set up various projects, where each of them get a landing page, as well as the ability to attach files, set pricing (optional) and also maintain some blog posts:
For example, you can do both release posts, as well as document anything else you well damn please, and in practice it worked pretty nicely. Here's my post about Anthropic breaking Remote Control, before I had to write the proxy:
The payment model is also nice. I didn't want to prevent people from being able to access the software for free, but also wanted to at least gently nudge them in the direction of giving me a few bucks:
Personally, I think the "pay what you want" model is a great fit for software and I say that as someone who earned 0 EUR from any of it. Maybe I should have prevented people from downloading the precompiled binaries and just given the freeloaders the source code if they feel like it, but I think that because the software didn't get any attention I'm not making back the stupid fees I needed to give Apple to be able to sign software and stop getting those stupid warnings.
Either way, people have different circumstances and rather than trying to figure out a per-capita median disposable income normalized regional pricing model, it's easier to just give one figure and let people decide themselves what the software is worth to them. It just so happens that in my case the answer was "nothing at all" based on the current sample size. It is what it is.
Another thing, I decided to run a homepage of my own with mdBook:
I think for the less flashy and more documentation heavy sites it's a great fit! It's essentially a static site builder where you feed it some structured Markdown pages and it outputs HTML websites for you, along with some customization. It wasn't too hard to make my own custom theme to match the Itch.io page design I made and it's delightful - if everything is sourced from Git repos, I can just tell an agent to scan over all of the docs and catch the drift that I would have missed myself.
It was a bit odd, because along the way it seemed like I've messed up or that Itch.io doesn't allow embeds:
However in the end it didn't turn out to be a problem with my site or their configuration, rather the whole Itch.io page was down for a few hours:
Pretty awkward and I didn't get any information about what caused that outage, but then again, the service itself is free and I didn't expect stellar uptime anyway. Frankly, I don't mind, because the rest of the experience was quite relaxed. One thing I was missing, though, was automating the uploads of new versions to their site - if I did releases more frequently, I probably would have wanted to do that. In the end, the pipeline ended up being:
- do the work on my daily driver Windows PC
- push the code to my Git repo once all pre-build checks are done
- this kicks off the website build and the new version gets deployed in the background (Itch.io asset updates are manual later)
- pull it on my MacBook and build it there, because Mac needs signing and that's where I can do it easily
- once done, have the build script put everything in a Nextcloud folder
- when that gets synced back to my PC, just drag & drop into the Itch.io site
- make a release post on Itch.io
Not overly complex, but enough friction not to make me do that too often - while also not enough to make me go through the trouble of automating everything and making sure that the automation isn't brittle and that the wrong stuff doesn't get pushed out. Curiously, I had the 5.0.0 version on my MacBook for a few weeks, but my day job kept getting in the way and as a consequence, releasing it got put off more and more.
I also think that my current config examples mention the Kimi API endpoint not the coding one and the stupid AI agent put a reference to the hosted profiles in the default config file template, instead of just inlining the other API endpoint, but I don't feel like making 5.0.1 right now, it's already 8 PM today and I should make some soup.
Oh and before being able to even release the 5.0.0 version, Apple still decided to reject my code signing request, which is one of the more annoying ways of them telling me that I should go to their site and agree to a bunch of ToS changes:
From what I know, Homebrew generally focuses on free and open source software and not commercial projects, but not dealing with Apple's code signing mess would be preferable.
Reflections on building software
First up, I probably should have tried spreading the word around and focused on marketing. It's not enough to build it, nobody will come if they don't know that your thing exists. It would probably be quite uncomfortable for me to do that and right now it's preferable for me to let the project die rather than try to keep going with it - because of both my introverted personality (you will never catch me doing those development vlogs or being some tech personality, I just don't have that in me) and also how insanely burnt out from work I am right now, there's just a never ending stream of more and more work to do, that never seems to end.
Not just that, but also if nobody cares about the tool and don't use it and don't give you feedback, then the amount of knowledge about whether you should keep going, pivot, or abandon it is one big fat 0. I built it first and foremost for myself, then decided to make it more widely available, that's about where it stopped. I don't regret not going open source, because it would have still been nice to make some money from this. On the other hand, I don't know how I'd deal with bug reports and feature requests and all the other stuff, had it attracted any attention - I've seen how demanding people can get, from GitHub Issues, Twitter posts and even places like YouTube comments. While the tech audience is generally a little bit nicer (e.g. there aren't that many mean people on HN), I fail to muster the desire to attract critique.
If building some software, I'm not sure whether you should do it alone if your personality is anything like mine - I got a working tool for myself, but a team will probably be more functional and go further than any individual would. It's also a weird Catch-22 - you need familiarity with the full life cycle of not just building software (which I'm pretty okay at), but also releasing, marketing and selling it, you need to do all of those things to get better at them. For example, a friend of mine is in consulting and is moving around over 100k EUR in networking gear, whereas I have no idea how I'd even start doing something like that, nor do I feel like I'd be good at that, while I've built entire systems from the ground up and definitely have consulted clients and done a bunch of technical and expert work.
It feels like my skillset (or at least what I gravitate towards) does not and will not encompass that whole process, while I also do acknowledge that there's plenty of developers that are comfortable with writing just back end code and never want to write front end, or do full stack work without ever wanting to think about DevOps and so on. Well, either it's that kind of a situation, or I might benefit from a bunch of anti-ADHD, anti-anxiety, anti-depression and who knows what other meds. Things that appear to come quite naturally to other folks don't come at all to me.
Another thing I have written down, is that I watched an episode of the Changelog podcast called Automation at the speed of Swamp (and here's a non-Apple link) where they talked about modern software development in the era of AI:
Something that jumped out at me and that nobody really talks about is, when they basically said, how they'll take feature requests and most likely implement them quite quickly, but will not take direct code contributions (around 1 hour 59 minutes and 30 seconds in the episode) due to issues with auditing the volumes of code and dependencies that get pushed around nowadays due to the prevalence of slopping things together.
Nobody can ever accept contributions ever again if they're gonna work at this rate and they want to maintain supply chain security.
Your agent can write code at a rate that no human can review and I can't trust that every agent will catch the security problems that you inject.
No. Swarm will never accept a pull request from no one, ever.
It was also interesting and maybe a bit jarring to hear someone whose answer to most questions was "use more agents not less" in most circumstances and also essentially the argument boiling down to "adapt or perish" and suggests a fundamental, inevitable change to how software development is being done. Having seen the events of just the past year, unless there is an LLM provider collapse, I can't fully doubt that claim either.
In my own case, I can check that the code works, I can test a lot of things, but I doubt I want to bear responsibility over something getting sent to the wrong API endpoint etc. Long story short, the more features and more code we generate, the higher the likelihood that things will go wrong, since none of our programming languages or tools actually give us sufficient confidence in our work.
With that in mind, I probably should have asked whether I even want to create software like that, especially for a broader audience, with so much AI involvement, and such a creeping scope. On the other hand, people who don't even consider that probably collectively have way more money on average than my broke as hell bank account (or at least more experience with building and shipping things), though unfortunately on the other side of the coin, I can't quite tell how many of them have gotten in trouble due to moving fast and breaking things.
Seeing how hard it was to find the timestamp in the podcast episode above, maybe I should just build a product that transcribes and summarizes podcasts or something. Way less risky than wrapping a coding harness, same as that one time when I thought:
Yeah, I can write my own bespoke team-based credential manager for this project... but do I really want to poke my fingers in such a risky domain?
Oh, also, this blog is proudly human written slop, but I do sometimes feed it to LLMs to review (and then promptly ignore their suggestions). One of them suggested that this is two posts smashed together, another suggested that it's three posts, and then I also got a suggestion that this should be four separate posts - the release and feature tour, port-mortem, thoughts on the LLM ecosystem, as well as commentary on development and burnout. I guess it's not just my software that ends up getting some scope creep. I do think this sentence in one of the summaries was kinda cool, though:
I built a workaround for a walled garden, then decided the garden wasn’t worth gardening.
Heh. Either way, I need a vacation.