Honestly I would not be surprised when it actually IS claude using those resources... It is very clearly vibed
But modern bloat manages perfectly well to make apps that wait for network calls run poorly enough to give you a bad experience.
(I actually have/am writing a harness in Java fwiw, but mostly as a hobby/experimentation)
Having Oracle's tramp-stamp on it may have been the final kiss of death in terms of totally-superficial "coolness" factor.
I stopped paying attention the third time they redefined matrix arithmetic semantics. That happened to be around the 100th time I was sent a script and it only ran on the author’s machine. Maybe they will fix it some day. When they do, I will not believe it.
In contrast, TS has a much nicer type system and better async support. It runs well on web, mobile, desktop and server. Yes, sometimes you have to ship node.js or a whole web browser, but the tooling for that is slightly less insane than the analogous tooling for python.
Its language interoperability story is slightly nicer too (invoke native code, or use wasm). It’s UI story is much, much better since it reuses all the web stuff.
Pip practically invented the supply chain attack; npm perfected it. That’s probably a draw.
Of course, if you care about performance, then other choices make more sense. If you’re training a model then python probably still wins, but very few customers have a $1M+ machine.
Any reason why it should not be written in nodejs?
There’s an interesting counter example for DeepSeek called CodeWhale, though:
The documentation, built from repo, is available here: https://deepseek-harness.github.io/deepseek-harness/en/guide... (I find the development and reference sections easier to read and navigate)
Do the first party harnesses really have an advantage when paired with the maker's model?
I also just do a bit of hand-coding to guide the agent still.
I worry the $200 / month plans are loss-leaders encouraging you to maximize token usage to churn out slop, rather than thoughtfully use coding agents in a way that still engages your brain, and produces good software.
Anyway very happy with it, I use it as a plugin to RubyMine and Webstorm.
One of the primary advantages is being able to choose your model - and it often has free deals for newer models that are running promotions. Whenever I switch to Claude Code it seems clunky. Would rather use Claude with Cascade.
Instead, they currently own the entire Pareto frontier — they have the lowest cost model (in terms of inference and training) at every commercially-available level of output quality.
We saw the same attitude from Silicon Graphics, Sun, etc vs Linux and Windows during the 1990s. It led to those companies’ ruin.
Concretely, I remember lots of arguments that the Linux kernel team would stall out once they implemented posix, since that was the end of the “copy for the sake of compatibility” runway.
While making such claims, none of the Unix vendors produced anything vaguely price-competitive with whitebox PCs (they were slightly better for niche workloads at 10x the cost, with crippling guardrails, er, license gated features).
Those vendors even tried getting the US government to intervene with procurement regulations, etc.
Anyone that was paying attention during the dotcom era should know how the current bubble ends.
Aren't VS Code, Claude Code, Hermes Agent, Goose or Letta harnesses, but with UI, too?
This other day I was looking at that “caveman” skill, and was shocked to see it evolved to become a company, and, in one of its modes, the highest form of compression seems to be “Wenyan” which is Classical Chinese.
Should I get started on learning Chinese?
For those who want to know what it achieves: it adds a hot-reload, dynamic enable/dispose capability to the plugin system in Pi agents, though they push the boundaries further, to the UI components and so on.
For those who want to know what it does: if you have some PLT knowledge, ask your agent to explain the algebra to you better; for those who aren't familiar, the framework requires each plugin to provide how it initializes and how it destructs (like C++'s RAII, Rust's Drop trait and so on), and the runtime will then properly handle the lifecycle events and the common pitfalls. In addition, it provides a clean way to declare the dependencies between plugins, and the runtime will also properly process the lifecycle changes on a broader plane.
I think it's worth reading if you are not familiar with OSGi, iPOJO, React's useEffect and so on (which the paper itself mentions); for others, a skim is enough: it does point out the gotchas for some common problems, but the algebra may not help you further.
If anybody has tried it, does it let you preview components in any frontend framework with perfect fidelity? That would be a big win.
oof
What if DeepSeek never copied anything from anyone? They cannot prove something they haven't done.
Same here, you gotta provide the proof or at least trace of where DS might have done so.
---
Also in this field, nothing is original
"Everything the model sees is recorded in an append-only session log: system prompts, reasoning, tool calls and results, subagent scheduling, and every context injection. In the Trajectory view, you can inspect these records by source. Resume, fork, search, and replay all operate on the same event stream."
Seems pretty helpful - have sort of wanted something similar (I use Pi).
They also released this research paper that backs their whole plugin composability system that seems pretty cool: https://github.com/cordiverse/paper
217•52m ago
esafak•7m ago