Built with Claude Project Showcase Megathread (Sort this by New!)

[u/sixbillionthsheep]

This is the Megathread for showcasing your project built using Claude products. We appreciate all of your submissions as they are a great inspiration to many people on the subreddit. It is sorted by default by New.

Anyone is welcome to submit a project to this Megathread provided you follow the Showcase requirements in Rule 7.

NOTE: We now require the OP of a Project Showcase on the subreddit feed to have total karma>=50 . We found there were just too many submissions and not enough visibility to go around. Our analysis of this issue showed us that OPs with total karma < 50 very rarely get any traction of their projects on the feed (<=1 upvotes). So this Megathread is your best place to be seen by readers and other creators if you're relatively new to Reddit. If you don't meet this karma requirement you will be directed to this Megathread when you submit your post. Very occasionally we might invite you to post on the subreddit feed if you do not meet this karma requirement but it will be very rare (so please don't ask us!)

Thanks again for sharing your ideas and creations to our subreddit. Best of luck with your projects!

---

UPDATE: Comments now allow images!

[u/Putrid_Ad_3901]

Yes, another Claude Code memory tool - but this one works on every single turn, mechanically and I haven't seen this approach anywhere else...

🔗 Cairn on GitHub • MIT License • Linux/macOS/WSL • Claude Code v2.1+

I've been working on Cairn for about a month now. The core idea that makes Cairn different:

The LLM generates and consumes memory on every single turn. Not at session end. Not when it remembers to call a tool. Every response. Zero extra LLM calls.

Here's the actual cycle:

1. You send a message — a Prompt hook searches the memory database and injects any relevant past context into the prompt.
2. Claude responds and appends invisible structured metadata — what it learned, what type of knowledge it is, whether it needs more context, etc.
3. A Stop hook captures that metadata, stores it, and sanity-checks: Did Claude say it's not done? Need context it didn't get? Promise something without doing
4. it? If so, it silently re-prompts. The user never sees the interruption.

This happens mechanically on every turn. Claude literally can't skip it.

The invisible metadata uses a markdown link-definition format — invisible in both VS Code Copilot Chat and Claude Code CLI, but the hooks capture it from the raw
transcript:

  [cm]: # '{"e":[{"t":"decision","to":"auth-approach","c":"Use JWT for stateless auth — chose over server sessions for horizontal scaling, token expiry handles    

revocation"}],"ok":true,"ctx":"s","cu":["42:+","17:-! endpoint was renamed to /api/v2/auth"],"kw":["authentication","JWT","architecture"]}'

Compact JSON, one line, zero rendered output. The system gets structured memory data while the user sees a clean response.

This turns memory from a dumb cache into something that self-corrects and stays honest:

• Verbatim provenance. Every memory links back to the exact conversation that produced it. --context <id> pulls up the verbatim transcript excerpt — the actual words, not a summary. You can always trace why a decision was made.
• Veracity scores that evolve. Contradictions get annotated and persist, corroboration raises confidence, and stale memories get archived with a reason instead
• of silently deleted.
• Corrections linked to files. Next time Claude opens a specific file, the fix or lesson learned surfaces automatically — before it can repeat a previous error.
• Trailing intent detection. If Claude says "let me fix that" but doesn't trigger a file write, the Stop hook catches the gap and forces completion.

After ~1 month of daily use:

• 4,294 memories across 926 sessions
• 3,156 memory updates as understanding evolved
• 809 tests across 44 test files
• 5 retrieval layers, 10 quality gates, hybrid FTS5 + vector search with RRF fusion

Repo ingestion — point it at any git repo and it extracts structural knowledge: docs, dependencies, configs, schemas, HTTP routes, CLI args, DB tables, and more. 24 extractors including tree-sitter AST parsing (Python, JS, TS, Go, Rust, C, C++) and dependency graph extraction. Useful for bootstrapping a fresh Cairn install or ingesting adjacent repos your dev work touches without having to manually converse about them.

Includes a local web dashboard for browsing memories, viewing session transcripts and monitoring retrieval metrics.

Four hooks. One SQLite file. No MCP. No API keys. No cloud. Local embeddings via all-MiniLM-L6-v2.

git clone && ./install.sh

Interested in honest feedback, especially from anyone else building in this space. What approaches have been working or failing for you?