The editorial argues that Kulaxyz has found a cross-agent primitive that drops unchanged into Claude Code, Codex, Cursor, Windsurf, and Cline — five agents that share no company, spec, or roadmap. This de facto standardization from a single indie repo is more significant than either individual skill's mechanics.
Kulaxyz frames token-diet as an always-on skill that trims prompts and tool outputs — pruning tool call transcripts, collapsing redundant file reads, stripping whitespace from grep output — and claims ~31% lower bills with no loss of correctness. The pitch is that the savings are boring mechanics, not benchmark tricks.
The editorial endorses the framing that a 31% reduction is the difference between evaluating a tool and buying fifty seats. Cost, not correctness, is what makes or breaks adoption at team scale, and prunable transcript bloat is the wound this patches.
Kulaxyz positions self-learning-skills as a fix for the amnesia problem: it watches a session for the one path that actually worked (usually after three that didn't) and harvests it into a reusable skill or rule for next time. The 994 stars and 24 comments suggest the memory-across-sessions problem resonates more strongly than raw cost reduction.
The editorial reads both repos as patches on the same wound from different sides — amnesia between sessions and expensive memory within them. Self-learning-skills attacks the amnesia side by turning hard-won working paths into durable primitives the agent can reach for next time.
Two repos from the same GitHub account, [Kulaxyz](https://github.com/Kulaxyz), are trending this week. The first is token-diet: an always-on skill for coding agents that trims prompts and tool outputs, claiming ~31% lower bill on average with no loss of correctness. 425 stars and climbing. The second is self-learning-skills: 994 stars, and it does something narrower and more interesting — it watches a coding session for the one path that actually worked (usually after three that didn't) and harvests it into a reusable skill or rule for next time.
Both repos list the same target matrix in the README: Claude Code, Codex, Cursor, Windsurf, Cline. Not "compatible with," not "port available" — the same file drops into all five. That's the story worth reading.
One indie dev is quietly standardizing what a "skill" looks like across five coding agents that don't share a spec, a company, or a roadmap. Anthropic ships Claude Code with its own skills format. Cursor has .cursor/rules. Windsurf has cascade rules. Codex reads AGENTS.md. Cline has its own. Kulaxyz found the shape that fits all of them and started shipping reference implementations.
The uncomfortable read on coding agents right now is that every one of them ships with amnesia and expensive memory. Amnesia because context resets between sessions. Expensive because the workaround — cramming your entire repo into a 200k-token window — is a linear cost function against your monthly bill. Both of Kulaxyz's repos are patches on the same wound, from different sides.
token-diet attacks the cost. The mechanic is boring in a good way: it prunes tool call transcripts, collapses redundant file reads, strips whitespace from grep output, and does the small unglamorous work that agent authors keep meaning to do and never getting around to. A 31% reduction is not a benchmark trick — it's the difference between "we're evaluating Cursor for the team" and "we bought fifty seats." If the numbers hold under adversarial testing (they might not — the README doesn't say what dataset produced the 31%), this is the kind of optimization that gets absorbed into the agents themselves within a quarter.
self-learning-skills is the more interesting repo. The premise: your coding agent's "memory" isn't memory, it's an append-only log of every typo, dead end, and abandoned refactor. Vector retrieval over that log gives you the average of your mistakes, not the golden path. self-learning-skills instead asks the agent, at the end of a session, one specific question: *what did you wish you knew when we started?* Then it writes that answer into a skill file the next session actually reads.
This is the first "agent memory" primitive I've seen that treats the session as a source of expertise instead of context. It's also the mechanic that could reframe the whole prompt-engineering-is-dead debate. You're not writing prompts anymore — you're curating a growing library of hard-won heuristics that your agent wrote for you, one session at a time.
The community reaction has been telling. On Hacker News, the self-learning repo drew comparisons to Emacs Lisp and Smalltalk image-based development — languages where the environment learns and persists what you did. That's not wrong. What's new is that the "language" here is English, and the runtime is a coding agent that's already reading your repo. The bar to instrument your own workflow just dropped by an order of magnitude.
If you're on Claude Code or Cursor and haven't tried a skills-style file yet, this is the week. Two concrete moves:
First, drop token-diet into your project and measure. Don't take the 31% on faith — instrument your API bill for a week before and after. The savings are real but the shape of the savings depends on your workflow. Repos with lots of tool calls (grep, find, cat) benefit more than repos where the agent mostly writes new code. If you're already using Claude Code with the file-search skill, some of the wins overlap.
Second, and more importantly, adopt the self-learning-skills pattern even if you don't use the repo. At the end of any non-trivial session, ask your agent to write a one-page "skill" describing the path that worked, and check it into your repo. Over three months, this becomes the highest-leverage documentation your team owns. It's also the only documentation that gets updated automatically, because the next session that hits the same problem will refine it.
The deeper implication for tool builders: if the skills format stabilizes across five agents, it becomes the next .eslintrc — a single file every tool respects, portable between vendors, versionable in git. That's a big deal. It means teams can switch coding agents the way they switch linters, without losing their institutional knowledge. Vendor lock-in on coding agents has been the quiet worry for anyone deploying them at scale. A shared skills format is the escape hatch.
The skills format won't get standardized by a committee. It'll get standardized the way markdown got standardized — one popular reference implementation, then everyone copies the shape. Kulaxyz's repos aren't the reference implementation yet, but the fact that 994 stars accrued on a repo whose value prop is *"we handle five agents from one file"* tells you the demand for that primitive is there. Watch what Anthropic and Cursor ship next. If either of them adopts a schema that reads Kulaxyz's format without modification, the standard is settled.
A self-improving skill for AI coding agents (Claude Code, Cursor, AGENTS.md): recognize a hard-won golden path in a session and harvest it into a reusable skill/rule for next time.
→ read on GitHubAlways-on token-efficiency skill for coding agents (Claude Code, Codex, Cursor, Windsurf, Cline). ~31% lower bill on average, no loss of correctness.
→ read on GitHubTop 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.