One interesting quirk of the AI-written READMEs these days is how they can include every detail on how it works, thoroughly document every optional flag, known limitation, experimental result, and still not communicate the essence of the project and the problem it solves.
I have read through the project and I still don't understand what this thing is for and why it is to be preferred over the harness's native memory management tools.
Yeah, I've started dialing back my use of AI for READMEs because of this.
My previous rule was that I never use AI for writing that expresses my own opinions or tries to be convincing (anything on my blog for example) but I'll let it do technical documentation.
The top of a README is about convincing and explaining why I built something though, which means it should fit my no-AI policy after all.
Just prompt the AI to keep README concise and to the point, and to remove any implementation details that don't belong in README-style documents. I regularly run such debloating/decluttering prompts on my docs.
I don't understand people leveling criticisms at the output of AI, when that is exactly how you program them. Have people all forgotten the "prompt engineer" phase of our roles?
Give them 2 positive examples. A list of things to do, a list of things not to do and you have them giving you the exact output you want.
"Write a readme make no misteaks" is not deft usage.
The AI language really stands out, too. "What is automatic and what depends on the agent". A human might write, "jevmen watches your coding session with Claude Code or Codex and picks just the right moment to remember important things that you decided along the way. There are some differences in how jevmem works, depending on which coding harness you are using. The table below summarizes these differences:"
I don't know why the models were generally trained to be so brief, but it's definitely not the way anyone I know actually writes. A second pass is always a good idea to clean this stuff up. And, thankfully, the models are all pretty good at that.
The big tell for me is assuming the reader has context straight out the gate. "What is automatic and what depends on the agent" assumes the reader, like the LLM at the time it wrote that sentence, has all of this pre-context available. That sentence makes more sense as an h3 header further down in some detailed list where the human has all of the knowledge of how the system works. Whereas a human obviously does not, so they lead with the important context of why you give a shit
My pet theory is that while the pretraining -> RL pipeline achieves very impressive results, it does not reward clarity of thought or elegance. It's not obvious whether it even should for most tasks, but it does grind on me as a human who needs elegance in order to keep everything under control. You give astra/codex many tasks, it retires them all more efficiently than I could by hand. But you look under the hood and every bugfix is another codepath, it just hammers away at things with admirable persistence and vigor until the tests pass. Similarly in discussions and docs, I've noticed many LLMs like to "beat around the bush."
it does not reward clarity of thought or elegance.
Well duh. RL can only train behaviors that can be defined. Clarity and elegance are damn subjective.
Also, I doubt we'll ever get AI to understand what clarity is to a human. They have such enormous contexts that what's clear to them is not clear to us.
Subjective doesn't mean you can't define it. RL works well for human preference and any other subjective goal as long as it's defined. In fact Claude used to be trained for human likeness, reading between the lines, character, languages, and understanding the intent. Claude 3 was outstanding in that. It was their entire marketing shtick. Then they neglected it starting with Sonnet 3.5, ignored it in favor of code since Claude 4.0, and new models completely lost their ability to write and understand humans. Code pays better.
I once told the agent explicitly not to write like it's trying to impersonate Hemingway and it started writing like a normal human being. It's surprising how a writing style that was once revolutionary is now a hallmark of sloppyness.
Maybe give it a try next time you write a readme with agents. That and giving it an example of good README in real world repos can increase dramatically the likelihood of synthesizing a serviceable README.
Next time you read I suggest focusing less on punctuation and more on style of writing, because it's not about which syntactic markers you use, but which words you choose and how you use them, emdashes notwithsanding.
He wrote in short bursts. Sentences that connect but barely. Crude, honest. It's not a style you want to use for flow. It's a style you want to use to impress.
It's a function of scarcity. Generation (or "writing" as it used to be known back in the day) is now cheap, so judgement and taste are the new bottleneck and therefore the difference between slop and effort.
AI readme should be a starting point. I typically remove at least 50% of the details (without any particular skill use, it goes into extremes like "x clears the edit" and writes a related wall of text in the middle of the important explanation).
It’s funny to me because pre-AI it’s something I something I saw all the time managing interns and junior software engineers when I’d start trying to tech them about writing design docs. You can explain the process to them and give them a million examples of what good looks like, but for a lot of them the first few docs they write will just be this weird combo of way too much information and very little of it being useful.
My belief has always been that they see the document as more like a test that’s a single task and not just one piece in a larger process and so they treat it like a test where there’s a right answer. They know they don’t really understand the question being asked though so they default to a mindset of, “Well if I just put everything in there some of it has to contain the correct answer” so you end up with this document that’s full of “what”s and “how”s, but completely void of “why”s.
You’ll also often see them fill up space answering easy questions that match the structure of things that are in other documents instead of focusing on the actual hard problems in the design because the hard problems are often unique and their answers may not fit the existing patterns in the examples. There isn’t the instinct to go, “Yeah, none of these example documents talk about the servers were going to deploy it on, but this has to be deployed in an EU cluster because of GDPR laws so I need to add that” because they’re mostly just pattern matching at first.
Usually once they’ve experienced the whole process first hand it starts to click because they start to understand where a design document fits into the larger process so they get a feel for what information matters and what doesn’t.
I think when people just tell an agent to create a README you have the same problem because both the human and the agent see it as just a checkbox type task. The agent sees it as an isolated task snd has no fucking idea how the README is going to be used and the human isn’t giving them that context so they just spit out a bunch of stuff that’s factual and fits the patterns it knows, but is fairly useless.
> When you change your mind, the old line is marked superseded, not deleted
To me, this seems like a design error. You're polluting context with false/outdated information (even if the LLM is instructed to ignore it). The biggest issue with the memory systems built into Claude et al. is that they're terrible at pruning old/conflicting information as the project evolves, so I'd hope a replacement would do something to improve that.
> Its an avenue already visited, tried and abandoned
I suppose if you could guarantee that the nondeterministic model can not only know all of those disparate pieces of information, but connect them together in that order, and arrive at a decision that it was abandoned because it was already visited and tried, every time.
I’m looking at the LLM-generated SECURITY.md and this thing seems to pump a LOT of information back to some place called TypeSafe AI. That and the AI-generated comments from OP here make a few red flags go up for me.
TypeSafe AI are the providers for Jev. This complaint is like saying it’s a red flag that Claude Code sends lots of information to somewhere called Anthropic.
Ah, well that makes a bit more sense. Admittedly I haven’t really looked into Jev and thought it was an open decision model rather than a proprietary product from TypeSafe.
deciduous seems like a great way to ensure there is no space left in context for useful work.
Problem with all these automatic memory managment tools is that they can't reliably classify if something is useful or not. Once it start using some tool it will heavily become biased towards using that tool during that session. First you will have decision to use postgres as a database, by the end of session it will start saving "decided to use SELECT query for this method because that is how you pull data out of database".
Just start a cheap chinese agent in a context where it has only one tool, and JSON-schema constrain that toolcall to the response shape you want. Prompt the agent to make only one tool call and not speak. Done.
The people that run local jev like models do sth similar. Train a seperate nn adapter on top of qwen 4b so it has balanced probabilities whatever that means and apparently it works quite well.
Side note: conspiracy theorists say that jev is a qwen model fine tuned but who know if true
jevmem watches Claude Code, Cursor & Codex chats and keeps a JEVMEM.md in your repo up to date. After each message, Jev (TypeSafe) decides whether anything is worth remembering — a decision, a bug, a change of mind — and writes the keepers to that file. Reversed decisions get marked superseded.
Install: npm i -g jevmem (needs a TypeSafe API key)
Held-out check on 66 messages (23 Sep 2026) vs six frontier LLMs: save/skip 98.5% (tied with Astra); save+correct kind 95.5% (Astra 98.5%, Opus 97.0%); changes of mind 5/5; median 0.30s via Jev API (~0.6s end-to-end) vs 2.8–4.3s for the LLMs; cost $0.000127/decision. Single run by me — treat 1–2 message swings as noise.
Limits: early v0.4; fully automatic only in Claude Code today (Cursor/Codex via agent/MCP); messages go to the TypeSafe API with secrets stripped; if the API is down it skips.
One interesting quirk of the AI-written READMEs these days is how they can include every detail on how it works, thoroughly document every optional flag, known limitation, experimental result, and still not communicate the essence of the project and the problem it solves.
I have read through the project and I still don't understand what this thing is for and why it is to be preferred over the harness's native memory management tools.
Yeah, I've started dialing back my use of AI for READMEs because of this.
My previous rule was that I never use AI for writing that expresses my own opinions or tries to be convincing (anything on my blog for example) but I'll let it do technical documentation.
The top of a README is about convincing and explaining why I built something though, which means it should fit my no-AI policy after all.
Just prompt the AI to keep README concise and to the point, and to remove any implementation details that don't belong in README-style documents. I regularly run such debloating/decluttering prompts on my docs.
I don't understand people leveling criticisms at the output of AI, when that is exactly how you program them. Have people all forgotten the "prompt engineer" phase of our roles?
Give them 2 positive examples. A list of things to do, a list of things not to do and you have them giving you the exact output you want.
"Write a readme make no misteaks" is not deft usage.
The AI language really stands out, too. "What is automatic and what depends on the agent". A human might write, "jevmen watches your coding session with Claude Code or Codex and picks just the right moment to remember important things that you decided along the way. There are some differences in how jevmem works, depending on which coding harness you are using. The table below summarizes these differences:"
I don't know why the models were generally trained to be so brief, but it's definitely not the way anyone I know actually writes. A second pass is always a good idea to clean this stuff up. And, thankfully, the models are all pretty good at that.
The big tell for me is assuming the reader has context straight out the gate. "What is automatic and what depends on the agent" assumes the reader, like the LLM at the time it wrote that sentence, has all of this pre-context available. That sentence makes more sense as an h3 header further down in some detailed list where the human has all of the knowledge of how the system works. Whereas a human obviously does not, so they lead with the important context of why you give a shit
My pet theory is that while the pretraining -> RL pipeline achieves very impressive results, it does not reward clarity of thought or elegance. It's not obvious whether it even should for most tasks, but it does grind on me as a human who needs elegance in order to keep everything under control. You give astra/codex many tasks, it retires them all more efficiently than I could by hand. But you look under the hood and every bugfix is another codepath, it just hammers away at things with admirable persistence and vigor until the tests pass. Similarly in discussions and docs, I've noticed many LLMs like to "beat around the bush."
it does not reward clarity of thought or elegance.
Well duh. RL can only train behaviors that can be defined. Clarity and elegance are damn subjective.
Also, I doubt we'll ever get AI to understand what clarity is to a human. They have such enormous contexts that what's clear to them is not clear to us.
Subjective doesn't mean you can't define it. RL works well for human preference and any other subjective goal as long as it's defined. In fact Claude used to be trained for human likeness, reading between the lines, character, languages, and understanding the intent. Claude 3 was outstanding in that. It was their entire marketing shtick. Then they neglected it starting with Sonnet 3.5, ignored it in favor of code since Claude 4.0, and new models completely lost their ability to write and understand humans. Code pays better.
I once told the agent explicitly not to write like it's trying to impersonate Hemingway and it started writing like a normal human being. It's surprising how a writing style that was once revolutionary is now a hallmark of sloppyness.
Maybe give it a try next time you write a readme with agents. That and giving it an example of good README in real world repos can increase dramatically the likelihood of synthesizing a serviceable README.
I don't recall Hemingway ever using semicolons or em-dashes.
Next time you read I suggest focusing less on punctuation and more on style of writing, because it's not about which syntactic markers you use, but which words you choose and how you use them, emdashes notwithsanding.
Hemingway did not write like a LinkedIn influencer, if that's what you mean.
He wrote in short bursts. Sentences that connect but barely. Crude, honest. It's not a style you want to use for flow. It's a style you want to use to impress.
It's a function of scarcity. Generation (or "writing" as it used to be known back in the day) is now cheap, so judgement and taste are the new bottleneck and therefore the difference between slop and effort.
AI readme should be a starting point. I typically remove at least 50% of the details (without any particular skill use, it goes into extremes like "x clears the edit" and writes a related wall of text in the middle of the important explanation).
This is quite easily promptable. Tricks like these do well: https://news.ycombinator.com/item?id=49065956
It’s funny to me because pre-AI it’s something I something I saw all the time managing interns and junior software engineers when I’d start trying to tech them about writing design docs. You can explain the process to them and give them a million examples of what good looks like, but for a lot of them the first few docs they write will just be this weird combo of way too much information and very little of it being useful.
My belief has always been that they see the document as more like a test that’s a single task and not just one piece in a larger process and so they treat it like a test where there’s a right answer. They know they don’t really understand the question being asked though so they default to a mindset of, “Well if I just put everything in there some of it has to contain the correct answer” so you end up with this document that’s full of “what”s and “how”s, but completely void of “why”s.
You’ll also often see them fill up space answering easy questions that match the structure of things that are in other documents instead of focusing on the actual hard problems in the design because the hard problems are often unique and their answers may not fit the existing patterns in the examples. There isn’t the instinct to go, “Yeah, none of these example documents talk about the servers were going to deploy it on, but this has to be deployed in an EU cluster because of GDPR laws so I need to add that” because they’re mostly just pattern matching at first.
Usually once they’ve experienced the whole process first hand it starts to click because they start to understand where a design document fits into the larger process so they get a feel for what information matters and what doesn’t.
I think when people just tell an agent to create a README you have the same problem because both the human and the agent see it as just a checkbox type task. The agent sees it as an isolated task snd has no fucking idea how the README is going to be used and the human isn’t giving them that context so they just spit out a bunch of stuff that’s factual and fits the patterns it knows, but is fairly useless.
[flagged]
[flagged]
[flagged]
> When you change your mind, the old line is marked superseded, not deleted
To me, this seems like a design error. You're polluting context with false/outdated information (even if the LLM is instructed to ignore it). The biggest issue with the memory systems built into Claude et al. is that they're terrible at pruning old/conflicting information as the project evolves, so I'd hope a replacement would do something to improve that.
I've recently started trying out a little approach that half makes me cringe as I think of gastown, but sharing FWIW
- All decisions get logged to DECISIONS.md, sequentially
- Before writing a decision, read through past decisions to see if any conflicts
- If no conflicts, encode the decision into the CODE.md
- If any conflicts, ask a Tribunal of 3 agents to find a resolution—each of them should be prompted in slightly different ways
I've only done this for one pretty big project but so far it seems to be working well
It's such a Claudism.
Everything is inundated with info about other things tried.
Comments and docs flooded with things found out in the process when you want something about the info you need to know now.
From reading the readme, it looks like superseded decisions are not added to context.
> Next session, the relevant lines are added to Claude's context.
At least that's how I interpret it? If it is adding superseded decisions, that does seem bad.
Is it outdated? Its an avenue already visited, tried and abandoned, so valuable info regarding architectural decisions.
> Its an avenue already visited, tried and abandoned
I suppose if you could guarantee that the nondeterministic model can not only know all of those disparate pieces of information, but connect them together in that order, and arrive at a decision that it was abandoned because it was already visited and tried, every time.
[flagged]
[flagged]
[flagged]
I’m looking at the LLM-generated SECURITY.md and this thing seems to pump a LOT of information back to some place called TypeSafe AI. That and the AI-generated comments from OP here make a few red flags go up for me.
TypeSafe AI are the providers for Jev. This complaint is like saying it’s a red flag that Claude Code sends lots of information to somewhere called Anthropic.
Ah, well that makes a bit more sense. Admittedly I haven’t really looked into Jev and thought it was an open decision model rather than a proprietary product from TypeSafe.
[dead]
a supercollision of 2024 hype with 2026 hype
I'd rather make a decision on where else to put the contents of a generated memory file than to maintain a memory layer
Curious how this compares to my own tool, https://deciduous.dev
I will have to give it a run-through today.
I haven't used Jev yet so this should be interesting. I'd be interested to see if any Deciduous users have opinions, too.
deciduous seems like a great way to ensure there is no space left in context for useful work.
Problem with all these automatic memory managment tools is that they can't reliably classify if something is useful or not. Once it start using some tool it will heavily become biased towards using that tool during that session. First you will have decision to use postgres as a database, by the end of session it will start saving "decided to use SELECT query for this method because that is how you pull data out of database".
Not how it goes in practice at all, would encourage you to actually try it out.
[flagged]
[flagged]
[flagged]
[dead]
Does it thrash the session's KV cache?
I really don't undertstand the jev-hype.
Just start a cheap chinese agent in a context where it has only one tool, and JSON-schema constrain that toolcall to the response shape you want. Prompt the agent to make only one tool call and not speak. Done.
The people that run local jev like models do sth similar. Train a seperate nn adapter on top of qwen 4b so it has balanced probabilities whatever that means and apparently it works quite well.
Side note: conspiracy theorists say that jev is a qwen model fine tuned but who know if true
something I always wanted
Every user turn, the previous two turns, and your whole memory file go to TypeSafe AI, a young vendor.
[flagged]
[flagged]
[flagged]
[flagged]
jevmem watches Claude Code, Cursor & Codex chats and keeps a JEVMEM.md in your repo up to date. After each message, Jev (TypeSafe) decides whether anything is worth remembering — a decision, a bug, a change of mind — and writes the keepers to that file. Reversed decisions get marked superseded.
Install: npm i -g jevmem (needs a TypeSafe API key)
Held-out check on 66 messages (23 Sep 2026) vs six frontier LLMs: save/skip 98.5% (tied with Astra); save+correct kind 95.5% (Astra 98.5%, Opus 97.0%); changes of mind 5/5; median 0.30s via Jev API (~0.6s end-to-end) vs 2.8–4.3s for the LLMs; cost $0.000127/decision. Single run by me — treat 1–2 message swings as noise.
Limits: early v0.4; fully automatic only in Claude Code today (Cursor/Codex via agent/MCP); messages go to the TypeSafe API with secrets stripped; if the API is down it skips.
Wake me up from this nightmare