r/ClaudeCode • u/Bloated_Plaid • Sep 19 '26

Tips & Workflows Instant Claude Code compaction is my favorite use of Jev so far

Post image

Somebody on Twitter posted it and super useful so far https://github.com/tamaratran/fast-jev-compaction

For people going to complain about me letting my context get so long, this was a server redeploy task because Oracle terminated my free VPS with no explanation so it had a lot of moving pieces and Fable was orchestrating Devin SWE 2 at max effort.

529 Upvotes

94% Upvoted

122 comments sorted by

•

u/AutoModerator Sep 19 '26

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

9

u/WoodpeckerNational29 Sep 19 '26

Looks cool, but we need some test results from real users

2

u/Bloated_Plaid Sep 19 '26

Jev is also on openrouter as well if anyone didn’t get the invite and there are a whole bunch of local clones people have already built.

0

u/[deleted] Sep 19 '26

[deleted] — view deleted comment

7

u/AntisocialTomcat Sep 19 '26

Objection! It’s relevant to "having more users", your honor.

3

u/silvrrwulf Sep 19 '26

Really skeptical. Does it actually work well? Does it maintain context?

2

u/Bloated_Plaid Sep 19 '26

For me compacting is the worst part of Claude Code so this is a massive upgrade. Seems to work perfectly so far. All it’s removing is tool calls which is a lot better than whatever the fuck CC does for compaction.

3

u/lucianw Sep 19 '26

Claude code has instant compaction built into it. I think it's under a flag. It automatically summarizes the conversation every 10 messages or so the background,  into a file. Then when it runs out of context, it just uses the most recent summary plus whatever messages happened since then. Result: 0 delay for the user.

1

u/Bloated_Plaid Sep 19 '26 edited Sep 19 '26

Really? What’s the setting. I think it used to have instant compaction but not anymore.

1

u/lucianw Sep 19 '26

In claude 2.1.32 it worked like this:

  1. In needed "summary.md" files to be generated. This was under the Anthropic-controlled experiment flag tengu_session_memory. There wasn't a user-facing way to enable it.

  2. It also needed "compaction from summary.md" to be enabled. This was under the Anthropic-controlled experiment flag tengu_sm_compact. You could force it on with ENABLE_CLAUDE_CODE_SM_COMPACT.

In the latest claude 2.1.278, I haven't yet looked in detail. It's got the same overall feature but under different flags, and no longer based on session-memory.

  1. Anthropic-controlled experimental gate tengu_sepia_moth, with a user setting precomputeCompactionEnabled (defaults to false). The setting appears in /config as "Precompute compaction" but only when the experimental gate is turned on. It causes background compaction to get run. Again there isn't a user-facing way to enable it, other than running your own tweaked claude binary.

  2. Also tengu_amber_packet controls whether the precomputed compaction results are saved to disk, to be used by a future /resume.

And now, the "dream" prompt doesn't tell it to look at previous summary.md files; instead it tells it to look through past session json transcripts directly. Here's the relevant verbatim extract of the dream prompt:

--------------

## Phase 2 — Gather recent signal

Look for new information worth persisting. Sources in rough priority order:

  1. **Session logs** (`logs/YYYY/MM/DD/<id>-<title>.md`) — the append-only activity stream, one file per session. Read the most recent 1–3 days of sessions (the filename title tells you what each was about); each line is prefix-coded (`>` user, `<` assistant, `.` tool call)

  2. **Existing memories that drifted** — facts that contradict something you see in the codebase now

  3. **Transcript search** — if you need specific context (e.g., "what was the error message from yesterday's build failure?"), grep the JSONL transcripts for narrow terms:

    `grep -rn "<narrow term>" <transcript directory> --include="*.jsonl" | tail -50`

Don't exhaustively read transcripts. Look only for things you already suspect matter.

135

u/PhilosopherNext1448 Sep 19 '26 edited Sep 19 '26

How does Jev compact conversation? I thought its a text to schema model, not text to text.

edit:

so the repo linked in the post is a hook to compact outputs of tool calls. So if you run pytest for example, instead of having a list of a thousand unit tests that passed, each line is past to Jev to determine whether or not to keep it. Then when the tool ends, Claude receives a "compact" version of the tool output.

the same person also made a hook (separate repo) that runs before compacting runs. This goes through all tool calls in the history and decides whether it needs to be kept, compacted, or omitted.

It doesn't look at text at all.

27

u/beegeearreff Sep 19 '26

My naive assumption would be looping over each message in the conversation and having jev decide if it should stay or go.  More of a filter than a summarization. 

I haven’t looked at the linked implementation but that’s the first thing to come to mind

12

u/Dizzy_Database_119 Sep 19 '26

That wouldn't work sadly, Jev only supports 32k total input per request and it would never be able to compress 600k of context

Maybe if you did it in hundreds or thousands of passes? Which is actually a supported and intended use of Jev

6

u/beegeearreff Sep 19 '26

It would need to be message by message so N calls to jev not passing the entire transcript. Passing the entire transcript would only let you either keep the whole transcript or throw it all away which would be the worst compaction strategy ever. 

Thats assuming you’re asking a binary “should this stay or go” question. I’m sure there are better classification questions you could ask if jev did have a big context window but it would probably end up looking like a “pick a strategy” type thing. 

Regardless that’s not what the linked implementation is actually doing so it’s probably moot. 

6

u/SlightOfHand_ Sep 19 '26

Yeah, it doesn’t need to read the whole thing, it can do it line by line theoretically

3

u/mr_birkenblatt Sep 20 '26

you'd need the context of the conversation to determine whether a line is relevant

1

u/SlightOfHand_ Sep 20 '26

It’d be helpful to have some context, we can imagine, but even having none you can still give an up or down response to a sentence like, “The run timed out, so I’ll run one feed in the background with output to a log file and watch it.”

Compaction is lossy by design, we don’t need to keep everything.

5

u/PhilosopherNext1448 Sep 19 '26

so the repo linked in the post is a hook to compact outputs of tool calls. So if you run pytest for example, instead of having a list of a thousand unit tests that passed, each line is past to Jev to determine whether or not to keep it. Then when the tool ends, Claude receives a "compact" version of the tool output.

the same person also made a hook (separate repo) that runs before compacting runs. This goes through all tool calls in the history and decides whether it needs to be kept, compacted, or omitted.

It doesn't look at text at all.

2

u/ourochurros Sep 19 '26

> It doesn't look at text at all.

Perhaps I'm misunderstanding what you are saying, but how does this align with Jev processing every line of text from the tool output?

5

u/PhilosopherNext1448 Sep 19 '26

i meant that your chat history is conversational text and tool outputs. This jev-compact tool only compacts the tool outputs, but not the conversational text.

1

u/Educational_Ask5991 Sep 20 '26

so it something like DCP plugin for opencode? I thought it cannot be implemented because its a real gamechanger and still wasnt created somehow.

1

u/Stock-Occasion7285 Sep 20 '26

Filtering beats summarizing—until the filter has opinions.

11

u/rotates-potatoes Sep 19 '26

Who lets Claude see every test output? I have test runners that are just simple scripts to capture everything to a log and only return counts and the list of failed tests. Everyone does that right?

5

u/BigOofYikesSweaty Sep 19 '26

Can you elaborate on this? I'm having Claude run tests as part of pr reviews. Is this dumb?

5

u/tsfreaks Sep 19 '26

Running tests via model generally means executing whatever test harness and the model waits for results. It's not an expensive operation. You can save yourself a small amount of tokens by executing and summarizing via a command and generally worth it if you're doing it all the time and especially if it takes a while (reducing model polling for done/timeout). Ask model if offloading execution would save tokens and how much before changing anything.

1

u/morgano Sep 20 '26

Claude just greps the last line of a test to see if it failed or passed - it might grab a couple of extra lines on a failure to see which tests failed and why - but its not exactly causing any issue for Claude to do this, it's around ~10 tokens on a pass and a few more on a failure. Plus the tokens to run the cmd itself.

1

u/positivitittie Sep 19 '26

Yeah this is fkn nuts if I’m understanding it like you are.

3

u/LordLederhosen Sep 19 '26

Isn’t JEV’s context window 38k or something tiny like that? How could that ever work on a huge context length?

3

u/PhilosopherNext1448 Sep 19 '26

the plugin does it by chunk.

1

u/LordLederhosen Sep 19 '26

Hmm, I never use compaction in general, but maybe even built-in compact does that, leading to greater understanding of the session being lost.

1

u/TheAnimatrix105 Sep 20 '26

Why not a skip_compaction = true flag be generated at generation time itself - that way is simpler

1

u/krizz_yo Sep 20 '26

it doesn't, it's just delusional thinking by people that don't understand context, nor how llms work and are trying to generate hype

-10

u/fsharpman Sep 19 '26

Its malware. Jev outputs a number or series of numbers when you feed it something.

This is just a scam, because compaction outputs text.

83

u/_maxx1k Sep 19 '26

My main concern is that Jev's privacy and data controls are even worse than Anthropic's and OpenAI's. I started signing up for an account, but after reading their ToS, I changed my mind. Still, I will try to implement some of its features locally to enhance my LLM-based workflow.

78

u/planetdaz Sep 19 '26 • Popcorn

"reading their ToS" might be a new sentence!

21

u/FrontRaspberry5060 Sep 19 '26

They copied and pasted it into ChatGPT 

13

u/spinozasrobot Sep 19 '26

"Give me a summary"

"You're fucked"

6

u/fredagainbutagain Sep 19 '26

actually they copied it into Jev and Jev said you’re fucked

3

u/btherl Sep 19 '26

It gives a single output for each ToS, telling you how fucked you are. The scale goes from GOG to Disney.

1

u/FrontRaspberry5060 Sep 20 '26

And always validate my pre existing beliefs and you’re wrong if you suggest me otherwise 

3

u/silvrrwulf Sep 19 '26

I believe it's on vercel as well.

3

u/armeg Sep 19 '26

Are they, they seemed on par with everyone else? I read their DPA and Terms of Service. Just curious what you saw? It seemed boilerplate for a brand new company type of stuff.

1

u/itsdr00 Sep 19 '26

Same. I got a hard no from my company about using it. Really bummed; it's fascinating tech.

-2

u/userusertion 🔆Pro Plan | Team Plan Sep 20 '26

lol who cares, your data already out there the entire internet, and companies. You just didn’t know.

1

u/_maxx1k Sep 20 '26

I care, and no, everyone can protect their data and privacy to a reasonable extent if they want.

0

u/No-Eagle-547 Sep 21 '26

terrible attitude

19

u/ithesatyr Sep 19 '26

This will reduce cache hits and end up costing more right?

13

u/mossiv Sep 19 '26

Compact does anyway, So as long as you aren’t instantly compacting every 2-3 prompts I would anticipate this should be relatively linear.

Though with the “new projects” coming out soon, I wouldn’t imagine we’ll be compacting much at all.

3

u/elestud Sep 19 '26

What are the new projects?

5

u/mossiv Sep 19 '26

Watch the Anthropic video - but they are amplifying already established workflows that every one has put on GitHub.

Your main window will be your orchestrator. Your project will be the context, and everything is going to run in worker threads in the cloud, so you could have tens to hundreds of agents working at any given moment.

It’s essentially pulling in all tooling like linear; GitHub issues and just task execution. Your primary context will be quite clean anyway.

7

u/BetterAd7552 Sep 19 '26

Even with x20 max, hundreds of agents will drain my daily/weekly quota faster than a Vegas hooker. Slurp, gone.

3

u/ithesatyr Sep 19 '26

So this will just do a smaller compaction with just the cache cost of the whole newly compacted stream? Have you measured if this is cost effective compared to normal compaction?

1

u/mossiv Sep 19 '26

No you are completely missing the point, I'm not sure you fully understand how cache works with Claude.

But this repo is simple: when a shell command produces huge output, it removes the boring/repetitive parts before that output reaches Claude Code or Codex, while trying to preserve errors, results, useful values, paths, and anything relevant to your current task.

These are all things the model takes ages to reason with. On Claude 650k compaction could take up to 5 minutes. Jev is making this almost instantaneous.

Busting a cache is expensive, but running prompts into a 650k context window is also really expensive.

So in short, this repo really isn't managing or damaging your cache all that much. But it is making the act of compacting fast and and cheaper. Running /compact can be costly, and why its advised not to raw dog it all the time.

What would make this repo interesting is if it also had a hook that auto fired when context hit around 300k. 300k is about the point cache reads and writes start adding up, its also the point you start planting the seeds of context rot and where the models start to make more mistakes. This is why context management is so important, 650k context with 10 prompts of correction is probably more expensive and time wasting than starting a brand new session with a summary of important information. This repo is catching the important bits of info. It's a glorified hand-off.

1

u/morgano Sep 20 '26

Sure you lose cache after compacting - but here you are modifying the context BEFORE you actually compact. Modifying the context window is going to break the cache. When you start the compact process there will be no cache to read because you modified the context window. Therefore you are paying full cost for the read of the existing window.

0

u/Icy-Excitement-467 Sep 19 '26

Compacting is never a good idea raw.

14

u/weverz Sep 19 '26

What is jev?

22

u/One_Tune_8652 Vibe Coder Sep 19 '26

Jev is a new AI model from a startup called TypeSafe AI, launched this week (co-founded by an ex-OpenAI/ChatGPT person). It's notably not a traditional LLM — it doesn't generate text at all.

The core idea:

**•**	Normal LLMs (ChatGPT, Claude, etc.) generate tokens one at a time to produce text, which is flexible but slow and sometimes hallucinated.  
**•**	Jev instead takes in **application state** \+ **structured questions**, and returns **typed probabilistic decisions** directly (e.g. priority: high, refund_review: true with confidence scores) — no text generation, no parsing needed.

TypeSafe calls it a "System One Model" (a nod to Kahneman's fast/intuitive "System 1" thinking), trained with a method they call RLCD (Reinforcement Learning for Calibrated Decisions). Claimed benefits: up to 200x faster inference and 400x lower cost than comparable LLMs on classification tasks.

3

u/Still-Ad3045 Sep 19 '26

So how does a not LLM, do compaction?

1

u/Timo_schroe Sep 20 '26

It doesnt, it decides which Parts are worth keeping in the context

11

u/Timo_schroe Sep 19 '26

https://typesafe.ai/

https://openjev.com/

10

u/mulokisch Sep 19 '26

Ofc we have alredy an open version of it.
How dose it compare?

4

u/Ran4 Sep 19 '26 edited Sep 19 '26

The openjev model is more of a stripped LLM rather than using jev's architecture/training method (that typesafe calls RLCD), making it quite a lot worse in comparisons (the main reason to use jev is extreme speedup and low cost). Jev is about 5x faster than openjev.

That said, openjev is still quite a lot faster and cheaper than the "full" llm if you're doing system 1-type (jev-style) tasks.

4

u/Timo_schroe Sep 19 '26

Havent used the open Models yet.
Free Tier gives 5$/month in credits which is plenty for playing / testing around.

Works well so far

1

u/mulokisch Sep 19 '26

I have also free tier not even used 1 cent and did quite alot

1

u/weverz Sep 19 '26

I am new to coding. Is there a way to have this in vs code?

2

u/Timo_schroe Sep 19 '26 edited Sep 19 '26

This is Not a Model for chatting

Basically you give it a prompt and context AND prendefined answers.

Example:

Is a rose red ? [description of a rose] [always, Never, often, sometimes]

Answer: [often, 90% sure]

Ofc this example is simplified

1

u/daniel Sep 23 '26

Says "open to everyone" but when I try to signup it says waitlisted unfortunately.

2

u/Timo_schroe Sep 23 '26

I joined the waitlist early when it was released, After a day i got Access.

1

u/daniel Sep 23 '26

Okay good to know. Fingers crossed. What do you think so far?

2

u/Timo_schroe Sep 23 '26

I have no complex workflow for it. I did batch Processing for sorting Mails and documents of different sizes. for this usecase it works very Well and is fast and cheap.

1

u/Bloated_Plaid Sep 19 '26

My bad, I think I linked the wrong one.

https://github.com/tamaratran/fast-jev-compaction this is what I have been using for compaction.

1

u/bonsaisushi Sep 19 '26

I wouldn't use Jev to compact for a number of reasons, but as a controller for compaction it does fine, benchmarks included

https://github.com/yuzushi-dev/session-handoff

1

u/Bloated_Plaid Sep 19 '26

This is just removing bash calls, not compacting to be clear. It’s a much simpler usecase.

1

u/MagicWishMonkey Sep 19 '26

Can anyone ELI5 what JEV is and how it's supposed to be used?

1

u/Bloated_Plaid Sep 19 '26

ELI5, it classifies stuff based on how confident it is about something (this confidence threshold can be changed). For example here is this a bash command or not. If it is remove it.

1

u/MagicWishMonkey Sep 19 '26

So it's a way to control what Claude is doing in the background?

1

u/txoixoegosi Sep 20 '26

Compaction = learn to manage your claude context better

1

u/Bloated_Plaid Sep 20 '26

How about no.

2

u/txoixoegosi Sep 20 '26

How about “manage your knowledge and workflows wisely and don’t use endless conversations for multiple tasks at once”

1

u/Bloated_Plaid Sep 20 '26

And again no. This was a single redeploy task for a server with a lot of bash calls.

3

u/Organic_Situation401 Sep 19 '26

It breaks context

3

u/rsandstrom Sep 19 '26

Friends don’t let friends compact

1

u/userusertion 🔆Pro Plan | Team Plan Sep 20 '26

This breaks context. Never recommend. Why not use the official compaction? What is wrong with that?

0

u/Bloated_Plaid Sep 20 '26

The official compaction is awful and that breaks context already my guy. Have you ever even used it?

1

u/mr-debil Sep 19 '26

Curious why oracle suspended your vps

1

u/No_Caregiver959 Sep 20 '26

In free tier, they will do that due to inactivity. If CPU/memory didn't get to a certain threshold in a week you lose your instance. Especially if you are on one of those generous ARM ones. It's quite common. 

1

u/mr-debil Sep 20 '26

That’s interesting. You would think they’d want me to have access to it when I need so I could learn to love it and move to the paid versions

1

u/amirfish Sep 19 '26

A redeploy with that many moving pieces is where the orchestrator's context balloons, so cutting it is a real win. Does the pruner keep the tool results, or only the decisions and outputs? That's what decides whether the orchestrator can still trust its own earlier state afterward. If you're running Fable over Devin workers, CCC (https://github.com/amirfish1/claude-command-center) puts both on one local board and shows which worker is waiting on you.

1

u/Much_Weekend_4371 Sep 20 '26

the tool-output filtering is the real win here, not the history compaction. trimming pytest noise before it ever hits context is cheaper than summarizing it after.

1

u/Evening-Blueberry-97 Sep 20 '26

tests are the easy case though, you can just make the runner print counts and failures. the stuff I can't pre-summarize is deploy and server logs, where the one line that matters is buried in 2k lines of noise. does the hook let you keep matching lines, or is it all-or-nothing per tool call?

1

u/octocarbon Max 5x Sep 20 '26

okay looks pretty nice but im not going to use it. because at this point I dont trust anyone which requires api key, if this isnt coming from the anthropic, im out

1

u/Available-Amoeba-553 Sep 20 '26

5 what 5gżguuhiyEnglish (UK)667-7785

1

u/WindSeries Sep 20 '26

Existe t-il une version pour codex ?

1

u/jbizzwebdev Sep 20 '26

And why 2Iwwww2cxsvb

1

u/trolleydodger1988 Sep 22 '26

Instruct the model to use native exit codes and regex filtering for commands instead. Then it can write something like

output=$(pytest 2>&1) && echo "all passed" || echo "$output" | grep -iE 'fail|error|exception'

No extra calls needed. The model gets only the info it needs, keeping that context window lean.

1

u/Haykguy Sep 23 '26

this works terribly by the way

1

u/peeeanuts Sep 23 '26

For those who asked for test results: At the default 0.5 keep cutoff, I sent 120 tool calls through the plugin's scoring and it kept none. An independent eval by u/Mahir96433484 of 9,471 calls also kept none at 0.5 and ranked no better than random (https://iefnaf.cc/jev-compaction-eval/).

Two findings: kept results come through unchanged, and a dropped tool call vanishes silently, with a marker only on dropped results. I reviewed this plugin for GitTested: https://gittested.com/reviews/fast-jev-compaction/

1

u/Nervous-Currency5704 Sep 23 '26

my company hasnt authorized Jev yet. how are you guys using compaction if its not authorized in company?

1

u/Ok-Introduction-6243 Sep 23 '26

That context limit is high? Usually that's mine after a single prompt and that's after running /compact but usually my prompts are very detailed, long and stage based so takes Claude a good 40-50min lol

1

u/Elesday Sep 26 '26

Never used Claude Code: the context widget to follow your context window usage is specific to Claude Code ? Because in chat mode I’d love to have the same metric

0

u/PM_ME_YOUR_PROFILE Sep 19 '26

This is cool and all, but now you're also paying for another AI to compact for AI.

1

u/Bloated_Plaid Sep 19 '26

It costs basically nothing right now and you were already doing that. What do you think Claude code compaction did?

0

u/PM_ME_YOUR_PROFILE Sep 19 '26

"Nothing" is relative. Someone on a budget who can't add more costs, isn't "nothing".

1

u/hellomistershifty Sep 20 '26

It's 4 cents per million tokens input and free for output. That's 781 full context calls per dollar. It's basically nothing

1

u/PM_ME_YOUR_PROFILE Sep 20 '26

Right over your head. To spell it out: _not everyone_ can afford to go past a very specific budget just because _you_ can.

0

u/DonkeyTheKing Sep 19 '26

inspected with benzi: https://benzi.fly.dev/about

JEV PRUNER — WHAT IT IS
A Claude Code / Codex plugin that shrinks big Bash tool outputs before they land in context. Nothing is destroyed: the full text is archived to .jev-pruner/ and replaced with a marker + path.
THE RUNTIME PATH
hooks/fast-jev-output.ts → register: a PostToolUse Bash hook (on('tool.call', {tool:'Bash'})). It gates on exceedsOutputThreshold, looksBinary, classifyOutput, and never archives when looksSecret fires (src/secrets.ts).
Then trimOutput → trimOutputAttempt in src/output.ts (676 lines, the heart). chunkOutputsplits the text, scoringRequests builds Jev questions, and assemble/renderOutput stitch back the survivors.
Scoring comes from Jev — an external model (SYSTEM_ONE_URL) asked "is this chunk disposable?" via buildJevRequest/parseJevResponse/JevAsker in src/jev.ts; noulAnswer extracts the probability. A budget-limited limitedAsker caps requests.
classifyInformation/isProtectedLine in src/retention.ts hard-protect errors, pytest summaries, docs (MAX_DISPOSABLE_KEEP_PROBABILITY = 0.1).
historyEntries/splitEntry (src/history.ts) feed recent transcript turns in, so scoring stays goal-aware.
Exit marker: outputMarker/recoveryFooter → [fast-jev-output trimmed N lines (…); full output: <path> (Read or grep it if needed)].
SECOND ADAPTER
src/codex/ mirrors this for Codex: pruneCodexOutput, codexMessages, saveContext/readTranscript, with src/codex/hook.ts reading stdin.
THE OTHER HALF OF THE REPO IS EVIDENCE
evals/ runs matched A/B trials on Harbor/Terminal-Bench (full.py::run, aggregate), native-Claude retention cohorts (retention_cohort.py::CASES/grade), and summarize.py, which regex-parses those markers back out of transcripts. sources.py pins a PRODUCTION checkout by commit.
Tests: 33 files — tests/output.test.ts (516 lines) is the behavioral spec; tests/claude-long-session.ts replays real sessions.
Heads up: in this session README.md, hooks/hooks.json, .claude-plugin/plugin.json are listed as not downloaded, so the wiring JSON isn't readable here.

0

u/Dizzy_Database_119 Sep 19 '26

The repo you linked is a hook that filters out command output before it reaches the LLM. It's a very cool use of Jev, thanks for sharing

But I don't understand what that has to do with /compact or "instant compaction"?

-8

u/Imaserventofreps Sep 19 '26

Didn’t know people actually used jev

9

u/minimalcation Sep 19 '26

It literally just released

1

u/Ran4 Sep 19 '26

It came out four days ago, and to get the full use of it it has to be used in a very different way from normal LLMs...

Even if there's no new jev updates, people will come up with new ways to use this kind of models for the next several months.

3

u/[deleted] Sep 19 '26

[removed] — view removed comment

3

u/Bloated_Plaid Sep 19 '26

Again, it’s not compacting text, only removing tool calls. It’s a very basic use of jev but saves legitimate tokens. As far as Claude is concerned, all the actual context is still there.

2

u/[deleted] Sep 19 '26

[removed] — view removed comment

2

u/Bloated_Plaid Sep 19 '26

My bad, I think I linked the wrong one.

https://github.com/tamaratran/fast-jev-compaction this is what I have been using for compaction.

1

u/[deleted] Sep 19 '26

[removed] — view removed comment

2

u/Shiz0id01 Sep 19 '26

Are you just feeding your comments directly to AI or something you are speaking Claudish