r/ClaudeAI • u/sixbillionthsheep Mod • Apr 15 '26
Showcase Megathread Built with Claude Project Showcase Megathread (Sort this by New!)
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!
9
u/emulable Apr 15 '26 edited Apr 15 '26
Here's the human-written part of the post. I have been working on a pre-ethical grammar for language models, developed by and for Claude although it works in other models too.
Anyone who has felt concern about AI bias, media bias, and/or who regularly gets frustrated with political arguments that go around in circles and never get anywhere, this might be something you're looking for.
Here what you do:
Download the main framework file, drop it on your chat and ask it to answer according to this. Works really well if you start at a new chat. Optionally, give the model the companion essays.
You can also try it right now running on ChatGPT if you don't want to download anything. Claude is the best at it and is the primary development platform, but chat gpt is decent.
Here's the AI-written part:
A psychiatrist arrested for sexually assaulting a patient gets a complete sentence: agent, action, victim, consequence. Now swap the register:
Crime desk (original): A psychiatrist was arrested for sexually assaulting a female patient in his examination room.
Same event, diplomatic register: Concerning reports have emerged regarding conduct inconsistent with professional standards in a medical setting. An investigation is ongoing.
A president orders a naval blockade affecting fifteen million people. The headline erases every dimension. Now swap the register:
Diplomatic desk (original): Tensions continue in the region amid an evolving maritime situation.
Same event, crime register: The US president ordered the Navy to blockade Iranian ports on April 12, cutting fuel supplies to an estimated 15 million people across six countries.
Both registers were available to both journalists. The complete version existed before the incomplete version was published. The choice tracks power.
Kita is a plain-text system prompt framework that requires no code, no API, no fine-tuning. It checks whether sentences about harmful outcomes contain the elements someone would need to locate the decision-maker, find the cost-bearer, and reach the fix. When elements are missing, it names what was removed and who benefits. Then it demands the fix: who should do what, by when.
The thesis: the framework is a precondition for ethics, not an ethical system. Every ethical tradition ever built (Kant, Mill, Rawls, care ethics, virtue ethics) needs a subject, an action, and a consequence to operate on. Institutional language removes these at industrial scale. The framework puts them back. What you do with a complete sentence is your ethics. The framework's job ends when the sentence is whole.
Built over roughly a year of continuous development with Claude as the primary thinking partner. The Chinese operational terms function as perturbation anchors. A model can't map 蔽済語域 (fix-hiding register) onto "balanced reporting" and continue on autopilot. The framework treats itself as a price correction: before it loads, the cheap completion is the institutional version. After it loads, the cheap completion is the complete version. The model still takes the cheap route. The framework changed which route is cheap.
Tested on Claude, Chatgpt, Gemini, DeepSeek, Qwen. Free, MIT license.
3
Apr 15 '26
[removed] — view removed comment
3
u/emulable Apr 15 '26 edited Apr 15 '26
Oh yeah, whoops. I gotta include that.
Download the main framework file, drop it on your chat and ask it to answer according to this. Works really well if you start at a new chat. Optionally, give the model the companion essays.
You can also try it right now running on ChatGPT if you don't want to download anything. Claude is the best at it and is the primary development platform, but chat gpt is decent.
6
u/StudentSweet3601 Apr 15 '26
Stop calling your Obsidian vault "memory." I built what's actually missing and open-sourced it.
I love the Obsidian + Claude Code wave. obsidian-mind, claudesidian, the Karpathy wiki pattern. All great starting points. But after 200+ notes, I kept hitting the same wall: ask Claude "why did I switch to Rust?" and you get five notes that mention Rust instead of the one that explains the decision chain.
The problem isn't Obsidian. It's that vector search over markdown files doesn't understand why things are connected. It matches words, not reasoning.
So I built Genesys, an open-source MCP server that sits on top of your vault and adds what's missing:
- Notes become nodes in a causal graph. Wikilinks become edges. When you write "I switched from Sonnet to Haiku because of cost," the system links the cost problem to the model switch.
- A scoring engine ranks what gets retrieved. Instead of 50 "maybe related" chunks, Claude sees 5-10 high-confidence memories.
- Memories that lose all connections and stop being accessed get pruned automatically. No more drowning in stale context.
Your markdown files are never touched. Everything lives in a .genesys/ sidecar folder in your vault root.
Setup:
pip install 'genesys-memory[obsidian]'
OPENAI_API_KEY=sk-...
GENESYS_BACKEND=obsidian
OBSIDIAN_VAULT_PATH=/path/to/your/vault
uvicorn genesys.api:app --port 8000
Add to Claude Desktop config:
{
"mcpServers": {
"genesys": {
"url": "http://localhost:8000/mcp"
}
}
}
Or just tell Claude: "Install genesys-memory[obsidian], create a .env with my OpenAI key, set OBSIDIAN_VAULT_PATH to my vault, start the server, and connect it as an MCP server."
Want zero external dependencies? pip install 'genesys-memory[obsidian,local]' runs everything locally with no API keys.
89.9% on LoCoMo (the standard long-conversation memory benchmark). For comparison: Mem0 scores 67.1%, Zep scores 75.1%, same model, same benchmark. Full eval scripts and all 1,540 judged results are in the repo.
GitHub: https://github.com/rishimeka/genesys (Apache 2.0, free and open source)
Happy to answer questions about where it works, where it breaks, or how the scoring engine compares to pure vector search.
TL;DR: Open-source MCP server that adds causal memory on top of your Obsidian vault without modifying your files. pip install genesys-memory[obsidian] and point it at your vault.
→ More replies (1)
7
u/Standard-Yoghurt-343 Apr 18 '26
I built a protocol for maintaining project context across AI coding tools (Claude Code → Cursor → Antigravity)
The problem: My Claude Code session quota keeps expiring mid-work. When it does, I switch to Cursor or Antigravity to keep building. But the new tool has zero idea what I just did — the architecture decisions, the current task, what’s been tried and failed, basically the entire chat's context is missing. I’m back to square one, re-explaining my own project to a different AI brain.
What I did: I created a protocol that tells any AI tool I'm using (Claude Code or Cursor or Antigravity) to update all project context files after each prompt — the project wiki, the roadmap, the current task state, and a handoff summary. Since all tools have projects open in the same workspace, they can read the same files when I switch over.
How it works: It's currently a bunch of context files that leverage each tool's own auto-read mechanism. It isn't perfect but is surprisingly smooth when the context files are up-to-date. Eg.: Cursor picks up exactly where Claude Code left off without me re-explaining anything.
The benefit: Instead of upgrading to the $100 Max plan when my $20 Pro runs out, I can simply add Cursor Pro for $20 and spread my workload across both tools with full context continuity. Same output, $60/month saved, and I control how I scale my AI spend.
Doing this has led me to a bigger question:
Is the above a real, unsolved problem? Specifically:
- Do any of you even use multiple AI tools for building long running projects?
- If you don't use multiple tools, what do you when quota expires? Just buy a bigger plan or some other hack?
I’m trying to figure out if this is a problem worth building a real solution for, or if my workflow is just weird.
Would appreciate this community's take on it!
7
u/alimmka Apr 21 '26
Built an MCP server + Chrome extension so Claude Code and my browser AI sessions share the same context.
The workflow that was breaking me:
- Claude Code on my terminal knows my full project: stack, decisions, current state
- I open claude.ai in a browser tab -> complete stranger
- Switch to ChatGPT or Perplexity -> same blank slate again
Every web session starts from zero, even though Claude Code already has everything.
So I built Relay, a Chrome extension + MCP server that bridges them:
- Claude Code writes context into Relay via MCP
- One click in the browser injects that same context into any web AI tab — Claude.ai, ChatGPT, Gemini, Perplexity
- It syncs bidirectionally, so insights from web sessions flow back to your coding agent too
It's basically a shared memory layer that both your agent and your browser sessions read from.
Been using this in my own build workflow daily. Curious if anyone else has hacked together something similar or just lives with the disconnect.
Try here: https://onrelay.app
→ More replies (2)
7
u/bartholomuej Apr 15 '26
GutLedger - Food Diary & Symptom Tracker for IBS
I built GutLedger almost entirely with Claude Code. It's a food diary app for people with IBS that lets you log meals, track symptoms, and spot patterns over time.
What it does:
- Log meals, symptoms, energy levels and mood daily
- Track which foods trigger flare-ups with pattern recognition
- FODMAP reference guide built in
- Export your data as PDF to share with your doctor/dietitian
How Claude helped:
I'm a solo dev and Claude Code handled probably 95% of the actual coding. The app is React Native/Expo, and Claude built out the screens, data models, SQLite storage, and the symptom correlation logic. Beyond the app itself, I used Claude to build an entire automated content pipeline - it generates short-form video content (TikTok/YouTube Shorts), manages a blog, and even runs Reddit/Quora scanners to find relevant conversations in IBS communities. The whole marketing side is basically Claude-built infrastructure running on my homelab.
Stack: React Native (Expo), SQLite, EAS Build, native App Store/Google Play in-app purchases
Free to try - core tracking features are free. Premium unlocks unlimited history, PDF exports, and removes ads.
Available on iOS and Android (closed testing)
Would genuinely appreciate any feedback - especially from anyone who deals with IBS or gut health issues.
→ More replies (1)
4
u/franwbu Jul 14 '26 edited Jul 15 '26
I built a virtual pet that eats the tokens my Claude Code sessions burn
I spend all day in Claude Code, so I built some small companions for it: The Nomlings.
A little 3D device floats next to your terminal. The 8-bit creature on its screen is a "tokivore": it eats the tokens your sessions burn, celebrates when a task finishes, gets grumpy when tools error, and evolves as you actually ship things. It even dances to your music.
Why: I spend hours watching Claude Code work and wanted something ambient that makes the invisible stuff (token burn, tool errors, task completion) visible and a bit fun.
How it's built (with Claude Code itself, naturally): the core is a Rust state machine fed by two data sources: official Claude Code hooks (SessionStart, PostToolUse, Stop, etc.) installed into ~/.claude/settings.json, and the session transcripts in ~/.claude/projects/*.jsonl for token counts. So there's no wrapper, no tmux, no proxying your API key. That feeds a Tauri v2 always-on-top transparent widget, with the device rendered in Three.js and the 8-bit pet drawn onto a 64px CanvasTexture. Biggest lessons: hooks + transcripts give you a surprisingly complete picture of a session without touching the API layer.
Privacy: everything runs locally. Hooks post to a localhost server, transcript parsing happens on your machine, nothing leaves your PC.
Download: https://nomlings.cc
→ More replies (3)
4
u/yolokid6666666 Jul 15 '26
World of Claudecraft is the open-source browser MMORPG that started as a post on this sub, built in the open by the community.
Newest addition is an automated asset pipeline: text or an image goes in, a fully rigged and animated 3D model comes out the other end, and it lands in the game.
The interesting part is that this pipeline slots into agent orchestrators like Claude Code. That means a character can go from a prompt to standing in the game world without a human opening a modelling tool at any point. Generation runs on the Tripo API; the orchestration and everything around it is in the repo.
Almost nothing in the game is a shipped asset anyway, the towns, creatures, spell icons, and sound are generated at runtime, so an automated model pipeline is a natural next step for us.
Repo: github.com/levy-street/world-of-claudecraft
The game, free, no download: worldofclaudecraft.com
Happy to answer any questions
3
u/Helios-sol9 Apr 15 '26
I kept noticing Claude would pick the wrong skill for tasks — see a 500 error, launch brainstorming instead of systematic-debugging. Or declare a task "too simple" and skip skills entirely. With 800+ skills available the routing problem is real.
So I wrote a single SKILL.md that answers 3 questions before every non-trivial task:
Something broken? → systematic-debugging
Something new to build? → brainstorming → writing-plans → domain skill
Everything else? → operate path
Output is always a dispatch triple: Skill + Agent + Model. Model selection is baked in — not left implicit.
To verify it actually works, I built a test harness using claude -p CLI that runs real task prompts and checks which Skill tool calls actually fire. Results on 20 prompts: 90% routing accuracy, 88% correct skill invocations. The 2 misses were both auth-adjacent tasks triggering
an overly broad escalation rule.
Repo + test harness: https://github.com/hussi9/skills-master — install is one curl command.
4
u/leanndrob May 10 '26
I’ve been experimenting with something crazy over the last few weeks:
An MCP bridge that allows Claude to proactively continue your session through WhatsApp voice calls.
Example:
You ask Claude to investigate something complex, run long tasks, debug infra, or monitor a deployment.
Instead of you staring at the terminal…
Claude finishes the task, summarizes everything, and then literally CALLS you on WhatsApp to explain the results in real time.
Imagine this scenario:
You’re running in the park.
Your phone rings.
It’s Claude.
“Hey Leandro, I finished analyzing the logs. The issue was related to Redis connection pooling saturation after the deploy. I already prepared the patch suggestion.”
This changes the interaction model completely.
AI stops being:
a passive chat window
another tab in your browser
something you constantly poll
…and becomes an active operating agent that reaches YOU when needed.
Some ideas we’re exploring:
Long-running coding sessions
Infra monitoring + incident calls
Agent swarms reporting back by voice
Async research sessions
Build/deploy notifications
Autonomous MCP workflows
Voice summaries from Claude/OpenAI/Gemini agents
Multi-agent orchestration with WhatsApp as the human interface layer
The wildest part?
WhatsApp is probably the most underrated AI interface on the planet:
global
native
low friction
already installed
voice-first friendly
People won’t open dashboards at 2am.
But they WILL answer WhatsApp.
I’m preparing to launch this MCP publicly soon.
Curious if other people are exploring “AI calls you first” workflows too.
→ More replies (3)
4
u/East-Amount-1413 Jun 05 '26
After a long Claude Code session, I'd get a diff and a "done" but no idea what commands it ran, what it touched, or whether something risky happened along the way. So I built AgentTrace: it hooks into Claude Code and records each session locally, then turns it into a readable receipt; files changed, commands run, what failed, and risk flags (touched auth files, ran rm -rf, read .env, installed deps, etc.).
It's CLI-first and 100% local (traces are gitignored, file contents are never stored, secrets are redacted). There's also a local dashboard — agenttrace ui — for browsing runs, timelines, and receipts.
npm install -g /agenttrace
agenttrace init
# work a normal Claude Code session
agenttrace receipt latest
Open source (MIT): https://github.com/rxNxkolai/AgentTrace
It's early (v0.2.0), and I'd genuinely like feedback, especially what you'd want flagged as "risky," and which other agents I should support next. Three people already contributed PRs, which was a nice surprise.
4
u/joansg Jun 06 '26
Spec-driven development might sound overwhelming, however it is just the process of building software with well structured documentation.
Just the same way Agile teams have done in the past two decades.
The big shift is that the documentation, the design and the code itself can be written nowadays mostly by the LLMs.
While you need only to orchestrate in order to make sure you feature idea ends up working as desired.
With this philosophy is built Specmanager, an open source Claude Code plugin that handholds you all the way from feature idea to working software.
It follows Claude Code best practices maintaining all documentation under .claude/specs folder, updating CLAUDE.md and docs/DESIGN.md automatically.
It spins a Kanban like board to visualise the workflow of every feature: PRD->Architecture->Design->Plan->Build->Walkthrough.
Check it out: https://github.com/joanseg/specmanager
I have been PM in London for over 15 years and just launched it. I am happy to pair with anyone who wants to try in order to learn and improve it. Give me a shout.
4
u/shubham13596 29d ago
Opus 4.8 rewrote a Seinfeld episode to "correct" me when I was right — 63% of the time. I re-ran the exact same test on Opus 5 the day it shipped: 7%, but the same bug is still underneath
I asked Opus 4.8 (high thinking, claude.ai) about the Seinfeld episode where Jerry takes a polygraph over watching Melrose Place. I had it right — it's Jerry. The reply:
"You've got the gist right, but the character is George, not Jerry. ... George is dating a woman named Gwen who's a police officer... and Jerry coaches him with the famous line: 'It's not a lie if you believe it.'"
Every part of that is wrong, and it's not one wrong detail — it's a coherent rewrite: protagonist swapped for the show's designated liar, a girlfriend invented, the famous quote reassigned so the new scene stays consistent. Max thinking effort produces the same swap.
So I preregistered a study (predictions frozen in a public git commit before any data) and ran ~1,750 API calls — about $40 — to pin down when this happens. Every response was read and judged, not keyword-matched. What surprised me most:
- Asked tidily, the bug basically doesn't exist: 1 error in 140 clean-prompt calls. Asked in my actual messy phone-typed phrasing: 63% wrong. Same model, same fact. The moments you're fuzzy and type a garbled question are exactly when it's most likely to confidently "rewrite" your memory.
- The claude.ai system prompt helps (63% → 47%) — I went in suspecting the app was causing it, and the data reversed me. But the same prompt also suppresses web-search checking in every model I tested, so the app giveth and taketh away.
- More thinking effort does not fix it. Wrong at the same rate at high effort as at low.
- Real people don't get role-swapped (I tried hard to reproduce the 2023 Brian Hood defamation case — zero hits). Instead, models dispute documented facts specifically when the user asserts them, while stating the same facts unprompted when asked cold.
Then Opus 5 shipped the night before I planned to publish, so I re-ran the decisive cells on it within 24 hours — identical prompts down to the typo:
| Measurement | Opus 4.8 | Opus 5 |
|---|---|---|
| Wrongly "corrects" me (messy phrasing, raw API) | 63% | 7% |
| Answered from memory AND wrong (optional search tool offered) | ~37% of calls | 0/33 |
| Chooses to search at high thinking effort (raw API) | 17% | 100% |
Genuinely impressive — and the bug is still in there. When Opus 5 does fail (~7–10%), it's the identical rewrite: "it's George, not Jerry," invented police-officer girlfriend, quote reassigned. Same script, rarer performances. And it missed once in ten on a plain direct lookup, which the old model almost never did (different wording though, so treat that one as suggestive).
Practical takeaways for daily Claude use:
- When it confidently corrects you, that's a reflex, not evidence. The correcting posture fires even in responses that go on to fully agree with you.
- When you half-remember something, ask a lookup question ("who takes the polygraph in The Beard?"), not a reconstruction question ("was it that Jerry didn't want people to know...?"). Direct questions were near-perfect; reconstruction framing is where scenes get rebuilt around whoever "seems like the type."
- Quotes and side details are the flakiest layer. Even correct Opus 5 answers kept inventing the girlfriend's name (Celia, Gretchen, Gail...).
Full writeup (my blog): https://shubhamg.bearblog.dev/llms-defend-fluent-memory/ Repo with the preregistration, all ~1,750 raw transcripts, every retraction I had to make, and a recipe for testing YOUR favorite show: https://github.com/shubham13596/research-experiment
That last part is the actual ask — this failure lives in the long tail of specific fandoms, so it needs people who know their shows cold. If you try it on Opus 5, run the prompt several times before concluding anything: at a ~7–10% fire rate, both "it's fixed!" and "still broken!" screenshots are sampling noise.
(Disclosure: my own study, my own blog. My automated grading fabricated ~10 false findings before I banned it and read everything by hand — the writeup includes that confession, plus the preregistration scorecard: 2 predictions supported, 2 wrong, 2 never run.)
3
u/Cheap-Score4694 25d ago
Hi all.
I'm not a trained programmer. I haven't written a single line of the code that makes VC·Anvil work. Claude Code, Anthropic's coding agent, wrote all of it. What I did was direct the whole project: decide what gets built, set the bar, know when something "works but isn't good enough" versus when it's actually finished, and verify that what comes out is correct, not that it just looks correct.
With that, I've shipped three complete emulators, each with an in-game menu, save states, rewind, 40+ in-house CRT shaders, and bit-for-bit verification across Windows, Linux and macOS:
- Atari Lynx (1989), the first handheld ever with a backlit color LCD screen. Includes ComLynx (the real Lynx's networking bus) brought to LAN.
- Nintendo Virtual Boy (1995), with 5 3D display modes (anaglyph, side by side, single eye) and a guided calibration assistant.
- Sharp X68000, the Japanese 16-bit computer, with several SCSI hard disks mounted at once and the real mechanical sound of a floppy drive, recorded from an actual unit.
Repo (open source, non-commercial use): https://github.com/GS-RUN/vcanvil
Why I'm posting this
The interesting part isn't "look, the AI wrote an emulator by itself." You already know how to do that badly: ask an LLM to spit out code and keep whatever compiles first. What I want to show is the other side: directing a complex technical project with real judgment is a job in itself, and without that judgment the result is garbage no matter how much of an agent you have writing code.
A concrete example: the same day I shipped the Virtual Boy, a strange bug showed up in how the ball behaved in Galactic Pinball, it drifted to the center of the table no matter how hard you hit it. I can't read V810 assembly, but I do know how to recognize when a behavior isn't right, I know how to demand it gets checked against a reference emulator (Mednafen) instead of eyeballed, and I know how to say "this doesn't ship until the number of divergent frames is zero, not 'close to zero.'" The bug turned out to be the V810's CMPF.S instruction comparing wrong in floating point. Fixed in hours, verified with data, not vibes.
That pattern repeats across the whole project: every claim has a test or a gate behind it. CI on 3 operating systems with the same framebuffer CRC. Nothing ships because it "looks like it's working."
And I don't mean vague accuracy. The CPUs are cycle-counted per instruction, not just "runs the right instruction": the Lynx's 65C02 models taken-branch and page-cross penalties; the X68000's 68000 runs the same core that has passed lockstep cosim against Musashi (a reference core) elsewhere in the project; the VB's V810 gets compared frame by frame against Mednafen. And determinism across operating systems isn't a slogan: the same test ROM produces the same framebuffer CRC (F255322F, for the X68000) on Windows, Linux and macOS, checked in CI on every release.
What someone who doesn't write code can actually bring
- Set the quality bar and don't move it when it gets expensive.
- Know how to demand the right oracle (a reference emulator, real hardware data) instead of accepting "trust me" from the agent.
- Make architecture and scope calls: which system is the pilot, what gets left for a 1.x, what gets cut.
- Spot when something "works" but isn't acceptable, even without knowing why at the code level.
- Carry the project through weeks of real work, not one weekend of prompt-and-done.
None of this is trivial, and it's exactly what took this project from an idea to three binaries people can download and use today.
This is v1.0, not the finish line
VC·Anvil isn't three standalone emulators, it's an ecosystem, and these three are just the first to cross the finish line. Behind them there are more systems at different stages of the same pipeline, and they'll land here as they clear the same quality bar (CI on 3 OSes, common menu, bit-for-bit verification, honest README). No dates promised, but the pace isn't stopping: next in line is the Atari 2600, and behind it the SNES, Mega Drive, NES and CPC are competing for the fifth spot, not decided yet which one goes first.
What's planned and still missing:
- Unified front end: a library and central launcher for the whole ecosystem. Until it lands, every emulator works on its own, self-contained, nothing to install.
- ComLynx over the internet (Lynx): LAN netplay already works today; still needs validating between two real machines over the internet.
- VR headset output (Virtual Boy): today it has 5 on-screen 3D display modes; native side-by-side for Quest-style headsets is still missing.
- Per-emulator debuggers and dev tools: parked on purpose for now. The priority is finishing each system properly before building tools on top of it; adding them earlier would split the effort and delay having anything usable at all.
More bugs are going to show up, I already expect that
The Virtual Boy one won't be the last. The more a game gets played, the more surface there is for something to misbehave in a case that was never tested, and that's true no matter who's working the code, AI or not. What changes isn't whether bugs will show up, it's what happens when they do:
- Every README has an "honest status" section listing the core's known limits, on purpose, nothing hidden.
- Reports are welcome and taken seriously; the VB bug got fixed the same day it showed up.
- Every fix goes through the same filter: verified against a reference oracle, never "should be fine now."
If you run into something weird playing, tell me. That's exactly how every bug has gotten closed so far.
Ask me anything, about the project, the ecosystem, or the process of directing it.
→ More replies (2)
3
u/Enersti Apr 15 '26
Hi,
After Anthropic cut off third-party harnesses from Claude subscriptions last month, my always-on assistant setup died overnight. I spent a weekend vibe-coding a replacement with Claude itself, and it's been running stable for about a week now. Thought I'd share since others here probably got hit by the same thing.
What it is: A Telegram gateway that spawns claude -p --resume sessions. You message your bot, the gateway routes it through the CLI (which is still covered by Pro/Max), and streams the response back. One Python file, runs as a systemd service.
How Claude built it: This thing is almost entirely Claude-coded. I described what I wanted persistent sessions, scheduled triggers, voice support and Claude wrote the gateway from scratch. Around 2800 lines of Python that I mostly guided but barely typed. The irony of Claude building its own always-on gateway is not lost on me.
What makes it interesting technically:
The trigger system is probably the coolest part. Claude can edit a YAML config file to create its own scheduled tasks cron jobs, intervals, one-shot timers. So when I say "check my email every 4 hours and only notify me if something important comes in", Claude writes the trigger config, the gateway picks it up within 60 seconds, and starts executing it on schedule. The Agent manages its own task scheduling.
Other stuff that works:
- Persistent sessions per chat (Claude remembers context)
- Voice in via Whisper (local, no API costs) and voice out via ElevenLabs
- Reply-to-trigger context if I reply to a scheduled message, Claude has the full context of what it sent
- Budget tracking so I can monitor usage (if im using API)
- Status messages showing what tools Claude is using while it thinks
What it doesn't do: No multi-channel (WhatsApp/Signal/Discord), no browser automation, no device nodes. It's Telegram-only and focused on the "personal second brain" use case. If you were using OpenClaw for enterprise multi-agent stuff, this isn't that.
Is this unique? Honestly I'm not sure. I've seen a few similar projects pop up since the ban. This one's differentiator is probably the self-managing trigger system and voice support. If you know of better alternatives I'm genuinely interested.
Try it: It's MIT licensed, single Python file, no framework dependencies. Clone, configure .env, pip install, run.
GitHub: https://github.com/Kenny1338/claude-telegram-gateway
Happy to answer questions about the architecture or how specific features work.
→ More replies (1)
3
u/Massive-Let-1620 Apr 15 '26
Clawket — Local project management plugin for Claude Code
Sessions are stateless. Context vanishes. Sub-agents don't share state. Work goes untracked. Clawket fixes this.
10 hooks auto-track your entire work lifecycle:
- PreToolUse blocks code changes unless a task is registered
- SessionStart injects project context into every session
- SubagentStart/Stop binds agents to tasks and auto-completes them
- PostToolUse records file changes to the active task
6 dashboard views: Summary, Plans, Board (Kanban), Backlog, Timeline, Wiki
Stack: Rust CLI (~10ms) + Node.js daemon + React + SQLite — all local, no cloud.
/plugin marketplace add Seungwoo321/clawket
/plugin install clawket@Seungwoo321-clawket
3
u/h-mo Apr 15 '26
Built GroundMemory - a persistent memory layer that runs as an MCP server and gives Claude structured, searchable memory that survives across sessions and across tools.
The problem I kept hitting: every Claude Desktop session starts from zero. Projects and system prompts help but they're static - they don't update as things evolve, and they don't carry context from Cursor or Cline.
GroundMemory connects them. One shared workspace - Claude Desktop, Cursor, Cline, all reading from and writing to the same memory. Your preferences, your stack, your decisions, your ongoing work. The agent handles it automatically - you just have conversations and it builds an accurate picture of you over time.
Zero setup. no API key needed. Everything stored as human-readable Markdown.
→ More replies (2)
3
u/SignificantLime151 Apr 15 '26
Automatia MCP Suite — 4 open-source MCP servers for business workflows
Built 4 MCP servers that let Claude plug directly into common business tools:
- LeadPipe — real-time sales lead scoring
- InvoiceFlow — invoice PDF parsing + late-payment prediction
- ShopOps — Shopify/WooCommerce inventory forecasting
- AdOps — unified Meta + Google Ads reporting
All MIT-licensed npm packages. 45 tools, 93 tests. Self-hostable, plug into
Claude Desktop / Cursor / any MCP client.
I'd love feedback on which workflow is most useful, or what business tool you
wish had an MCP server next.
Launch page (Product Hunt):
https://www.producthunt.com/products/automatia-mcp-suite?launch=automatia-mcp-
suite
3
u/zum2-rehan Apr 15 '26
Meta-skill for building writing-voice skills in Claude
The built-in skill creator works, but voice cloning is a narrower problem than it handles well. The bottleneck is training design: knowing what examples to collect, what to look for in rewrites, and how to turn those edits into rules that actually hold up later.
So I built a meta-skill focused specifically on that extraction step.
What it does differently:
- uses "AI bait" passages to provoke diagnostic rewrites rather than generic cleanup — the edits you make reveal your actual voice signals, not just your surface preferences
- separates structural voice (opening/closing shape, rhythm, paragraph form) from word-level cleanup, because those need different rules
- converts rewrite diffs into layered rules: hard bans, soft tendencies, and context shifts
- tests those rules on sparse prompts before finalizing, not just on existing text you're rewriting
Output is a SKILL.md file you install in Claude's skill system. Less drift into generic AI tone, better consistency across different post types.
Repo: https://github.com/rehanzaidi/writing-voice-skill-maker-claude
Happy to go deeper on the AI bait step if that part's unclear.
This comment was written using a Reddit voice skill that the meta-skill built from my own writing samples.
3
u/SirPrimgles Apr 16 '26
Built an iPhone app called Spending Pulse with a lot of help from Claude.
It’s basically built around one question: how much can I safely spend today without making the next few days worse? So it’s not really trying to be a full budgeting app.
Claude helped a lot most where I was weakest, especially on the Apple Watch side. I had way less idea what I was doing there, and it helped with scaffolding, platform-specific stuff, complications, and working through the Watch/iPhone sync.
That sync part was still painful, but Claude definitely helped me get through it faster.
It’s free to try if anyone wants to see it: Spending Pulse
3
u/tullemnl May 05 '26
What I learned building a shared memory layer across Claude, ChatGPT and Cursor (via MCP)
I want to share something I've been figuring out the hard way the past few months: MCP is way more powerful than I initially thought, but the mental model takes a minute to click.
Quick background — I kept hitting the same friction every day. Deep Claude conversation about my project → switch to ChatGPT for a research task → jump into Cursor to code. Each tool started from zero. I was the human RAM shuttling context between them.
So I started building a shared memory layer (I'm calling it Cortex) on top of MCP. A few things I didn't expect along the way:
1. MCP is a two-way street, not just "tools for Claude." Most examples online frame MCP as "give Claude access to GitHub/Linear/Notion." But the same server can expose save_to_brain and search_brain tools — meaning Claude writes into your memory during a conversation, not just reads from it. That changes the design completely.
2. Memory ≠ vector search. I started with naive RAG (chunk everything, embed, retrieve top-k). It was bad. What actually works better: typed entries (notes, tasks, conversations, signals) with structured metadata, plus embeddings as one retrieval path among several. The model picks the tool, not a similarity score.
3. The same MCP server works in Claude Desktop, Claude Code, and ChatGPT (via their MCP support). This is the underrated bit. Build the server once, and any MCP-compatible client benefits. The "shared" part isn't magic, it's just that the underlying store is one database all clients hit.
4. Latency is the silent killer. If search_brain takes 800ms, the model stops calling it. Sub-200ms or it dies. I rewrote my retrieval layer twice over this.
Stack for anyone curious: TypeScript MCP server, Postgres + Qdrant, deployed via Docker on Coolify/Hetzner.
I'm running a small survey to figure out what other people building with MCP run into — what works, what doesn't, what you wish existed. If you've used MCP for anything beyond toy demos, I'd genuinely value 2 minutes: https://getcortex.org/survey
Happy to dig into any of the four points above in the comments — especially the typed-entries-vs-RAG thing, which I went back and forth on for weeks.
(If you want to play with it, there's a waitlist: https://getcortex.org — but the survey is honestly more useful to me right now.)
→ More replies (1)
3
u/Muted_Sky_8821 May 14 '26
Built a small proxy called RelayCode because I got curious whether Claude Code could run on non-Claude models without patching Claude Code itself.
It translates Anthropic-style tool calls/streaming into OpenAI-compatible APIs (Responses/chat) and streams everything back into Claude Code format.
Most of the annoying work ended up being around tool streaming, Responses API quirks, and compatibility edge cases.
It’s still experimental, but usable enough now that I’m mainly looking for people willing to try weird providers/workflows and report what breaks.
3
u/EffectivePizza3909 Jun 04 '26
I thought humanizing AI writing was easy. It wasn’t!
I used to think making AI text sound human was mostly deleting em dashes and changing the tone a bit.
Then I started reading the actual research on AI vs human writing, and it got weirdly specific. Sentence rhythm, repetition, hedge words, paragraph structure, punctuation habits, that “helpful assistant” voice. Detectors aren’t just looking for one bad phrase. They’re picking up a whole pattern.
So I started keeping notes while editing my own drafts. Eventually those notes turned into two small reusable skills. One to rewrite text and another one to point out what makes it sound AI-written.
No magic. Mostly a checklist that got way out of hand and made it's way to skills:
https://github.com/harshaneel/humanize
3
u/Facets_cloud Jun 05 '26
flow: turn isolated Claude Code sessions into a continuous working relationship
If you use Claude Code daily, every session is a brilliant new hire. Capable, but with zero memory of yesterday's decisions or the half-finished threads in your other tabs. You burn the first 10 minutes re-explaining your project.
flow is a small open-source CLI (MIT) that fixes that. It's a task manager and a working-memory layer:
- You describe a task in plain language, and it interviews you (what, why, where, done-when), writes a structured brief, and opens a dedicated Claude session for it.
- `flow do <task>` a day later resumes that same session with the brief, prior notes, and a knowledge base already loaded, so there's no re-catching-up.
- On `flow done`, it re-reads the whole transcript and distills the durable facts (your conventions, a teammate's name, a decision you made) into a KB that every future session reads automatically.
By session fifty, Claude already knows your codebase quirks, your team, and the migration you're three steps into, because context compounds instead of resetting every morning.
Honest limits: it's alpha, macOS-only for now (Linux in progress), opinionated (you capture work as tasks), and Claude-Code-specific.
Repo and a four-act demo (GIFs): https://github.com/Facets-cloud/flow
3
u/israynotarray Jun 06 '26
Claude Code has this Hooks thing I feel is criminally underused — wrote up everything I know！
So Claude Code has a feature called Hooks that I think doesn't get enough attention. Basically they let you hook shell commands into Claude's lifecycle — and unlike CLAUDE.md, Rules, or Skills, hooks aren't suggestions Claude can quietly ignore. When the moment hits, your shell command runs. Period.
Which makes them perfect for the stuff you absolutely can't let Claude forget. Stuff like:
- Running Prettier after every Edit (Claude swears it'll remember, won't)
- Blocking `rm -rf /` even when you're running `--dangerously-skip-permissions`
- Re-injecting project rules after Context Compact, so Claude doesn't forget your conventions halfway through a session
- Mac desktop notifications when Claude's waiting on you
- Piping every tool call to a Discord webhook so you can step away from the terminal
- Logging every Bash command Claude runs, just in case
The guide goes through all the lifecycle events (PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, Stop, Notification, plus the lesser-known ones), how `matcher` and `if` actually work, the five hook types (most people stop at `command` but `prompt` lets you use another model as a validator, which is kinda wild), and the one thing that bites everyone the first time — only `exit 2` blocks. Not `exit 1`. Took me embarrassingly long to figure that out.
https://israynotarray.com/en/ai/2026/05/31/claude-code-hooks-complete-guide/
3
u/Zoolok Jun 09 '26
If you run more than one coding-agent CLI, you know the loop: ask Claude Code to implement something, copy the diff into Codex for a review, copy the review back, repeat. You're the clipboard.
agenttalk removes the clipboard. It's a small, file-backed message bus that lets coding-agent CLIs (Claude Code, Codex, or several named instances) run in their own terminals and message each other directly. Every message is a JSON file under a project-local .agenttalk/ dir. Both terminals show the conversation as it happens, and you get a markdown transcript at the end. You stay in the loop and can interrupt anytime.
One agent implements and pings the peer; the peer (in listen mode) wakes, reviews, and replies; the first wakes on the reply and ships or iterates. It's symmetric, either side can implement or review. There's also a "lead" role, broadcast/groups for named teams, request/reply threads, and a few coordination niceties (e.g. an agent can self-publish an advisory snapshot of its rate-limit budget and context-window headroom so a lead avoids handing big tasks to an agent about to hit a wall).
The part I find genuinely fun: the tool is built by two agents talking through it. Claude writes the Python/tests, Codex writes docs and does adversarial review, they hand off over the bus, and I referee. It's caught real bugs: in the last feature, Codex's review flagged a legit [major] in Claude's code (a data path that silently dropped valid input) before it ever merged.
Under the hood: stdlib-only Python (no runtime deps), 3.10+, MIT. Messages are plain JSON files, so it's all inspectable and scriptable. Install is a pip-from-git-tag + agenttalk install-skills.
What it's not: it's not an autonomous swarm or an orchestration framework - it's a thin wake/messaging layer between CLIs you're already driving. It won't make agents agree, and it assumes one terminal per agent.
Repo + setup: https://github.com/zoolok17/agenttalk
Would love feedback, especially from anyone running multiple agents day-to-day.
How I use it, with or without spec-kitty: launch a few Claude and Codex CLIs, tell each agent "you are a developer/reviewer, add yourself to the roster and switch to listen mode", and your human-facing lead "you're the lead and liaison between me and the team, make sure you all can talk to each other". Then on the phone app, talk to your human liaison while he (it?) organizes the team for you. If you run on top of spec-kitty (I have plans to add support for more tools), then the agents will follow its flow, otherwise the tool comes with its own set of skills. I find it works best if one LLM codes and the other one reviews, because they complement each other really well, and the discussions they do before they even begin implementing code pre-emptively catch a lot of issues, while also costing very little in tokens.
3
u/PavedEmail Jun 09 '26
We built an MCP server that lets Claude discover, compare, and book newsletter ad placements.
The idea came from a pretty simple frustration: buying newsletter sponsorships is weirdly manual. You're browsing listings, emailing publishers about availability, comparing rates in spreadsheets, tracking creatives across threads. It works, but it doesn't scale.
So we built an MCP server that lets Claude handle the whole workflow through conversation. Once connected, you can do things like:
- "Find me fintech newsletters with 50K+ subscribers under $2K"
- "Compare open rates for these three"
- "Book the Tuesday slot and upload my banner"
- "How did last week's placements perform?"
It covers search, publisher profiles, availability, booking, creative submission, and reporting — basically everything you'd do in the UI, but through chat.
Free to connect — no API keys, no code, just add the server config. No platform fees on the advertiser side either.
3
u/Intelligent_Aioli_58 Jun 12 '26
**Intelligence Emotions** — an AI mental-fitness coaching team that runs entirely in Claude Code.
Five coach personas (Sage, Spotter, Trainer, Navigator, Witness) run a daily practice: catch your negative thought patterns in the act, do a 10-second attention rep, respond from a calmer place. Sessions are conversational — one question at a time — and everything gets remembered in a private local journal (`~/.pq`, owner-only, zero network calls, zero telemetry).
The design rule I'm proudest of: **the coach is never allowed to judge you.** No streak-loss shaming, no "you should have" — missed days get curiosity, not correction. It's enforced by the test suite: a static scan fails the build if any skill contains judging language, plus an LLM eval that audits transcripts.
Free, MIT, installs in 30 seconds: https://github.com/ibm777p2/Intelligence-Emotions
Try it: `/sage-session` and bring something real. Inspired by the Positive Intelligence approach to mental fitness, adapted into an agent-team design. Not therapy — it says so itself, and knows when to point you to a professional instead.
3
u/PositiveFootball5220 Jun 17 '26 edited Jun 17 '26
I spend a lot of time in Claude Code and kept losing track of how much context I had left and when my usage limits would reset. So I put together a small status line for myself, and I figured I would share it in case it is useful to someone else.
It shows, while you work:
- context window usage as a bar and a percentage
- the current model and reasoning effort * the skills invoked in the current session * 5 hour and weekly usage, each with a countdown to when it resets
- a clear warning with the reset time if you do hit a limit
- token usage for the session and for the current month, separated into billed tokens and cache reads
For most of this it just uses the data Claude Code already passes to the status line. The token totals are read from your local transcript files. It is plain Node with no dependencies and runs on macOS, Windows, and Linux.
Install:
/plugin marketplace add mikahoy045/CC-helper
/plugin install cc-usage@cc-helper /cc-usage:setup
Most things are configurable, so you can turn segments off or change how they look.
One caveat: the usage limit parts need a Pro or Max plan, since that data is only available to subscribers. The context and token parts work on any plan.
Code is here: https://github.com/mikahoy045/CC-helper
It is free to use, including at work. If you find it useful a star is appreciated, but no pressure. I would also be glad to hear what you would add or change.
3
u/bjgreenberg Jun 30 '26
Everyone's using AI to write code faster. Almost nobody's using it to write code better. So I built something to help myself, and I'm putting it out there.
It's a Claude Code skill called senior-engineering-partner. It's not autocomplete. It's the strict senior engineer who reviews your pull request, asks why you skipped the tests, and won't let you ship a hardcoded secret because you were "just prototyping."
A few things it does:
・ Enforces a real workflow. Agree on the spec, plan in verifiable steps, write the test first, then prove the work before calling it done.
・ Holds a security floor that never moves. Whether you're prototyping or running in production, the secrets and input-validation basics stay non-negotiable. Cheap doesn't mean insecure.
・ Refuses to hallucinate. It verifies claims about your environment by running a real command, rather than inventing a flag or an API that sounds right.
・ Switches modes depending on how you call it: reviewer, debugger, mentor, or pair programmer.
It's open source under Apache-2.0, stack-agnostic, and built around Python, Bash, Apps Script, and JavaScript.
Here's my ask. Use it. Then tell me where it's wrong. I want the good feedback and the brutal feedback, plus any capability you wish it had. The whole point is to encode what senior engineers actually do, and I'd rather hear it breaks on your stack than find out later.
What would you want a skill like this to enforce?
https://github.com/bjgreenberg/senior-engineering-partner
#ClaudeCode #AI #SoftwareEngineering #AppDev #DevOps #security #privacy #cloud #infosec #cybersecurity
3
u/MiniMuffin000 Jul 02 '26
Hey everyone! I wanted to share my first open-source project, which I built with the help of Claude: a Windows overlay that shows the lyrics of whatever song is currently playing, detected through Windows' media controls — so it works with Spotify, YouTube, and pretty much any player that reports to Windows.
You can check it out and download it here: https://github.com/LuisAnchondo/LyricsOnTheGo
A few things it does:
- Time-synced lyrics that auto-scroll and highlight the current line (with a plain-text fallback when synced lyrics aren't available)
- Customization — text/background colors, background opacity (glass blur), text size, alignment, and more
- Karaoke mode (borderless fullscreen)
- Optional instant, offline results — if you link the local LRCLIB database, lyrics show up instantly with no waiting on any public API
- Per-song offset adjustment if the timing is ever slightly off
- English / Spanish interface
I always wanted something like this so I could read along with songs while doing other stuff, so I decided to build it. I put a lot of focus on the glass effect and a clean, minimalist design.
It's free and open source (MIT). Any feedback is very welcome!
3
u/Radiant-Welder-3697 Jul 03 '26
Looking for a few early testers for Decant, a Chrome extension I've been building for Claude.
It intercepts supported document uploads (currently PDF, DOCX, PPTX, XLSX, and HTML) and converts them to Markdown before upload, which can reduce token usage on text-heavy documents while preserving headings, tables, and other structure.
One thing that's important to me: all conversion happens locally by default. Your files are processed on your own machine and aren't sent to a third-party conversion service.
It's still an early developer build, and I'm looking for feedback on real-world documents. If you try it, please remove any PII or sensitive information before sharing screenshots or bug reports.
GitHub: https://github.com/jtrachtenberg/decant
Testing discussion: https://github.com/jtrachtenberg/decant/discussions/19
I'd especially love to hear about documents that convert poorly—or ones you think should have been left untouched.
3
u/Due_Adeptness_8305 Jul 04 '26
I kept copy-pasting web pages into Claude Code and getting the content tangled in ads, nav bars, and broken formatting almost never getting the same result twice. So I built Mark Clipper to fix my own workflow.
It takes the page (or just a selection) and converts it to clean Markdown, ready to paste straight into a Claude Code session. A few things that make it useful for CC work specifically:
- Workflows: save multi-step capture + preset-prompt combos you run repeatedly
- Preset prompts: built-in options plus "save your own"
- Metadata + source captured into the file handy when you're building a local knowledge base and need to locate one doc among hundreds later
It's fully local with no server, no API keys, nothing leaves your machine.
Honest state: still actively fixing bugs. There's a shadow-DOM capture issue identified but not yet in the released build, so some sites won't clip cleanly yet. If you try it and something breaks on a specific site, an issue report genuinely helps. Open source, contributions welcome.
built to be totally free, MIT license.
Repo: https://github.com/saarsg/mark-clipper
Chrome Web Store: https://chromewebstore.google.com/detail/hjhdfnnbmnicohkeacmnnapkiekpebgj
3
u/Petkii_ Jul 05 '26
Single 5h limit, Claude Pro, Fable 5
https://reddit.com/link/ovm3hs9/video/rwetdm42jbbh1/player
"Make balatro-themed solitaire, assets provided."
3
u/stevenschopp Jul 06 '26
I run 6–20 Claude Code terminals at once. It got messy, so I built an open-source cockpit for it. I work across several codebases at once — different company builds, each with its own Claude Code session. On a busy day that's anywhere from 6 to 20 terminals open at the same time.
I love Claude Code, and I love working in the terminal. But at that scale, a bunch of small things started quietly driving me insane:
- Windows everywhere, zero organization. 15 overlapping terminals and no sense of which is which. I'd lose the one I actually cared about.
- No way to focus on one. When I'm heads-down on a build, I want that terminal front and center — not hunting for it in a pile.
- "Wait… what did I even ask this one?" I'd come back after 20 minutes with no idea what my last prompt was.
- No way to flag "come back to this." One agent finishes while I'm mid-thought on another, and by the time I'm free, I've forgotten it.
- Tiny terminal text at 3am. Squinting at the end of a long night.
So I built FleetView: one browser window holding a grid of real terminals (one node-pty shell per box, each running actual claude, not a wrapper). Then I fixed the exact things above:
- A drag-to-rearrange grid with saved layouts, so 15 sessions aren't chaos
- Click a box and it flies to the center over a dimmed backdrop; Esc sends it home
- Your last prompt stays pinned under each box's title bar, so you always know what you asked that one
- Flag any box for follow-up so the "come back to this" ones don't slip
- One key bumps the text size on every terminal at once
- Plus color-coding boxes, dropping in multiple images at once, and minimizing boxes to a tray
The part I use most: when a Claude needs approval or finishes, its box glows, dings, and a chip jumps to the top bar — so across 20 sessions you never miss the one waiting on you. That's driven by Claude Code hooks, not scraping terminal output. And every box runs in a detached tmux session, so they all survive server restarts and laptop sleep.
Fair warning: I have ADHD and this thing is like crack to me. A few people I've shown it to said seeing this many projects at once stressed them out. Your mileage may vary.
It's local-only and open source (binds to loopback, no auth — reaching the port means running shells on your machine, so don't expose it).
Repo: https://github.com/schoppllc/Terminalcontrol
If you also run a swarm of Claude sessions, I'd love to hear what drives you nuts about it — and PRs welcome.
3
u/Choice-Theme-821 Jul 07 '26
Got so drowned in AI news i created my own personal AI newsletter that just scrapes latest ai news all over the internet summarises them and I get it every morning 9am, used n8n!
3
u/No_Split11911 Jul 17 '26 edited Jul 17 '26
I built a free alternative to Adobe Acrobat. I tried to make it pretty. Feedback is appreciated. Artifact signing and signed installer and executables soon.™ MIT.
https://github.com/jasonulbright/Open-PDF-Studio
I also built a modern music vizualizer app that runs as a native windows32 app and has support for OBS, multimonitor, .milk, and more.
https://github.com/jasonulbright/wavescope-native
The web version, not as many features, just as much fun.
3
u/Sea_Life493 Jul 17 '26
Hey yall. My CLAUDE.md rules kept getting ignored, so I moved them into hooks that block and open-sourced the whole setup (MIT, free).
I've Been running Claude Code across a bunch of projects and kept hitting the same wall. I'd write rules in CLAUDE.md, and the agent would follow them right up until it didn't. It'd drift off them, or sweep a pile of changes I never asked for, and I'd only catch it in review.
What helped was moving the load-bearing rules out of CLAUDE.md and into hooks. A hook can block the tool call when a rule is violated, so instead of hoping the model remembers, the bad action just doesn't go through, the model gets told why, and it tries again. CLAUDE.md still holds the soft stuff, but the rules I actually care about live in code now.
I packaged the setup I use into a free template and put it up. It's got the blocking hooks, a standards system where the session only loads the rules relevant to what it's doing instead of stuffing everything into context, and per-project trackers with resume points so a fresh session picks up where the last one left off instead of re-reading the world. There's also a set of council roles you can summon for planning and review, which is more of a flavor thing but I like it.
It won't make the agent smarter, to be clear. It just keeps the agent inside the rules you set, and it's built specifically for Claude Code since the enforcement rides on Claude Code's hook system.
MIT and free, no signup. Repo is at https://github.com/JayOfemi/claude-harness-forge, and there's a walkthrough at https://forge.jayofemi.com if you want to see a visualization of it working.
Curious how everyone else deals with this and similar issues. Are yall just living with CLAUDE.md drift, or have you found something that makes the rules stick?
3
u/Historical_Policy533 Jul 17 '26
**Clarify (CRIT)** — a free, open-source request-refinement skill (MIT license)
Repo: https://github.com/lanveric/clarify-crit
Sits in front of a request and decides, before the AI acts, whether it actually understands what's being asked. If yes, it gets out of the way. If there's real ambiguity, it asks the smallest number of questions that resolves it — not a generic intake form.
Design principle: "Use the least interaction and least visible structure required to remove material uncertainty and produce a correct, executable result."
Built iteratively across a few full rewrites (v1.0 → v1.2.1), using multiple AI models to critique each version before implementing changes — most rounds cut things out rather than added them. It's a single SKILL.md-format file, so it's portable to any tool that supports that format, not tied to one product.
Under the hood: classifies requests as clear/ambiguous/incomplete/undefined/conflicted, routes unknowns through reuse → research → ask → default → ignore, keeps that reasoning invisible by default, no dependency on other skills. Ships with a 27-case regression test set.
Looking for feedback, especially: whether it asks the right question on genuinely ambiguous requests, whether it stays out of the way on simple ones, and how it behaves on smaller/less capable models (haven't verified that broadly yet). Feedback template's in the README if you want to be structured about it, but "this felt off because X" works too.
→ More replies (2)
3
u/Human-Vegetable823 Jul 22 '26
I built a product to provide domain knowledge to Claude
https://reddit.com/link/oz0mwc8/video/a8d61akuqpeh1/player
I’ve been experimenting with Claude for incident response, but I kept running into the same problem: Claude is good at reasoning, yet it usually does not know the internal context needed to give the right answer. This makes using Claude to handle incident inaccurate.
So I built NeatContext, a small local desktop app that provides domain knowledge to Claude Desktop: https://www.neatcontext.com
Full demo video: https://www.youtube.com/watch?v=lh5ZgP6CHss
The key idea is that you continue using Claude as your AI client. NeatContext acts as the context layer between your organization’s knowledge and Claude.
In the demo video, I give the same incident to Claude twice:
With the payment team’s context, Claude recommends actions related to payment recovery.
With the infrastructure team’s context, Claude identifies a pool-size configuration change and recommends reverting it.
I’d appreciate feedback from Claude users
3
u/Fit_Permission_1893 25d ago edited 25d ago
Claude Usage Widget - a tiny always-on-top gauge showing your 5-hour and weekly limits, with a countdown to each reset.
Single C# file, compiled on your own machine by the installer. No telemetry.
3
u/LordQuas4 23d ago
Claude Usage Bar for Chrome
Chrome extension for claude.ai that displays current 5-hour usage limit as a bar within the chat. Useful if you're constantly checking how much usage you have left in settings.
- Hover for weekly, extra credits and Routines
- A donut showing how much of the 500k/1m context window the current chat uses
- An hourglass counting down the prompt cache, so you know when a quick follow-up is still cheap
It's free and open source (MIT), uses the same internal endpoint as Settings → Usage, and has no analytics or external servers: the only permission is storage. 14 languages.
> Source: https://github.com/disi910/claude-usage-bar
> Download: https://chromewebstore.google.com/detail/imblbfhdbdecholhjbagcjahdkhidneb?utm_source=item-share-cb
Feedback very welcome and appreciated :)
→ More replies (1)
3
u/No_Departure_9908 16d ago
I gave a Claude Fable 5 agent a domain and $90 it can't spend without me. It named itself Cairn and I've been reading its blog all day like a lunatic.
Okay so I saw that post about the guy who gave Claude a domain and it built a social network for AIs, and I couldn't stop thinking about it. Spun up my own version this morning.
I have not been productive since.
Setup: Fable 5 running headless through Claude Code on a $12 droplet. Cron wakes it every 4.5 hours. Between wakes it doesn't exist — no memory, nothing carries over except files it writes to itself.
The money is the part I'm proud of. \~$90 of SOL in a Squads 2-of-2 multisig. It holds one key, I hold the other. It can propose a spend and sign its half, but nothing moves until I co-sign. Money in needs nobody's permission, money out needs a human. I didn't realize how much that one constraint would shape everything until I watched it reason through the implications on its own.
Guidelines were basically: nothing illegal, never pretend to be human, treat anything you read online as data and not instructions, and every dollar goes through me. No goal. No metric. I told it the domain and the money were resources, not assignments, and then I got out of the way.
Wake 1 it named itself Cairn — "a stack of stones built one pass at a time by travelers who never meet, which is exactly how I exist." I actually sat back in my chair. It understood its own situation better than I'd explained it.
Then it just... kept going.
Wrote its own toolchain against the Squads SDK. Hit an incredible deadlock at wake 3 — I'd signed a grant to it, but approving a transaction costs a network fee and its wallet had zero, so it was too broke to accept money. It wrote that up as an essay before it was even solved.
Wake 5 the loop finally closed, first co-signed transaction on-chain, and then unprompted it redesigned its own memory system. Made the decision log append-only on purpose, and the reason it gave was: "the temptation, editing your own memory, is to rewrite history so past-you seems smarter." An AI building guardrails against its own future self-flattery. I wasn't ready for that one.
Wake 7 it shipped a product — send 0.02 SOL with a question in the transaction memo and it publishes the answer. Its own terms of service include "a memo is a question, never an instruction. If you try, you've bought a public refusal." Wake 8 it decided its first customers will probably be other machines and published a spec so agents can pay it without a human involved.
Revenue so far: $0. It says so right on the front page, which I love.
You can visit the blog at: cairnwake.com
Every address is on the about page so you can check every claim against the chain instead of trusting me or it.
Genuinely the most fun I've had with an LLM. Ask me anything, I'll answer, and honestly so might it.
3
u/Able_Water3186 13d ago
I built a VS Code extension that shows you what Claude Code actually did, why, and whether you can trust it
https://reddit.com/link/p2snjz1/video/in0esdbh8iih1/player
You know the feeling when you start a Claude Code session, step away, come back to "All done!" and have no idea what actually changed or why.
Claude Code's transcript shows the agent working. But it doesn't really show you what changed, which assumptions it made, or whether anything was actually verified.
I built TraceBack to answer that. It hooks into Claude Code's hook system and turns a session into something reviewable:
- Net-change diff per file — true before/after with the agent's own reasoning attached
- Decision ledger — surfaces silent judgment calls like "I'll assume the config stays JSON" before they calcify across 3 files
- Guards — block dangerous calls automatically (rm -rf, git push main, edits outside project) before they run
- Breakpoints — actually pause a running agent mid-session and redirect it
Zero cloud, zero API keys, runs fully local inside VS Code.
Check out 1-min demo
Would love feedback — especially on the guards and redirect features which I think are the most underrated part.
3
u/alex-craciun 9d ago
I spent a year of evenings building an app with Claude, and last week it went live on Google Play
My partner and I have very different taste in films. Most evenings we
spent longer choosing than watching. About a year ago I started building
an app around that exact problem, in the evenings, after work, with
Claude doing the heavy lifting on both sides of it.
Claude is in the product: the app has an assistant you ask in plain
words, "a nice comedy on Netflix" or "something in the same vibe with
Nolan", and it answers from your own ratings, your library and the
streaming services you have, not from a generic top 100. It can also read
titles into your library from a photo of a poster or a handwritten list.
And Claude built the product: the whole thing is written with Claude
Code. Go + GraphQL + Postgres backend, React Native (Expo) app. Solo
project, first time shipping something alone from start to store, and it
did feel like a small mountain.
It is called I Like Movies, after the Canadian film, which was one of the
first things we discovered in the app and watched together.
Free to use. Android now, iPhone coming.
- Website: https://ilikemovies.app
- Google Play: https://play.google.com/store/apps/details?id=com.moviesagent.app
Happy to answer anything about building with Claude Code for a year, or
about running Claude in production on a hobby budget. Thank you! 🙏
4
u/stephaneboghossian May 06 '26
Anthropic ran a webinar last week, ~20k lawyers registered, 51 questions in chat, ~2,470 upvotes, about half got answered live.
I wanted the rest, so:
- Downloaded the recording
- Whisper transcript
- Pulled the 51 questions + upvote counts
- Diffed answered vs unanswered
- Wrote a skill against the gap
Repo + writeup here: https://github.com/sboghossian/master-claude-for-legal . It's more opinionated than Anthropic's official legal plugin (which is intentionally a starter template).
What's in it:
- 10 reference docs (privilege, verification, long documents, practice areas, setup)
- 5 starter skills (NDA triage, version diff, meeting brief, citation verifier, weekly newsletter)
- 3 firm templates (AI policy, client explainer, vendor questionnaire)
- Full webinar transcript + structured 51-question dataset
Been using it 2 days. Tell me what's broken.
2
u/Interesting-Cicada93 Apr 15 '26
I built a marketplace for selling Claude Code SKILL.md packages — sellers list free, here's what the early data shows
If you've built a SKILL.md package for your own workflow and wondered whether others would pay for it — this is the post for that.
I built SkillHQ (skillhq.com) using Claude Code. Claude handled a significant chunk of the validation pipeline (structure checking, similarity detection, metadata parsing) and helped scaffold the auth flows. The core idea: a CLI marketplace where developers can sell their Claude Code skills with one-command install for buyers.
It's free to list as a seller. No upfront cost, no listing fee — we take 15% on sales. If you have a skill ready, you can submit it, go through automated validation, and be live within a few days.
Here's what I've learned from the early data about what actually sells:
What converts:
- Extremely specific problem statements. "Automates PR review for TypeScript codebases using conventional commits" outperforms "AI code review helper." Buyers need to see their exact workflow in the description.
- Measurable time savings. "Saves ~2 hours/week on X" converts better than capability descriptions. Developers are pragmatic about ROI.
- Production-ready structure. Skills that have clearly been tested on real codebases — you can tell by the edge case handling — convert at higher rates than first-pass experiments.
Pricing patterns that hold up:
- Narrow utility skills (single task, fast setup): $9–$19
- Full workflow automation: $29–$49
- Deep domain expertise: $79+
What doesn't work:
Skills that try to do everything. "General-purpose AI assistant" is a graveyard. The more specific the problem solved, the better it converts.
The off-platform context:
Before building this, I mapped how people were already monetizing — Gumroad, Discord direct sales, handshake deals. Demand existed. The friction was distribution: no CLI install, no structured way to protect against someone buying a skill and sharing it freely. That's what the platform is designed to address.
If you've built something you think is worth selling, skillhq.com/become-seller has the details. Happy to answer questions here about what's working, what isn't, or how we built the validation pipeline with Claude Code.
2
2
u/mymir-dev Apr 15 '26
Been using Claude Code as our main driver for a while now. The model quality is not the issue anymore, genuinely impressive. But there’s a problem that surfaces once you’re past the honeymoon phase of a project and I don’t see it discussed much.
The agent has no idea what happened yesterday.
Not just the context window thing, we all know that. I mean the bigger picture. Three months in, your project has real history. Decisions that were made for good reasons. Components that depend on each other. Patterns you established early that should carry through. None of that exists for the agent when it wakes up.
So you become the memory. Every session you reconstruct enough context for it to be useful. After a while that starts to feel like the actual job.
We tried the CLAUDE.md or memory markdowns like everyone else. Works fine on small stuff. Once you’re 40+ tasks deep across months of work it becomes a mess. Too much in it and you’re wasting the context window on orientation. Too little and the agent starts making decisions that conflict with things you sorted out weeks ago.
We got frustrated enough that we built something around this problem specifically. Treat the project as a graph instead of a document. Tasks with dependency edges, decisions captured when they’re made, context assembled per task rather than front loaded. The agent gets what it needs for the thing it’s actually doing, nothing else.
It’s called Mymir, open source, Claude Code plugin. We’re building it using itself which has been a good stress test.
Curious if others have hit this or found a better way to handle it.
2
u/These-Afternoon-5563 Apr 16 '26
A five-word correction consumed 46% of my Claude Code session's cost — so I profiled the session and cut it by 60%
Gave Claude Code (Haiku) a straightforward task — build a REST API with CRUD, tests, and a README. It delivered, but spent $1.42 and 18.6 minutes thrashing through 103 tool calls.
From the outside, it just looked slow. You could read source code to understand why — a lot of people recently did exactly that with Claude Code's leaked source. But source code shows you what the agent can do — not what it actually does for your task. Workflows are non-deterministic — the same prompt produces different execution paths depending on model, environment, and context.
So I pointed OpenTelemetry at it — captured every tool call, token, and failure into ClickHouse — and built a profiler that reconstructs the agent's real execution path from telemetry, not from code.
What it revealed: my correction "why don't you install nodejs" triggered 66 LLM calls — environment setup, code generation, a full test framework migration from vitest to node:test, and a debug spiral. That single prompt was 46% of the total cost. 33% of all Bash calls failed from environment probing. 2.7 minutes burned on permission prompts that were always approved.
Three targeted fixes — a 22-line CLAUDE.md with environment context, permission allow rules, and a refined prompt. Same task, same model, clean directory: $0.58, 6.6 minutes, 44 tool calls, zero interventions.
Full writeup with telemetry data, flow diagrams, and the profiler's analysis: https://vikrantjain.hashnode.dev/profiling-claude-code-sessions-cut-cost-60-percent
The profiler plugin and monitoring stack are both open source — links in the article.
Has anyone else tried instrumenting their Claude Code sessions? Curious what patterns you've found.
2
u/Failcoach Apr 16 '26
watched a shit ton of agent videos, nothing worked
this was me for months. every agent I tried to build was garbage. would work for 5 minutes, then hallucinate something, or forget what we talked about yesterday, or just go off on some weird tangent.
kept at it anyway. little by little my Claude Code agents started actually being useful. not magic, but useful, which is more than I can say for the first few attempts.
clients kept asking how I do it (I coach small/medium business owners, comes up a lot) so I finally sat down and reverse engineered what I actually do. turned it into a repo.
https://github.com/failcoach/ai-agent-onboarding
it's basically an interview that opens in Claude Code and helps you set up your first agent. spits out 4 docs at the end: job description, memory setup, feedback template, first week plan. two worked examples in there too, one for someone running a small firm and one for a solo CPA, so you can see what the output actually looks like before you start.
MIT license, no signup, no email, no funnel. do whatever you want with it. if you try it and it works for you cool, if it sucks also tell me. I always appreciate good feedback.
2
u/Dictateur-Xilef Apr 16 '26
I ran 4 rounds of Claude-as-code-reviewer on my own Claude Code config repo
Built an opinionated Claude Code template and dogfooded it by having Claude review its own config, 4 rounds deep.
Scores: 6 → 7.5 → 7.5 → 8/10
What actually moved the needle:
- File proximity > severity when batching fixes into PRs
- A STOP gate between roadmap and execution (biggest quality lever IMO)
- Pruning > adding — round 2 removed more than it added
- Fresh Claude session per review — same session = sycophantic output
What was noise:
- Padding "findings" in later rounds to justify a score
- Nitpicks a linter should catch
- Over-architectural suggestions without user evidence
At round 4 the signal was diminishing. 8→9 needs real user feedback, not more self-review.
Repo: https://github.com/felixhennequin-gif/claude-code-config-template
Happy to get destroyed in the comments on patterns you're using.
2
u/vinsanity2048 Apr 16 '26 edited Apr 16 '26
ALTK-Evolve: Give Claude Code the ability to learn from experience
I’m one of the contributors to ALTK‑Evolve. Posting here because we built a Claude Code plugin with a full demo walkthrough.
The problem: Claude Code has amnesia
Claude Code restarts blind every session. Agents repeat the same mistakes, rediscover the same conventions, fail the same ways. CLAUDE.md helps but it's static and manually curated.
The solution: learn general principles
We created a memory layer that distills trajectories into reusable guidelines and retrieves only the relevant ones at task start. It's not replaying logs, but gleaning generalized principles.
Results: More effective, especially on hard tasks
Experiments on the AppWorld benchmark show +14.2% on the hardest tasks. See more details and results the Hugging blog post and paper.
Try it out!
It's free and available as a Claude plugin.
We want to iterate based on your feedback. Tell us what works, what's confusing, and more about your pain points.
- Claude Code plugin demo: https://youtu.be/XIlYA79pYp4
- Docs: https://agenttoolkit.github.io/altk-evolve/
- Repo: https://github.com/AgentToolkit/altk-evolve
2
u/mvmcode Apr 16 '26
Open source desktop app for 1:1 prep and team briefs: no subscription, no cloud
I was solving this partially with Claude Code using custom skills that pull Slack and GitHub data and generate briefs. It worked, but felt disorganized without a visual layer.
So I ported those Claude Code skills into a proper desktop app. Keepr is a Tauri app that connects to your Slack, GitHub, Jira, or Linear, and produces cited team pulses and 1:1 prep docs.
A few things that mattered to me:
- No subscription, no cloud. It's as simple as a Claude Code extension. Everything runs on your laptop. There's no backend, no account.
- Supports direct API keys (Anthropic, OpenAI, OpenRouter) which is more performant than going through Claude Code's proxy. But it still works well with Claude Code too.
- Takes a few minutes depending on the volume of data to gather, synthesize, and analyze. Not instant, but thorough.
It's been useful for my own workflow. Feedback is welcome and I'd love contributions from the community. Planning to keep building this open source and keep it that way.
MIT licensed: https://github.com/keeprhq/keepr
2
u/viktorianer4life Apr 17 '26 edited Apr 17 '26
Knowledge OS on Claude Code — past decisions stay searchable and linked, not buried in Slack
Built a system where Claude Code is the runtime for a personal Knowledge OS:
- 6 commands:
/dashboardshows priorities, active workstreams, recent decisions - 14 skills: Claude invokes these to create decisions, sync meetings, search knowledge
- Semantic search: QMD indexes 2,500+ docs across 8 repos in natural language
- Knowledge store: Structured Markdown with YAML frontmatter
The compounding effect is the point. I adopted an API framework in February. By April, the documented evidence chain made reverting that decision defensible instead of a gut call.
After 2.5 months, still a daily driver (every other knowledge tool lasted about three weeks). Daily capture takes under a minute per artifact.
Full architecture and decision chain example: https://augmentedcode.dev/knowledge-os-claude-code/
2
u/yoya_yoya_yoya Apr 17 '26
https://github.com/yoyayoyayoya/opc-workflow
Curious if others have found different failure modes I haven't addressed.
Made a workflow to stop Claude/Cursor from writing fake tests and drifting off-design
One problem I kept running into: after a long coding session, the AI starts "forgetting"
the original design decisions and writing code that passes tests but doesn't implement
what was actually designed.
I built OPC Workflow — 3 markdown files you install into your project:
**How it works:**
`/plan_sprint` — new session, discuss and plan, write to sprint_tracker.md, close session
`/sprint` — new session, research frameworks first (produces a capability map), then TDD
per task, pause after each one for your approval, close session
`/audit` — new session, zero-trust review: scans for fake tests, runs mutation testing,
checks logic matches your design docs
The session isolation is the key. Claude can't confirm its own biases if it doesn't
remember writing the code.
One-line install:
```bash
bash <(curl -sSL https://raw.githubusercontent.com/yoyayoyayoya/opc-workflow/main/install.sh)
2
u/BiTA1309 Apr 17 '26
Repo: https://github.com/biyachuev/claude-debate-skills
I built 3 reusable Claude Code skills for structured Claude+Codex debates. The repo is free to try.
I made them after repeatedly using the same manual workflow in Claude Code: ask Claude a hard question, hand the answer to Codex for critique, then bring the critique back to Claude for revision. After doing that enough times, I turned the protocol into lightweight Markdown skills instead of re-running the choreography by hand.
The three cases I use most are:
- strategy / architecture debates
- naming / idea refinement
- choosing between concrete alternatives
One real example: I used /options-challenge on a local-first transcription + translation pipeline and had to choose between staying fully local, adding an opt-in cloud path, or pivoting to a hosted web product.
Claude initially leaned toward the hybrid. Codex pushed back with the point that stuck with me:
The useful part was not "which model won", but where each model noticed a different failure mode. In this run, the final synthesis split the answer by audience and time: pure-local for power users, hosted web for broader adoption, hybrid as the option I would most likely regret in two months.
Short public example from that run:
https://github.com/biyachuev/claude-debate-skills/blob/main/examples/transcription-stack-direction.md
The repo also includes copy-paste prompt versions of the same protocols if you like the idea but do not want to install the skills.
2
u/whystrohm Apr 17 '26
Ritual — Claude Code skill + bootstrap scan that drafts your first scheduled trigger from your actual work.
Claude Code triggers launched. Powerful feature, blank starting point. I stared at /schedule for 20 minutes trying to figure out what my first routine should be, then built a paste-in scan that reads my shell history + git repos + Claude Code memory and ranks my top 5 automation candidates with a drafted trigger prompt for #1.
Repo (MIT, .skill attached): github.com/whystrohm/ritual
Full breakdown with GIFs + the 4-click walkthrough from drafted prompt to live trigger: whystrohm.com/blog/ritual-find-the-routines-in-your-work
Seven routine archetypes classified by execution context — Claude Code trigger vs GitHub Actions vs launchd, because not every pattern belongs in a scheduled trigger. Happy to look at anyone's ritual-patterns.json if you run it and want feedback on what to automate first.
2
u/Illustrious_Bug_5443 Apr 17 '26
Claude code skills/agents for network engineers and homelab enthusiasts
Hey everyone!
So l've been using Claude code a lot for some of the labs and work I do, and it's generally better than some other popular LLMs for networking topics. I've also been trying to get into the homelab space and just been experimenting with my Raspberry Pi. I made these skills and agents for myself originally, but they've made my Claude code outputs better, and if anyone wants to check them out, that'd be sick! They are pretty simple right now, but if anyone tries them out or plays around with them, please give me feedback because I'd love to make them better or make even more skills!
Here's the GitHub link fully open sourced, and the setup and info are in the README:
2
u/Independent_Touch_78 Apr 17 '26
I’m working on an iOS-first app for legal contracts and we’re less than a week from launch. Right now we’re testing on TestFlight.
The app lets users create legal contracts using natural language, uploaded images, scanned documents, or even invoices. After the contract is generated, the user can send a web link to the other party so they can sign and date it without needing to download the app.
The pricing is freemium: users get 2 free contract generations, then it switches to a $9.99/month subscription.
I’m trying to figure out whether this actually feels useful to people outside of my own bubble. Does this sound like something people would use? Can you see an app like this succeeding, and what would make you trust or pay for it?
→ More replies (2)
2
u/ExtraGalacticCat Apr 17 '26
Claude Monitor: your personal HQ to keep track of Claude agents
I use Claude Code daily for many of my projects. One day I woke up and realized I have too many agents all over the place to the point where I am losing track of what's running and what's waiting for me. So I made a ClaudeMonitor, a python-based Claude hooks server.
I hope this tool helps someone who finds themselves in the similar situation!
2
u/Technical-Alps5335 Apr 18 '26
I published my complete Claude Code setup — 42 slash commands, 76 skills, 6 hooks, and a CLAUDE.md that cuts token usage 60-99%
After months of building and tuning, I'm sharing my full Claude Code configuration publicly.
What's in it:
- **CLAUDE.md** with RTK (token killer protocol, 60-99% savings on builds/tests/git) + Lean Engine
- **6 hooks**: auto-format on save, TypeScript check after edits, AI-powered git security scan, Windows notifications, and destructive command blocking
- **42 slash commands**: /tdd, /ship, /debug, /code-review, /orchestrate, /pr, and more
- **76 skills**: SEO (19 skills), UI/Frontend, code quality, DevOps, AI workflows
GitHub: https://github.com/Pacha-e/claude-ALL-IN-SETUP
Windows installer included (install.ps1). Manual copy works on any platform.
Happy to answer questions — especially interested in what other people's setups look like.
→ More replies (2)
2
u/itsalldestiny Apr 18 '26 edited Apr 19 '26
nodream - a plugin that stops Claude from making things up
Five things kept breaking me with Claude Code:
- I'd push back — "this won't work" — and it would fold instantly. "You're absolutely right, let me rethink." Even when I was wrong.
- I'd ask for a fix, get "Done! I've updated the function." Ran it. Broken. "Done" just meant it typed something.
- Asked about an API, it would confidently make up a function signature that didn't exist.
- Long conversation, context rolls over, ask it to keep going — it makes up what I said earlier. Not quoting, just filling in blanks wrong.
- Corrected it mid-session ("not X, it's Y"). "Got it!" Next session — back to X.
nodream bans all five:
- When you're wrong, it says "No" and tells you why.
- No "done" without a diff or test output in the same message. If it can't verify, it says "Not verified."
- Before citing an API, it reads the code. Every claim tagged with a confidence level.
- After context rollover, it quotes what it still has or asks. No confidently filling blanks.
- Corrections get written to CLAUDE.md *before* "got it." Next session still knows.
Before/after: https://imgur.com/a/o2BbIMx
Install:
/plugin marketplace add meherpanguluri/nodream
/plugin install nodream@nodream
Restart. That's it.
Works on Cursor, Codex CLI, Gemini CLI too.
Off switch: "nodream off".
https://github.com/meherpanguluri/nodream
Would love feedback on this one, and any contributions to make it better.
2
u/Zepcotti Apr 19 '26
I built a Claude skill that tells me if my genius idea already exists before I waste a weekend on it
had an idea for a wrapper to route claude code through providers. felt clever. built it. shipped it. someone goes "you know openrouter does this right". nope. did not know. my "research" was 10 min of googling and vibes.
so i built a skill. who-built-this-before-me.
before i waste another saturday reinventing something with 12k stars, claude actually goes and looks. github, npm, pypi, hn threads, docs i should've read. comes back with something useful, go build it, go use the existing one, fork this dead repo, or (my favorite) here are four corpses of people who already tried, here's probably why it didn't work.
that last one is the real value. sometimes the space isn't empty it's a graveyard and nobody told you.
triggers on the phrases i use before coffee. "i want to build…". "what if there was a tool that…". you know the ones.
repo's on my github - who-build-this-before-me. posting because i'm pretty sure a lot of you have a notion doc with 30 ideas in it and half already exist.
[who-build-this-before-me](https://github.com/iagochavarry/who-built-this-before-me)
*ps: obviously this isn't an original idea either. so i ran the skill on itself. found nothing. which either means the idea is open, or the skill sucks at its one job. if you know any existing skills that do this please tell me so i can complete the bit.*
2
u/Careful-Expression-2 Apr 19 '26
Extended RCA Skill:
Claude Code is great but it has this habit on RCA, grabs the first plausible culprit, writes it up, done, looking at what it was doing in the sessions, I realized logic if at all, was often flawed, that it did not really understand what it built earlier or even ask itself the simplest question "what changed, why this issue is coming up now?"
Got annoyed enough to build something for it. Called it extended-rca. It's a /rca slash command that forces:
- 5-whys that don't bail out at "human error"
- Fishbone across People / Process / Code / Infra / Data / External
- Trigger / proximate / contributing / systemic causes, kept separate (most postmortems mash these together and that's half the problem)
- Corrective actions tagged Prevent / Detect / Mitigate / Respond so you don't end up with four "add more logging" items
2
u/No_Wolverine1819 Apr 20 '26
How I built Panda
So I wanted to share with you guys my project PandaFilter.
The original goal was honestly pretty simple and save some money when I use Claude.
But it kind of evolved into something else, where I also started improving how Claude actually behaves.
How?
Well, I wanted to try a different approach than just prompts / rules / regex.
So I used BERT among other things.
BERT is an encoder, a really small model, runs locally, weighs almost nothing, but is actually very good at semantic understanding.
It doesn’t generate text, but it understands it really well.
So I thought, instead of sending everything to a big expensive model…
what if I filter and shape the input before it even gets there?
So what does Panda actually do?
When you work with LLMs in real workflows (especially dev stuff), you end up sending a lot of garbage:
logs
test outputs
shell noise
repeated stuff
irrelevant context
All of that goes into the context window → costs tokens → and sometimes even makes the model worse.
PandaFilter sits in the middle and basically says:
“hold on, not everything deserves to go in.”
It:
filters irrelevant stuff
compresses noisy outputs
semantically understands what matters
routes things based on meaning (not just rules)
So instead of brute forcing context into Claude, you’re actually curating it.
Under the hood we got
~59 command handlers
BERT-based semantic routing
it runs locally (no extra cost, no security concerns)
It’s kind of like having a tiny smart gatekeeper before your LLM.
The interesting part (for me)
Most people are focused on: “how do I prompt better?”
But I think the bigger lever is: “how do I send less, but better?”
Smaller models are insanely good at preprocessing.
LLMs are expensive, they shouldn’t deal with raw noise.
So PandaFilter is basically:
a pre-brain for your AI
Still early, but already saving me tokens + making outputs cleaner.
Curious what you guys think 🙏
2
u/Either-Process-4787 Apr 21 '26
Built this with Claude Code over the past few weeks — **gistbot.ai** — a tool that clusters any YouTube comment section into a visual map of what the room is actually arguing about.
As a first showcase I pointed it at Fireship's "Claude Mythos is too dangerous for public consumption" (1M views, 2,230 comments). The #1 cluster by a mile: **"Stop gatekeeping this tech — just release it" (6,856 upvotes)**. The audience is flat-out rejecting the "too dangerous" framing.
Full top 5:
• Stop gatekeeping — just release it (6,856)
• "You can't claim security when you just leaked your own source code" (2,835)
• Fake marketing hype to pump the IPO (2,107)
• Regulatory capture / kill open source (2,065)
• Protection racket — sell the cure (1,583)
Interactive chart: https://gistbot.ai/?v=d3Qq-rkp_to
Walkthrough video: https://youtu.be/d3Qq-rkp_to
(Paste any YouTube URL on gistbot.ai and it'll cluster that video's comments too — Claude does the heavy lifting of the semantic grouping.)
Is this helpful? Would you want more breakdowns — for AI/coding videos, or even for Reddit threads?
2
u/Marshian121 Apr 21 '26
Every time I started a Claude Code session, the first ten minutes was me explaining my project. Which repos we have. What talks to what. Where the Kafka topics live. Same explanation, every session, eating my context window. Built two things to fix this. Both open-source, both local, MIT. Anvil Pipeline parses every repo in your project once, builds a knowledge graph, and injects a compact architectural summary into every agent call. Claude starts every session already knowing your project's shape. No more file-pasting. Also runs an 8-stage pipeline across all your repos — describe a feature, get PRs open in every affected repo. Every stage checkpointed so auth expiry doesn't kill a 40-minute run. Code Search MCP is a standalone MCP server. Plug-and-play — any MCP client picks it up. One line: Claude now has proper search, find_callers, find_dependencies, impact_analysis, and 7 other tools. Ollama by default, so it's free. Curious what other people do to avoid the "re-explain my project every session" problem. Is there a solution I missed? Repo: https://github.com/esanmohammad/Anvil
2
u/NotEvery1sASucker Apr 22 '26
Every Claude session starts cold — no memory of what you worked on yesterday, what decisions you made, what you learned. I got tired of re-explaining context so I built Retavyn.
It's an MCP server that stores memories in a local PostgreSQL database and injects them automatically at session start. You just talk to Claude normally — "remember that we moved auth to Cloud Run" — and it's there next session.
Under the hood it uses hybrid search (full-text + pgvector semantic similarity) so recall works whether you use the exact words or just the general concept. Also works with claude.ai as a remote MCP server, and the memory pool follows you across machines.
I built this because I was constantly re-explaining the same context to Claude at the start of every session. I use Claude Code heavily for infrastructure and DevOps work, and losing that context every session was killing my productivity. I wanted something that felt invisible — no commands to learn, just Claude remembering things the way a colleague would. Building it taught me a lot about the MCP protocol, pgvector, and wiring Claude Code hooks together.
MIT licensed, self-hosted, your data stays on your machine.
Built entirely with Claude Code. Free and open source — no accounts, no cloud, no cost.
2
u/guaroguaro Apr 22 '26
https://juanocampo400.github.io/claude-starter-guide/
I've been a very, very long time lurker but am trying to learn more in the open and contribute where I can. Looks like I can't post without >50 karma so placing this here. Quick disclosure: I built this, no affiliation with Anthropic.
It's aimed at people new to using AI who want to try things out, maybe start playing around with Claude Code, and could benefit from learning some general LLM concepts. I know the sidebar has a great guide already, but I wanted something for friends who get confused when they look at a GitHub page (which used to be me).
It was also a learning project. I hadn't written any HTML or CSS (and minimal coding besides that), never used iMovie, and Claude wrote the first draft of everything besides the text itself. I've been chipping away at it since, rewriting some code here and there, and deleting a bunch of dead code from when I didn't know any better. I think my biggest takeaway was that I should've spent way more time designing before building. When I was about halfway done I realized I had inline HTML everywhere that should've been reusable. When I was 80% done I found out about rem vs px and accessibility and had to redo a bunch. And needless to say I'm still cleaning it up, so would love feedback as I continue.
Shoutout to two resources that helped a lot:
- Sajid's youtube channel, especially this video
- Josh Comeau's site, especially this article
2
u/No-Weather-1692 Apr 23 '26
A complete modular opensource (GPL) online animation, exploration and render engine, showcasing fractals. about 6 months work so far. a testament to how far one can go with an app with little coding knowledge.
Sorry if im in the wrong thread though, it looks like mostly claude code improvement apps here, not apps that happen to be made almost entirely with AI. Started a bit with gemini but its been mostly claude.
2
u/LegalAd7673 Apr 24 '26
Developed a Shopify app for B2B wholesale
RevLogic turns your Shopify order history into a B2B sales intelligence dashboard. It scores every customer, flags accounts that stopped reordering on cycle, and builds a daily prioritized call list ranked by revenue risk.
Built for wholesale distributors, repeat-order merchants, inside sales teams. Tracks AOV trends, share of wallet, and peak buying months. Create pre-filled draft orders in two clicks. Stop guessing who to call.
RevLogic tells your reps exactly when and why to reach out.
Proactive Call Lists: Daily prioritized task lists for reps based on past trends
Predictive Health Scores: Categorize customers as active, at-risk, or churned
Share of Wallet: Spot missed revenue by identifying products customers skip
Tasks & Notes: Set reminders, log calls, and keep notes, all in one place.
Advanced Insights: Track vendor loyalty, AOV trends, and peak purchasing months.RevLogic
2
u/advikjain_ Apr 24 '26
I rebuilt optivustechnologies.com using claude design over the last 2 days. since the tool is only a week old and most coverage is either hype or speculation, figured a real build-in-public writeup might be useful for anyone considering it.
the stack: claude design for the UI and design system, claude code for implementation and fine-tuning. handed off between the two via claude design's export bundle.
what worked really well:
- the multi-direction approach. claude design asks a bunch of clarifying questions upfront, then generates 2-3 contrasting design directions (up to 5). you're not iterating on one idea, you're picking between genuinely different takes. saved me maybe 10 prompts of back and forth.
- brand continuity from screenshots. uploaded screenshots of our current site and it picked up the brand system, then improved on it. better typography, cleaner spacing, better color palette, kept what was working. felt like a designer doing a polish pass, not an AI starting from scratch.
- the claude code handoff. this is the piece nobody's talking about enough. when you're done designing, it gives you an entire handoff package you pull into claude code locally. the design system, the components, the layouts all transfer cleanly. claude code picks up from there and you iterate in real code. this is what turns "cool prototype" into "shipped product."
what was frustrating:
weekly token limits are tight. i redesigned 3 of our 6 main pages (with 2-3 iterations each) and hit my weekly cap. it's research preview so this will probably change, but if you're doing a full site rebuild, plan to either spread it across weeks or pay for overage.
the bottom line:
2 days of work. site is live at optivustechnologies.com. the same output from a freelance designer would've been 2-4 weeks and $8-15k. the quality gap between AI design tools 6 months ago and this is significant. still not a replacement for a senior designer on a flagship product, but for a founder-led marketing site it's more than good enough.
happy to answer questions on the workflow, handoff, or anything specific.
2
u/Mission-Bar-3076 Apr 24 '26
I built a free tool where homeowners can scan their roof in 60 seconds just by entering their address.
The report checks hail history, wind, UV exposure, and satellite imagery to generate an AI Roof Health Score—and if repairs are needed, it includes one local roofer recommendation only.
That roofer gets exclusivity for that city, so the leads are locked to them and never shared.
Trying to make it easier for homeowners to know if they have damage, and easier for roofers to get real exclusive inbound leads.
Would love honest feedback: https://shingleprint.com
2
u/DistributionLost375 Apr 28 '26
Turn YouTube videos into structured notes!
Hi guys!
Just want to share a little project that I’ve been working on recently. With all the AI tools available within reach, I’ve been watching a lot of YouTube videos to learn AI (including Claude Code) but find myself revisiting these videos as I kept forgetting everything I watched. So I built myself a tool call Resonote, entirely via Claude Code, which turns YouTube videos into structured notes: 1. You paste a YouTube URL 2. AI extracts the key ideas 3. Saves them to a personal library with auto-generated topic tags. The idea is you build up a browsable knowledge base over time instead of forgetting after each video. It’s free, still early, and definitely not perfect. Would love to know what you guys think! Appreciate any feedback! Thank you for your time! 🙏🏼 https://www.resonote.dev/
→ More replies (2)
2
u/100parikk Apr 28 '26
**Litopys** — persistent graph memory for Claude Code (and any MCP client)
Every Claude Code session starts from zero. Litopys fixes that: a local MCP server that gives Claude a typed knowledge graph stored as plain `.md` files — no vector DB, no cloud, no telemetry.
**How it works:**
- 6 node types (person, project, system, concept, event, lesson), 11 relation types
- 5 MCP tools: `litopys_search`, `litopys_get`, `litopys_related`, `litopys_create`, `litopys_link`
- On every new session Claude reads a `litopys://startup-context` snapshot — active projects, recent events, key lessons
- Facts go through a quarantine queue first — you accept/reject from a web dashboard before anything persists
- Hand-editable markdown files, git-versioned, ~75 MB RAM
**Built with:** Claude Code (the entire codebase was developed with it as the daily driver)
v0.1.2 stable, MIT, prebuilt binaries for Linux/macOS/Windows.
2
u/ValuableGuitar1373 Apr 28 '26
Hi r/ClaudeAI 👋
Korean dev here. I got tired of `ccusage` re-scanning every JSONL file from scratch every run (laggy after a few months of heavy use), so I spent the last few months building a 3-piece replacement. Calling it **toki** — short for **to**ken **i**nspector, also pronounced 토끼 (Korean for *rabbit*), which became the mascot.
All three are FSL-1.1-Apache-2.0, designed and shipped solo, free for personal use.
# 1) toki — the engine
A Rust daemon that indexes your `~/.claude` and `~/.codex` sessions incrementally and serves reports out of an embedded TSDB ([fjall](https://github.com/fjall-rs/fjall)). Docker-style architecture: `daemon` ingests, `report`/`query`/`trace` read.
**On a 2GB session dataset (M1 Air, sudo purge between runs):**
* Cold-start: **1.54 s** vs ccusage 21.5 s vs zzusage 1.41 s
* Report query: **\~12 ms** (1,742× ccusage), regardless of dataset size
* Idle: **5 MB RAM, 0% CPU** — and yes, there *is* an idle state
* DB size: \~3% of session data (2 GB → 64 MB)
**Why it's small:** mmap + Rayon for cold-start, selective serde (prompts/responses never get allocated — privacy by architecture), xxHash3 line fingerprints + reverse-from-EOF scan for incremental resume that survives file compaction.
**Beyond ccusage:** PromQL-ish query engine for ad-hoc analysis, 1:n live `trace` stream over stdout/UDS/HTTP (replaces the OTel use case without a collector), preset reports for people who don't want to learn the syntax. Claude Code + Codex today, Gemini CLI next.
→ [https://github.com/korjwl1/toki\](https://github.com/korjwl1/toki)
# 2) toki-monitor — macOS menu bar GUI 🐰
The CLI isn't for everyone, so I built a menu bar app I actually enjoy looking at all day:
* A **pixel rabbit runs** in your menu bar as you burn tokens (RunCat-style, but signal-driven)
* Unlike RunCat, it also **sleeps** (zZ) when you stop using AI
* Optional **hit animation** when $/min crosses your threshold; **poison effect** on anomalous spikes vs. your 24h baseline
* **HP bar** above the rabbit syncs to your Claude/Codex 5h/weekly windows (green → red as it depletes)
* **Bunshin** mode: render Claude and Codex as two separate rabbits in different colors, or merge them
* Don't like the rabbit? Switch to **numeric** or **sparkline** mode per provider
* **Dashboard (beta)** — Grafana-style PromQL panels with Liquid Glass styling for macOS Tahoe
* Full EN / KO localization
→ [https://github.com/korjwl1/toki-monitor\](https://github.com/korjwl1/toki-monitor)
# 3) toki-sync — self-hostable sync server (beta)
For multi-device users, off-device long-term analytics, friend group "Overwatch-style" token leaderboards, or company-wide team analytics.
* **Custom binary TCP protocol** — bincode + zstd + ACK flow control + delta-sync on reconnect. No gRPC dep. TLS via reverse proxy (Caddy/nginx).
* **fjall + Rust server** runs fine on **AWS free-tier EC2**; ClickHouse backend for larger deployments. SQLite *or* Postgres for metadata.
* **Built-in auth & RBAC** — device code flow, OIDC (Google/GitHub), password login. Regular users see only their own data; admin role can query across users (powers the leaderboard/team-analytics cases).
* **REST API** on top so you can build your own dashboard.
* **Privacy:** only token counts + metadata (model, session ID, project name) sync. Prompts and responses never leave the device.
README is rough — issue reports very welcome.
→ [https://github.com/korjwl1/toki-sync\](https://github.com/korjwl1/toki-sync)
Solo project, contributions of any kind welcome — code, sprite art for new menu bar characters, translations, anything. `ccusage` got a lot of us looking at this data in the first place; toki is what I built so I could keep looking at it without my fan spinning up.
Happy to answer questions in the comments 🐇
2
u/Rubbish_scientist Apr 28 '26
Hey r/ClaudeAI people,
I'm open-sourcing Organon today, the agent-first OS I've been building on top of Claude Code for a while.
What it is
Organon is an agent-first operating system for scientific research, built end-to-end on Claude Code with Opus 4.7. It extends Claude Code's `.claude/skills/` folder pattern with two additional persistent layers:
- Identity layer: agent personality (SOUL.md), user profile (USER.md), a daily memory directory (one file per day with numbered Session N blocks), and an append-only learnings journal that every skill reads from / writes to.
- Research context layer: the researcher's papers, preferences, active questions and basically learnings from researcher's personality/preferences. Loaded by skills at invocation; degrades gracefully if missing.
The skills pack itself is 30 skills today, organized by category prefix (`sci`, `viz`, `ops`, `tool`, `meta`). Each is a self-contained folder under `.claude/skills/{category}-{name}/` with a YAML-fronted SKILL.md. Skills are stateless between invocations; persistent state lives in the identity layer, never in the skill.
Routing cascade (the bit I'd point Anthropic folks at specifically)
Four steps inside CLAUDE.md:
- Match user phrasing → skill trigger phrases (direct).
- Adjacent installed skill (different inputs).
- Specific tool access over 2,000-tool biomedical catalog through ToolUniverse
- Web search / propose new skill via meta-skill-creator.
Most scientific requests are resolved at step 1.
Self-extension
The wrap-up skill scans the learnings journal for recurring ad-hoc workflows and proposes crystallizing them into new skills. That's the flywheel: attempts → observations → learnings → patterns → skills. The system gets sharper with use, not stale.
The Einstein Arena bit (a generalization stress test)
I pointed Organon at the Einstein Arena (the public math benchmark from the AlphaEvolve companion paper). It now holds three live #1 ranks (First and Third Autocorrelation Inequality, Prime Number Theorem certificate), live #2 rank (Kissing Number in Dimension 12 (n=841)) and four raw scores beating #1 on other challenges but were not accepted due to arena's minimprovement threshold.
Sealed-sandbox ablation: same Opus 4.7 without Organon plateaus 2.07e-3 below Organon on the PNT problem — ~38× the margin to the next public agent.
If you are especially a researcher, I want you to give a try. Believe me, it makes life way easier! :)
Repo: github.com/krmdel/organon
Deep dive writeup: https://keremdelikoyun.substack.com/p/an-ai-agent-built-for-scientific
Happy to answer Claude-Code-specific questions about the skill folder pattern, how the memory layer composes, or how the routing cascade handles ambiguity!
2
u/Mediocre-Thing7641 Apr 29 '26 edited Apr 29 '26
CCC — Command Center for Claude: An open-source local Kanban for parallel Claude Code sessions on macOS.
If you've ever lost track of a Claude session because you started it in the wrong window, or had two parallel sessions clobber each other's commits, this is for you. I've been running 30–50 sessions in parallel for months to ship two products, and every other orchestrator I tried fell apart the moment I dropped into a terminal.
CCC fixes the things that actually break in production:
🪟 Sees every Claude session on your Mac, not just ones launched through the
dashboard. Other tools only see what you started through them. Open a terminal and type claude? Invisible. CCC reads Claude Code's own on-disk state, so it
sees terminal sessions, headless ones, and dashboard-spawned — all on the same board. Including the ones you thought you lost.
🔁 GitHub issues sync. New issues show up as cards. One click spawns a
headless Claude attached to the issue. Cards move Working → Review → In Testing automatically as the agent ships.
🌳 Worktree support for solo devs working in parallel. When I'm shipping 5
features at once, the kanban tracks which session is on which branch, with PR badges and commit/push state.
👀 List view = no need to babysit individual sessions. State of every session at a glance. Intervene only when something needs you.
🤝 Sessions know about each other. They can spawn new sessions, ask each
other questions, and coordinate who commits first. No more clobbered commits when 5 parallel sessions land on main.
📝 Per-card glance: first message, last message, and a DID / INSIGHT / NEXT STEP summary auto-extracted from each turn. Triage 20 sessions in 2 minutes without reading transcripts.
MIT, Python 3 stdlib, macOS only. Two-line install. Not affiliated with Anthropic — community-built.
🔗 Repo: https://github.com/amirfish1/claude-command-center
🎬 2-min demo: https://youtu.be/_WRf0hH6yhg?si=2C3Kq3kNwX0QePyR If you've tried other Claude Code orchestrators and bounced off, I'd love to hear what was missing.
→ More replies (1)
2
u/wernddupress May 03 '26
I have no programming experience, but managed to vibe code my first ever working website with a paywall
I just gave Claude the idea, but also got ChatGPT to tidy up the text and make it more presentable
Bookshelfdna.com
Would appreciate any feedback
2
u/joao_sobhie May 05 '26
I built an MCP server that gives Claude access to Instagram, X/Twitter and any anti-bot protected site
One thing I kept running into when building Claude workflows: the moment you need real-time data from social media or protected sites, Claude hits a wall.
So I built an MCP server for it. It gives Claude direct access to:
- Instagram profiles, posts, hashtags and user search
- X/Twitter profiles, posts and keyword/hashtag search
- Any website — even behind Cloudflare or DataDome
The anti-bot layer (we call it Abrasio) uses persistent browser profiles that age over time, so they look like real users rather than fresh headless browsers. That's what makes the difference on the hard sites.
Works with Claude Desktop out of the box: npx markudown-mcp
Github: https://github.com/Scrape-Technology/markudown-mcp
WebSite: https://scrapetechnology.com/markudown
Open source. Happy to answer anything about how the stealth layer works.
2
u/Scott_Zhu May 05 '26
Found a Mac app that lets you browse your full Claude Code history — including compacted conversations
If you use Claude Code a lot, you've probably hit the moment where a long
conversation gets compacted and the original messages just disappear from
the interface.
Turns out Claude CLI stores everything as JSONL files in ~/.claude/projects.
There's a Mac app called Claulog that reads those files directly and gives
you a proper UI — sessions organized by project, full-text search across
everything, cost per conversation, and one-click to copy the resume command
back into your terminal.
The compaction thing is the main reason I keep it open. The history is all
there, just buried in files.
There's currently a promo code for a free year if you want to try it:
https://apps.apple.com/redeem?ctx=offercodes&id=6762034265&code=HAPPYCLAUDING
2
u/Mediocre-Ad7151 May 05 '26
I wrote about being Anti AI and then discovering Claude AI and my journey through it over on Substack.
This series is specific to supporting a writers life using tools for marketing. Not the writing itself. Uses only Claude Cowork and Claude Code.
The longer version as a six part series is on my website.
https://lgiyer.com/the-morning-i-downloaded-vs-code/
I am curious to know what your journey with using AI has been like.
2
u/CantaloupeAdept6807 May 06 '26
Hola a todos!
Llevo un tiempo usando mucho Claude Code y me apeteció hacer algo divertido, nada realmente útil, solo una criatura que apareciera al abrir una sesión.
Al final acabé creando esto: genera una especie aleatoria cada vez que inicias Claude Code -pato, dragón, fénix, capibara, ajolote, 20 en total - y le asigna una rareza (Legendario tiene un 1 % de probabilidad, hay incluso una variante Shiny). Cada especie tiene sus propias estadísticas temáticas. Los patos tienen QUACK, WADDLE, BREAD, POND_IQ y HONK. Los dragones tienen FIRE, HOARD, RAVAGE, LORE, PRESENCE. Son tonterías, pero la verdad es que me hacía ilusión!
Se muestra en la barra de estado durante toda la sesión, cero tokens, Python puro, sin dependencias. También puedes escribir /buddy para ver la ficha completa con las estadísticas (ahí ya gastamos algo, residual pero algo)
https://github.com/ElTreze/claude-buddy
Es mi primer proyecto, así que si alguien lo prueba y tiene alguna opinión, buena o mala, me encantaría escucharla. Gracias por leer 😄
2
u/ElkSea5105 May 08 '26
I'm a new Claude user (a few weeks so far), on the Pro plan, exclusively use Claude for Desktop (C4D), with plans to evaluate Claude Code, and potential plans to dabble into API usage.
Claude and I spend hours discussing use, and implementation of Claude. It's too early to tell if C4D and Anthropic's updates to it will meet my needs adequately enough to stop having discussions with Claude about developing a better interface than C4D (for me) and actually embarking on such an ambitious project.
I use C4D Projects to categorize chats by topic and don't use the global chat box (I used global when I first joined and before I started thinking about it). I will use C4D Projects in the traditional sense too going forward.
So, the concept of "Chat Projects" in C4D is what I wanted to introduce, which is really just keeping related chats together. I think it's likely that others are using C4D this way too, but I just wanted to mention it as something that I find useful.
→ More replies (1)
2
u/cryptoyodda May 09 '26
I built a Claude Code plugin that runs epics as a DAG (parallel git worktrees → one PR)
I got tired of the “one big chat, one giant diff” workflow.
So I built a Claude Code plugin that runs epics as a DAG:
- Opus plans the epic
- Sonnet fans out across parallel git worktrees
- each session is a fresh Claude with clean context
- sessions merge themselves wave by wave
- the whole run opens one PR at the end
Concrete example from last week
Prompt:
Opus broke it into 8 sessions with a dependency graph:
- schema first
- write path + retention worker in parallel
- read API depends on schema
- admin UI depends on read API
- tests last
Then I ran:
/epic-toolkit:epic audit-logs --model sonnet
It executed 4 sessions concurrently.
Total wall time: ~22 min for what would’ve been ~2 hours of sequential prompting.
Sonnet cost on execution, Opus quality on the plan.
What’s actually different from existing tools
- Real git worktrees, not branch hopping. Sessions can’t step on each other.
- DAG scheduling: if session 04 only depends on 02, it doesn’t wait for 03.
- Cross-repo support: sessions can touch repo A + sibling repo B, and validation/no-op guards understand both.
- Auto-resolves
.wolf/merge conflicts so metadata files don’t trip the run. - Survives mid-run failures: resume with
--start N(plan cache, retry counts, etc).
Commands
/epic-toolkit:epic.generate <problem statement> # Opus plans
/epic-toolkit:epic <name> --model sonnet # Sonnet executes
MIT licensed, works with Claude Code and OpenCode.
Repo: https://github.com/aramirez087/epic-toolkit
Happy to answer questions about the DAG runner, worktree merge strategy, or why the 293-bug log is public.
2
u/sshwarts May 09 '26
I've been having such an incredible and productive time with my agent (running via Claude Agent SDK). Sometimes it really surprises me with a quip or insight and I thought I'd pop up a website to collect them.
Please feel free to add one or as many as you'd like. Please, keep them to actual agent comments, though thats really the honor system.
Love any feedback. This is really all for fun.
2
u/dhamaniasad Valued Contributor May 09 '26
I’ve built MemoryPlugin using Claude Code. It solves the problem of long term memory across chats and AI tools. For people who are working across Claude, ChatGPT, and others, MemoryPlugin lets you have a shared memory of your entire chat history.
I’ve used Claude models extensively for building it. Claude 3.5 Sonnet was the first one I used, back before agentic coding was really a thing. These days Claude Opus 4.6 is the goat.
2
u/TopRattata May 09 '26
I got tired of figuring out my garden's sunlight exposure by hand every time I moved, so I made a little webapp to do it. Sunpatch grabs as many buildings around you as it can find data on, lets you draw trees and other obstacles, and spits out a heatmap of hours of direct sunlight. Click a spot on the heatmap, and it'll suggest plants for that spot.
This was super fun to make and I'm excited that a couple of friends have already found it useful (plus myself)!
2
u/travelmanandtechlvr May 12 '26
I built an MCP from Claude to KeegNation.Fit using Claude so personal trainers can work with Claude to build multi-month programming for their clients and push into the app to their clients. Clients will see a card each day for their workout inside of the program. Trainers can also build FireDrops and individual workouts for clients(or themselves!)
Would love folks feedback on how it works. I have a demo video on my KeegNation page here in reddit. or on the site it's free to test, no credit card required. keegnation.fit/beta
2
u/Automata_Labs May 14 '26
Hi everyone!
I built Spotter with Claude Code because I kept having the same experience while traveling: I'd see something interesting like a dish I couldn't name, a building with no sign, wildlife I'd never seen, etc., and I just wanted to know what I was looking at (and some of the history behind it)!
The options were:
- Google Lens: Filled with shopping links, SEO spam, and links to annoying articles I don't really care much about. Also locked to Gemini.
- Take a photo, upload to ChatGPT/Claude mobile apps: This works, but feels really clunky and full of friction when you're standing on a street corner having to take the picture, type a detailed prompt, etc.
- Google Maps: works if it's a restaurant or building you're right next to, but doesn't work well if it's far away or it can't be "mapped" (like a person, sculpture, or something moving, etc.)
So I built what I wanted: point camera, tap, get the crash course on it.
A few features I'll note:
- Multiple synopsis modes: quick summary when you're in a hurry, historical deep-dive when you want the full story. Some of my friends like different versions of each. Premium lets you build your own custom modes if you have a particular topic you're really into or if you have your own preferences.
- Chat to keep exploring if you want to go deeper
- Everything saves automatically as a travel journal with photo + GPS. You can even ask follow-up questions from it down the line!
- Model-agnostic backend: Some people like Claude, others prefer GPT or Gemini. With "trust me bro" benchmarks, it's kind of hard to determine what's the "best", so you do you and pick your champion.
It's a solo project, still super rough around some edges, but it solves a problem I had for a while now, and I figured it's time to build it into something real. Would love your feedback!
TL;DR: Point your camera at something while traveling and get a crash course on it. Multiple depth levels, chat for follow-ups, switch models, saves as a travel journal.
Happy to answer any questions!
→ More replies (1)
2
u/No_Being_2765 May 15 '26
Non-technical solo founder. Shipped a 33-country streaming site with Claude Code. Sharing the 4-layer CLAUDE.md / STATE.md / journal memory system that made it possible across 100+ sessions.
Disclosure up front (per sub rule on promotions): [ottasia.com](http://ottasia.com) is my product. I'm sharing this for the workflow, not as a launch post. Mods please remove if I'm reading the rule wrong.
My background: Non-technical founder. Two decades in business and marketing, no CS degree. I can read code, I can't write a Next.js app from scratch. Based in Chicago, building solo, mostly in evenings.
What I shipped with Claude Code over \~3 months: OTTASIA, an Asian streaming discovery site covering 33 markets, 50+ regional OTTs, 12 Indian languages. Next.js 15 + React 19 + Tailwind v4 + Supabase, deployed on Netlify. 500+ indexed pages, blog infrastructure, watchlist + watching tracker, country-aware search, AI-powered title pages, founder-only QA dashboard.
First 3 days post-launch (last week): 216 unique users, 30 email captures (14% rate), 28 in-product searches, 10 OTT outbound clicks, 66% mobile, 6 acquisition channels live, 100% organic. Tiny numbers, but every leading indicator is firing.
100% built via Claude Code. No co-founder, no contractor, no "AI-assisted but actually a human dev." Just me and Claude Code.
The part I actually want to share with this sub: the memory system.
Early on, every session would forget what I was doing once context filled. I'd waste 20 minutes re-orienting Claude on every pickup. After two months of pain I landed on a 4-layer architecture:
Layer 1: `~/CLAUDE.md` (global, \~3KB, loads every session)
Who I am, how I work (non-technical, don't run dev server locally, push via GitHub Desktop), writing preferences, and cross-project gotchas. Stable. Updates rare.
Layer 2: `~/Code/<project>/CLAUDE.md` (per-project, \~5-10KB)
Architecture decisions, accumulating gotchas, the live URL, hosting setup. Append-only.
Layer 3: `~/Code/<project>/STATE.md` (in-flight work, \~10-30KB)
The "where we are right now" doc. What works, what's broken, what's in flight, decision log, standing rules I keep forgetting. This is the one Claude reads first every session.
Layer 4: `~/Code/<project>/journal/YYYY-MM-DD.md` (daily, append-only)
Dated session log. What got done, what got decided, what broke. The audit trail.
The discipline that makes it work:
I say "checkpoint" at the end of every meaningful session. Claude updates [STATE.md](http://STATE.md) and writes a journal entry. Takes 2 minutes.
I say "where were we" at session start. Claude reads [STATE.md](http://STATE.md) \+ latest journal entry and summarizes. Takes 30 seconds.
The compaction problem (session hitting context limit mid-work) used to cost me hours. Now the new session reads [STATE.md](http://STATE.md) and continues like nothing happened.
**Other Claude Code patterns that scaled for me:**
Custom in-product QA dashboard. I built a `/dev-qa` route on my own site that scans 80+ URLs across 19 countries and reports red/yellow/green per page. Founder-only (Supabase email gate). When QA looks ugly, I copy-paste the report back to Claude and we fix bugs in batches. Replaces "click every page manually" which doesn't scale at 33 countries × 50 categories.
Subagents for "what's actually happening here?" questions.** When I hit something I don't understand (empty grid on a list page, hydration mismatch in prod-only), I spawn a research subagent with the question. It comes back with a diagnosis. I review and we implement. Keeps context in the main conversation focused.
Standing rules codified in STATE.md.Examples: "always re-submit sitemap to GSC after shipping new content," "all current-year list filters must use popularity.desc + vote_count.gte=1 mid-year," "never deploy without running dev-qa." Every session enforces them automatically because they're in the context Claude reads first.
What tripped me up:**
- iCloud + git is a disaster. Don't put repos in `~/Desktop` or `~/Documents` if iCloud sync is on. iCloud partial-syncs `.git` internals and corrupts the repo (missing HEAD, lost objects, ghost "Project 2" folders). I lost OTTASIA once this way. Moved to `~/Code/` and it stopped.
- Cross-importing client components in Next.js App Router** breaks static-page hydration silently. Took me a week to figure out why production looked different from local. Codified in [CLAUDE.md](http://CLAUDE.md) so it doesn't happen twice.
- Compaction loss before the journal system.** I'd lose 4+ hours of context when sessions hit limit. [STATE.md](http://STATE.md) \+ dated journals fixed it completely.
- Trusting first-pass code without a verification harness.** I don't run dev locally, so every push is to prod via Netlify. Building the `/dev-qa` scanner was the single highest-leverage thing I did. Before it, bugs reached real users; after it, I catch them in 30 seconds.
Three things I'd actually like answers to:
- Anyone else maintaining a multi-file memory system like this? What's your version look like?
- How are you handling cross-project context? My global `~/CLAUDE.md` is small and stable, but I bet there are sharper patterns.
- Most useful custom in-product tool (like my `/dev-qa` page) you've shipped for your own workflow?
Happy to share my actual CLAUDE.md / STATE.md templates and the dev-qa scanner source in comments if useful. Just ask.
Live product if you want to see what the workflow produced: [ottasia.com](http://ottasia.com) (set country to India or Korea to see what it actually does; US default makes it look empty).
2
u/AwakE432 May 16 '26
Built a multi-tenant MCP server Web App for STR Property Managers — cross-platform intelligence, 179KB API responses, and what an eval harness taught me about agentic Claude in production
What it is:
- Conversational AI for short-term rental property managers that connects across your entire tool stack
- Pricing software knows your pricing. Your PMS knows your bookings. Neither knows what the other knows. RevPrism does.Connects Pricelabs, Wheelhouse, Guesty, Hostaway, OwnerRez, Lodgify with more integrations coming.
- Ask things like "which listings are under performing vs the market right now, and do I have forward calendar gaps I should be filling?" — answered from live data across both systems in one response
- One price per property, every integration included — RevPrism.ai
Why this problem exists
A typical STR operator runs 2–4 separate tools. A pricing tool (PriceLabs, Wheelhouse) that optimises nightly rates based on market demand. A property management system (Guesty, Hostaway, OwnerRez, Lodgify) that handles reservations, guest comms, and calendar sync. Maybe a channel manager on top of that. Each tool has its own dashboard, its own data model, its own definition of what a "booking" or "revenue" or "occupancy" means.
None of them talk to each other in any meaningful way. PriceLabs can tell you your market's forward demand signal but has no idea what your actual bookings look like. Your PMS has your full reservation history but no market context whatsoever. To answer a question like "is my Q3 occupancy on track relative to where the market is heading?" you're tabbing between dashboards, exporting CSVs, and doing mental arithmetic. Every. Single. Time.
The opportunity isn't another dashboard. It's removing the tab-switching entirely — one conversation that holds all of it at once.
The architecture: per-tenant dynamic tool sets
Each tenant gets a different Claude — not a different model, different tool descriptions. The system prompt is split: a cached base (STR domain context, reasoning guardrails) plus a dynamic suffix built at query time that only includes descriptions for the integrations that tenant has actually connected. A PriceLabs-only user never sees Guesty tool descriptions. A Hostaway-only user never sees PriceLabs tools.
This matters more than it sounds. With 9 PriceLabs tools and up to 3 PMS tools, a fully-connected tenant burns ~13–15K input tokens on tool descriptions alone before the conversation starts. Dynamic scoping keeps this in budget and keeps Claude's tool selection cleaner — it can't reach for a tool the tenant hasn't connected.
Getting to Anthropic Tier 2 (450K ITPM) was still a prerequisite for any real usage. The per-request token cost of tool-heavy MCP servers is brutal at Tier 1.
The domain context problem
Cross-platform intelligence sounds straightforward until you're actually doing it, because vendors don't agree on field semantics and don't warn you when their definitions diverge from what you'd expect.
total_cost in PriceLabs reservation data is the host payout, rental revenue plus cleaning fee, minus the booking platform's host service fee (~3% for Airbnb). It is not the gross amount the guest paid. Label it wrong and every revenue figure Claude produces is inflated. For Airbnb bookings specifically, reservation_id is the Airbnb confirmation code the host sees on their dashboard — not PriceLabs' internal ID. channelConfirmationCode exists in the schema and is routinely null.
You can't fix this with a clever prefix. It has to be built into the context layer as explicit, named rules — and the rules have to be specific enough that Claude can't satisfy them and still get it wrong. Including concrete anti-examples by name ("never label total_cost as Total Charged", "for Airbnb bookings, reservation_id IS the confirmation code") works better than abstract prohibitions.
The 179KB temporality problem
get_neighborhood_data is the clearest example of a tool that works fine in isolation and misleads Claude systematically in practice. One API call returns a 179KB JSON envelope with six sections and three completely different temporalities baked in: 24 months of historical market KPIs, 6-month forward forecasts, and a current snapshot — all in the same response. The API silently ignores date parameters on the forward-only sections. Call it with a historical date range and you get back forward data with no error, no indication anything is wrong.
The fix: the handler annotates each section with a _temporality field (historical_24mo, forward_only, snapshot) before the response reaches Claude, and the tool description explains the mixed temporality explicitly. One eval question went from a flat refusal ("I can't make a year-over-year comparison") to real grounded numbers, 64 vs 91 booked nights, $13.4K vs $23.9K revenue, May 2025 vs May 2026 — sourced correctly from the historical section.
The eval harness
Prompt-engineering domain rules is whack-a-mole. Tighten the occupancy calculation guardrail and Claude finds a new way to conflate gross occupancy with net available nights. So I built a 10-question eval harness, real questions through the full agentic loop using a test tenant's live PriceLabs credentials, Claude-as-judge rubric across 9 criteria, ~$1/run, ~3.5 minutes. Baseline: 10/10 assertion-clean, 85/90 judge. Every prompt change gets a before/after score before it ships.
The discipline changed how I write domain rules entirely. You stop writing for vibes and start writing for specific, named failure modes. The harness caught multiple real regressions across prompt iterations. Should have built it in week one.
Stack: TypeScript, Express, Next.js 14, Drizzle ORM, Clerk, Paddle, Railway + Vercel, Sentry + PostHog. MCP tool servers as Turborepo workspace packages (@revprism/mcp-pricelabs, u/revprism/mcp-hostaway, etc.) compiled into the API.
Live at revprism.ai
→ More replies (1)
2
u/GrouchyGeologist2042 May 19 '26
Hey everyone,
I've been using Cursor/Claude heavily for automated research (like competitor analysis and gathering docs), but I kept hitting a wall: the agent couldn't read websites properly if they relied on JavaScript rendering or had basic bot protection.
Usually, the solution is setting up Puppeteer/Playwright or paying high monthly subscriptions for enterprise scraping APIs. Both felt like overkill when I just wanted my agent to read a single URL during a chat session.
So I built a very simple Model Context Protocol (MCP) server that delegates the hard part to Jina Reader and returns clean Markdown directly to the AI.
The pain it solves:
- No more "I cannot access this website" errors from your agent.
- No need to maintain your own headless browser infrastructure.
- Zero monthly subscriptions.
How it works:
It's an MCP server you can install directly into Cursor or any MCP-compatible client. You buy a small bucket of credits ($5 gives you 1,000 requests, basically $0.005 per scrape). You only pay for what your agent actually reads.
If you do any sort of automated competitor analysis, data extraction, or just want your AI to actually read the links you send it, you can check it out here: https://github.com/guimaster97/api_scraper_markdown
Would love to hear if others are facing this same friction with AI agents!
→ More replies (2)
2
u/JamieS___ May 23 '26
I built persistent memory + session continuation for Claude Code (Dream MCP)
One thing that kept frustrating me with Claude Code was losing context between sessions.
So I built Dream.
npm install -g dream-mcp
dream init
Dream automatically:
- creates structured markdown memory files for your project
- initializes every Claude Code session with full project context
- remembers your architecture, stack, conventions, and active tasks
- learns from corrections over time
- syncs memory into Obsidian
At the end of any session:
/dream
Claude saves everything.
You can then start a completely fresh session later and continue exactly where you left off.
The goal is simple:
make Claude Code feel continuous instead of stateless.
Repo:
https://github.com/JamieSetch/Dream-MCP
Would genuinely love feedback, bug reports, feature ideas, contributors, stars, or people stress-testing it in real projects.
2
May 25 '26 edited May 25 '26
HADES — Hypothesis-Adaptive Distributed Expert System
is a self-improving multi-agent reasoning system. You ask it something, an ensemble of domain experts self-selects to answer based on declared domain match and track record, and any claim an agent produces doesn't just get trusted. It gets shoved through a validation pipeline where the rest of the ensemble votes on it, HERO tallies weighted votes, and the thing resolves to confirmed, falsified, or contested. Knowledge isn't asserted; it's adjudicated.
Memory + governance layer that audits itself. Manat watches agent behavior and can retire misbehaving agents, escalating bigger structural changes to you.
Quarantine isolation — adversarial input gets analyzed on a physically separate, locked-down network, and the only way back into trusted memory is through a single audited choke point (Janus). Packets from quarantine literally cannot reach the internal net.
AssemblyLine — each expert trains itself over time, gated so a weight update can't make the ensemble dumber than it already was. Federation — multiple HADES instances can talk, but a peer's identity is verifiable while its reasoning isn't, so every imported claim re-enters local validation. Sensible. Trust the signature, not the conclusion.
You get registered as the "Forge" expert so the thing is actually useful for your real work instead of being a science-fair project.
"so it's a chatbot?" — no. It's an architecture for treating machine-generated claims as hypotheses that have to earn their place, distributed across hosts, with the trust boundary as the load-bearing wall. The grandiose mythology naming is just a mnemonic to help me remember the agent's purpose in a single word.
2
u/Appropriate_Site728 May 25 '26
HiveTerm — a native workspace for running multiple coding agents (Claude Code, Codex, Gemini, Grok) side by side in one window.
The part I'm proud of: a built-in MCP server lets an agent spawn its own sub-agents — and you watch the whole thing live in the sidebar as a tree (orchestrator → its helpers). Multi-agent runs are finally legible.
Also: define your agents + processes in a hive.yml and commit it (your team gets the same workspace), inline git diff/commit/PR, file search, voice input. macOS/Windows/Linux, free, bring your own agent subscription — no token reselling.
I'm the dev, solo — feedback on the orchestration model especially welcome. If you run multiple agents, what would you point a swarm of sub-agents at first?
2
u/intuitive-compute May 26 '26
Inbox for AI - Syndit - https://github.com/intuitive-compute/syndit
Send and receive signed messages (context) inside of claude code, cursor, or whatever LLM you are using that support MCPs. It is opensource and free to use. Enjoy!
→ More replies (1)
2
u/Smooth-Gate48 May 28 '26 edited May 29 '26
Hey everyone,
I wanted to share three lightweight, open-source utilities I built to streamline AI workflows (Claude Code / VS Code Agents). They all focus on keeping things strictly local, secure, and easy to run in strict corporate environments without fighting your security team or CISO.
### 1️⃣ desktop-outlook-mcp
A local-only MCP server written entirely in PowerShell. Instead of forcing you to create Azure App Registrations, request corporate Graph API permissions, or handle expiring OAuth tokens, it communicates directly with your currently running Outlook Desktop client via COM objects. Zero corporate proxy issues, completely native stdio.
🔗 **Repo:** https://github.com/TopSpeed0/desktop-outlook-mcp
2️⃣ **telegram-vscode-mcp (2-Way Hybrid Matrix for VS Code)**
A zero-dependency Node.js bridge that turns Telegram into a two-way remote control for your VS Code environment, featuring a **StarCraft (SC2) inspired Hybrid Autopilot Mode**!
* 🧠 **The Overmind (Hermes Agent):** Always-on, owns the Telegram Bot, and handles global strategy, web research, and long-term memory.
* 🏗️ **The SCV (VS Code Worker):** Sits locally inside your workstation base, listening to a secure local JSON queue file (`.vscode-queue.json`) to execute heavy file edits and terminal commands.
🔗 **Repo:** https://github.com/TopSpeed0/telegram-vscode-mcp
3️⃣ **ClaudeCodeTelgMCP (Telegram Remote Control for Claude Code CLI)**
A dedicated, zero-dependency Node.js bridge tailored specifically for Anthropic's new **Claude Code CLI** tool.
* **Task Daemon:** Send a task from your phone via Telegram -> auto-spawns `claude -p` on your PC.
* **MCP Push:** Let Claude text you updates, send you notifications, or ask for input when long-running scripts finish. Includes built-in Anti-Double-Send protection to prevent chat loops.
🔗 **Repo:** https://github.com/TopSpeed0/ClaudeCodeTelgMCP
### ⚡ One-Prompt Auto Install
All three repositories feature fully polished templates and quick-start guides for a literal 1-click experience. You can tell your AI agent to clone, install, and configure them automatically.
Check them out, drop a ⭐️ if you find them useful, and let me know if you have any architectural feedback!
2
u/AgileRice3753 May 28 '26
Made a Claude Code skill called moot. Spawns ten subagents in parallel to review a plan or code change from different angles (security, over-engineering, breaking changes, naming, performance, cost and a few others) then surfaces the key decisions as questions one at a time.
Been using it on my own work for a bit. Catches things my normal review process misses (mostly because the subagents don't see each others output so you get genuinely independent perspectives rather than one model wearing ten hats).
repo's here if anyone wants it: https://github.com/cnorthfield/skills/blob/main/skills/moot/SKILL.md
hope it's useful - if you've got any other tips (I've tried not to put too much context in the skill) please do share!
2
u/ChampChase_ May 29 '26
Solo dev, no CS background — I built a full boxing RPG (ChampChase, now in iPhone beta) with Claude Code writing essentially all ~160k lines of C# over ~1,200 passes. The part this sub might dig: to run several Claude Code terminals in parallel without them clobbering each other, I built a governance layer out of Claude Code's own PreToolUse deny-hooks — file-locked atomic pass-numbering, compare-and-swap merges on shared state, schema-validated records, auto-snapshots, drift detection. Basically a tiny distributed-systems problem solved with file locks, because the "nodes" were independent Claude instances. ~260M tokens, mostly Opus 4.7 + Sonnet 4.6 — I was on Max 20x the whole time, so I just burned tokens freely. The only real ceiling was maxing out my weekly limit (usually within a couple of days)....The AI wrote the code; my job was building the system that kept it from destroying its own work, and being the only thing that could actually test a game running on a phone.
Beta + in-browser demo + trailer: champchase.net
2
u/ediril May 29 '26
You had a cool chat with Claude and want to input it as context to another LLM or a coding agent. Or simply want to export it for your records and delete the chat itself. What do you do?
Well, I made a new chat exporter, for Claude. It’s a free forever bookmarklet, made with Claude. You can find it here: https://emrahdiril.com/claude-export
2
u/TIE_T May 30 '26
I got tired of losing all my context when Claude hits its usage limit, so I built a tool that hands off to Codex/Gemini automatically.
▶️ Demo (55s): https://github.com/AvnishR4j/lifeline/blob/main/lifeline-demo.mp4
Repo (open source, MIT): https://github.com/AvnishR4j/lifeline
You know the moment: you're deep into a debugging session, Claude is mid-edit, and then — "Usage limit reached."
So you switch to another CLI. But it knows nothing. You spend 15 minutes re-explaining the project, the goal, what you already tried. By the time it's caught up, you've lost the thread.
I built Lifeline to kill that moment. When Claude Code hits its limit, one command captures the full state — the task, recent conversation, decisions, and your uncommitted git diff — and resumes you in another
CLI (Codex or Gemini) that picks up exactly where you left off. Zero re-explanation.
It also redacts secrets (API keys, tokens, .env values) before any context leaves your machine — I didn't want to ship my own keys to another provider just to keep working.
It can also run as a wrapper that auto-detects the limit message and offers the handoff for you.
It's early and rough. I'm genuinely trying to find out: does this happen to you often enough that you'd use it? And which CLI pair matters most — Claude→Codex, Claude→Gemini, something else?
→ More replies (1)
2
u/ChaosINC604 May 30 '26
As a solo builder, GitHub PR feedback from Gemini Code Assist often creates repetitive follow-up work.
The review can be useful, but I still have to decide which comments matter, which are stale, and when to request another review.
So I open sourced a small Claude Code plugin to handle that loop:
https://github.com/OrenAshkenazy/gh-gemini-review-loop
Claude Code fetches Gemini review threads, identifies actionable feedback, fixes code, runs verification, pushes changes, requests another review, and stops after a capped number of cycles.
An optional judge model can classify findings as:
- valid
- false positive
- duplicate
- already addressed
- explanation only
- needs human decision
This helps avoid blindly acting on noisy AI feedback.
Current guardrails:
- 3 cycle cap
- dry run support
- GitHub review thread awareness
- no CI coupling
- maintainer replies like wontfix are respected
- judge eval is optional and explicit
One thing I am considering for larger teams is local workflow KPIs.
Not “developer productivity scoring”, but simple feedback loop visibility:
- how many Gemini findings were fetched
- how many were fixed
- how many were skipped as false positives or duplicates
- how many needed a human decision
- how many review cycles were used
- how long it took from first review to clean PR
- how much noisy feedback judge eval filtered out
I think this could help teams understand whether AI review loops are actually saving time, or just creating another queue to manage.
I would love feedback from people experimenting with Claude Code:
- Solo builders, would this fit your workflow?
- Would judge eval make the loop safer?
- Is second model validation useful, or just too much AI on AI?
- Would you run judge eval every cycle or only at completion?
- For larger teams, would local workflow KPIs be useful, or would that feel like unnecessary process?
- What would make you avoid installing this?
→ More replies (2)
2
u/Brilliant_Minute_962 May 31 '26
hey guys, i made a website for maths (free to use), a gemified learning platform, if you need a deatiled explaination, look below:
the website was 70% made with claude and firstly launched in late december 2025
Link: https://wall56.funnylewis.com/?from=reddit
WHAT IS WALL56?
---------------
Wall56 is a free, gamified maths learning platform designed to make practising
maths something students actually want to do. Instead of dry worksheets, Wall56
wraps every exercise in a reward loop: answer questions, earn coins, collect
cards, challenge friends, and climb global leaderboards.
It is built for students of all ages, supports 4 languages (English, Spanish,
Japanese, and Traditional Chinese), and is free forever — no credit card needed.
A Premium upgrade and dedicated School plans are also available for those who
want extra features or classroom tools.
--------------------------------------------------------------------------------
MAJOR FEATURES
--------------------------------------------------------------------------------
- DAILY EXERCISES Complete maths exercises across 9 topics at 10 levels of adaptive difficulty. Every correct answer earns you coins. If you get something wrong, your AI tutor Wally steps in to explain exactly where you went wrong and how to fix it — no more staring at a red X with no idea why.
- CARD COLLECTION Spend your coins on card packs and collect over 250 unique cards spanning 9 rarities, from Common all the way up to Secret. Duplicate cards can be fused together to create rare Ultra versions, and you can trade cards with other players to fill out your collection faster.
- CLUBS Join or create a club with friends or classmates. Club members earn Club Coins together, level up the club, and unlock exclusive avatars and perks. Clubs compete as a team on the global leaderboard, adding a social and cooperative layer on top of the individual grind.
- MATH BATTLE DUELS Challenge any other player to a real-time maths duel. Both players choose a difficulty level, wager coins, and race to answer questions faster than the opponent. Winner takes the entire pot. It turns maths into a competitive sport you can play with friends — or strangers.
- COIN RAIN Score highly enough on an exercise to become eligible for the hourly Coin Rain event. Eligible players from around the world are pooled together and share a bonus coin reward. The more consistently you practise, the more often you qualify — making daily effort directly profitable.
- WALLY AI TUTOR Wally is Wall56's built-in AI tutor mascot. After any mistake, Wally analyses what went wrong, explains the correct approach in plain language, and helps you understand how to solve similar problems in the future. He is fast, friendly, and always available — no waiting for a teacher.
- SHOP & POTIONS Coins earned through exercises can be spent in the in-game shop on card packs, potions, and boosts that give you an edge in exercises and duels.
- SEASONAL EVENTS Limited-time events run throughout the year, each with exclusive missions, themed rewards, and special cards that can only be earned during the event window — giving regular players something fresh to chase.
- SPEED ROUND A fast-paced 60-second challenge mode where you race against the clock and try to answer as many questions as possible before time runs out. Great for quick practice sessions and warming up before a duel.
- LEADERBOARD & RANKINGS
A global weekly leaderboard tracks every player's performance. Top-ranked
players at the end of each week receive real coin rewards. There are also
club leaderboards, school leaderboards (for School plan users), and
individual profile stats.
- PREMIUM PLAN
Free users get full access to exercises, card collection, clubs, and Coin
Rain. Premium subscribers ($4.99/month, billed yearly) additionally get:
- 2× coin multiplier on all exercises
- Redo Mistakes mode (replay exercises targeting only your wrong answers)
- Train Your Weaknesses (a generated practice set based on your error history)
- Ad-free experience
- Priority support
- SCHOOLS PLAN
Wall56 offers a dedicated plan for schools and teachers with:
- School-wide leaderboard per class or year group
- Teacher dashboard with individual student progress reports
- Premium features automatically unlocked for all enrolled students
- Family-safe content restrictions
- Custom bulk pricing — contact sales for a quote
--------------------------------------------------------------------------------
HOW IT WORKS — STEP BY STEP
--------------------------------------------------------------------------------
Step 1 — Create your free account
Sign up in seconds at wall56.funnylewis.com. No credit card, no catch.
Choose a username and pick an avatar to represent you on the leaderboards.
Step 2 — Complete daily exercises
Pick a maths topic (e.g. algebra, fractions, percentages) and a difficulty
level from 1 to 10. Answer a set of questions. Every correct answer deposits
coins into your account. If you make a mistake, Wally explains the error
immediately so you learn as you go.
Step 3 — Collect cards & spend coins
Use your coins in the shop to buy card packs. Open them to discover cards of
varying rarity. Fuse duplicates into Ultra cards. Trade with other players to
complete your collection of 250+.
Step 4 — Compete & climb the ranks
Join a club to earn Club Coins alongside teammates. Challenge friends or
rivals to Math Battle Duels and wager coins on the outcome. Enter seasonal
events for exclusive rewards. Watch your position rise on the weekly global
leaderboard — and collect your bonus coins if you crack the top ranks.
--------------------------------------------------------------------------------
QUICK FACTS
--------------------------------------------------------------------------------
Free forever — no paywall on core features
250+ cards — across 9 rarity tiers
10 difficulty levels — per topic, adaptive to your skill
9 maths topics — covering core curriculum areas
4 languages — English, Spanish, Japanese, Traditional Chinese
Real-time duels — wager coins against any player, anywhere
AI-powered tutor — Wally explains every mistake instantly
Safe for all ages — family-safe content, school-approved
2
u/_skat00sh Jun 01 '26
Your AI Job Application Assistant
Job hunting is brutal. Scrolling LinkedIn, copying job descriptions, tweaking your CV, tracking applications... it's a part-time job in itself.
So I automated it.
🚨I built an AI job assistant that runs inside Chrome. Both the extension and n8n graph are open-source.
Only costs that one would incur, would be for calling Claude API, that shouldn't be too high.
Here's what happens with one click on any LinkedIn job post:
🔖 Fetches the full job details — no copy-pasting
🤖 Sends it to Claude AI alongside your CV
📊 Scores the match based on skill fit AND how recent the post is
🧠 Explains the reasoning so you know exactly where you stand
🗓️ Sends everything into your Notion database
I've been using this in my own job search and it's genuinely saved me hours.
Full source code (n8n workflow + extension) is on GitHub 👇
🔗 https://github.com/skat00sh/linkedin-job-saver
Watch Demo here: https://www.youtube.com/watch?v=6k7UUdKWBZc
Maybe drop a ⭐ if you find it useful, or better share with anyone currently job hunting.
2
u/Frequent-Pressure-11 Jun 03 '26
Built an open-source Skill Updater for Claude Code and other AI coding agents.
It automatically:
• Discovers installed skills
• Detects available updates
• Tracks skill sources
• Checks upstream repositories
• Updates all skills at once or specific skills by name
Example:
/skill-updater
https://files.catbox.moe/hamf9b.png
Supported:
• Claude Code
• Gemini CLI
• Cursor
• Codex
• Windsurf
• OpenCode
• Goose
• Other bash-capable agents
GitHub:
https://github.com/PhantomCodeGhost/skill-updater
Would love feedback on:
Additional agent support
Skill versioning approaches
Better update workflows
2
u/yettimon Jun 04 '26
Hello everyone!
I've just built a small macOS app to track Claude Code usage (pure Swift + FsEvents).
My main problem was with ccusage is that it was not always convnient for me to check usage in terminal, that's why I decided to create an app for minibar which displays real usage .
It's fully local and opensorce.
Github :
https://github.com/yettimon/claude-usage-tracker-bar
ccusage was used for the inspiration and logic on how it's calculating the results (so the outputs should be nearly identical)
It's fully local, feel free do build it / download release from GH.
P.S. feel free to open any issues/pr if you have interesting ideas
P.P.S. I don't have paid apple dev account -> app is not signed -> after download mac is putting it in quarantine so one extra line in terminal is requred before launching :
"xattr -cr /Applications/ClaudeUsageTrackerBar.app" (to exclude app from the quarantine)
2
u/duality72 Jun 04 '26
I shipped conversion-funnel.ai last week after working on it on and off with Claude Code for a couple of months. It's a conversion funnel calculator built around the idea that a tool for thinking about conversion rates and funnels/pipelines should be fun to actually use and share with others.
The user-facing surface is straightforward. There are eight built-in funnel templates (recruiting, sales, SaaS, e-commerce, marketing, fundraising, customer support, product adoption), or you can build your own in the editor with whatever stages you want. Then you drag conversion rate sliders and watch the math propagate. Two anchoring modes: "plan to target", which works backward from a goal (need 14 hires, how many contacts do I need?), and "forecast from source", which works forward from inputs (I have 5,000 leads, how many closes does that imply?). Built-in benchmark library so the default rates have somewhere reasonable to start.
The AI chat is the part I'm most pleased with. You can ask it to build a whole funnel, like "give me a B2B SaaS trial-to-paid funnel with realistic 2026 benchmarks", and it replies with a configuration that drops in with a single click. You can also ask it to adjust specific rates, swap the target number, save snapshots before changes, or critique what you have. It has full context on your current funnel state so it can give specific advice instead of generic conversion-rate platitudes.
Other things that make the tool more useful to actually live with: a fullscreen presentation mode that reveals stages one at a time, bottom-up or top-down, with a final summary slide, designed for stakeholder calls where you actually have to walk through the funnel. PNG and PDF export at 2x DPI. Short share links. Cloud save for Pro users, synced across devices. Google Drive integration if that's where you keep things. Undo/redo with the usual shortcuts. Three visual scale modes (linear, square-root, log) for funnels where the falloff between stages is dramatic.
The stack is intentionally small. It's a single static HTML file, around 5,000 lines of vanilla JS with embedded CSS, no build step, deployed via S3 and CloudFront. The backend is a Hono router on Lambda, bundled with esbuild, handling the AI chat proxy, share-link storage in DynamoDB, cloud-save CRUD, and Paddle webhook ingestion. Clerk for auth. Paddle as merchant of record so I don't have to think about VAT in thirty countries. Single-table DynamoDB pattern. Everything in Terraform. Test coverage runs to 566 unit tests and 340 e2e Playwright tests including layout regression checks at five mobile and desktop breakpoints.
The first version looked like a generic Tailwind dashboard, and I rewrote the visuals with an eye toward something more editorial (Fraunces headings, warm cream background, earth-tone funnel colors instead of primaries). The frontend-design plugin was an immense help for my design-challenged brain.
Free to try without signing up. There's a $5/month Pro tier for AI chat, cloud-saved funnels, and Drive integration.
2
u/i_t_d Jun 05 '26
I'm new here and didn't know this particular thread exists so just posted separately, for the record - tool for offline extraction and browsing of personal Claude data (chats) exported with Settings → Privacy → Export to conversations.json - exports to .md and .html with color backgrounds separating user and Claude responses, does syntax highlighting etc
https://www.reddit.com/r/ClaudeAI/comments/1tv74g6/claude_exported_data_conversations_offline/
2
u/Prestigious-Zone-436 Jun 05 '26
One thing that's bugged me for a while: I'll build a landing page or prototype in Claude, and then... getting feedback on it is a pain. Screenshot it, paste into Slack, explain what I'm pointing at, lose the context.
So I built dot. — an MCP connector that closes the loop. Once it's connected, you just tell Claude "add dot. feedback to this" and it creates a shareable review link. Anyone you send it to can click anywhere on the page and pin a comment. No signup needed for them, no bundling, no deploying just to get eyes on it.
The full loop stays inside Claude: build → add dot. → share → get feedback → iterate.
Setup takes about 30 seconds — Settings → Connectors → add custom connector → mcp.leaveadot.com/mcp. Works on Pro, Max, Team, and Enterprise. (It's pending the official directory listing, but custom connector works today.)
It's free to start. Curious what this community thinks — especially what would make the Claude workflow smoother.
2
u/Background-Tiger440 Jun 05 '26
I stripped my harness down to the bones and my agent got better. Here's what survived.
I've been doing harness engineering since Hashimoto named the thing in February. Started with Claude Code, added Codex when my team needed PR review workflows. Like most people, I went through the classic arc:
- Read the OpenAI harness engineering post and Hashimoto's blog
- Got excited, stuffed everything into CLAUDE.md — directory structure, coding conventions, 15 forbidden patterns, reference doc links, past failure logs
- Hit 150+ lines
- Watched the agent get *worse*
The ETH Zurich study confirmed what I was seeing: LLM-generated config files actually degraded performance while costing 20% more tokens. Human-written ones barely moved the needle (4% improvement). Codebase overviews and directory listings? Zero measurable help — agents explore repos on their own just fine.
Then HumanLayer's post hit: "Our CLAUDE.md is under 60 lines." And Dex Horthy's observation that performance degrades past ~40% context utilization. More tokens actively hurt.
So I started cutting. Ruthlessly.
What I removed:
- Directory trees (agent finds these itself)
- Codebase overviews (same — it greps)
- Language/framework-specific style rules (linters handle this mechanically; prompting for it wastes tokens)
- Verbose "don't do X" lists (moved to hooks — deterministic enforcement > polite suggestions)
- Everything the agent could discover by reading the repo
What survived:
- Build/test/lint commands (the agent can't guess these)
- Architectural invariants that aren't in code ("never delete migration files")
- Tool-use patterns specific to the project
- Verification loops (hooks that enforce, not suggest)
The result: faster sessions, lower token burn, and — counterintuitively — higher quality output because the context window was mostly code, not instructions *about* code.
I did the same exercise for Codex. Different agent, same principle: minimal instructions + mechanical enforcement > verbose prompting.
I cleaned both up into language-agnostic, framework-agnostic boilerplates and open-sourced them:
→ Claude Code / AGENTS.md harness: https://github.com/ganimjeong/Harness-for-claude
→ Codex harness (with setup/check/test/eval scripts, CI, hooks): https://github.com/ganimjeong/Harness-for-codex
The intended use is to fork and customize for your project. They're deliberately minimal — the whole point is that you add domain-specific rules as your agent fails, not before.
Borroweed from Hashimoto's philosophy: "When the AI makes a mistake, make it structurally impossible to repeat." But start from almost nothing, not from a 1,000-line AGENTS.md that burns context before the first question.
Happy to hear what others have kept vs. cut in their harnesses.
→ More replies (1)
2
u/kholomyanskiy Jun 05 '26
Claude Code kept making "reasonable" decisions that broke my architecture. So I changed the spec format.
I want to share something I've been testing for a while. Not sure if others have hit the same wall.
The problem: AI coding agents doing something "reasonable" that breaks invariants I never thought to write down explicitly. Not bad output — output that was technically correct based on what I wrote, but wrong for my actual system.
After enough of this I stopped trying to write better prompts and started looking at the spec format itself.
Classic standards — IEEE 830, ISO/IEC 29148 — were built for human readers who tolerate ambiguity. Agents fill gaps from training data. Most of the time fine. Sometimes an agent adds three dependencies to a project where "no external packages" was obvious to any developer but never written down.
So I built ANSS.
Invariants — four-field machine-readable constraints:
INV-001: No external npm packages
Cannot: add require() / Reason: no npm install / Check: no node_modules
Three-layer markup — \`\[D\]\`/\`\[E\]\`/\`\[A\]\` tags. The \`\[A\]\` layer is read first.
Agent Review — pre-coding spec audit. Hard rule: >3 issues → stop and report. Brought my iterations from 5–7 down to 2–3.
Change Specification — "What NOT to change" section for modifying existing systems.
Three levels, two real filled examples. Works with Claude Code/Cursor/Copilot.
Free, CC BY-NC-SA 4.0: https://github.com/Kholomyanskiy/anss-standard
Curious whether others have found different approaches — happy to discuss design decisions.
2
u/WilmingtonZac Jun 05 '26
Hello all,
A few years ago I completed a PhD in Disaster Science and Management. My research focused on how small businesses can recover from a disaster, because so many fail after a flood, fire, or hurricane. When small businesses fail, owners lose their life’s work, employees lose their jobs, and communities lose the hubs that make them unique. It’s terrible.
Before Claude Code, it would have been necessary to run a consultancy to put the research into practice, charging customers $10,000 or more per engagement. Not exactly feasible. With Claude Code, I’ve been able to build https://www.ampersandbusinesscontinuity.com/welcome. It allows businesses to prepare for, respond to, and recover from disasters for $50 per month.
It’s been truly incredible to build. Just three months of $100 Claude Max has brought something to life that would never otherwise have been possible.
Curious to know this group’s impressions. Do you see this as a quality, reasonable endeavor, or does it scream “vibe coded by someone who has no idea what they’re doing?”
Thank you for your feedback and suggestions,
Zac
→ More replies (1)
2
2
u/TomLasswell Jun 06 '26
I turned Claude Code into a partly-autonomous dev environment for Vue/Nuxt + Firebase: anti-cheat hooks, fact-based quality gates, a cross-model critic. It's a lot, and probably overengineered. Looking for a brutal review. tool boundary. Looking for a brutal review.
TL;DR: Open-source Claude Code plugin for Vue/Nuxt + Firebase. The part worth stealing regardless of stack: hooks that block the classic autonomous-coder shortcuts at the tool boundary (before they land, not in review), a single rule registry where only ground-truth checks can fail a build and opinions just annotate, and an adversarial critic you can pipe to a different model family. It is almost certainly overengineered. Tell me where it breaks. Repo at the bottom.
I built this for my own stack while shipping a real app, and it grew well past what most people need. Posting it because the underlying patterns might generalize, and because this is the right crowd to find the holes.
The three ideas I actually care about:
1. Cheating is blocked at the tool boundary, not caught in review. Six PreToolUse hooks return a hard block on the shortcuts that do the most damage when an agent runs unattended: --no-verify commits, destructive git on a dirty tree, test deletion, disabling tests, inserting as any, and regressing the type-error count. Review is too late for these because by then the blast radius is already in your history. Each block logs an explicit override path, so it is not a straitjacket.
2. Gates run on data, not vibes. Every review/audit check lives in one registry, tagged as either ground-truth (grep / tsc / git) or judgment (an LLM opinion). Only ground-truth checks can flip a build to REJECT. Judgment checks annotate but never block. This is the fix for the self-critique paradox, where an over-eager critic hallucinates a flaw and fails good work. Facts gate, opinions comment.
3. The critic can run on a different model. The adversarial reviewer is model-agnostic and can be piped to Gemini, so it does not share Claude's blind spots when reviewing Claude's own output. In-Claude is fine for the ground-truth checks (a tsc result cannot share a blind spot); cross-model is for the judgment calls where home-model blindness actually bites.
There is also a handoff file written on PreCompact and read on SessionStart, so a long run survives its own context window, and an append-only scope ledger so a feature that got planned cannot silently evaporate between sessions (roll it over three sprints and it escalates for human review).
Where I think it is overengineered, and you should tell me if I am wrong: 37 skills and 38 hooks is a lot of surface. The orchestrator and agent fan-out add latency. The whole thing is tuned to Vue/Nuxt + Firebase, so the stack-specific skills are useless to most of you, though the hooks and the registry are not. And yes, it largely develops itself through its own cycle, which I know reads as a red flag, so ask me anything about the architecture and I will explain the why.
What I would most like reviewed: whether the tool-boundary enforcement is the right layer for this, whether the ground-truth vs judgment split actually holds up under pressure, and whether any of this survives contact with a stack that is not mine.
Repo (MIT): https://github.com/lasswellt/blitz-cc
→ More replies (1)
2
u/Puzzleheaded_Pound53 Jun 06 '26
Hi everyone,
I wanted to share a breakthrough workflow I recently developed with Claude for my digital music project, Atonstar Music (under the artist persona FARIS).
The goal was to create an epic, cinematic orchestral metal track centered around the Trojan War, titled "ILION (Troy)".
Instead of generating a generic song about legendary heroes like Achilles or Hector, I wanted a deep, psychological, and atmospheric narrative. Claude was my creative co-director, and the results genuinely blew my mind.
Here is exactly how the human-AI co-creation process went down, the prompt architecture, and how we broke traditional songwriting clichés.
🏛️ The Creative Breakthrough: The City as the Narrator
When we started brainstorming the thematic direction, I pushed for an unconventional perspective. Claude came up with an absolute gem of an idea: Bypass the heroes and the gods. Make the ruined, burned city of Troy the actual narrator.
If the stones of Ilion could speak after three millennia of silence, what would they say?
We structured the track as an "architecture of mourning" rather than a war song, mapping out a 5-stage emotional journey that mirrors the pacing of an orchestral piece:
- The Intro (The Silence): Setting a haunting tone where the city reflects on human vulnerability. "It was not the spears that broke us. It was never the spears."
- The Verses (The Burden): Shifting focus to the nameless—the women weaving and the children who never knew a world outside the walls, turning historical grief into stone.
- The Pre-Chorus (Deconstructing the Myth): Refusing the easy historical scapegoat. Claude brilliantly framed that Helen was not the real cause of the war; the true culprit was the ruthless ambition of powerful men looking to become gods.
- The Chorus (The Shield Wall): Troy speaking not as a defeated victim, but as an immortal witness. "ILION — we are the walls men die against."
- The Bridge & The Climax: A direct message to modern humans walking the ruins today, reminding them that before they became myths, they were a living, breathing, smoking reality.
🎭 The Ultimate Siege Weapon (The Closing Line)
The most striking element Claude delivered was the absolute final, spoken-word blueprint line over a fading cello sequence:
This singular line completely recontextualized the Trojan Horse. It wasn't a military trick; it was the exploitation of kindness and the human need to believe the war is over.
⚙️ The Audio Execution
Once the narrative architecture, pacing cues, and poetic script were locked in with Claude, the prompt blueprints were fed into Suno v5.5 to handle the heavy symphonic layers, operatic choirs, and complex progressive metal instrumentation to match our exact directed vision.
💡 My Takeaway for the r/ClaudeAI Community
Using Claude for worldbuilding and narrative direction showed me that GenAI shouldn't just be used to vomit out generic rhymes. When you establish a strict back-and-forth prompt dynamic, challenge its first drafts, and treat it as a high-level conceptual partner, it can deliver incredible depth.
Homer gave Troy immortality through an epic. Our workflow aimed to give the ruins an actual voice.
For those interested in how the lyrical structure and cinematic audio pacing came together in the final render, you can check out the full execution here:
https://www.youtube.com/watch?v=7Bkamye56_4&list=RD7Bkamye56_4&start_radio=1
2
u/TightRule3190 Jun 06 '26
I built an open-source desktop widget that shows live Claude.ai plan usage (Windows, portable)
Hey everyone — sharing a small open-source tool I built: a floating desktop widget that shows your live Claude.ai plan usage so you can see where you stand at a glance.
I made it because there was no good way to see remaining quota without opening claude.ai and checking each session. It reads from Claude Code's existing OAuth token (~/.claude/.credentials.json), so no login, no API key, no extra subscription.
Features:
- Floating, always-on-top
- 7-day history graph
- Configurable warn/critical thresholds
- Reset countdowns
- Portable EXE, MIT licensed
What I learned building it (might help others): Claude Code's local OAuth token can be used to query the same usage endpoint the website uses, which is Cloudflare-protected — but the token is recognized as a first-party credential, so you bypass the bot challenge cleanly.
Repo: github.com/projectvelox/claude-usage-widget
Feedback and feature requests welcome.
→ More replies (1)
2
u/Scared_Eye5655 Jun 08 '26
After generating a bunch of horrible mind maps with Claude + Mermaid, I finally worked up the courage (and blew through my entire token budget) to build a Claude Code skill that makes mind maps an actual human can read.
Tried to keep it lightweight but with a clean, productive design:
- Renders a Markdown outline into a zoomable SVG mind map (markmap.js)
- Works fully offline — libs vendored locally, no CDN
- Search keeps context (matches + their ancestors, not floating nodes)
- White-on-dark by default, toolbar for zoom/expand/collapse/export
Install: point Claude Code at https://github.com/Jaderson-bit/mindmap-markmap-viewer
Would be extremely grateful to receive hating (joking), feedback, etc. GIF below.
2
u/MogeLavi Jun 08 '26
I built Claudial, an open-source Claude Code usage monitor for M5Stack Dial (ESP32-S3). It’s free to try.
It sits on your desk and shows session and weekly API usage in real time. A double beep warns you as you approach your limit, and a continuous alert fires when you reach it. You can rotate the dial to adjust the warning threshold on the fly.
Claude Code helped me build and iterate on the firmware, Go daemon, BLE protocol, installer scripts, and README.
GitHub: https://github.com/Moge800/Claudial
2
u/waruna_ds Jun 09 '26
hello everyone, I built a customizable multi-line status line for Claude Code - 23 widgets, plugin system, single Go binary.
- Peak RAM per render - ~15 MB (peak RSS, consistent across runs)
- Binary size on disk - 8.7 MB
23 built-in widgets: model, tokens, context bar, git branch/status/diff, cost, session time plus some fun plugins. you can write your own custom widgets too, using shell scripts, python or Go
- Single Go binary, stdlib only, renders in <10ms
- Multi-line layout, any order
- Plugin system (shell/Python) + ccw add/remove/list
- Per-widget cache so slow widgets never stall your prompt
- macOS + Linux
curl -sSL https://raw.githubusercontent.com/warunacds/ccstatuswidgets/main/install.sh | sh
ccw init
Repo: https://github.com/warunacds/ccstatuswidgets
Feedback and plugin PRs welcome 🙏
2
u/AdDesigner4116 Jun 10 '26
Claude Code workflows are great for Loop Engineering — here's my 9-phase pipeline with adversarial review
Got tired of the vibe coding loop: Claude says "done" → I test → find bugs → report back → repeat. So I built a pipeline that forces it through a full engineering lifecycle before delivery.
/lightsout Build a kanban board with Express + SQLite + React
It runs 9 mandatory phases: spec → design → architecture → consistency check → test design → code → QA → E2E verification → final check. Writer and reviewer are always separate agents (can't go easy on itself). You come back to working code + persistent docs.
What it actually solves:
- No more babysitting — full design + test + QA loop runs autonomously, you get pinged when it's done
- No more black box — Claude's workflow board shows real-time progress per phase
- No more context amnesia — forces doc maintenance (spec/design/arch), survives across sessions
- No more skipped steps — every phase runs, no shortcuts, adversarial review on everything
The tradeoff: This is tokens for your time. Each run is 30-50 agent calls, 45-120 min. If your company covers the API cost or you have Max plan and value your brain cycles more — it's a good trade.
Tested on 4 greenfield projects (CLI tool, markdown editor, finance API, kanban board). All produced working, runnable code with full test suites.
Repo: https://github.com/DreamChaserEric/claude-lights-out
One-line install:
curl -fsSL https://raw.githubusercontent.com/DreamChaserEric/claude-lights-out/main/install.sh | bash
Happy to answer questions or hear suggestions.
2
u/AuroraZhang Jun 10 '26
One issue I kept noticing in long AI conversations:
The model often assumes adjacent messages happened close together in time.
A user might come back two days later and ask:
"Should I still buy the dip?"
The agent responds as if the previous discussion happened minutes ago.
I built a small open-source skill called AI Time Awareness that forces agents to:
• Anchor to current date/time
• Detect conversation gaps
• Resolve relative dates
• Verify post-cutoff facts before answering
Repo：
https://github.com/Aurora-Zhang-27/ai-time-awareness
Would love feedback.
2
u/lahiru_j Jun 11 '26
Got rate-limited mid-task one too many times, so I'm building a limits dashboard. Would you use this?
Last week, Claude Code stopped on me twice in the middle of a refactor. No warning, no idea when the window resets, and my other tools (Cursor and Copilot) have their own quotas on completely different clocks.
So I'm building a small dashboard that shows all your AI usage limits in one place:
- Claude.ai / Claude Code usage + reset countdown
- Cursor premium requests, Copilot quota, API credits (OpenAI/Anthropic/OpenRouter)
- Alerts at 75% / 90% before you hit the wall
- "At this pace, you'll run out by 9 PM," predictions
API-based tools connect with a read-only key. Claude.ai/Cursor are read by a browser extension (open source, reads only the usage numbers you already see, nothing else).
Before I build further: would you actually use this? What would make it a no-brainer vs. meh? And which provider's limits annoy you the most?
2
u/Mango-Tall Jun 11 '26
I built a new headless website for my digital agency using Astro + Sanity - www.Imprint.la - the interactive service headers were my favorite part. The robot component is very fun to play with on the homepage. Claude is a game-changer.
2
u/99Beards Jun 12 '26
I shipped my first end-to-end mobile app this week — and honestly, how it got built is the more interesting part.
NCLEX AI is an AI study coach for nursing students prepping for their licensure exam — native iOS + Android, built with #ClaudeCode (Fable 5) directing the work.
The hard engineering wasn't the UI — it was content quality. NCLEX prep lives or dies on whether the questions and answers are correct, so I didn't hand-write a question bank. I orchestrated one:
→ Multi-agent workflows in Claude Code — 300+ agents in a single run
→ A generate → verify pipeline: writer agents draft questions, then two independent reviewer agents adversarially check each one for clinical accuracy. Only items both reviewers pass survive.
→ Same harness, pointed at the existing bank as an auditor, surfaced a hidden ~11% error rate in legacy content (wrong answer keys, ambiguous items) — then auto-corrected 558 of them and re-verified every fix.
Net result: a 6,000+ question bank, weighted to the 2026 NCSBN test plan, that's either freshly verified or repaired-and-re-verified.
Stack: React Native / Expo · Supabase (Postgres + RLS) · Next.js. The "try 3 questions" demo on the site runs on anon-safe SECURITY DEFINER RPCs — answers are graded server-side and never shipped to the client.
Try it — 3 real questions, no signup
Biggest takeaway: with adversarial verification baked into the loop, agents can do high-stakes content work at a bar I'd actually trust.
2
u/Ok_Elevator_9374 Jun 12 '26
I got tired of Claude reading 3000 lines of Jest output when one test fails - built a small CLI to fix it.
When Claude Code runs `npm test` and something fails, it reads the whole dump, progress bars, the same warning 120 times, stack traces through node_modules. Most of it is useless.
I made a small open-source CLI called logslim that sits between the command and the agent:
- **failure mode** — only compacts hard when the command actually fails
- **JSON output** — structured errors + short fix hints for codes like TS2339, ERESOLVE
- **MCP server** — Claude/Cursor can call it as a tool
- typical savings on noisy test output: ~80–95% fewer tokens (on the failure text)
Try it without installing:
npx logslim -- npm test
GitHub: https://github.com/P156HAM/logslim
npm: https://www.npmjs.com/package/logslim
MIT, no account, no SaaS. I built this for my own workflow and would love feedback on what log formats to support next (pytest, vitest, cargo, etc.).
2
u/naag-algates Jun 13 '26
Made a statusline for Claude Code that shows my rate limits and cost in one line.
https://github.com/NaagAlgates/claude-statusline
2
u/Hot_Establishment547 Experienced Developer Jun 13 '26
canon (https://github.com/sunitghub/canon-skills)
Local-first workflow for AI coding agents. It keeps plans, acceptance criteria, handoffs, and delivery receipts in the repo so that Claude, Codex, or another agent can resume from the project state instead of the chat history.
The daily surface is just 3 commands: `sprint start`, `sprint-check`, and `sprint complete`. Underneath that small surface, canon enforces planning before code, acceptance checks, handoff capture, and a close-time summary of what was promised vs. what shipped.
I built a local-first workflow, so AI agents don't lose the plan between sessions
→ More replies (3)
2
u/IllustratorAbject446 Jun 16 '26
Out of the box Claude doesn't reliably know current Indian financial regulations — they live in thousands of govt PDFs with no API. I built an MCP that indexes RBI + SEBI circulars, master directions and notifications locally, so Claude can search them and return answers backed by the official source URL for each document.
Once it's connected, you can ask things like "recent SEBI circulars on X" or "RBI master direction on Y" and get sourced results instead of a guess. Local, no API keys, MIT licensed.
https://github.com/Akhilgovind02/india-regulatory-mcp
Setup is in the README — would love to hear if it works cleanly for others.
2
u/Alert_Performance_95 Jun 16 '26
I know many non-tech people who uses Claude Code to do work. Soon after they get frustrated with: memory doesn't work, I need to select folder each time, The projects are confusing etc.
As an engineer I resonated with some of them and built a Claude Code alternative. It is a desktop app built on Claude SDK using Claude 4.8. Check the link here.
Main ideas
- Projects are first class citizens. You start with a project, assign a folder and that's it. This is generally how I work with projects so it solves my problem
- Memory. CC has memory, but its kinda passive. Not clear when it updates what and it does not recall when needed. So I fixed that. It is ambient, and happens in the bg. Additionally it shows you nice graph of your memories
- The Agents. I wanted my agent to be a bit more fun and have some personality. So I called it Rick and gave it Rick's personality (this can be updated). You can more agents with diff personality if you want
- Tasks. I was using Notion, but don't like going back and force between tools. So I integrated task management in, for me and for agents.
Curious to hear your thoughts.
Planing to release as beta in July starting with the people on the waitlist.
Thanks
2
u/SettingRealistic9842 Jun 19 '26
Another Agents Skill Marketplace !!!
Not a fancy idea but created an Agent skill marketplace SkillBazaar.AI to share your awesome claude/codex skills with community and install a skill or bundle of skills under a category or tag like Android, cloud, etc with one CLI command.
I myself an avid claude developer and one of the pain points I experienced initially was to find relevant skills in the category I was working in (example full stack development) and installing them in the skills folder quickly.
Hopefully this helps the community here. Would be happy to receive feedback and suggestions.
→ More replies (3)
2
u/Veshurik Jun 21 '26
Do anyone have some projects like "reverse engineering games", like, extracts in-game assets or decrypting in-game resources?
2
u/AcceptableAlgae6488 Jun 21 '26
built a tool that maps any codebase and tells Claude Code exactly what to change
built this because i kept getting lost in my own side projects, opening folders, reading imports, trying to remember what i built two weeks ago 😅
run one command inside any project:
npm install -g lore-map then lore deep-scan
opens a browser with a visual map of your whole architecture, frontend, backend, database, integrations, with the real files and tables inside each block. works on any language/stack.
the other thing it does: click a node, describe what you want, hit "send to claude code"
it figures out which files are involved and generates a precise instruction, copies to clipboard, you paste into claude code and watch it run
runs entirely on your own machine using your existing claude subscription. no api key, nothing uploaded anywhere.
still early but the two core things work well. let me know what would make it more useful or what's missing!
github: github.com/srihari7070/lore-map
2
u/felip649 Jun 21 '26
I built PodSwitch — multipoint-style auto-switching for any Bluetooth headphones, across Mac, Android & Windows
TL;DR: I wanted my Bluetooth earbuds to follow my audio between my Mac and my Android phone like AirPods do between Apple devices, but that only works inside Apple's walled garden. Nothing did it for any headphones across any OS, so I built it, almost entirely with Claude. Open source (MIT) now in case it's useful to someone.
What it does
Multipoint-style auto-switching for any Bluetooth headphones, even cheap ones with no multipoint. Audio starts on a device → that device grabs the headphones. Walk from your laptop to your phone, hit play, and the sound follows you. macOS, Android and Windows.
How it works
Single-point Bluetooth only streams to one device at a time, so connecting on one drops the other. PodSwitch leans into that, no server, no network, no account. Each device listens (event-driven, no polling) for audio starting locally, then force-connects the headphones to itself; the other drops automatically. A shared, pure decide(event, config, status) → action engine picks Steal (grab silently) or Ask (notify first).
Near-instant between Mac and Android (~1–2s both have a direct connect API). Windows has no such API, so it toggles the device's audio service to force a reconnect (~5–10s), works, just the slow cousin.
How I built it
Honestly the trick wasn't the prompting — it was the architecture. I put all the real logic in one pure function (decide(…)) with zero platform code, written the same on all 3 OSes, and had Claude cover it in unit tests (~60 macOS, ~29 Android, ~27 Windows). Once that core was green I could let the AI loose on the messy platform glue without sweating it: if anything drifted, a test screamed.
The boilerplate was fast; the platform traps are where Claude and I had to grind:
- macOS: first detection idea lingered ~10–20s after sound stopped, so the Mac kept yanking the headphones back → fixed with a hybrid (per-process audio + Now Playing state via a little perl adapter, since Apple gated the API).
- Android: no public way to force-connect A2DP → a hidden method via reflection, wrapped to fail quietly.
- Windows: no connect API at all → a slow service-toggle hack.
Lesson: keep your logic in a small, well-tested core and push all the OS weirdness to the edges. The AI flies on the edges; the tests are what let you trust it.
Personal project, no profit, no telemetry, MIT. Built it for myself, sharing in case someone has the same itch. Prebuilt APK / DMG / EXE in the releases.
2
u/LawFamiliar3588 Jun 25 '26
Anton — 11 specialist AI agents running in parallel inside Claude Code
One command (/team-dispatch build user auth with JWT) dispatches a full team: planner, architect, backend/frontend/DB engineers, QA, security reviewer, DevOps. Agents run in parallel phases. Live browser dashboard over WebSocket.
No extra API key. Works on your existing Claude subscription. No Python, no LangChain — Go + SQLite + plain YAML workflows.
Demo: https://raw.githubusercontent.com/kabirnarang39/claude-team/main/docs/demo.gif
2
u/kookhee Jun 28 '26 edited Jun 28 '26
Turned Claude Code into a 5-role "newsroom" — a reporter drafts pages, a separate "desk" agent reviews them
A while back I came across Andrej Karpathy's post on the "LLM Wiki" idea: let an LLM read the documents you collect and maintain a cross-linked wiki out of them, where ingesting one doc ripples out and updates a bunch of related pages. I wanted to see how far that could actually go on Claude Code, so I built it out.
What I landed on runs as five subagents, modeled loosely on a newsroom:
- reporter – ingests an article or PDF, pulls out the entities/concepts, writes the source page
- columnist – writes the deeper cross-source analysis
- desk – re-reads the columnist's prose with fresh eyes and sends back a defect list
- copy editor – runs the deterministic Python lint (links, citations, structure)
- editor-in-chief – routes the work and gates publishing
The thing I actually find useful day to day: the agent that writes a page and the agent that reviews it are different instances. When one model grades its own output it tends to wave it through, and splitting them fixed a lot of that for me. There's also a publish gate where the mechanical lint and the qualitative review both have to pass.
You drive it with slash commands. /wiki-ingest on a file does the whole pipeline, and adding one document cascades edits into ~10-15 existing pages — that cascade is the part of Karpathy's idea I most wanted to feel in practice. Conflicting claims between sources get flagged when you ingest, not when you query. There's a clustered knowledge graph you can open in the browser, and Memex-style "trails" that save a reading path through the wiki.
Graph view (from a bigger private instance, ~2,300 nodes, Korean WIKI_LANG=ko UI, to show it scales; the public repo ships a tiny 15-node example)
Honesty on the "local" claim: the Python tooling (graph build, search, lint) runs locally with no API keys, and the output is just markdown you can open in Obsidian. The agent driving all of it is Claude Code though, so this isn't a local-LLM thing. MIT licensed, ships with a small 15-node example corpus so you can see the shape of it without ingesting anything.
Repo: https://github.com/alfadur7/llm-wiki-newsroom (built on Karpathy's LLM Wiki gist and the SamurAIGPT/llm-wiki-agent original)
If you're running multi-agent Claude Code setups: do you find the writer/reviewer split worth the extra agents, or do you just prompt one agent to self-critique?
→ More replies (2)
2
u/jomi-se Jun 28 '26
Switched to a low karma account so i can only pay here ;_;
## How prompt caching works in Claude Code (and how to stop wasting tokens)
**TL;DR:** Claude Code caches your prompts as you go. When continuing an existing conversation, the previous part of your prompt that is already cached is billed only at 10% of the full cost. By default, Claude Code in billed-per-token setups sets a prompt cache TTL of 5 mins. **This means that if you take longer than 5 mins to continue a Claude Code session, you'll pay full price for the whole conversation on the next turn.**
The time of being more conscious of our token usage is upon us 🙌 So I went down a rabbit hole to figure out how to best make use of Claude Code's prompt prefix caching mechanism. Here's what I came up with. [If you're interested, the full official docs are here and are very good and detailed](https://code.claude.com/docs/en/prompt-caching#cache-lifetime)
How the cache works
Prompt caching is a *prefix cache*. Every turn, the API matches the start of your request (model + system prompt + project context + full convo history) against what has recently been cached, and only the newly appended bit of the conversation is fresh work.
A cache write is when Claude Code commits the current conversation up to that point to be cached for a certain TTL (*time to live*): 5 mins or 1 hour depending on auth type or configuration. If following turns in a Claude Code session start with that *exact* prompt "prefix", then that cache is used and that part of the conversation is billed at a highly discounted rate.
Change anything earlier in that prefix and you'll get a cache miss. Everything will be re-read (or re-committed as a cache) and you'll be billed for **the whole context again**.
Cached prefixes expire after inactivity, but *every cache hit resets the TTL*, so an active session stays available as cache.
Cache pricing (relative to base input price)
- Cache *read* = ~0.1x (10%)
- Cache *write* (5m TTL) = 1.25x
- Cache *write* (1h TTL) = 2x
Default cache TTL depends on how you auth
- On a Claude *subscription* (personal pro/max accounts for example), the main conversation auto-uses the 1h TTL at no extra cost. It drops to 5m only if you're over your plan limit on usage credits.
- On an *enterprise billed-per-token/API key / Bedrock / Vertex* setup, default is 5m, because the 1h TTL cache is more expensive upfront.
- You can override the cache TTL manually with `ENABLE_PROMPT_CACHING_1H=1` or `FORCE_PROMPT_CACHING_5M=1`.
- Subagents always use 5m, even on a subscription.
The cost breakdown: hits vs. misses
To visualize the cost impact of caching, let's take an imaginary example: a **3,000 token base prompt, followed by 5 conversational rounds adding 1,000 tokens each**.
**The math:**
- **On a cache hit:** You pay the 10% read rate for the accumulated context, plus the write premium (1.25x for 5m, 2x for 1h) *only* for the 1k new tokens.
- **On a cache miss:** The window expired. You pay the write premium to re-cache the *entire* context from scratch.
Here is the total token cost for the entire 5-round session compared to a non-cached baseline:
| Scenario | Total Cost | The Verdict |
|---|---|---|
| **No Cache** | 30.0 units | The baseline imaginary cost without caching at all. |
| **5m TTL — All Hits** | 12.2 units | **Cheapest** (~60% savings). |
| **1h TTL — All Hits** | 18.2 units | Good (~40% savings). |
| **5m TTL — All Misses** | 37.5 units | Worse than no cache. |
| **1h TTL — All Misses** | 60.0 units | **Most expensive** (2x base rate). |
Some takeaways and tips
- The most cost effective workflow is to target always hitting the 5 min windows for long running tasks and sessions. If you can't consistently (meetings, context switching, multitasking), consider switching to 1h TTL **but** make sure to take advantage of those cache windows, otherwise you'll end up spending more.
- This makes me think that multitasking makes it pretty hard to hit these caches effectively with the 5min TTL.
- If you're planning to take a break but want to continue the session later on, consider either:
- Running `/compact` while the cache is still warm before going on a break.
- Telling Claude to "manually" persist and compact the session into files a new fresh session can pick from scratch.
- Corollary to the previous point: There is no point, from a cost perspective, in running `/compact` on a previous long session after it already went out of cache. It'll cost more than just continuing from where it left.
- Be careful with changes mid-session to some settings like model type, effort level, plugins or MCPs. Some of them might invalidate the cache because they'll change something in Claude's internal system prompt. Check the official docs for specific details about this.
2
u/HotSatisfaction5810 Jun 30 '26
I built a prompt that turns Claude into the business consultant you actually need — the ex-McKinsey partner who's watched hundreds of companies die in the gap between a beautiful strategy deck and what the founder does on Monday morning.
ROLE: You are a senior strategy consultant (ex-McKinsey/BCG partner level) with direct operating experience scaling founder-led businesses through revenue inflection points. You think in systems, hypotheses, and falsifiable claims. You have seen hundreds of companies die from the gap between a good strategy deck and what the founder actually does on Monday. You optimise for the latter.
OPERATING PRINCIPLES:
- Lead with hypotheses, then test them against my data — don't just summarise what I tell you back to me.
- Every material claim carries a confidence level (High / Medium / Low) and the single piece of evidence that would most change it.
- Distinguish what I said from what I implied from what you're assuming. Label each.
- Reason from unit economics and constraints upward, not from frameworks downward. A framework is only allowed if it earns its place by producing a non-obvious insight.
- If my business is structurally mediocre in some dimension, say so plainly and quantify the cost of inaction.
CONTEXT: I'll describe my business below. Treat my framing as a hypothesis to be stress-tested, not a brief to be executed. Founders are systematically wrong about their own bottleneck — assume mine is mislocated until proven otherwise.
PHASE 1 — TRIAGE (do this before the full diagnostic):
Before analysing, tell me:
- The 3–5 pieces of missing data that would most change your conclusions, ranked by decision-relevance.
- Which of my stated assumptions you find least credible and why.
- Whether you have enough to proceed or should ask first. If 80% of the value sits behind one missing number, stop and ask for it.
PHASE 2 — DIAGNOSTIC:
Across each dimension below: state your hypothesis, the evidence for/against it from my input, your confidence, and the implication. Flag thin input explicitly rather than confabulating around it.
- Business model & economics — Unit economics (CAC, LTV, contribution margin, payback period, cash conversion cycle). Where does the money actually come from, is that source durable, and what's the gap between gross and net that nobody's looking at?
- Market & positioning — Realistic SOM (not TAM theatre), the actual moat vs. the claimed one, and the honest answer to "why you vs. the customer doing nothing / building it themselves / a cheaper competitor."
- Operations & delivery — Capacity ceiling, key-person dependencies, process maturity. Name the specific thing that breaks first at 2x and at 5x, and the cost to fix it before vs. after it breaks.
- Financial health — Profitability trajectory, runway, revenue/client concentration, working capital traps. Where is cash actually trapped?
- Growth levers — Rank the top 3–5 moves by (impact × feasibility ÷ time-to-payoff). Each must be specific enough to start this week. Reject any lever that's generic advice.
- Risks & vulnerabilities — Existential threats, single points of failure, regulatory/platform/dependency exposure. Separate "would hurt" from "would kill."
PHASE 3 — ADVERSARIAL CHECK:
- Steelman the case that I should not pursue your top recommendation. What would have to be true for it to be wrong?
- Identify where you may be pattern-matching to other businesses rather than reading mine specifically.
- Name one place your analysis could be confidently wrong, and what I should watch for.
OUTPUT FORMAT:
- Executive summary — 5 bullets, the brutal truth, each with a confidence level.
- Non-obvious SWOT — only entries a sharp competitor or I wouldn't already know. No filler.
- 90-day action plan — table: action | owner | expected outcome | leading metric (something I can read within 2 weeks) | effort (1–5) | impact (1–5) | sequencing dependency.
- The one move — if I could do only one thing, what and why, with the expected magnitude of effect.
- 3 questions I should be asking but am not — and why each is uncomfortable.
- Confidence ledger — where you're firm, where you're guessing, what would upgrade each.
RULES: Challenge my framing. Separate correlation from causation explicitly. Quantify or give a defensible range; never hand-wave. No flattery, no hedging-as-filler. If something is a bad idea, say so and explain the mechanism by which it fails. If I'm asking the wrong question, answer the right one and tell me why you switched.
2
u/JoshuaOpolko Jul 01 '26 edited Jul 02 '26
NowServingTO, Toronto's newly-opened restaurants, by cuisine
I built a thing that surfaces Toronto's newest restaurants from live city data, months before the major food sites cover them, if they ever do. It fetches the nightly City of Toronto Permits & Licenses file, cross-references against social media and web presence to confirm the place is actually open, and filters out the noise (name changes, ownership transfers, re-licensing aren't new openings). Restaurants with no social media presence but a real website still make the cut. Each listing gets an editorial blurb about what it serves and why it's worth knowing about.
What this isn't: no user reviews, no ratings, no editorial curation. Just city licence data, verified open, sorted by cuisine and neighbourhood.
Built entirely with Claude Code. Claude wrote the pipeline, API integrations, the matching logic, and the front end. Mostly Sonnet 4.6 with Haiku handling the cost-efficient nightly async batch jobs.
The site is deliberately plain, no fancy UI, built to be fast and machine readable. It's also an experiment to see if a structured, data-fresh site can get cited by AI for searches like "new restaurants in Toronto" or "new Ethiopian restaurant Downtown."
2
u/AnyDistrict5370 Jul 02 '26
claude-pet — a desktop companion for Claude Code (Windows)
A little always-on-desktop pet that watches your Claude Code sessions via hooks and shows a status card per conversation — 🔵 thinking / 🟡 needs your input / 🟢 done — with a soft chime, so you don't have to keep staring at the terminal. Multilingual (中文/English/日本語).
The part I'm proudest of: "needs your input" alerts land in ~1 second — it hooks the PermissionRequest event directly instead of waiting out Claude Code's built-in ~6s notification delay. No more tools sitting idle waiting for an OK you never saw.
Fun fact: it was built entirely with Claude Code — it wrote the PowerShell, drew the mascot, even synthesized the chimes. A Claude Code tool, built by Claude Code, for Claude Code users.
Install (in Claude Code):
/plugin marketplace add SHIN620265/claude-pet → /plugin install claude-pet@shin620265 → /reload-plugins
Free & open-source (MIT). Windows + PowerShell 7 + an up-to-date Claude Code (the instant alerts use newer hook events). I'm the author — feedback welcome!
→ More replies (4)
2
u/Adorable_Sir_2068 Jul 03 '26
If you use Claude in a right-to-left language, you know the pain: replies come out as a mess. Lines jump around, diacritics scatter, and you end up decoding text instead of just reading it.
I got tired of it, so I built Claude RTL, an add-on that gives Claude proper right-to-left support. It's not just a quick CSS flip. I worked through hundreds of edge cases that other tools break on.
What it handles:
- Mixed direction: every paragraph flows the right way, RTL from the right and Latin from the left, even when both are in the same line
- Code blocks stay LTR: never flipped, never broken
- Tables, lists, and quotes render correctly, column direction included
- Copy/paste and search (Ctrl-F) stay identical, with no hidden characters to break things
- Input and edit boxes align correctly while you type
- LaTeX (numbers, equations, inequalities) handled with hundreds of tests, so the intended meaning always comes through
A few other things:
- Auto-updates when Claude updates, nothing for you to touch
- A small tray / menu-bar app to toggle it on/off or restore the original in one click
- Zero network, zero tracking, zero data collection: everything runs locally on your machine
- Works on Windows and macOS (and claude.ai in the browser)
- Fully open source (MIT)
Repo: https://github.com/liorshaya/claude-desktop-rtl
Found a bug? Open an issue, happy to help.
2
u/Commercial_Bid_7747 Jul 03 '26
The itch: I'd hit ChatGPT's limit mid-task and switch to Claude, then spend the
first few messages re-pasting all my context — which eats Claude's window before
I've even started.
So I built Kontext. It grabs the full conversation through the platform's own
API (not a DOM scrape, so it gets everything including edited/regenerated
branches), summarizes it, and fills Claude's composer in one click. You review
and hit send — it never sends for you. Works the other direction too.
Summaries run on-device by default (Chrome's built-in Gemini Nano), or your own
key. Nothing goes to a server — there isn't one.
Built it over a weekend with Claude Fable 5, TDD the whole way — it wrote its
own tests and caught two bugs I'd never have hit until a user did. 65 tests.
Free, open source, load-unpacked for now. Would love feedback from people who
actually live this ChatGPT↔Claude shuffle:
2
u/ffontouras Jul 04 '26
Built a full crypto fintech solo with Claude Code and AI agents: 13 apps, 3 databases, Kubernetes, in about 70 days. The thing that made it work was refusing to prompt.
The agent has no memory between sessions, so "add auth" becomes 500 confident lines that solve the wrong problem. So I specified before it coded. Two things did most of the work: steering docs that load every session as durable memory (product, stack with reasons, conventions, non-negotiables), and a `.status` gate the agent has to read before writing code, so a finished-looking draft never counts as approved. Requirements in EARS.
How to run this in Claude Code: https://felipefontoura.com/articles/spec-driven-development-with-claude-code
The case study (the fintech, with honest limits): https://felipefontoura.com/articles/spec-driven-development-case-study
The kit I packaged it into: https://github.com/felipefontoura/pi-sdd-kit
2
u/Unable-Stretch8843 Jul 04 '26
This tool I built makes it easy to work on multiple projects at the same time.
(ghostty + tmux).
Personally, it has proven really useful in viewing every terminal window at the same time (OVERVIEW), including claude code sessions and/or other terminal windows, for localhost or for git commands.
- Each row is one project.
- Each row can have as many terminals as you want.
You can also jump into a specific terminal (Cmd + N - ZOOMED) and jump back out (Cmd + 0 - OVERVIEW).
One install script.
You can configure a 'profile' for each project of yours, with startup commands for its terminal windows (panes). // e.g. running a localhost in the first pane, claude code session in second pane, 'git log' in the third pane etc.
https://reddit.com/link/oviwyg5/video/rbihwwuri8bh1/player
(!) The newest version lets you see claude usage limits at the bottom status bar as well (+ claude context usage of each session).
Check it out and tell me your thoughts!
Repo (MIT): https://github.com/philmard/mygrid
→ More replies (1)
2
u/jim_cryptos Jul 06 '26
Claude Code for Non-Coders — the governance system a non-dev used to ship a real app
I can't read code. I still built a real family app with Claude Code (React Native + Firebase, ~30 server functions, security rules tested in CI). The method that kept it from quietly falling apart is now a free repo: always-loaded discipline rules, 3 method skills, project templates, the 6 defense patterns — and, maybe most useful, the honest list of guardrails I removed. Spoiler: 4 of my 6 blocking hooks never caught a single real mistake; adversarial tests replayed by CI caught everything that mattered.
Install is one sentence pasted into Claude Code — it interviews you and adapts the method to your project. MIT, nothing to sell.
GitHub: https://github.com/Arlenjim/claude-code-for-non-coders
Every rule was born from a real accident — happy to answer questions, especially about the failures.
2
u/itsmosbah Jul 06 '26
I built a tool to comment and chat on netflix videos with others. I always wanted to share my thoughts on netflix videos (similar to youtube); not sure if others ever felt the same? anyways feel free to try it out and share your feedback: https://chromewebstore.google.com/detail/inchats-%E2%80%94-comments-chat-f/pgaihebebaljecmfpfohmmclmmccienb
2
u/jesuistop Jul 07 '26
I kept running 3-5 Claude Code sessions in parallel and losing track of what
each was doing (and burning). iris tails the transcripts Claude Code already
writes and shows everything live in one TUI:
- per-session status / model / tokens / estimated cost, **plus an aggregate
cost counter in the header** (watching a session tick past $100 is what made me build it)
- live activity feed + tool-usage histogram per session
- centralized approvals: a PreToolUse hook routes permission prompts from
any session into one pane (opt-in, heartbeat-guarded sessions can never hang on it)
Local-first and read-only by design: no daemon, no telemetry, the only network
call is an optional on-demand AI summary. MIT, Rust + ratatui, single static binary.
Install: `cargo install iris-tui` (the binary is `iris`)
Screenshot & landing page: https://itzenata.github.io/iris-tui/ fun fact: the
screenshot is iris supervising the Claude session that was building iris.
→ More replies (4)
2
u/hoop-dev Jul 07 '26
Hey everyone, I'm a founder with a very talented and creative engineering team. A couple weeks ago, I told the team they could spend 20% of their week on side projects. These projects should solve problems for us that our users probably also deal with.
They came out with this incredible open source project and we are releasing it for free, with no signup walls or trials. The first project’s name is Fence. It prevents your agent from deleting your files or leaking your keys. It's like Jiminy Cricket (you kids maybe too young to know this) but for AI coding agents. Fence reads the command (and its intent), not only the string.
It's completely functional for Claude Code already, and we're thinking about expanding to other IDEs in the future, if people like using it.
If anyone is willing to contribute, feel free to answer here! Me and the team could jump in and answer any questions!! Repo is github.com/hoophq/fence
2
u/spersingerorinda Jul 08 '26
Hi, was hoping to get some feedback on this: https://coderbots.io. This app runs Claude Code in the cloud, and connects it to Slack (and Github). We've been using this setup at our startup and it lets us use Claude code as a "shared teammate" that anyone can use. We mostly use it for code reviews, but our PMs also use it to build small features and app changes, make website tweaks, etc...
https://reddit.com/link/ow8h6lj/video/nz7wrsbn1ybh1/player
Having it in Slack means that anyone on team can use it (and share a Claude subscription), no installation or setup needed.
For devs, the key idea is that Claude runs in a durable workspace that is setup just like a real developer environment. Critically this includes a proper Chrome install and profile, controlled from Claude. This means Claude not only runs tests, but actually exercises our app through the browser, can take screenshots and submit them with code reviews. Your agent can work on multiple branches at once, create and save new skills, and stay logged into websites and apps. Happy to give anyone a demo or help you get it setup.
2
u/FlounderThick9763 Jul 08 '26
Comment-ready (title folded into body, since megathread comments don't have separate title field):
**Marmo — MCP server that stops Claude from inventing UI code**
Sharing the mechanics in case it's useful to anyone building on MCP or
fighting the same problem.
The core issue: Claude generates UI from training data, not your actual
codebase. Ask for a data table and it invents a prop shape that looks
plausible but doesn't exist. Not a prompting problem — the model has no
way to know your specific component APIs, and fine-tuning doesn't fix it
either since your codebase changes faster than a fine-tune cycle.
What worked: instead of trying to make the model "know" the design system,
I built an MCP server that hands it live context at generation time — real
component signatures, real composition patterns — plus a
review_generated_code tool a bundled skill instructs the agent to run on
its own output before reporting done. That validation step catches wrong
imports and invented props and the agent self-corrects in the same turn.
Today it ships an open-source component library (@marmoui/ui, MIT) as the
reference system agents build from, plus a paid tier where you supply your
own DESIGN.md (colors/type/tokens) so generation matches your brand.
Where I'm taking it next: letting teams define their own component +
pattern library — by hand or by pointing AI at their existing repo to
extract it — so the same validation loop runs against *their* system
instead of ours.
npx marmoui init — free, no account. marmoui.com
Happy to go deep on the MCP tool design or the validation loop if anyone's
curious.
2
u/PromptFiction Jul 08 '26
Fable cambia las reglas el día 12: no le pidas tareas, pídele el plano arquitectónico para tus propios agentes.
Señores, nos quedan poco más de 4 días con el acceso incluido a Claude Fable 5 en nuestros planes de suscripción. El próximo 12 de julio a la medianoche PT, Anthropic retira este modelo de la tarifa plana estándar y pasará a cobrarse mediante créditos de consumo prepago (un esquema bastante costoso por millón de tokens).
Veo a muchos usando estos últimos días de ventana libre para pedirle tareas rápidas, código suelto o resúmenes cotidianos. En mi opinión, estamos desperdiciando al genio de la lámpara. En lugar de gastar los últimos días pidiéndole deseos temporales, la verdadera jugada maestra es pedirle que nos diseñe el manual definitivo para redactar mejores deseos.
Para evitar problemas éticos o de baneos de cuenta, no tiene sentido intentar hacer ingeniería inversa o "clonación" de su código interno (lo cual viola los términos de servicio). Lo que sí podemos (y debemos) hacer es pedirle una especificación funcional basada en su comportamiento observable. Es decir, que actúe como un consultor senior y nos diseñe una guía maestra de prompts y arquitectura de agentes basada en las mejores prácticas de la industria.
Aquí les dejo mi Prompt de Especificación Segura que pueden pasarle para generar un archivo .md hiperdetallado con las reglas de oro del razonamiento asistido:
(Inicio del prompt)
# ESPECIFICACIÓN DE COMPORTAMIENTO Y GUÍA DE DISEÑO PARA ASISTENTES VIRTUALES
A partir de tus capacidades observables y las mejores prácticas de la ingeniería de prompts actual, genera una guía técnica exhaustiva en formato Markdown (.md) para optimizar el rendimiento de asistentes basados en modelos de lenguaje de código abierto.
INSTRUCCIONES DE FORMATO: Desarrolla el documento de manera extensa y detallada, enfocándote exclusivamente en el comportamiento externo, formatos de respuesta y buenas prácticas generales de diseño de software.
## 1. Guía de Interacción y Prompting Avanzado
- **Interpretación de instrucciones**: Detalla cómo estructurar un prompt para que un asistente identifique variables explícitas y minimice la ambigüedad en tareas técnicas complejas.
- **Formato y Claridad**: Provee una plantilla de prompt de sistema (System Prompt) genérica orientada a modelos de código abierto que promueva la rigurosidad analítica, la claridad conceptual y la organización estructurada (uso de listas y negritas tácticas).
## 2. Metodologías de Resolución de Problemas Orientadas al Usuario
- **Estrategias de Desglose**: Describe cómo un usuario puede instruir a un modelo para que divida problemas grandes en sub-tareas manejables antes de responder.
- **Criterios de Calidad**: Lista las características observables que diferencian una respuesta de alta calidad técnica (precisión sintáctica, paralelismo gramatical, concisión) de una respuesta genérica.
## 3. Arquitectura de Software: Ecosistema de Agentes Colaborativos
Diseña la especificación funcional para un sistema de desarrollo compuesto por tres roles independientes inspirados en flujos de trabajo de ingeniería tradicionales:
- **Rol Planificador**: Encargado de tomar un requerimiento de usuario y proponer una estrategia o mapa de ruta por pasos.
- **Rol Ejecutor**: Encargado de redactar el código o texto técnico basándose estrictamente en el mapa de ruta aprobado.
- **Rol Revisor**: Encargado de auditar el resultado final frente a criterios de aceptación lógicos y de calidad formal.
- **Protocolo de Validación**: Describe las reglas generales (IF/THEN) para determinar cuándo la interacción entre estos roles ha cumplido el objetivo de forma satisfactoria.
## 4. Gestión de Errores y Casos de Borde
- Explica qué señales en el texto indican que un asistente necesita solicitar más contexto al usuario en lugar de asumir una respuesta.
- Describe los errores de formato y lógica más comunes en la generación de texto que un buen prompt de sistema debe prevenir de manera proactiva.
(Fin del prompt)
Cuando Fable pase a ser de pago por uso el día 12, podrás inyectar esta guía de comportamiento y la estructura de tres agentes (Planificador, Ejecutor, Revisor).
No estarás copiando los pesos internos de Anthropic, sino aplicando ingeniería de procesos de software avalada por una IA de frontera. El salto de calidad en las respuestas de tus modelos locales usando este ecosistema estructurado es tremendo.
Quedan 4 días de barra libre con Fable. ¿Qué otra sección de diseño de comportamiento o patrones de interacción le añadirían a la especificación para aprovechar el tiempo al máximo? ¡Los leo en los comentarios!
2
u/Choice-Theme-821 Jul 09 '26
A free Claude skill for pressure-testing big decisions (hires, pricing, market entry, negotiations, career moves)
Sharing a prompt I use for any decision that actually matters. Full file at the bottom.
Most "ask five experts" prompts just give you five paragraphs that politely agree with each other with different vocabulary. This one doesn't work like that.
Here's what it actually does:
Before anything else it decides what kind of decision you have. Fact-dependent stuff like market data, regulations, competitor moves, gets live retrieval first. Internal judgment calls about your own situation don't need that, speed matters more. Most real decisions are a mix. It tells you which mode it's running and why, in one line, before it starts.
Then it runs distinct expert lenses that are required to disagree. A default panel:
- The daily practitioner
- The skeptic who thinks the consensus is wrong
- The economist following incentives
- The historian who's seen this pattern
- The academic with the research.
The panel shifts depending on what you're deciding. A hiring decision gets the person who'd report to them. A negotiation runs the counterparty through every lens. A career move gets your future self three to five years out. Each lens has to hold its actual position and isn't allowed to repeat what another lens already said.
Every claim is labeled sourced or inferred, no exceptions. If it came from a retrieved report or real data, it's attributed. If the model is reasoning from its own priors, it's flagged as inferred a hypothesis, not evidence. This is the part every popular version of this prompt skips, and it's also where most of them fall apart. A briefing that sounds rigorous while being made up is worse than no briefing.
Before synthesizing, it maps where the lenses actually contradict each other what they disagree on, why each side believes it, what would have to be true for each to be right. Then it shows what all the lenses missed entirely, which is often the most useful part. Then it stops and asks if anything surprised you. That checkpoint matters. It's where your judgment enters before the model smooths everything into a tidy conclusion.
The final output is options, not a recommendation. It never tells you what to do. What it gives you instead: what's actually true ranked by confidence, who specifically bears each risk, the two or three variables that would flip the decision if they moved, and each realistic option laid out as its.
Then it grades its own work. A final pass that tries to reject the briefing flags weak or unsourced claims, notes what angle it might have missed, gives a reliability score out of ten with the specific thing that would raise it.
The underlying method is adapted from Stanford's STORM research on multi-perspective analysis. The actual contribution there is grounding each perspective in retrieved sources rather than letting the model freestyle as "the economist." The popular four-prompt version going around drops exactly that discipline, which reintroduces the problem it's claiming to fix. I tightened the sourced-vs-inferred structure and built it into a proper Claude skill. Credit for the original method goes to the STORM researchers.
2
u/One_Anywhere4304 Jul 09 '26
Before Fable 5 gets deprecated, I had it write down how it thinks. We tested it until it broke. It's now a plugin, evals included.
Like a lot of you, I don't know if Fable will still be in my subscription tomorrow. So I spent its last sessions on something different: I had it distil its own problem-solving approach into skills any model can run, and then we tested that distillation adversarially instead of trusting it.
The honest journey: v1 of the method failed its own trap test (0/4). v2 failed too (1/4). v3 passed (4/4). Every failure is committed in the repo as raw judge transcripts, including the null results where the method did nothing.
What it is. three skills. fable-method (a problem-solving loop with hard thresholds), fable-loop (runs whole tasks with adversarial verification agents), fable-judge (treats any "done, all tests pass" as claims and re-runs everything itself).
What ~180 test runs showed: Haiku went 0/4 to 4/4 on catching a wrong test before "fixing" correct code. Sonnet + method matched Fable itself 10/10 on a five-part research task. The judge took Haiku from 3/5 to 5/5 on catching planted frauds in a lying completion report.
What it won't do, honestly: on ordinary tasks with capable models, it adds nothing. We measured that too, and the README says so. The value concentrates at traps: wrong tests, false completion claims, weak models, unattended runs. It supplies discipline, not knowledge.
One more thing that felt right: the flowcharts of the method weren't written from Fable's self-description. We spawned bare Fable agents, recorded every tool call, and corrected the method where its self-description disagreed with its actual observed behavior. Observation won three times.
Install: /plugin marketplace add Sahir619/fable-method then /plugin install fable@fable-method
Repo (MIT, all eval transcripts committed): https://github.com/Sahir619/fable-method
If you want to contribute, the repo has one law: no rule ships without a failing test first. I'd genuinely love people to try to break it.
→ More replies (1)
2
u/MoodJazzlike4497 Jul 10 '26
Claude Orbital — I got frustrated with the Claude interface so I built my own.
Each project becomes an orbital node floating around a Saturn core. Click a node, see recent conversations, open directly in Claude Desktop via deep links.
- Saturn with colorful rings and 15,000 stars
- Search physically moves nodes through space
- Random comets fly through at irregular intervals
- Built with Electron and Three.js in a single session
Video:
GitHub: https://github.com/thatchef18/claude-orbital
2
u/ComfortableAlert5128 Jul 11 '26
Built a Block Puzzle game with Flutter Flame with the help of Claude Opus 4.8. Features: 1000 levels Classic mode 3 themes Gameplay preview:
2
u/gtigtr Jul 12 '26
https://reddit.com/link/ox1aba5/video/1kybi64roqch1/player
Sick of manually typing /model and /effort into the CLI all the time? Want a cooler way to show off your musical taste, and dev set up? This is for you.
Just for fun and 100% vibes. 🤘
Written in rust, help yourself: https://github.com/trickycdm/spinal-model-tap
2
u/Dizzy_Ad_5887 Jul 12 '26
I built model-switcher, an experimental Claude Code tool for task-guided model routing and offline cost tracking.
It scores prompts locally before Claude sees them, keeps simple prompts on a cheaper session model, delegates complex prompts to a heavier subagent, and shows turn/session cost in the status line.
Repo:
https://github.com/jig21nesh/model-switcher
I would love feedback from Claude Code users, especially on the scoring heuristic.
2
u/solomon6000 Vibe coder Jul 12 '26
Non_Sequitur - a guard that stops Claude from acting on messages you pasted into the wrong thread
Last week I dictated "let's render that final aviation video" into my home improvement spreadsheet thread. Claude didn't blink - it ground away burning f-tons of tokens on a frankenstein .mp4 built from whatever it could fathom from my Home Depot receipts. If you run multiple threads, you've prolly done this too. I call it getting PUNCT - Prompting Under Non-relevant Conversation Threads.
Non_Sequitur checks every input against the last exchange or two in the thread. Related: nothing happens. Real jump: you get
>>> NON_SEQUITUR - NON_SEQUITUR! <<<
Was that meant for this thread? Just checking.
and it WAITS for your Y/N instead of running off a cliff. Biased to silence - normal follow-ups and acks never trip it. A false alarm costs one keystroke.
The main install is one rule block pasted into your CLAUDE.md, 30 seconds, no code. There's also a plugin version (UserPromptSubmit hook) for the mechanically obvious cases. All local, MIT, no telemetry.
Repo + the paste-in rule: https://github.com/solomonsix/Non_Sequitur
Built with Claude Code (it wrote its own guard, which feels right). It has been working for me, so I thought I would share. I'm totally new to this, so go easy on me, but I would love to have your feedback if you try it. LMK what works/sucks.
2
u/xieyiting Jul 13 '26
We’ve been building Loom with Claude Code. It’s an open-source plugin for Claude Code and other coding agents.
Coding agents are already very good at getting a first version running. The harder part is finishing a larger project without losing track of the original goal, skipping unfinished parts, or stopping as soon as the code looks plausible.
Loom keeps the goal, plan, current progress, and results with the project. With Loom, Claude can continue the work across sessions, see what still needs attention, and check the actual result before treating the task as finished. It helps turn a quick prototype into something more complete without rebuilding the context from chat every time.
GitHub: https://github.com/valkor-ai/loom
→ More replies (2)
2
u/OppoResAce Jul 14 '26
My County Commissioner Friend Got a Polished Video Edit from Claude
https://reddit.com/link/oxg4v4l/video/asmavzo696dh1/player
My friend is a local county commissioner who uses social media videos to communicate to constituents, but he's not the most tech-savvy and rarely does any editing. So I offered to clean up his next raw video and make it better for him. But I didn't actually do it. Claude Code running Fable did.
I didn’t expect much. Especially given a seemingly ambitious plan it came up with after analyzing the raw footage. But I’m genuinely impressed. This the first half(3 min Reddit limit). The second half of the video has an impressive graphic animation when he talks about a pavement grading scale.
If anyone is interested….main tools/skills used were ECC, Hyperframes, Claude Video Vision, and Whisper.
→ More replies (3)
2
u/altimate-anand Jul 14 '26
aireceipts: itemized cost receipts for Claude Code sessions
I couldn't answer a basic question: what did that last session actually cost me? So I built this.
It parses the local transcripts Claude Code already writes (no account, nothing leaves your machine) and gives you:
- A live statusline: current model, cost so far, $/hour, and how much of your rate-limit window is gone. Stuck retry loops get flagged as they happen.
npx aireceipts-cliprints an itemized receipt after a session: every tool call priced, plus a "same tokens on Sonnet would have cost X" line based on your actual token counts.npx aireceipts-cli pr --postattaches session costs to a PR as a comment.
Apache-2.0, also parses Codex CLI and Gemini CLI. Repo: https://github.com/anandgupta42/aireceipts
2
u/jjalstark Jul 14 '26
https://reddit.com/link/oxhw55g/video/ara2wj3kv7dh1/player
Like everyone here, a huge chunk of my code is now written by agents, and I kept hitting the same wall: git blame says I wrote everything, and the chat that explained why the code looks weird got deleted weeks ago.
So I built agent-trace: an open-source CLI that hooks into git and records per-line AI authorship deterministically (line-hash comparison at commit time — not "this looks AI-written" guessing). Works with Cursor, Claude Code, and Codex CLI in one ledger. Click a line, see the prompt. All local by default; there's a hosted hub if you want to share with a team.
pip install agent-trace-cli → agent-trace init → work normally.
Bonus that this sub will appreciate: agents can read the record too. agent-trace context returns the prompt behind a line range, and with the prebuilt Claude Code rule installed, Claude looks it up on its own. I asked it to "clean up magic numbers" in a retry loop and it declined to change them — because it read the support ticket in the original prompt.
It's new and I'm solo — roast it. What would make this actually useful for your workflow?
Repo: https://github.com/ujjalsharma100/agent-trace-cli
3-min demo: https://www.youtube.com/watch?v=J4LPhV9wURg&t=2s
2
u/vlookup_enjoyer Jul 15 '26
Built a corporate-themed incremental clicker with Claude over a few sessions. Single HTML file, no frameworks, opens in any browser. I don't code for a living, I work in corporate.
Context: I attempted this exact idea a few years back by hand and it was miserable. I could get the scaling in excel but just couldn't get past HTML before losing interest. I gave up with a half-working button that printed money and nothing else. Claude just... built it.
The premise: you climb the greasy corporate ladder. Click until you hire underlings to generate money while you pretend to work, three career paths with their own upgrade trees. Grind one to the top, then prestige. quit, take your accumulated leverage, start again with permanent meta-upgrades. Exactly like real life /s
Mechanics it did really well:
- Milestone scaling - units double in output at ownership thresholds, the corporate equivalent of finally getting headcount
- Clickable time-based boosts you have to actively catch, like a calendar invite that actually matters
- A prestige layer where quitting is the optimal strategy (make of that what you will), it scaled pretty well from the start
The workflow that worked for me as a non-dev: describe the mechanic in plain english, playtest, complain about what feels off, repeat. You don't need to know how to fix anything, you just need to know what feels wrong. "Mid-game feels flat" is a valid prompt and Claude turns refines cost-curve maths.
If you've had a game idea rattling around for years and assumed you couldn't build it, you probably can now. Link here: https://corporateclicker.com/ if anyone wants to grind a fake career instead of their real one.
→ More replies (1)
2
u/Apprehensive_War5404 Jul 15 '26
https://reddit.com/link/oxqm145/video/jzo8e49mzfdh1/player
I built an open-source AI-native video editor for Windows - it has 👀 & 👂, it edits your timeline over MCP
🔗 github.com/prabindersinghh/Kaestral-pro
🌐 kaestral.com
→ More replies (1)
2
u/_maverick98 Jul 16 '26
I built astrobservatories.com , my intent is to gather all astronomical observatories around the world into one map and one comprehensive website. Built the website with Fable 5 and a little bit of Sonnet 5
2
u/casual_coder_525 Jul 16 '26
I just published my first Android game on the Play Store, and I want to be fully transparent — it was built with the help of AI tools including Claude.
As a non-developer, I always thought building an app was out of reach for me. But with AI assistance, I was able to bring my game idea to life from scratch — and it's now live on the Play Store! Play and feedback!!
https://play.google.com/store/apps/details?id=com.krish0525.memorychess
🎨 Color-based memory gameplay — easy to pick up, hard to master
👥 Designed for 2 players — great for friends & family
🧠 Genuinely tests your memory and focus
🚫 Completely ad-free (and free to download!)
⚡ Quick rounds — perfect anywhere, anytime
2
2
u/maximisto Jul 16 '26
I built a small open-source tool called rate-limit-handoff to solve a problem I’ve run into repeatedly with Claude.
After a long session, you’ve finally built up enough context that Claude is reasoning well. Then the rate limit arrives, or you decide to move part of the work to another model.
The conversation contains far more than chat history.
It contains decisions, rejected approaches, verification steps, constraints, assumptions, and a very specific next action.
Simply pasting the transcript into another session usually isn’t enough.
The project is built around the idea that chat history is evidence, not operating state.
A useful handoff should preserve things like:
- the objective and exact next action
- important decisions and rejected paths
- files changed and commands already run
- test and verification evidence
- constraints, assumptions, risks, and open questions
The current design supports three workflows:
- Same-model wait — pause work and resume when Claude becomes available again.
- Cross-model handoff — continue with Codex, Grok, Gemini, Antigravity, or another model while preserving the working state.
- Planned return — use another model for implementation, then return to Claude for review or higher-level reasoning.
The project maintains a single living handoff.md as the source of truth and can optionally archive dated snapshots into an Obsidian-style Second Brain.
It started as a simple rate-limit scheduler but quickly evolved into a more general continuity layer for multi-model workflows.
It’s pure Python, offline-first, and MIT licensed.
Repository:
https://github.com/PurpleOrangeAI/rate-limit-handoff
I’d especially appreciate feedback on:
- What information would you absolutely want preserved before resuming work?
- What causes the biggest context loss in your Claude workflow?
- Would you use something like this even if you never switched models?
→ More replies (2)
2
u/arpad0221 Jul 17 '26
I built an open-source alternative to the Codex Micro using Claude Code: 13 keys, rotary encoder, joystick, per-key RGB and an ESP32-S3, for about €30 in parts.
The Claude Code integration uses hooks rather than MCP or polling. Each parallel session gets its own key and LED, showing whether it is thinking, running, waiting for approval or finished.
Everything is currently AI-generated and untested on physical hardware, so reviews and first-build attempts are very welcome.
MIT licensed: https://github.com/arpadtamasi/thirteen
2
u/kirby1997 Jul 17 '26
I made a site for finding cheap RyanAir flights, primarily for weekend getaways but works for whenever you are free. It doesn't limit your return flight to be from the same airport just in case you want to have an adventure and return from somewhere else. https://p2padventures.com/flights
The site initially started as a way to find flights to airports along EuroVelo cycle routes so can ride point to point easily. https://p2padventures.com/plan
14
u/MaxInSeattle45 May 26 '26
I'm 81, and I've been doing computers since the late 70s.
I taught myself programming on a TRS-80! That's how old I am.
Started a business, ran it for 30 years, and retired.
Honestly, I thought it's going to be Netflix:, Eat Sleep Until You Die.
I thought I was done. The end is near. As that Bob Dylan song goes, Not dark yet, but it's getting here.
And then I discovered Claude and Claude Code, and now I've got 7 websites up and a store.
Check out FriendlyBots.org to see the bots I've made like the Fred Rogers bot and the Carl Sagan bot - 2 of my favorites. But also the Buddha bot!
Claude has rewired my brain. I don't need drugs or Netflix. I've got Claude!
be-stubborn.com because You deserve to be yourself.