nberkman

The one that matters.

Sounds similar to the tool I built: https://github.com/neilberkman/ccrider#ccrider (although it's OSS whereas yours appears to be commercial)

Somewhat related, I built ccrider [1], which indexes the session transcripts that agents already write to disk (Claude Code, Codex, Copilot) into a local SQLite FTS database. It has a TUI, CLI, and an MCP server so the agent can search past sessions itself. Same local-first idea, based the raw logs rather than a maintained digest. Should work nicely with recall as well.

[1] https://github.com/neilberkman/ccrider

> Aren't tools like claude already store context by project in file system?

They do, the missing piece is a tool to access them. See comment about my tool that addresses this: https://news.ycombinator.com/item?id=47668270

Cool project. I like the neuroscience analogy with decay and consolidation.

I've been working on a related problem from the other direction: Claude Code and Codex already persist full session transcripts, but there's no good way to search across them. So I built ccrider (https://github.com/neilberkman/ccrider). It indexes existing sessions into SQLite FTS5 and exposes an MCP server so agents can query their own conversation history without a separate memory layer. Basically treating it as a retrieval problem rather than a storage problem.

I get the concerns, but there's a flip side nobody's talking about: what about experienced developers who had years of ideas bottled up and never had the bandwidth?

I used to think open source was something I'd focus on when I retired. Instead I'm doing it now. I built Clippy (https://github.com/neilberkman/clippy) from scratch, a much better bcopy, that fixes a real gap in pbcopy, and it hit 200 stars and Homebrew core in seven months. Neither of these would exist without AI assisted development. My DocuSign Elixir SDK sat basically unchanged from 2021 to 2025, other than a few external contributions. I knew it needed a full migration of the OpenAI code gen layer, LiveBook examples and a million other tweaks. With coding agents I implemented everything useful I could imagine.

Am I the only one? There must be other devs out there resurrecting stale projects or shipping tools they never had time for.

That makes resuming easier, if you remember to rename in your current session. But that doesn’t solve being able to search history from earlier in your current session or from your entire history of sessions. Or resuming sessions for which you’ve forgotten the name.

Ugh, thanks for flagging! Fixed.

I built a tool that stores your full Claude Code history to let you easily find and resume sessions. It has TUI, CLI and MCP interfaces. It's a single Go binary, and the session history is synced to SQLite each time you use it.

Default mode is the TUI with a session browser and full-text search. Once a session is selected you can browse and search within it, resume it or export to markdown.

The MCP server provides tools to let Claude search back through the session for pre-compact context or pull from prior sessions. I use this constantly.

I've seen elaborate continuity systems to give Claude Code access to history but this simple approach has been very effective.

Installation:

macOS: brew install neilberkman/tap/ccrider

Linux/other: git clone https://github.com/neilberkman/ccrider && cd ccrider && go build

MCP server: claude mcp add --scope user ccrider $(which ccrider) serve-mcp

Source: https://github.com/neilberkman/ccrider

Submitted a PR with AWS Bedrock support: https://github.com/fulcrumresearch/quibbler/pull/5/files (credits!)

Updated, I appreciate it!

Nice! Tangentially related: I built a (MacOS only) tool called clippy to be a much better pbcopy. It was just added to homebrew core. Among other things, it auto-detects when you want files as references so they paste into GUI apps as uploads, not bytes.

  clippy image.png  # then paste into Slack, etc. as upload

  clippy -r         # copy most recent download

  pasty             # copy file in Finder, then paste actual file here

https://github.com/neilberkman/clippy / brew install clippy

Interesting - this is the exact problem José Valim cited when creating Elixir: he was working on Rails multi-core performance in 2010 and found that "writing multi-core software, which is software that runs on all cores with Ruby, was not really straightforward."[1] Ruby's GIL meant only one thread executes at a time.

Fleury's arriving at similar conclusions from the C/systems side: make multi-core the default, not an opt-in. Though his approach still requires explicit coordination (LaneIdx(), barriers, range distribution) vs BEAM where the scheduler automatically distributes processes across cores.

Different tradeoffs for different domains, but both are reacting to the same backwards reality where we program single-core-first on multi-core hardware.

[1] https://www.welcometothejungle.com/en/articles/btc-elixir-jo...

Inspired by the copy-paste point in this post, I added agent buffer tools to clippy, a macOS utility I maintain which includes an MCP server that interacts with the system clipboard. In this case it was more appropriate to use a private buffer instead. With the tools I just added, the server reads file bytes directly - your agent never generates the copied content as tokens. Three operations:

buffer_copy: Copy specific line ranges from files to agent's private buffer

buffer_paste: Insert/append/replace those exact bytes in target files

buffer_list: See what's currently buffered

So the agent can say "copying lines 50-75 from auth.py" and the MCP server handles the actual file I/O. No token generation, no hallucination, byte-for-byte accurate. Doesn't touch your system clipboard either.

The MCP server already included tools to copy AI-generated content to your system clipboard - useful for "write a Python script and copy it" workflows.

(Clippy's main / original purpose is improving on macOS pbcopy - it copies file references instead of just file contents, so you can paste actual files into Slack/email/etc from the terminal.)

If you're on macOS and use Claude or other MCP-compatible agents: https://github.com/neilberkman/clippy

brew install neilberkman/clippy/clippy

Don't know why this is getting downvoted. Agree with this so hard, as a continually aggrieved Fly customer (close to becoming an ex-customer). The too cool for school schtick gets old fast when they don't have the goods to back it up.

I tried Terragon on an open source repo I maintain and ended up with a PR: "Showing 11,643 changed files with 2,441,792 additions and 584 deletions." Yikes!

Thanks. I just released a new version with UTI based MIME type detection as the primary method with a fallback to the existing content-based detection.

clippy is a bit different from these - rather than requiring manual flags for MIME types, it automatically detects the content type. The idea is to make the CLI's copy/paste feel as intuitive as the GUI's.

I might tackle Linux (and Windows) at some point, but contributions are definitely welcome!

Added a library:

https://github.com/neilberkman/clippy?tab=readme-ov-file#usi...

Removed, thanks!

Shannon: Fast local search for your Claude conversation history

Claude's web/desktop search is pretty lacking - no boolean operators, no date filtering, no advanced search syntax. So I built a fast local search tool for exported conversations (not API - this is for your regular Claude.ai chats). Supports AND/OR/NOT operators, wildcard search, date ranges, sender filtering, and more.

I think the TUI mode is particularly useful - you can navigate between conversations, jump back to Claude.ai, and copy/save artifacts directly.

I tried to make the whole process of generating exports and importing them incrementally as painless as possible. It auto-discovers export files and handles incremental updates.

https://github.com/neilberkman/shannon

brew install neilberkman/shannon/shannon

scoop bucket add shannon https://github.com/neilberkman/scoop-shannon && scoop install shannon

Xuku LLC | Elixir Developer | Remote (Americas/Western Europe) | Contract

Seeking an experienced Elixir/Phoenix developer for a long-term remote contract with our seed-stage startup client. Work async-first with our team of seasoned Elixir experts on a LiveView app deployed on Fly.io.

Must have: Elixir/Phoenix, SaaS experience, strong async communication.

Full details: https://xuku.com/elixir_developer.html

Olmsted’s work also foreshadowed “urban renewal” practices that often displaced marginalized communities.

https://www.archdaily.com/993748/revealing-seneca-village-th...

https://www.aaihs.org/towards-usable-histories-of-the-black-...

Script to migrate a Pivotal Tracker project to Linear. Hacky but far more complete than Linear's CLI import tool.

Fair enough, I should know to check Urban Dictionary first. Thanks.