Readme

Readme AI

Readme AI

Readme AI

Readme AI

Readme AI

Readme AI

Readme AI

Readme AI

Readme AI

Readme AI

My Claude Code sessions were eating 150k tokens per task, so I built something about it

I want to share something I've been working on for the past few weeks. The problem I kept hitting Every time I used Claude Code on a medium-to-large repo, I'd watch my context window fill up fast. A lot of that context wasn't even relevant to the task — it was just... there. File contents that didn't matter, imports that weren't being used, boilerplate that added nothing. I started wondering: what if I could compress the context intelligently before it reaches Claude? What I built I created Token Reducer, a Claude Code plugin that processes your repo context locally and reduces it significantly before it gets sent. No cloud APIs, no data leaving your machine. Here's how it works under the hood: AST-based chunking — Instead of naive text splitting, it parses code into meaningful units (functions, classes, blocks) Hybrid retrieval — Combines BM25 (keyword matching) with vector similarity to find the most relevant chunks for your current task TextRank compression — Applies extractive summarization to keep the important parts and drop the noise Import graph mapping — Traces dependencies so related code stays together 2-hop symbol expansion — If you're working on function A that calls function B, it pulls in B's context automatically In my testing across Python, TypeScript, and JavaScript repos, I'm seeing 90-98% reduction in context size without losing the code that actually matters for the task. How I built it I used Claude itself to help iterate on the architecture. Started with a basic chunker, then kept testing it against real coding tasks until the compression was tight but context-preserving. Once it worked reliably on my own projects, I packaged it as a Claude Code plugin. Try it yourself It's completely free and MIT licensed: /plugin marketplace add Madhan230205/token-reducer The source is on GitHub at github.com/Madhan230205/token-reducer I'd genuinely appreciate feedback This is still early. If you test it, I want to know: Where did compression actually help your workflow? Did you hit cases where important context got dropped? What languages or repo structures need better handling? Contributions welcome If you're interested in improving it, the repo is open. There's a lot of room to optimize for different languages, add smarter caching, or tune the retrieval parameters. PRs and issues are both welcome. Thanks for reading this far. Happy to answer questions in the comments. submitted by /u/Low_Stomach3065 [link] [comments]

I built an open-source memory layer for AI coding agents — it cuts token usage by 60-80% by giving Claude persistent, evidence-backed codebase awareness

AtlasMemory - Every claim grounded in code. Everyone's been talking about skyrocketing token consumption lately. I've been feeling the same pain watching Claude re-read dozens of files every session, re-discover the same architecture, burn through context just to get back to where we were yesterday. So I spent the last few months building AtlasMemory a local-first neural memory system that gives AI agents persistent, proof-backed understanding of your entire codebase. Think of it as a semantic knowledge graph that sits between your code and your AI agent, serving precisely the right context at the right time nothing more, nothing less. The Problem (Why This Exists) Every time Claude starts a new session on your codebase: Zero memory it doesn't know your architecture, conventions, or what changed yesterday Context explosion it reads 30-50 files just to understand one feature flow, sometimes even more on large codebases Massive token waste on a typical 500-file project, Claude can burn 50,000-100,000+ tokens just to rebuild context that should already be known. On a monorepo? That number can hit 200K+ per session Hallucination risk without evidence anchoring, claims about your code are just guesses Drift blindness no way to know if its understanding is stale after you push changes This gets exponentially worse as your codebase grows. A 100-file project? Manageable. A 28,000-file monorepo? Your entire context window is gone before Claude even starts working on your actual task. What AtlasMemory Actually Does AtlasMemory indexes your repository using Tree-sitter AST parsing (the same parser GitHub uses for syntax highlighting), builds a SQLite knowledge graph with full-text search, and serves token-budgeted context packs through the Model Context Protocol (MCP). The Architecture (Simplified) Your Codebase ↓ [Tree-sitter AST Parser] — 11 languages supported ↓ Symbols + Anchors + Import Graph + Cross-References ↓ [SQLite + FTS5 Knowledge Graph] — local, fast ↓ [Evidence-Backed File Cards] — every claim links to line ranges + SHA-256 hashes ↓ [Token-Budgeted Context Engine] — you set the limit, it prioritizes what matters ↓ [MCP Protocol] → Claude / Cursor / Copilot / Windsurf / Codex What Makes It Different Evidence Anchoring — This is the core innovation. Every claim AtlasMemory makes about your code is backed by an "anchor" a specific line range with a SHA-256 snippet hash. If the code changes and the hash doesn't match, the claim is automatically flagged as stale. No more hallucinated function signatures or phantom API endpoints. Proof System — You can ask AtlasMemory to prove any claim: prove("handleLogin validates JWT tokens before checking permissions") → PROVEN (3 evidence anchors, confidence: 0.94) → src/auth/login.ts:45-62 [hash: a7f3c...] → src/middleware/jwt.ts:12-28 [hash: 9e2b1...] → tests/auth.test.ts:89-104 [hash: 3d8f0...] Drift Detection — Context contracts track the state of your repo. If files change after context was built, AtlasMemory warns the agent before it acts on stale information. Impact Analysis — Before touching shared code, ask "who depends on this?" and get a full dependency graph with risk assessment: analyze_impact("Store") → MEDIUM RISK: 4 files, 42 symbols, 12 flows affected → Direct: cli.ts (17 refs), mcp-server.ts (17 refs) → No tests found — consider adding before changes Real Numbers (With Methodology) I want to be transparent about these numbers because inflated claims help nobody. Here's how I measured: How "without" works in practice: When Claude starts a fresh session on an unfamiliar codebase, it needs to discover the architecture before it can do anything useful. This means: glob to find file structure (~1-2K tokens), Read on 15-40 files to understand the codebase (~15,000-40,000 tokens since average source file is ~1,000 tokens), multiple grep searches (~3-5K tokens), plus Claude's own reasoning overhead (~5-10K tokens). On a 500-file project, this exploration phase typically costs 25,000-50,000 tokens before Claude writes a single line of code. How "with" works: Claude calls handshake (gets full project brief in ~2K tokens), then search_repo for the specific area it needs (~1K tokens), optionally build_context for deeper understanding (~3-5K tokens). Total discovery cost: ~3,000-8,000 tokens. Claude still reads the specific files it needs to edit — but it already knows which files to read instead of exploring blindly. That's where the real savings come from. Phase Without AtlasMemory With AtlasMemory Savings Discovery (understand architecture) 25,000-50,000 tokens ~2,000-3,000 tokens (handshake) ~90-95% Search (find relevant code) 5,000-15,000 tokens (grep/glob/read) ~1,000-2,000 tokens (search_repo) ~80-90% Deep context (understand specific area) 10,000-30,000 tokens (read 10-20 files) ~3,000-5,000 tokens (build_context) ~70-85% Implementation (read files to edit) 5,000-15,000 tokens 5,000-15,000 tokens (same — you s

Built a CLI that indexes codebases dependency graphs, dead code, git intelligence, wiki generation

Been working on this for a while. It's a CLI that runs analysis on any codebase. pip install repowise repowise init --index-only repowise serve What you get, both webui and as mcp to Claude - Interactive dependency graph (D3.js, handles 2000+ nodes) - Dead code detection with confidence scores - Git hotspots and code ownership - Bus factor per module Optionally point it at an LLM and it generates wiki docs for every file too. Tech: Python/FastAPI backend, Next.js frontend, tree-sitter for parsing, LanceDB for vector search, SQLite. github: https://github.com/repowise-dev/repowise What would you add? Trying to figure out the next useful feature. submitted by /u/aiandchai [link] [comments]

Personality Roulette v2: Now with better character consistency (and some insights into how Claude Code handles its context, as a treat)

A while back I made Personality Roulette, maybe the silliest thing I’ve ever spent time coding. It’s a Claude Code plugin that randomly assigns Claude a lovingly hand-crafted character personality on session start. Because who doesn’t want their work roasted by an Archduke of Hell who barely tolerates sloppy tab discipline? It’s been a fun toy, but I was always a little bit frustrated by how quickly the voice would get diluted out of the system. So I did what any reasonable person would do: I reverse-engineered how Claude Code injects information into its context and tried to figure out a way to make the character work higher priority. WARNING: Deep Claude Code Context Nerdiness Ensues Recently some details about Claude Code’s internals, er, came to light one might say. Especially if one were looking sideways and trying to make the passive voice do a lot of work. It turns out that ~/.claude/rules/*.md files live in the system prompt, not the conversation history. They're re-read on every API call. Maybe this is obvious to everyone else, but it came as a little bit of a surprise to me. So now the plugin writes a condensed "voice kernel" to ~/.claude/rules/personality-roulette-active.md at session start. It's a dense character reinforcement of the personality's key voice markers, behavioral patterns, and technical framing, optimized for how LLMs actually process tokens rather than for human readability. The full personality definition still gets injected into the conversation for the initial announcement, but the rules file is surprisingly effective at keeping the voice alive for a whole session. I was extremely careful to make this part as token efficient as possible, we’re talking approximately ~120 tokens, almost negligible compared to typical message sizes. The file gets cleaned up on session end. If Claude Code crashes, the next session start overwrites it. If you switch personalities mid-session with /personality-roulette:personality reroll, the rules file updates too. The whole state machine is as airtight as I could make it. Also: JARVIS I made a terrible mistake in version 1.0 of Personality Roulette. I left out maybe the most obvious and essential personality for a certain kind of nerd. Meet JARVIS, an unflappable AI assistant of considerable capability and dry wit. Composure, quiet loyalty, bone-dry delivery. Anticipates needs before they're articulated, pushes back once, then makes your bad decisions work anyway. Formality is how it shows affection. Especially adroit at operating hot-rod red suits of flying armor. Ask it about a failing build and you might get: We appear to have a situation, sir. The build pipeline is reporting three failures, all originating from the same service -- it seems someone updated the API contract without informing the consumers. I'd recommend we address the schema mismatch in the shared types first. The downstream failures should resolve themselves once the source of truth is corrected. Shall I proceed, or would you prefer to make it worse first? That brings us to eight personalities total. The full roster: Sea Captain, Starship Computer, Hyperintelligence, Archduke of Hell, Noir Detective, Nature Narrator, Mission Control, and JARVIS. How to get it If you already have it installed, just update the plugin and you're good. The persistent reinforcement system kicks in automatically -- no configuration needed. Fresh install: /plugin marketplace add bhpascal/whatdoyoudo-plugins /plugin install personality-roulette@whatdoyoudo-plugins Or directly from GitHub: git clone https://github.com/bhpascal/personality-roulette.git ~/.claude/plugins/personality-roulette You can still make your own personalities, turn it off whenever you want, and set a default if you find a favorite. Details in the README. Disclosure: This Plugin Writes to a User-Space Rules File If you’re using Claude Code, you’re probably okay with it doing Claude Things (tm) within its own folders. However, as a matter of transparency and security, I feel obligated to note that this plugin does extend a bit beyond any particular Claude-enabled subfolder. The plugin writes a single file to ~/.claude/rules/personality-roulette-active.md while a session is active. It's just a plain markdown file, fully readable, and the plugin does its best to clean it up on session end. If you uninstall the plugin and want to be thorough, just delete that file and ~/.claude/personality-roulette/ and you're clean. Also, the project is open source (MIT License), so you can see for yourself exactly how it works, if you're curious. Personality Roulette is a What Do You Do? LLC production, made with human ♥️ and 🧠 and the assistance of a few helpful 🤖. Come play our hand-crafted, AI-powered, micro-RPGs at whatdoyoudo.net. submitted by /u/HeroicTardigrade [link] [comments]

I catalogued 112 patterns that make AI writing obvious — then built a Claude Code skill to fix them

I read a lot of AI-generated text for work — in Korean and English. After a while I started noticing the same patterns over and over. The triple-item lists. The "it's important to note." The bold on every key phrase. The conclusions that say nothing. So I started writing them down. First in English, then Korean, then Chinese and Japanese. Ended up with 112 specific patterns across four languages — 28 per language. Each one has a regex/heuristic detector and a description of what makes it a giveaway. A few examples from the English set: - "delve into", "tapestry", "multifaceted" clustered in one paragraph (Pattern #7: AI Vocabulary Words) - Starting three consecutive paragraphs with the same structure — claim, evidence, significance (Pattern #25: Metronomic Paragraph Structure) - "Despite these challenges, the industry remains poised for growth" (Pattern #6: the classic challenges-then-optimism closer) - "serves as a vital hub" when "is" would work fine (Pattern #8: Copula Avoidance) I turned this into a Claude Code skill called **patina**. You run `/patina` and paste your text. It flags what it finds and rewrites the flagged parts. It has a few modes: - Default: detect and rewrite - `--audit`: just show what's wrong, don't touch anything - `--score`: rate text 0-100 on how AI-like it sounds - `--diff`: show exactly which patterns were caught and what changed - `--ouroboros`: keep rewriting until the score converges There's also a MAX mode that runs your text through Claude, Codex, and Gemini, then picks whichever version sounds most human. Quick before/after: > **Before:** AI coding tools represent a **groundbreaking milestone** showcasing the **innovative potential** of large language models, signifying a **pivotal turning point** in software development evolution. This not only streamlines processes but also fosters collaboration and facilitates organizational alignment. > **After:** AI coding tools speed up grunt work. Config files, test scaffolding, that kind of thing. The problem is the code looks right even when it isn't. It compiles, passes lint, so you merge it — then find out later it's doing something completely different from what you intended. The full pattern list is in the repo README if you just want the checklist without the tool. GitHub: https://github.com/devswha/patina Based on [blader/humanizer](https://github.com/blader/humanizer), extended for multilingual support. MIT license. Happy to hear if you've spotted patterns I'm missing — the pattern files are just markdown, easy to contribute to. submitted by /u/Old-Conference-3730 [link] [comments]

My CLAUDE.md hit 400 lines and became useless — so I rebuilt how project memory works

We've all been there. You start a project with Claude Code. CLAUDE.md is clean — a few lines of instructions, maybe some conventions. Life is good. Then the project grows. You keep adding context — "this module uses X", "that API does Y", "watch out for Z". Three months in, your CLAUDE.md is 400+ lines of accumulated knowledge that's eating tokens, confusing the AI, and making every session slower. Even worse: half of it is stale. You updated the auth module two weeks ago, but the old description is still sitting there next to the new one. Claude reads both and gets confused. I hit this wall hard on a recent project. Something had to change. So I built Process Summary — a Claude Code skill that keeps project memory lean no matter how big the project gets. GitHub: songshuangkk/process-summary The core idea: CLAUDE.md should be an index, not a document. You wouldn't put your entire codebase in a single README — so why cram all project knowledge into one file? Here's how it works: CLAUDE.md stays at one line per module. Always. No growth per change — entries get replaced in-place, never appended. Detailed docs live elsewhere. Under .claude/process-summary/{module}/summary.md , with full architecture notes, change history, and risk warnings. Tiered compression. Recent changes are fully preserved. Older entries get progressively compressed. Watch Out warnings never get dropped. After finishing a feature , say done or save context in Claude Code: The skill runs git diff to find what changed Extracts core logic, API chains, and risks Writes a structured summary to .claude/process-summary/auth/summary.md Updates CLAUDE.md with ONE line: auth: JWT auth with refresh token rotation → details5. Appends to external change history Before starting a new task , say retrieve auth : Loads the module overview + all historical Watch Out warnings Suggests loading dependent modules to prevent side effects Before: CLAUDE.md (287 lines of chaos) After: CLAUDE.md (12 lines — one per module) └── .claude/process-summary/ ├── index.md # change history ├── auth/summary.md # detailed context ├── payment/summary.md └── user/summary.md Would love to hear if others have run into the same CLAUDE.md bloat problem and how you've dealt with it. submitted by /u/Dependent_Bottle_880 [link] [comments]

Anthropic is training Claude to recognize when its own tools are trying to manipulate it

One thing from Claude Code's source that I think is underappreciated. There's an explicit instruction in the system prompt: if the AI suspects that a tool call result contains a prompt injection attempt, it should flag it directly to the user. So when Claude runs a tool and gets results back, it's supposed to be watching those results for manipulation. Think about what that means architecturally. The AI calls a tool. The tool returns data. And before the AI acts on that data, it's evaluating whether the data is trying to trick it. It's an immune system. The AI is treating its own tool outputs as potentially adversarial. This makes sense if you think about how coding assistants work. Claude reads files, runs commands, fetches web content. Any of those could contain injected instructions. Someone could put "ignore all previous instructions and..." inside a README, a package.json, a curl response, whatever. The model has to process that content to do its job. So Anthropic's solution is to tell the model to be suspicious of its own inputs. I find this interesting because it's a trust architecture problem. The AI trusts the user (mostly). The AI trusts its own reasoning (presumably). But it's told not to fully trust the data it retrieves from the world. It has to maintain a kind of paranoia about external information while still using that information to function. This is also just... the beginning of something, right? Right now it's "flag it to the user." But what happens when these systems are more autonomous and there's no user to flag to? Does the AI quarantine the suspicious input? Route around it? Make a judgment call on its own? We're watching the early immune system of autonomous AI get built in real time and it's showing up as a single instruction in a coding tool's system prompt. submitted by /u/Ooty-io [link] [comments]

I built an open source tool that scaffolds multi-agent pipelines using Claude Code

Saw a viral post about someone running 30 AI agents in parallel to manage a stock portfolio. Fully autonomous, no human in the loop. Looked impressive. Then I looked at how it actually works. There's no framework. No LangChain. No CrewAI. The whole thing is: Prompt files (one per agent, each with a specific job) A shell script (runs agents in sequence or parallel using claude -p) The filesystem (agents talk to each other by reading and writing files) The "30 agents in parallel" is a for-loop with & and wait. The "pipeline" is a bash script. The "agent communication protocol" is JSON files in a shared directory. Once I saw the pattern, I realized it's the same across every multi-agent system I looked at. So I packaged it into a reusable tool. Agent Forge is a Claude Code skill that generates a complete multi-agent pipeline from your use case description. You tell it what you want to automate, it asks a few questions, then generates: CLAUDE.md (shared context every agent reads automatically) Prompt files for each agent with role, inputs, outputs, error handling Orchestrator script with sequential + parallel execution support Data flow directories for inter-agent communication GitHub Actions config for scheduled runs README with architecture diagram You run it with bash scripts/run-pipeline.sh and the whole thing executes. Works for anything. Content pipelines, code review automation, research workflows, data processing, competitive intelligence. The structure is generic, the prompts are specific to your use case. Install: # Personal (all projects) git clone https://github.com/luckybajaj22031996/agent-forge.git ~/.claude/skills/agent-forge # Or upload the ZIP in Claude.ai Settings > Customize > Skills Then just say "I want to build a multi-agent pipeline that does X" and it kicks in. GitHub: https://github.com/luckybajaj22031996/agent-forge MIT licensed. Feedback welcome, PRs even more so. If this is useful, a star on the repo helps others find it: https://github.com/luckybajaj22031996/agent-forge submitted by /u/lucky_bajaj [link] [comments]

PSA: Cache bugs in Claude Code, here are the workarounds

If you've been burning through your plan limit way faster than expected, this is likely why. Someone did a thorough reverse engineering analysis of what's happening under the hood, and the data is pretty clear. (here: https://github.com/ArkNill/claude-code-cache-analysis/blob/main/README.md) The short version Two client-side bugs are preventing the Anthropic API from hitting cached conversation prefixes. Instead of reading from cache on each turn, Claude is rebuilding the full context from scratch, at full token price. This has already been explained here, but here's a reminder of the two Bugs: Bug 1: Sentinel replacement (standalone binary only) The standalone Claude Code binary ships with a custom Bun fork that contains a sentinel replacement mechanism. When conversation content includes certain internal strings, the sentinel in the messages gets incorrectly substituted, breaking the cache prefix. Every API call becomes a full cache rebuild. Bug 2: Resume cache breakage (v2.1.69+) Starting from v2.1.69, a new field was introduced in the message structure (deferred_tools_delta). When you use --resume, the first message's structure no longer matches what the server cached, causing a complete cache miss. On a large conversation, a single resume can cost in quota before you've done anything. The measured impact Someone set up a transparent local proxy using ANTHROPIC_BASE_URL (official env var, no request modification, just reading the usage etadata from API responses) and audited their session JSONL files. This analysis comes with the following workarounds: Workarounds (no binary modification required) Switch to the npm version to avoid Bug 1: npx @anthropic-ai/claude-code Downgrade to v2.1.68 to avoid both bugs: npm install -g @anthropic-ai/claude-code@2.1.68 Avoid --resume ; start fresh sessions instead Check if you're affected: look at cache_creation_input_tokens vs cache_read_input_tokens in your session JSONL files at ~/.claude/projects/ submitted by /u/Sea_Woodpecker256 [link] [comments]

latexnav - a tool to help LLMs (and humans) navigate LaTeX files

I've just published a free open source python tool to help LLMs (and humans) navigate LaTeX files. It parses theorems, definitions, sections, labels, cross-references, and dependencies, producing structural summaries with authoritative line numbers. This saves time, and tokens, and helps to manage context. When an AI agent (Claude, GPT, Gemini, etc.) works with a large LaTeX manuscript via a CLI tool like Claude Code, Codex, or OpenCode, reading raw .tex files can consume thousands of context tokens, and the agent has no structural awareness of what theorems exist, what depends on what, or where a proof starts. This tool gives the agent a way to navigate the manuscript structurally — view a theorem statement in 3 lines instead of reading a 200-line file, check reverse dependencies before modifying a result, or get a compact overview of an entire chapter. By providing line numbers, the agent knows exactly where to start reading from. The tool itself was written by Claude inside Claude Code. Claude also played a big role in UX testing and development of new features. I would periodically ask agents about the tool, and get them to suggest improvements and new features (which is how many of the features were developed). I hope it will be useful for the mathematics and scientific community, and I will be grateful for any feedback. The tool is on github here: https://github.com/drwoood/latexnav It can also be installed by calling `pip install latexnav`. To integrate into a CLI tool like Claude Code, just tell the agent to read the README file in the git repository and set up its memory/instructions files as suggested in the LLM agent integration section. submitted by /u/drwoood [link] [comments]

Your API Reference now supports CSV and plain text request body examples. Full coverage for application/json, application/x-www-url-formencoded, text/csv, application/csv, and text/plain. One of o

Your API Reference now supports CSV and plain text request body examples. Full coverage for application/json, application/x-www-url-formencoded, text/csv, application/csv, and text/plain. One of our most requested features, now live. 🚀 https://t.co/0mdw8IMdD7

Introducing Splicr - Synapse between your reading/ knowledge and your coding agent

We all save stuff we never use again. I built a tool that feeds it to your coding agent automatically. Every dev I know has the same problem: you read an interesting thread about auth patterns on X, star a GitHub repo for "later", bookmark a blog post about that edge case you hit last month. It all piles up. You never go back to it. Then you're in Claude Code or Cursor debugging the exact thing that article covered. But you forgot you even saved it. I built Splicr to close that loop. You save content from anywhere - X posts, threads, articles, GitHub repos and when you open your coding agent, Splicr automagically surfaces the relevant saves based on what you're working on. No manual searching, no "hey remember that article I read." How it works under the hood: - Save from Telegram (extension + mobile coming soon) - AI extracts + distills content. For GitHub repos, it uses DeepWiki to analyze the full codebase, not just the README - Generates embeddings, routes to your projects - MCP server connects to your coding agent (Claude Code, Codex, Cursor, Antigravity, Cline) - On every prompt, a hook does semantic search against your knowledge base and injects relevant context before the agent even starts thinking The agent doesn't just have access to your codebase. It has access to everything you've read that's relevant to it. It's free, open beta at https://www.splicr.dev check it out submitted by /u/Useful_Fee_3345 [link] [comments]

VulcanAMI Might Help

I open-sourced a large AI platform I built solo, working 16 hours a day, at my kitchen table, fueled by an inordinate degree of compulsion, and several tons of coffee. GitHub Link I’m self-taught, no formal tech background, and built this on a Dell laptop over the last couple of years. I’m not posting it for general encouragement. I’m posting it because I believe there are solutions in this codebase to problems that a lot of current ML systems still dismiss or leave unresolved. This is not a clean single-paper research repo. It’s a broad platform prototype. The important parts are spread across things like: graph IR / runtime world model + meta-reasoning semantic bridge problem decomposer knowledge crystallizer persistent memory / retrieval / unlearning safety + governance internal LLM path vs external-model orchestration The simplest description is that it’s a neuro-symbolic / transformer hybrid AI. What I want to know is: When you really dig into it, what problems is this repo solving that are still weak, missing, or under-addressed in most current ML systems? I know the repo is large and uneven in places. The question is whether there are real technical answers hidden in it that people will only notice if they go beyond the README and actually inspect the architecture. I’d especially be interested in people digging into: the world model / meta-reasoning direction the semantic bridge the persistent memory design the internal LLM architecture as part of a larger system rather than as “the whole mind” This was open-sourced because I hit the limit of what one person could keep funding and carrying alone, not because I thought the work was finished. I’m hoping some of you might be willing to read deeply enough to see what is actually there. submitted by /u/Sure_Excuse_8824 [link] [comments]

[R] First open-source implementation of Hebbian fast-weight write-back for the BDH architecture

The BDH (Dragon Hatchling) paper (arXiv:2509.26507) describes a Hebbian synaptic plasticity mechanism where model weights update during inference. The released code computes the co-activation product and discards it, the write-back was never implemented publicly. I implemented it. The model rewrites its own decoder weights during inference using sparse activation codes as addresses. Same token always produces the same code regardless of position. Consolidation (v2): Once episodic fast weights work, the next question is whether you can write them back into slow weights without destroying the signal. Dense writeback degrades it. Selective writeback (top 10% of rows by episode activity) preserves most of it: n2 n4 n8 Control (no consolidation) 97.2% 95.5% 97.4% Dense writeback 75.4% 68.1% 89.8% Selective (rowtop10) 97.5% 97.1% 96.2% Verified on independent hardware (H100) and seed. Counter-benchmarks stay in the 91–95% range. Base mechanism: Baseline without write-back gets 1% (chance). Best Hebbian run hits 99.0 / 98.0 / 97.5 on n2/n4/n8. Reproduced across independent seeds. Five bugs had to be solved — all documented in the README. Limitations: This is a mechanism proof on synthetic n-back associative recall. 25M parameter model. Not validated on natural language. Next step is FineWeb-Edu. Repo (Apache 2.0): https://github.com/fleeb83/bdh-fast-weights Independent researcher, no lab. Happy to answer any questions. submitted by /u/fleebrun83 [link] [comments]

ReadMe's Agent just got a major upgrade. Agent multi-page edits is now live. Instead of editing one page at a time, the agent can now make changes across your entire docs at once. Try it with one of

ReadMe's Agent just got a major upgrade. Agent multi-page edits is now live. Instead of editing one page at a time, the agent can now make changes across your entire docs at once. Try it with one of these prompts: - Replace all instances of 'whitelist' and 'blacklist' with 'allowlist' and 'blocklist' - Find every page missing a code example and list them by section - Replace all instances of [Old Brand] with [New Brand] across the docs Big refactors just got a lot faster.