KronisLV

How much time do you spend on your setup vs getting a lot of stuff shipped by paying for Fable 5?

Relatively speaking, quite little (and it's more interesting than some of the stuff I'm otherwise shipping), I mostly just explored to see what's available.

I also agree that non-SOTA models are risky, that's why I was shopping around for them as well - DeepSeek V4 Pro is cheap but unreliable, GLM 5.2 is around and maybe slightly past Sonnet quality (though their quotas are a bit of a problem), whereas Kimi K3 is a proper contender.

I did write a tool to manage 3rd party providers for Claude Code: https://ccode.kronis.dev/

However, in the end I figured out that for the terminal use cases OpenCode is really comfy (provider TUI solutions are okay).

For web/desktop based stuff I like the UI of Claude Code Desktop, though ZCode comes close too (which is surprising, they sorta came out of nowhere and are patching the thing weekly), meanwhile Kimi Code and OpenCode desktop/web offerings still aren't great, but are functional.

I actually did write a bit more about my experiences on my blog.

GLM 5.2 with their harness and coding plan: https://blog.kronis.dev/blog/z-ai-s-glm-5-2-is-a-great-model...

Kimi K3 with their Allegro 100 USD plan and harness: https://blog.kronis.dev/blog/kimi-k3-is-out-is-anthropic-don...

That exploration let me switch over to Kimi fully because the tone of Anthropic's models is insufferable: https://blog.kronis.dev/blog/ai-slop-is-a-self-inflicted-tra...

Not to spam too much, but maybe those experiences are useful to someone. Long story short, most harnesses are okay but shopping around a little bit is definitely a good idea, the same way how spending some time choosing a font isn't a bad thing if you'll stare at it for 8 hours a day. I'm also happy that I managed to find software that's okay to run and also a model whose tone I actually enjoy, that is still near-SOTA in performance and that I can throw tasks at it without worrying about whether the model is or isn't good enough at those.

I will admit that I'm probably slightly overspending by moving over fully to Kimi, there's probably a plateau for each kind of task and not everything needs SOTA models, but at least this way I don't have to think much about it.

In long form tasks, across multiple harnesses (Claude Code, OpenCode, Kimi Code, ZCode) my cache rates are typically 96-99%.

I don’t think that’s particularly out of the ordinary. Do people have different experiences with other harnesses? Which ones?

Using the same software you might use at work and getting better at it, perhaps even exploring simpler distros like K3s, k0s, Minikube or whatever people use nowadays.

OpenCode has a desktop version, it's decent: https://opencode.ai/download

I wish they'd embed the Code UI as a tab, similar to Claude Code Desktop.

There's really no real reason for those tools to be separate and for them not to give me something a bit nicer than just a TUI in the terminal.

They already have a locally runnable web UI when you have Kimi (the CLI) installed: https://www.kimi.com/help/kimi-code/cli-getting-started

  kimi server run --foreground

Personally, I still liked ZCode better and will probably write a blog post about my experience with K3 too, the harness might need some more work, but the model is really, really good.

Euro-Office liberates the ONLYOFFICE code base

Oh that and the following paragraphs are salty, after all of the mess of Euro-Office violating their copyright (OO's arguments about which may or may not hold up in court).

Personally, I'll probably just stick with LibreOffice until things calm down a bit.

To be honest, they have both 5 hour caps, weekly caps and also monthly caps:

  Total usage
  12.85%
  Resets in 2026-08-17
  
  5-hour usage
  71.97%
  Resets in 07-20 03:14
  
  7-day usage
  31.29%
  Resets in 07-24 10:14

Can confirm, I see these monthly prices on both pages:

Moderato: 19 USD or 15 USD annually

Allegretto: 39 USD or 31 USD annually

Allegro: 99 USD or 79 USD annually

Vivace: 199 USD or 159 USD annually

However, they're saying that the plans might get split up again:

New Membership Plans Coming Soon

Kimi and Kimi Code benefits will be separated. Existing subscribers are unaffected.

You can still buy the current plan before launch.

Same as with the Tweet:

Going forward, we'll also split membership into two more focused plans: Kimi Membership for Kimi Web, App, and Work; and Kimi Code Membership for coding workflows. This will help us match compute more precisely and keep the experience stable.

Problem is I don't know whether to pull the trigger on the annual Vivace now or wait for after the split - whether it's gonna be a cash grab afterwards on the account of the demand, or whether I might save some money if I buy it after the split.

Currently using their 100 USD subscription, considering going up to their 200 USD subscription, because the model is approximately as capable as Opus (maybe sometimes better, sometimes worse) but less annoying to use in practice, a bit less of slop phrasing: https://blog.kronis.dev/blog/ai-slop-is-a-self-inflicted-tra...

The token limits do feel a bit less than I get with Anthropic Max 5x, but maybe that's because I've mostly been running it on Max reasoning (oh and Anthropic is also temporarily boosting the limits, who knows, it's hard to keep track of all of this stuff exactly) and there's plenty of tasks where High is still close enough in performance. The token limits still feel a bit more generous proportionally to the price compared to what I got when trying out the 65 USD tier of GLM Coding Subscription with GLM 5.2, and that was with the ZCode usage discount as well, though I did enjoy that harness.

Plus, if I decide to go with Kimi's annual pricing, then it'd come out to only around 159 USD per month or 139 EUR per month, which is really good and pretty close to what I pay Anthropic anyways: https://www.kimi.com/help/membership/membership-pricing

by making it cheap and fast to build whatever you like automatically.

Cheaper, but not free (if you don't buy into the marketing promises too much). The bigger the project, the bigger the cost, even with a discount.

At the same time, the early versions weren't very good and you can be sure that any rewrite will also need to be similarly iterated upon until it is also good enough and polished.

If you do that and don't spend enough effort on making it be something polished --> your competitors have a better product and you lose.

If you pause feature development to give enough effort to the initiative, you don't get to add new features quickly enough --> your competitors have a better product and you lose.

Maybe their priorities lay elsewhere, like how I've noticed that the desktop app version of Claude Code has gotten both faster (no 2-4 second lag when switching conversations), more stable and usable over time, to where I enjoy using the models because of it, not in spite of it (though not that they haven't had bumps along the way, like that one cache invalidation issue, or how people didn't like the auto accept timeout thing). I don't doubt that you can get pretty far with gradual patches and improvements, instead of only big rewrites.

Honestly it's really cool for me to see Kimi having their own CLI too, same with OpenCode, Pi, Hermes (well more of an agent than just a coding harness but you get the idea) - there's so many competing solutions out there, each good or bad in unique ways.

Just wish we'd see similarly many GUI solutions, for now OpenCode GUI seems like the one I've settled on (cross platform and supports most models), though it's not exactly ideal either (feels a bit barebones, especially in regards to sub-tasks and progress/plan tracking, even ZCode seems a bit better in that regard, it was actually surprisingly good after they pushed out some updates).

On long sessions even with workflows and sub-agents I typically hit around 500-750k tokens in context (say 4-16 hours of work in a session, across multiple 5-hour limits) with Claude Code.

I was going to explore paying for Codex since OpenAI seems to be a bit more generous with rate limits, but I'm now not sure - for the stuff I do limited context size would be a dealbreaker - basically lots and lots of documentation and guideline references, code review loops, documentation references and web searches, multi-repo exploration, lots of tool calls and so on.

I might just upgrade to Anthropic's more expensive Max subscription or something to get more subsidized tokens. Even with plan files and the plan mode, it's like a slot machine after compacting the context, sometimes steps or other details just evaporate in thin air, the less of that I need to do the better. It's not that it can't work, it just doesn't work reliably enough not to be annoying.

Luckily DeepSeek V4 Pro, GLM 5.2 and Kimi K3 don't seem to have those limits either - though DS is around Sonnet, GLM 5.2 feels a bit above Sonnet and only K3 only really is in the proper Opus ballpark that's good enough for me to work undisturbed, even if it seems to be slower.

I just hope that they’ll soon also have like 35B or 80B (like the older Qwen3 Next or thereabout) MoE models that can be run locally.

Like, throw us a bone, we all know we need SOTA for lots of dev work anyways, but at least some tasks can be local.

A simple git push is usually instant but that comes with an overload of some un intended changes being pushed, which LLMs take care of removing themselves.

In my experience it can often be the opposite - AI would commit a lot of slop comments and sometimes unnecessary stuff, whereas if you can review things in GitKraken or another program with diffs, things are closer to what you want. Writing commit messages and PR descriptions (maybe change summaries, the intro less so) is easily outsourced to the LLMs though.

I don’t think that it is possible to both allow the use of LLM and not mandate them in modern metric driven work places.

What I’d personally be most concerned about would be the risk of bad models instead of SOTA being used which would be especially error and hallucination prone.

If you’re gonna do it, do it right. Otherwise don’t bother at all.

Also, just to be clear, the AI generated videos are quite trash.

However, you could imagine that maybe with a decade of refinement they'll get better - the existing prompting and composition were okay, it's just that they were plain bad technically. Then again, so was Will Smith eating spaghetti.

I don’t think a 128B model will be that competitive with a 2.8T model. If anything, one should wonder why Mistral is so expensive in the current day.

Those old movies with old visual effects are watchable and still enjoyable.

Id say it’s definitely possible to get spoiled by high production quality - if I went back to the old Star Trek or even the first seasons of the Doctor Who reboot, I’d mostly have to try to enjoy it for the story (then again, Doctor Who has never been overly concerned with presentation, the most fearsome aliens in the galaxy being metal boxes with plungers sticking out of them is quite silly). Same with most CGI in the older movies or even the style of older anime, it can all be a bit hard to watch.

I guess I also experience the same with video games, though to a lesser degree - some like Hidden & Dangerous 2 can still be enjoyed whereas something like Operation Flashpoint would be quite frustrating, though more often due to controls rather than graphics.

Ehh, they did what they could at the time.

I've yet to find a way to run it on a monthly sub reliably for cheaper than Codex.

Matches my experience, I got their Pro subscription and while I enjoyed the model itself a lot and while their ZCode harness is also pretty nice, it gave me less tokens for similar amounts of money that Anthropic would give me on a subscription: https://blog.kronis.dev/blog/z-ai-s-glm-5-2-is-a-great-model...

I'm yet to try out Kimi, but if their subscription were to be anywhere comparable to Anthropic/OpenAI, I might just switch over because competition is good.

DeepSeek V4 Pro is really affordable per-token but regularly kept making mistakes in the tasks I gave it. I mean I could at least afford the tokens to go over the work a 2nd, 3rd, 4th and 5th time and gradually fix most of the issues, but it was a very frustrating mode of work.

They randomly withheld £20k from a business I was involved with for no stated reason and no direct means to talk to a human about it. It took months to resolve.

If only there was a regulatory framework to turn that into an extremely simple court case, and to also punish attempts of PayPal to ban users who stand up for access to their money.

If they’re a near-monopoly they shouldn’t be allowed to set their own rules.

If they somehow make it approach Fable in capability, I’ll be quite surprised!

...while KIMI and DeepSeek will release Fable-class models this week.

What new model is DeepSeek releasing? Their current V4 Pro at Max reasoning is consistently worse than GLM 5.2 at Max reasoning, though the latter is close to Opus 4.8 at Extra/Max reasoning, albeit a little bit worse in my experience (though if they gave comparable amounts of tokens to Anthropic 5x Max subscription I could see myself moving over, currently they give you less though even with their ZCode discount).

In practical agentic development, none of those seem to be that close to Fable to me. Spent 181 million tokens with GLM 5.2 with ZCode in the past month, 142 million with DeepSeek V4 Pro with ZCode and OpenCode and about 3.45 billion across all Anthropic models with Claude Code, though understandably with my workload between 95-99% of them are cached (very docs/plan/tooling/read heavy work to limit slop, albeit with sub-agents and workflows).

You can run each of your virtual desktops as their own user. You can run individual apps on the same desktop as different user accounts.

Literally never have I ever seen any of the desktop environments integrate this conveniently, albeit CLIs are better in that regard. "You can" isn't the same as "it's the idiomatic approach to doing X". Same with installing packages in a per-user way, so a bad package can't harm anything outside of its sandbox (which in practice you achieve with containers, but those can be inconvenient to work with and you'd probably want VMs for more security anyways). You can have many users, sure, but all it takes is one bad system-wide package, one bad script executed as root (e.g. install scripts, compromised packages) or even not being careful enough with file permissions and things go wrong.

Contrast that to Qubes: https://doc.qubes-os.org/en/latest/introduction/intro.html#q...

Now that was literally built for such a use case (it's based on isolated VMs and works well with Linux distros inside those, really cool project).

I hope some day they just train the models to be better, the slop writing is insanely frustrating and I don't think there's a good reason for things to be that way (in other words, they just trained it badly) https://blog.kronis.dev/blog/ai-slop-is-a-self-inflicted-tra...

I'd suggest CLAUDE.md or README.md (and just write in CLAUDE.md that instructions are in README.md, if they're also supposed to be used by human devs) for scripts and other operative instructions.

Ideally also the PLAN MODE for any long form work within the same session, possibly with sub-agents or dynamic workflows to not pollute the main context too quickly.

It also has a memory mechanism but holy shit is it annoying when it saves meaningless stuff that quickly becomes outdated.

If you want to go far, go together

Unless you encounter circumstances where it's death by committee (or something similarly bad), but overall I agree! It's just that you don't have the bad environment risk/problem when it's just you.

Yeah, my bad, though I’ve also heard those arguments more or less said genuinely - on one hand people hold LLMs to some unreasonably high standard, expecting to one shot apps before being deemed good, and on the other just outputting slop with no regard for the quality.

It’s up there with Stride

Edit: I mean that it's up there with Flax: https://flaxengine.com/ whoops

Stride, Flax and jMonkeyEngine are all pretty cool, not just Godot and O3DE!

What a take with no nuance.

do not hallucinate

They do, just less. To the degree of being usable, as long as there are guardrails and they're used responsibly. For example, if there's code being output, there should be type checking and compilation, as well as code tests that prove that it works or that it doesn't - seeing how abysmal code coverage is in most of the projects I've seem, for whatever reason people thought that they didn't really need it much. They were wrong.

This also implies you need SOTA models on max reasoning.

make things up

Same as above. Ideally you'd give them some way to verify their claims, like web search or browsing and referencing docs, Jira tickets etc., basically improve the signal to noise ratio.

contradict themselves

They do so way less than before, as long as the above is true.

can review their own output into perfection

They are pretty good at reviewing things, especially if you make them do adversarial review! It will never be perfect, but can be close in quality to human output (e.g. the code they produce, when used properly and with intent, is better than the code I've seen many developers write and ship before LLMs were a thing).

This also more or less scales with how much compute you give them - three parallel review agents will turn one output artifact into something good with higher confidence than two, and definitely better than with no review. There's a cost vs quality balance and it seems that all those xhigh and max reasoning modes are still geared way too much towards cost, instead of quality. So you have to make up for that shortcoming yourself.

regardless of task, goal or context????

Garbage in, garbage out. I won't be an asshole and say that you're holding it wrong, nor will I say that anyone should listen to the claims marketing AI (absolutely delusional takes, meant to attract investors), but we're slowly getting to a better position in regards to LLMs, year by year.

It's just a shame that the peak of inflated expectations hit while the technology still hasn't fully plateaued and reached whatever its ceiling is.

I probably also shouldn't ignore the fact that some people will not care about any of it and send AI generated slop verbatim and to an outside observer there's no way to easily tell apart the difference between the two, unless you make a technical report contain exact references to where the data is sourced from, for example (and then either verify the references yourself, or make another agent do it).

In the past (before LLMs) it was already hard to keep up, but now it feels like there's 10x more things waiting at any given time, and there could be 10x more if everyone just "optimized" and streamlined processes fed the AI even more tasks in parallel faster.

I find LLMs to help me manage the unrealistic workload I have, because at least now it's feasible instead of just getting more work piled on top of me with a never ending backlog (that people actually expect me to thin, not let grow). Add on top of that colleagues that would have death by commitee'd many ideas and now just have to argue against actual MVPs that work instead of ideas (or can be proven to not work and discarded without wasting time on them in some cases), and I don't even hate my job as much!

It's just that to ensure that the technology is not a net negative, I need millions upon millions of tokens every single day (tool runs, adversarial reviews, testing), but once you get that inflection point, alongside needing a good enough model, the floor for which currently I'd say GLM 5.2 on Max reasoning reaches, or use something like SOTA Anthropic/OpenAI models, it becomes a pretty good way of working. That said if you have missing pieces there (e.g. using cheap models that aren't very good), the curve of getting stuff done can go downwards and you'll just end up with a lot of slop - useless docs, bad code and an ever increasing amount of technical debt.

On average, each task that I do, needs about 15 minutes to 2 hours of planning and making the agents explore the codebase and refine the plans first.

Curiously, in my case this leads to less burnout cause I can actually pause and grab a drink, meal or go for a walk, while parallel agents do the work, once I've planned things well enough and have dispatched something that will work for 1-4 hours. I don't have to review their output immediately once they finish but can just batch things.

But my guess is that maybe it doesn’t have as robust a test suite?

Not sure about what's going on over there, but over the last year Claude Code has gotten way better, I sure hope that they're working on a good enough test suite to avoid a crapload of regressions (and pave way for more refactoring, should they need it).