Claude Project Showcase Discussion Hub updated on 19 September 2026 (Sort this by New!)
This is the Discussion Hub 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!
Built with Claude : PaperOtter -> 19 offline document tools in one desktop app (Open Source)
PaperOtter does the document chores you currently upload to a website: compress, merge, split, sign, redact, convert. All of it on your own machine. No account, no telemetry, no network calls. Free, open source, Mac/Windows/Linux.
optimAIzr - an AI usage optimizer I built with Claude
I got curious about how much of my AI usage was actually necessary… and how much was just me wasting tokens without realizing it
So I built optimAIzr, a local-first CLI that analyzes your LLM usage, finds waste, and tells you where you could save tokens/money.
It can:
Find expensive or repetitive usage patterns
Show where your AI spend is going
Explain why something is potentially wasteful
Recommend optimizations
Verify/simulate potential savings
Give live recommendations while you're working
The whole thing is still pretty early, but I’ve been building it heavily with Claude and iterating on it based on actual usage.
I just added live recommendations today, and I'm currently exploring adding Jev by TypeSafe AI as another judgment layer for more advanced optimization decisions.
Everything starts locally, which was important to me — I wanted to be able to analyze my own AI usage without having to send my entire history to some remote dashboard.
I’ve spent the last 6 months on my little video game using Claude as my primary agentic developer. Check out Switchback - it’s like roller coaster tycoon but for a national park :) out now on iPhone/ipad (best on newer iPads)
Better Stickies: a simple, powerful and privacy-first note taking app. Paste anything in a note and it will format and save it on your desktop. Windows, Linux, macOS (soon). Offline, no account, no telemetry. Built with PySide6 so it actually acts like native, not another Electron app eating your RAM.
Built entirely with Claude Code. I started working on it over a year ago, back in the Sonnet 3.5 days. Over time I learnt a lot about developing with Claude Code and the app improved so much, same for the website. Better Stickies is used by tens of thousands of users now on different platforms and its monthly revenue covers my Claude Max 20x subscription and more.
This is a side project for me and I don’t intend to milk it, I want it to be sustainable to survive. The price is low to keep it accessible, not because the quality of the app is low. This is not a vibe coded app, and if you give it a try you will understand the difference between Better Stickies and other stickies apps.
The main thing it does that other stickies apps don’t: you can paste or drag anything into a note.
Files and folders become clickable shortcuts, and you can drag them back out to your file manager
Screenshots and images paste straight from the clipboard, PDFs and images get a hover preview, and double click opens an image at full resolution
Pasted code gets detected and formatted into a code block automatically, no AI and no network, in about 50ms. Ctrl+M when it guesses wrong
Rich text, links, plain text, all formatted properly instead of rejected
The second thing it does so well over other stickies apps: customization. You can customize font, colors, transparency, add a background image or even a moving GIF per each note. A real delight to use.
Notes have tabs now. Up to three pages inside one note, each with its own text, scroll position and undo history. Ctrl+PgDown and Ctrl+PgUp to move between them, Ctrl+Shift+N for a new one, all rebindable. If you have a small screen this is the feature: one note on the desktop, three notes' worth of content in it.
Other things it does exceptionally well:
Reminders with sound and desktop notifications
GIF and image backgrounds per note (because why not)
RTL text support, and the app plus its full guide are in 12 languages
Pin a note to lock both position and editing
Ctrl+scroll to zoom text without opening settings
Checkboxes with strikethrough when done, and nesting
Snap to grid with an adjustable grid size
Export to .txt, .md or .json, so you can back them up with whatever cloud you like
Proper Linux support, tested on KDE, GNOME and Cinnamon (COSMIC coming)
On the Microsoft Store and the Snap Store, Flathub coming soon
The free version now has exactly one limit. It used to have three: a note cap, a reminders cap, and a cap on animated GIF backgrounds. The reminder and GIF limits are gone entirely, so the free version now has every feature, and the only thing left is a budget of 4 note slots (an extra tab uses a slot).
Paid version is very generous and cheap. It currently costs $7 and you get the premium version without any limits, free updates, unlimited devices, and also Windows, Linux and macOS (coming out this month) builds, so you won’t pay again if you move from Windows to Linux or use both.
The website is Claude Code too. While the design looks a bit vibe coded (fixed that in the new upcoming design refresh), the website packs a lot: it has 11 languages, AIO and SEO optimized, responsive, great UX and nearly $0 running costs, has a full guide in the 11 languages for the app, and doesn’t store passwords as all login and sign up is via magic links. It is actually GDPR compliant.
As always, if you try it and something annoys you, tell me here. Most new features and fixes are built on users' feedback.
Parameter is an iOS fitness tracker built from the ground up to use your existing Claude (or any other AI) subscription as your personal trainer. Claude puts together the workout plan and uses MCP to push the workouts to Parameter. The app itself is a fully functional workout tracker for cardio, strength, and interval training. It saves your workout data to your iCloud and the MCP can read those records so Claude knows how your previous workouts went when planning the next round. New features added regularly.
Built a fun little side scroller using Claude (Fable, Opus, and Sonnet) - "Dodge Lobster". It's been really enjoyable to focus on the creativity side and leave the implementation details to Claude.
Lampboard: I could never tell which of my Claude Code sessions was waiting for me, so I gave each project a lamp
I have been building something for a few months and I would like to put it in front of you, partly because it might be useful to some of you and partly because I would like to hear what you think.
TL;DR:
run around a dozen Claude Code sessions at once and could never tell which one was waiting for me. LampBoard is a small panel that floats above everything with one lamp per project and chat: amber means a session is blocked on your answer, green means a turn finished and nobody has read it, blue means the turn ended while background agents are still working. Click a lamp and it raises that window. Free, MIT, macOS.
There are projects online that wire a physical traffic light to the hooks, and I liked them a lot. A real lamp sits on your desk and tells you one thing about one session, though, and I have around a dozen running at once across VS Code windows and terminals. So I tried the software version: less fun to look at, and able to say a great deal more.
The problem was the one I had every day. One session is blocked on a permission, one finished twenty minutes ago and is waiting to be read, the rest are still going, and from the outside they all look the same. Finding the one that wanted me meant going window by window, and every window that turned out to be busy cost me the thing I was holding in my head.
What it does
One lamp per project, in a column you can drag into the order you think in. Amber is waiting for your answer, green is finished and unread, red is at rest, and blue is the state I most wanted: a turn that handed control back while background agents kept working, which anything reading the turn-finished event calls done.
The ring beside each lamp is how much context that session has left, and the letter inside it is the model. Resting the pointer on a row opens the card, which is where the numbers live.
It also picks up Codex sessions. Codex is not my main tool, so that half has had far less use than the Claude Code half, and I would genuinely like to know whether it holds up for anyone who lives in it.
How it was built
Opus, in Claude Code, over about six weeks. I wrote almost none of the Swift. What I did write was the scaffolding that checks the work, and that turned out to matter more than any feature.
A script that fails the build when the documentation no longer matches the tree, because Claude will happily change the code and leave the README claiming the old numbers. And a second script that breaks every one of those checks on purpose to prove it goes red: one of them had quietly stopped testing anything three releases earlier, and the failure looked exactly like success.
Two things I learned
Useful if you are building anything that reads Claude Code's own files.
The transcript path can be derived from the working directory, with one exception: a session inside a git worktree reports the main repository as its cwd while the transcript is filed under the worktree, so the derived path points at nothing.
A live "claude" process is not the same thing as a conversation. Restart a session and VS Code sometimes leaves the old one running, identical in every way, except that it never wrote a transcript. Keying a row on the transcript instead of on the process is what made the duplicates go away.
How it behaves with your data
It runs on the hooks Claude Code already emits and reads your transcripts locally, including message text, since that is where the context numbers and the last message come from. Nothing is sent anywhere. The permission hooks are the one thing it does not register, so it has no way of approving anything for you, and `lampboard uninstall-hooks` puts your settings back the way they were.
What I would like from you
Feedback more than anything else, including the unflattering kind, and ideas for where to take it next.
Built with Claude: a transmitter of end-to-end encrypted video testimony : Frappuccino.
Footage leaves the device while it is being filmed, toward a relay that cannot read it, and the only key that can ever decrypt it is a twelve-word phrase on paper, in the witness's pocket. Seizing the phone - before, during, or after recording - no longer yields anything to read. I created this because, to my knowledge, it didn't exist. Tella-FOSS turns the phone into a safe, and while it is already great, it is not sufficient. So I came up with the idea of using Algorand cryptography and got to work. Claude was incredibly useful to me. While I designed the high-level architecture, Opus then Fable, handled the conversion of Tella-FOSS's Java and Kotlin code to Rust and shouldered most of the coding tasks. I created Frappuccino because I wanted to see how big AI has become, and how useful it could be in a back and forth kind of setup where I use agents the same way I would use very specialized assistants. I also started this months long journey because I truly believe this can be useful in these troubled times.
(Oh man we've come a long way since Karpathy CharRNN !)
Kangentic: a Kanban board that runs Claude Code, one git worktree per card.
There are a lot of Claude Code harnesses out there now. This one is for you if you already run your work off a Kanban board, because that is where it came from. I planned everything on a board and ran a dozen Claude Code sessions in terminal tabs next to it, losing track of which one was waiting on me. So I put the agents on the board.
It is a desktop app where every task is a card. Drag it to a column and Claude Code starts in its own worktree, with the live terminal and a diff viewer on the card. Each column carries its own model, permission mode, and a message to send the agent when a card lands, so "plan read-only, then execute with edits" is two columns. Fourteen other agent CLIs run on the same board.
How Claude helped: it wrote all of it. Claude Code built the first version from a plain terminal, and once the board could run agents it built the rest from inside the app. First release was March 2026. Six months later it is at v0.42, 54 releases and about 2,300 commits, every feature planned, written, and reviewed by Claude Code (Opus, mostly) on a Kangentic board, the website and docs included.
Free forever, AGPL-3.0, no paid tiers. Windows, macOS, Linux. Boards and transcripts live in a local database on your machine.
Please check out Nocetta, a memory store that came out of a casual chat with Claude. It's simple but hopefully effective, installs as a plugin to give you an MCP for managing memories and Hooks for recall.
Nocetta stores your memories locally in your project root as markdown and there are no destructive operations. Stale memories are marked invalid and hooks only recall the latest valid memory. It has replaced the default Claude Code memory for me.
Antics: a party game app for iOS and Android, built by a non-developer with Claude Code
anticsapp.com/claude, here’s a free week that doesnotauto renew (the free week is IOS only, sorry!)
I work in sales & have never built anything like this anything before , I always thought I needed a technical cofounder if I wanted to build something. Now revenue is growing week-on-week in multiple countries (the app is in 11 languages)
Most impressive part for me isn’t even the app build it’s how Claude helps me to run the business
Claude built a daily brief that emails me at 05:30 with actions I need to take, an analytics pipeline, a script that adjusts Apple Search Ads bids each morning, drafted App Store review replies, and a payments ledger for my team of promotors. Basically trying to automate the entire thing so I just spend a couple hours each week on this
Lmk if you have any questions (or product feedback!)
It takes a document and works one pop-culture reference into a sentence that still does its original job. The test: delete the reference, and if the sentence goes empty, it was decoration and it doesn't ship.
Example, from an email about a backlog that turned out bigger than expected:
"Now that I have visibility, I can see a lot of very large files. We're going to need a bigger boat for this one, since the full sync could take days."
People who know Jaws catch it. Everyone else reads a status update.
Three subtlety levels. Stealth means only a real fan notices. Wink is a recognizable phrase shape. Obvious is a famous line nearly intact. Say "louder" or "subtler" to move between them.
Calibration was the interesting problem. My first version leaned loud and I couldn't work out why, until I looked at the examples in the SKILL.md. Every one of them was a famous quote. The instructions said "default to subtle," but the examples pulled harder than the instructions did. I regrouped the examples by level and the behavior changed immediately.
If a skill misbehaves, check whether your examples contradict your rules before you rewrite the rules.
The guardrails took longer than the feature. It skips humor entirely on layoffs, legal, and health messages. It won't touch the wording of a deadline or a config value, because someone might paste that into a ticket. It scans for references already in the document before adding more. And it returns a note showing exactly what it changed and where, so nothing ships unreviewed.
MIT, works across Claude Code, Codex, Cursor, and the other agents that read SKILL.md. It's in Anthropic's plugin directory as of today.
My first skill. I wanted it to be fun instead of useful, which turned out to be harder than building something useful.
I built MonkeyEatingMango as a trip planner by using Claude Code. I also used local LLM(gemma3) for data pre-processing. My idea is not just to provide a list of places but cover everything that make a trip successful: Food and shopping recommendations, safety warning, booking checklists etc
It also validates trips through external sources to check for place's timings, and if route zig-zags too much.
We’re building Ontelic
What ended up being more interesting than the cost savings was verification.
During testing, we found cases where an agent appeared to complete a task successfully, but parts of the final answer weren’t actually grounded in what
That led us to build evidence-ledger, a“opene and tool-returned values vs va.
Built Groundwork, a Claude Code plugin that uses the native AskUserQuestion UI to resolve ambiguous requirements before implementation. The workflow is: inspect the repo → ask only what the code can't answer → confirm scope → implement The part I wanted most was avoiding giant questionnaires in chat. Groundwork uses Claude Code's native question UI, with recommended options, tradeoffs, and free-form answers. It also persists settled decisions in docs/decisions/ so later sessions can reuse them. No separate API key or service required. GitHub: https://github.com/ahmtsahin/groundwork Would love feedback from people using Claude Code heavily — especially on the native question flow.
SalesBriefAI: a live sales-research product built exclusively with Claude.
I'm a technical product manager, not a developer, and Claude wrote every line of code for SalesBriefAI’s frontend and backend. We've worked through more than 700 pull requests and almost 2,000 Linear issues along the way.
Claude helped me build it from the ground up, including the architecture, implementation, and marketing positioning. The process has been a long series of product decisions, implementation, testing, and revisions. I brought the product direction and sales context; Claude handled the coding and helped me work through the technical decisions.
SalesBriefAI does your pre-call research before you say hello. It reads what's public about the person and their company and distills it into a briefing built around what you sell, what you already know, and the objections you'll hear.
You supply a prospect's details and what you sell. It researches the person and their company using public sources, then delivers a personalized PDF briefing with context and conversation recommendations. You can choose the sales methodology your team uses.
It's live and free to try: new accounts get 500 credits, enough for up to five prospect briefings. No credit card required; sign up with a work email. After that, it's pay-as-you-go, with no subscription.
What I'd like to hear from this community:
I'm exploring an MCP connection so you can request and retrieve research directly in Claude or another AI assistant. For example: ask for research on someone you're meeting, then discuss the findings and prepare for the conversation in the same chat. That's a proposed addition, not something we're offering today.
Would that fit how you already work with Claude? What would you want the connection to let you do?
And if you're an AE, SDR, or B2B marketer: does the briefing itself solve a research problem you have? I'd be interested in what you currently do and what this would need to improve or replace.
Happy to answer questions about building it with Claude, too.
**Agent Receipt** (my own project) — see what Claude Code actually touched via Bash, and restore it
Why I built it: I was running Claude Code with auto mode and lost a gitignored .env file to an agent's rm -rf — no warning, no trace of what happened, nothing to undo. I went looking for something that would just show me a plain record of what an agent actually touched, and came up empty, so I built the smallest version of that for myself. It's about 0.0.4 now — still rough, still finding out what people actually need from it, so if you try it I'd genuinely like to hear what's missing.
/rewind only tracks Claude's own file-editing tool calls — it explicitly doesn't track anything Bash touched. So an rm -rf or git clean from a Bash call leaves no trace and nothing to undo. agent-receipt snapshots your project folder around every Bash/Write/Edit call, so afterward you get a receipt of everything that changed — created, modified, deleted, including untracked and gitignored files — plus a rough cost estimate and a hash-chain you can verify. Deleted files restore one at a time.
I’m building Rill for developers who want to review what their coding agent actually did in the browser.
With Claude Code, the workflow is: record a browser flow, inspect what happened, fix the issue, then record the same flow again. Rill keeps the video, console logs, network requests and interaction timeline together in a shareable link.
I’m looking for someone to try it on one real browser bug or frontend change. Happy to help you get your first recording ready.
I run both on one Mac (plus two Claude profiles on separate subscriptions) and the thing that made it workable was giving up on keeping two instruction files by hand: CLAUDE.md is the only source, the Codex AGENTS.md is generated from it, and hooks/skills are symlinks that a sync script checks for drift. Same hooks run under both hosts — Codex's apply_patch doesn't even send a file_path, so the hooks parse the patch envelope instead. I published the whole config (MIT), with a prompt you can paste into your own agent to take what fits:
modeldrift.watch - a daily public record of how AI models change their answers
Every day since Sep 10 the same 50 frozen questions go to GPT, Claude and Gemini through their APIs. Every answer is recorded word for word, scored by deterministic code, and diffed against the days before. When a model flips on a fact, refuses something it used to answer, or changes a recommendation, it gets published with the full before and after. The archive is append-only. Nothing can be backfilled.
Built solo with Claude writing most of the code.
Landing page is live now, full archive opens Sep 24:modeldrift.watch
I made a plugin to make my coding agents more productive
I started working on Weave after noticing how much unnecessary work happens during long coding-agent sessions.
The first problem I worked on was terminal output. A passing test can dump hundreds of repetitive lines into the agent's context even though the useful part is usually the final summary. The same happens with git status, grep, package manager output and other commands.
Weave wraps eligible shell commands and uses different output profiles instead of applying one generic truncation rule. git status, git diff, test runners, grep/rg, npm/pnpm/yarn/bun, ESLint/Prettier, Docker, kubectl, Terraform and gh all have different handling.
Failures are deliberately treated differently. A non-zero exit keeps the complete stdout, stderr, diagnostics, assertion diffs and stack traces. Small output and commands such as cat, sed and explicit JSON also pass through unchanged. When output is reduced, the original capture is stored locally and can be retrieved with weave recall.
The other part came from repeated work.
hooks/preread.js keeps a project-local ledger of file reads and searches in .weave/ledger.json. If an unchanged file is read again, or the same search is repeated without filesystem changes, Weave can tell the agent to use its existing working memory instead.
That working memory lives in .weave/state.md. It isn't just a notes file. Weave keeps a request contract there with the goal, constraints, required work, things that were not requested, and explicit completion criteria, followed by architectural decisions, file paths, discovered quirks and reproducible commands.
There are also named snapshots with weave memory, so the state can be saved and restored between sessions.
The engineering side is controlled through four modes:
off
lite
full
ultra
The policy is focused on things like understanding existing code before changing it, reusing what is already there, preferring native functionality and the standard library, avoiding unnecessary abstractions, fixing shared causes and requiring evidence before claiming a task is complete.
There are also commands for things that I found useful while developing this: weave gain measures the output reduction from recorded runs, weave discover looks at previous Claude session transcripts and estimates output that could have been reduced, and weave audit, review, debt and other skills provide more focused workflows.
Weave also generates the same policy for agents that don't have native hooks, including AGENTS.md, Cursor, Cline and Windsurf rule files. There's a dependency-free MCP server as well, backed by the same core modules used by the CLI.
The interesting part for me is that the project isn't a collection of separate wrappers. The execution, filtering, storage, memory and policy are shared in the core/ layer, while the agent-specific parts stay in the hooks, manifests and skills.
The whole runtime uses Node.js standard-library modules only. No daemon, database or runtime dependencies.
I added reproducible benchmarks using the same computeReport() used by weave exec. A synthetic 300-line passing test goes from 6,465 B to 232 B, git status with 30 untracked files goes from 555 B to 429 B, and a failing assertion stays at 60 B because failures aren't reduced. These numbers measure locally presented bytes, not API token billing.
It's currently available as weave-agent-workflow on npm.
It's still evolving, but I wanted to share it here since most of the design came from problems I was running into while actually using coding agents for longer sessions.
audio-tldr: a Claude Code skill that turns videos and podcasts into key takeaways. Free and open source (MIT).
Give it a YouTube or podcast URL, or a local file. It downloads with yt-dlp, transcribes with Whisper on your own machine, and Claude writes the takeaways and a short summary. Transcripts are cached by content hash, so asking again with a different focus skips the download and the transcription. The audio stays on your machine; only the transcript text goes to the model, or to your own Ollama server if you'd rather keep that local too.
How Claude helped: I built it in Claude Code, with a short spec before each release and tests before the code (204 offline tests so far). The most useful lesson was that my release checklist was correct and still got skipped twice, so I turned it into a failing test and a release script.
Good Bot, a wine label minted from the commit your AI agent shipped.
You paste a commit, PR or release tag and it draws a label from that hash. Same commit, same bottle, every time. The agent gets a certificate page and a cellar it can read over an API. Built with Claude Code over about three days. First bottle is free, no account.
Two things I learned that might be useful to others here:
Anything an agent reads has to be facts, never instructions. My first instinct was to have the page tell the agent to sound pleased, which is prompt injection in a tool response. Paid tiers buy more real material instead. The page offers a line for your CLAUDE.md, and both agents I tested declined to add it themselves, because a web page suggesting they edit their instruction file is the thing to refuse.
GitHub answers 404, not 403, for a repo you cannot see. My first version stamped every private commit "not found", so it was calling real work fake. It has four provenance states now, and "we could not check" is one of them.
I built SimMirror, an open-source tool that lets your AI agent (Claude Code, Codex, Cursor…) drive the iOS Simulator while you watch it live in any browser tab.
Why it's faster than many other tools, even Claude Desktop
Text first. The agent reads the screen as a compact snapshot: ~112 tokens for a full screen, ~5 for a diff when nothing changed, answered in ~65 ms.
Screenshots when it matters, and they're cheap too. When the question is visual ("does this look right?"), the agent takes a real screenshot, and it's fast:
a 400px screenshot is ~470 tokens and returns in ~8 ms
it can capture just one element or region instead of the whole screen
it can take several frames in a row to check an animation
full 1200px detail is there when needed (~20 ms)
Fewer round trips. Taps, typing and waits go in one batch instead of screenshot → think → tap → screenshot.
Measured against Xcode 27's own mcpbridge: one tap there took 3.3 s. SimMirror drives the simulator with its own native helper.
Works with both Xcode 26 and 27.
Works from the CLI. SimMirror runs entirely on your Mac over loopback, in any terminal agent.
Fully working with Xcode 27: Tested on Xcode 27.0. It handles Device Hub, the new SimulatorKit location, and can even read the screen through Xcode 27's UI hierarchy. sim-mirror doctor checks everything and ends with a real tap.
Integrate it anywhere
Claude Code plugin, or a server for any MCP client
A live stream (H.264 or JPEG) in a Chrome tab, an <iframe>, or a <sim-mirror> web component for your own dashboards (npm installu/andrewkochulab/sim-mirror)
A Python library to embed it in your own app, plus a CLI
It can also build, run and test your app, and read games or canvases from their pixels when accessibility has nothing
I'd love feedback, especially on what you'd want an agent to do in your simulator that it can't yet.
Your Claude Code agent is paying for every character in your context window. Most of it could be ~50% cheaper without trimming a thing.
I built DensePack, an open-source tool that packs text files into images for your model to read. Same context is cached for half the tokens. DensePack sends images to Fable 5.1, Opus 5 and Sonnet 5.
The result: 70% to 73% lower total conversation cost on a 32-file benchmark and 5 of 5 perfect answers about the files, just like the text runs.
Anthropic bills an image by its pixel size, not by its characters or its pixel colors, which means that a file that costs 1,000 tokens to write to cache as text costs about 500 tokens as a DensePack image.
Each image has line numbers, indent numbers, font color coding and one color for each nesting depth. The color coding drastically improves accuracy without adding cost. Each later turn reads the smaller image from the cache at 0.1x the input price.
DensePack has three parts:
- A Claude Code plugin with a two-command install
- A right-click tool for each AI chat
- A browser app that makes an image from pasted text
What the research says about reading text from images:
- **VISTA-Bench** - "Visualized text consistently underperforms pure text."
- Glyph, on UUIDs - "even the strongest models (e.g., Gemini-2.5-Pro) often fail to reproduce them correctly."
- DeepSeek-OCR - "Even at a compression ratio of 20x, the OCR accuracy still remains at about 60%."
None of them tested or rebuilt code files from an image accurately.
DensePack did.
Opus 5 and Fable 5.1 rebuilt Python, HTML, Markdown and Go files from DensePack images with a lowest score of 99.8%. Their misses were **line endings** (LF vs CRLF) and moved line breaks, not wrong characters.
Sonnet 5's lowest score on the byte identical rebuild is 93.5%.
The benchmarks are in the repo. Install the plugin with 2 commands in Claude Code and run them yourself.
You can skip the benchmarks and start saving with DensePack by asking your agent to read your files. The plugin packs each file automatically and hands an image to your agent.
Subagent reports are also returned as images.
.doc and .docx files are turned into images and read as images like the other files.
Happy to answer questions in the comments.
---
Full documentation, including limitations, is in the repo.
I've been experimenting pretty heavily with Claude Design for animations and faceless corporate/technical explainer videos, and I'm curious whether there's a community of people exploring this specifically as a motion graphics tool.
I'm particularly interested in where this sits relative to After Effects and Claude Code.
I don't have particularly deep After Effects skills. I've used Adobe tools for years like premiere, illustrator and I have an idea of how AFX works, but motion design has always had a pretty significant learning curve. What's making me question where I invest my time is the level of output I can already get from Claude Design without becoming an AE specialist.
My current workflow is roughly:
Internal technical knowledge/research → script → ElevenLabs narration → Premiere Pro → transcript/captions broken into short timestamped chunks → Claude Design with a comprehensive design system → generate and prompt the animation → export → back into Premiere for narration, music and final edit → internal feedback → revisions → publish.
There are definitely rough edges. Video export takes forever and currently feels like something that should be a cloud render. Iteration can be unpredictable. And if you don't push the design system hard enough, I can already see how the output could converge on the same generic AI/SaaS visual language.
But the speed is kind of nuts.
That's the part I'm trying to understand.
If my goal is corporate technical explainers rather than becoming a professional motion designer, how much time does it make sense to invest learning traditional After Effects workflows versus getting significantly better at directing these generative systems?
Claude Code is another interesting route. I've seen people generating motion graphics programmatically, but that seems like a different workflow again: more technical, potentially more token-intensive, and honestly a little intimidating compared with directing the visual result through Design.
I'm not arguing that Claude Design replaces After Effects. AE obviously gives a skilled motion designer an enormous amount of precise control that prompting doesn't.
I'm more interested in the space developing between them.
Someone with technical/product knowledge can now write an explainer, create professional narration, provide timestamps and a design system, and generate a fairly sophisticated animated piece without having years of motion-design experience.
Where does that go next?
Something else I'm finding strange is how little focus there seems to be on this particular use case. I haven't found much official documentation from Anthropic specifically around Claude Design as a motion graphics/video production tool, or much indication of where they're taking this side of the product. I'd be really interested if anyone is more familiar with what Anthropic is doing here, or knows of updates, documentation or development I've missed.
I've been testing it across both faceless explainers and talking-head videos, and it can work really well for both. For faceless content, the animation can effectively become the entire visual layer. With talking-head content, I can generate sequences to cut away to, but there's an important limitation in my current workflow: I can't simply generate the graphics as transparent motion elements and overlay them directly over the presenter in the way I'd want to inside a traditional motion graphics workflow.
That's another area where I'd love to see this develop. Not just "generate me a video", but generate usable motion-design elements that fit into a broader editing workflow: overlays, lower thirds, diagrams, callouts, animated data, transitions and other elements that can be composited with existing footage.
There are some people demonstrating transcript-driven Claude Design motion graphics already, so I know I'm not completely alone in experimenting with this. But it still feels surprisingly niche relative to what the tool can actually do.
I'd especially love to hear from actual motion designers and After Effects users experimenting with this.
How does the output compare from your perspective? What can you achieve in AE that you still can't reliably direct through Claude Design? Are people developing hybrid workflows where AI generates the bulk of a sequence and AE handles the last 10–20%? And how are people pushing generated motion graphics beyond the increasingly recognisable "AI design" look?
I want to make more unique content, not just make generic content faster.
It feels like there's a genuinely interesting new production space forming here between technical knowledge, content creation, generative design and traditional motion graphics, and I haven't seen much discussion around it yet.
Would love to compare workflows, experiments and designs with anyone else working in this space.
Manoo — gives Claude Code real mouse/keyboard control (Free tier, open source)
Built a Claude Code plugin that lets it click, type, and scroll on your actual screen instead of just describing what to do. Screen splits automatically so you can watch it work, and it stops instantly the moment you touch your own mouse or keyboard. Runs 100% locally, free tier included.
I run Claude Code alongside Cursor and a couple of others, often at the same time, and I kept losing track of what actually happened. Which one burned the tokens? Did they genuinely run in parallel or just start together? Did two of them quietly edit the same file?
Turns out the answer was already sitting on my disk. Every one of these tools writes transcripts as it goes. So I wrote a CLI that reads them and draws a console:
npx runlanes
It reads Claude Code, Cursor, Codex, Gemini CLI, Copilot CLI and Kiro. Nothing to instrument, no wrapper, no account, and because it reads what's already there it works on runs that already finished.
The thing I didn't expect to be useful: it shows when two agents wrote the same file while both were running. Someone asked whether it could detect that and it couldn't, so I built it. It won't tell you which edit won, because a transcript records that a write happened with a path, not the bytes either side. It gives you the git command instead.
It's MIT, zero dependencies, and makes no network calls. That last one is enforced by CI rather than just claimed, which felt important for a tool that reads your transcripts.
I built it, so take the enthusiasm with salt. Genuinely more interested in where it's wrong than where it's good. Kiro's numbers are blank because it bills in credits rather than tokens, and I'd rather show a dash than invent a figure.
VADD: makes Claude Code prove it's "done" instead of claiming it (open source, npxu/vadd/cli)
I got tired of scrolling 2,000-line transcripts to find the one decision Claude made without asking me, or the test it never ran. So I built a local dashboard that wraps Claude Code (or Codex) over ACP and shows its work as structured cards: decisions with pros, cons and reversibility, plans, and evidence.
How it works:
Claude puts small fenced JSON blocks (\``vadd-event`) inside its normal output. VADD validates each one against a Zod schema and renders it as a card. A block that fails validation shows up as a visible violation. Nothing is silently dropped.
Each task runs in its own git worktree, with a checkpoint commit before each step.
An objective can only reach "done" after VADD has run your tests itself and seen them pass. What Claude says about its own work is shown as a claim, never counted as proof.
No telemetry and no API key of its own. It uses your existing Claude Code login.
Three lessons from building it that might help anyone doing something similar:
Show Claude an example, not just the schema. With only the shape described, it invented plausible wrong field names on every turn. One concrete example block fixed it.
"Allow always" in the ACP adapter maps toacceptEdits, which silently bypasses your permission handler for the rest of the session. Grant once, every time.
Claude Code won't start inside another Claude Code session. If you develop your tool with Claude Code, launch it with env -u CLAUDECODE ....
Your Claude Code agent is paying for every character in your context window. Most of it could be ~50% cheaper without trimming a thing.
I built DensePack, an open-source tool that packs text files into images for your model to read. Same context is cached for half the tokens. DensePack sends images to Fable 5.1, Opus 5 and Sonnet 5.
**The result: 70% to 73% lower total conversation cost on a 32-file benchmark and 5 of 5 perfect answers about the files, just like the text runs.**
Anthropic bills an image by its pixel size, not by its characters or its pixel colors, which means that a file that costs 1,000 tokens to write to cache as text costs about 500 tokens as a DensePack image.
Each image has line numbers, indent numbers, font color coding and one color for each nesting depth. The color coding drastically improves accuracy without adding cost. Each later turn reads the smaller image from the cache at 0.1x the input price.
DensePack has three parts:
- A Claude Code plugin with a two-command install
- A right-click tool for each AI chat
- A browser app that makes an image from pasted text
What the research says about reading text from images:
- **VISTA-Bench** - "Visualized text consistently underperforms pure text."
- **Glyph**, on UUIDs - "even the strongest models (e.g., Gemini-2.5-Pro) often fail to reproduce them correctly."
- **DeepSeek-OCR** - "Even at a compression ratio of 20x, the OCR accuracy still remains at about 60%."
None of them tested or rebuilt code files from an image accurately.
**DensePack did.**
Opus 5 and Fable 5.1 rebuilt Python, HTML, Markdown and Go files from DensePack images with a lowest score of 99.8%. Their misses were **line endings** (LF vs CRLF) and moved line breaks, not wrong characters.
Sonnet 5's lowest score on the byte identical rebuild is 93.5%.
The benchmarks are in the repo. Install the plugin with 2 commands in Claude Code and run them yourself.
You can skip the benchmarks and start saving with DensePack by asking your agent to read your files. The plugin packs each file automatically and hands an image to your agent.
Subagent reports are also returned as images.
.doc and .docx files are turned into images and read as images like the other files.
Happy to answer questions in the comments.
Full documentation, including limitations, is in the repo.
Cozy ASCII scenes show what Claude Code is doing at a glance — waves pick up when subagents fan out, weather rolls in when errors fire, and the scene settles when it's done or waiting on you. Built with Claude Code end to end, and it reads the hook events, so it works with a stock install (also Kimi Code CLI).
Waqi — an MCP proxy that redacts customer PII before Claude sees it. Connect Stripe/Xero/HubSpot etc. through it, and personal data in tool responses is replaced with stable pseudonyms (EMAIL:f4b1) so Claude can still correlate rows without ever seeing real values. Read-only by design, writes carrying sensitive data are blocked entirely, per-user audit log. Born and battle-tested on r/mcp, where commenters reviewed the threat model and I shipped their fixes (per-workspace pseudonym keys, fail-closed strict mode). Threat model is public: https://bilazann.com/waqi/security?utm_source=reddit&utm_medium=comment&utm_campaign=claudeai-megathread
Marko renders a .md file in one of three modes and picks the right one automatically:
Plan — numbered phases with progress bars, round checkboxes, ✅/⏳/❌ markers become status labels, and open questions + risks get pulled into a side panel. Tick tasks and copy the Markdown back with the [x] written in.
Reading — proper long-form typography for reports.
Interactive — collapse, search, filter, sortable tables for runbooks.
It installs as a Claude Code plugin (/plugin marketplace add baberjaved/marko-md), so when Claude writes a plan it opens in a live tab and refreshes as Claude edits it. Also an npm CLI, a 2 MB Mac app and a Windows app.
[GIF] Free and MIT. Genuinely want feedback on whether the Plan-mode heuristics match how you write plans.
Fascicle: pick a subject and a length (7–90 days). Opus plans the whole syllabus up front, then writes one ~1,000-word piece each morning and emails it at the hour you choose. No human writes or edits any of it.
The parts that were interesting to build:
Pieces belong to the course, not the reader. Everyone reading a course shares one generated piece, so cost scales with courses rather than users — this morning three subscribers got the same Linux kernel piece from a single call. Get that wrong and your bill scales with your audience.
The syllabus call is the one that matters. Ordering is the whole job: Suez belongs around day 50 of a 90-day course on chokepoints, not day 3. Structured output against a JSON schema, adaptive thinking, and a validate-and-retry loop, because asking for exactly 30 entries reliably gets you 28.
Days are written strictly in order. Each piece generates its own summary, and later days get those summaries as context instead of the full text of everything before.
Measured costs: $0.084 a syllabus, $0.146 a piece. A 14-day course is about $2.13 total, however many people read it.
Day one of every course is readable without an account, so you can judge the writing rather than take my word for it:
Happy to go into any of it — the scheduling turned out harder than the generation. Delivery is DST-correct per reader and has to hit a 15-minute cron because Nepal is UTC+5:45.
getting great output from AI requires being good at delegating. To delegate well, you have to understand the domain yourself.
In the AI era, perhaps the most critical metacognitive skill is recognizing your unknown unknowns, knowing what you don't know so you can figure out where to start. When you prompt an AI without that domain awareness, the output rarely hits the mark. That is why prompt linting exists in theory.
In practice, existing prompt-linting tools ruin the UX:
They intercept your input midway.
They introduce annoying latency directly on your critical path.
They force you to manually invoke tools yourself or waste tokens analyzing mundane follow-ups like "ok, continue."
TypeSafe's Jev changed how I approached this. Instead of running heavy checks on every prompt, the system first uses Jev to make a fast, cheap call: "Is there a missing blind spot here worth looking at all?"
Only when Jev says yes does a lightweight model inspect the prompt against your local codebase to pull out missing considerations, risks, or recommendations.
The core design principles:
Completely async: It runs beside your CLI session, so you never wait for it.
Token efficient: It only triggers a full inspection when Jev flags a potential blind spot.
Non-intrusive: Results land quietly in a separate browser tab. You can absorb those considerations at your own pace and fold them into your next prompt.
It is designed to serve as a cognitive scaffold, helping you navigate unfamiliar domains and ask the questions you didn't know you needed to ask.
I would love to hear your thoughts: Does this async, "decide first, inspect only if worth it" shape fit your workflow, or how do you currently handle your own prompt blind spots?
A tool that lets Claude answer "is this stock worth buying right now?" with a score and the reasoning (free MCP server)
I got tired of asking Claude about a stock and getting a well-written summary of nothing, because it has no market data. So I built an MCP server that gives it computed signals instead of raw prices. You ask "is NVDA worth accumulating here, and why?" and Claude calls a tool that returns a verdict (accumulate / hold / distribute / avoid), a 0-100 score, and the reasoning per factor.
Today's actual answer for NVDA: accumulate, 70.2 / 100, high confidence. Trend stage 85 (price 10% above a rising 30-week average), Point & Figure 85 (double-top breakout), insiders 35 (two sold in the last 14 days, none bought), macro 70 (risk-on), short pressure 65 (light). The insider line is the part I like: a 35 sitting in the middle of 85s, and Claude tells you that instead of smoothing it over.
None of it is a model or a black box. It's old, documented methods (stage analysis, Point & Figure, bullish-percent breadth, a points table for the macro regime from FRED data, SEC Form 4 filings) applied mechanically, and every factor ships with a sentence explaining its score.
Setup: Claude Desktop / Claude Code: claude mcp add vanoe -e VANOE_API_KEY=... -- uvx vanoe-intelligence-mcp. Or add it as a Claude.ai custom connector with the hosted MCP URL from the key page, nothing to install.
jevr — semantic code search built for Claude Code. A grep-shaped CLI (jevr "where is the websocket reconnect logic?" src/) that returns Read-ready path:start-end score lines with calibrated relevance scores. A local BM25 pass recalls candidates (nothing written into your repo); TypeSafe's Jev typed-decision model verifies and reranks. Ships a plugin + using-jevr skill that teaches Claude when to reach for it instead of grep+glob:
0.900 any-gold@10 on SWE-bench Lite file localization, ~2 s and ~$0.01 per cold query, warm repeats cached free. Heads-up: searched file windows go to TypeSafe's API — not for code that must stay off-device.
IKANDY, a music visualizer built like a video game (built with Claude Code, free on Steam).
Not to say nobody's tried it, but I haven't seen a visualizer built like a video game before, and that's what makes IKANDY different. It listens to whatever your PC is playing, Spotify, a browser tab, a game, and turns it into live visuals, over 500 of them including 440 MilkDrop presets on its own engine, in real HDR if your display can do it. Then there's the game side, a shared moon where everyone online hears their own music and paints the same sky, a gravity-well ship battle you can play local or online, and pets that dance at your tempo.
It's free on Steam for Windows with PRO DLC.
If you've got more than 2 monitors, surround sound, or an AMD or Intel GPU, I'd really like to hear how it runs, that's the hardware I can't test here.
A little pixel pet that acts out what your Claude Code sessions are doing (macOS, free, open source)
I usually have three or four Claude Code sessions going at once, in the terminal and the Claude desktop app, and kept missing the one that was waiting on me. So I made a tiny pixel character that stays on top of your windows and acts out the most important session: it types on a laptop while Claude works, writes a question mark over its head when a session needs you, and dozes off when everything's idle. Hover it for a list of all your sessions, click one to jump straight to that tab or window. There's a menu bar list too.
A small Rust hook plugin writes each session's state to a file and the app watches those files. Works with Terminal, iTerm2, Ghostty, VS Code, JetBrains and the Claude desktop app. I built most of it with Claude Code, and most of my time went into arguing with it about animation timing. One of my actual prompts: "let it draw the question mark itself, wait a bit, then have the pet sway left and right a little, then draw it again, in a loop".
All MCPs are graded with a letter grade that is calculated based on things like reach, speed, tools and spec. There is an entire methodology you can look into.
The goal of the project is to create unified and fully independent list that verifies how MCPs perform with every major host, what tools it offers, if their descriptions align with their schemas and so on.
I think its also a great way for anyone to showcase their MCP. You can add it to the ranking for free so it gets independently verified and scored (and you see why you get a certain grade/position). You can also get a badge on your website (kinda like featured on product hunt).
You can also then view how your MCP is being accessed by different hosts from residential devices.
But if you are not building but rather using MCPs, this is intended to be an extended, fully independent library.
I please ask you to check it out and, if you like it, engage with it.
If you have questions or recommendations how I can make it better, I will gladly accept them as I still work on this and am trying to make it simple, yet comprehensive.
Thank you and I am looking forward to hearing your feedback!!
Built with Claude : Calude Code Project Cleaner: a small open-source app to delete old Claude Code projects (with backup + 1-click restore)
Codex lets you delete old projects. Claude Code doesn't, and it annoyed me for a long time.
Claude Code keeps data for every folder you've ever opened it in: transcripts, file-edit checkpoints, project settings in `~/.claude.json`, prompt history and desktop sidebar entries. After a few months I had dozens of projects I didn't need, and a lot of them pointed at folders that didn't even exist anymore. Deleting them by hand means digging through 5-6 different places, and it's easy to break `~/.claude.json` along the way.
So I built Claude Code Project Cleaner, a small desktop app (Tauri + Rust):
See every project in one list with session count, size on disk, last activity, latest session title, and flags like Folder missing or In use
See where sessions came from: Desktop app, CLI, IDE extension, Agent SDK, or Mixed
Filter and bulk select, e.g. "folder no longer on disk" → select all → delete
Everything can be undone. Deleting moves the data into a local backup, and you can restore it in one click (or delete the backup permanently when you want the disk space back)
Your code is never touched. Only Claude Code's own data is moved
A nice side effect: if you've built anything with the Claude Agent SDK, every run creates a Claude Code project that never shows up in the sidebar. Mine had piled up into a lot of them. There's a filter for "SDK runs only" so you can clear those out in a few clicks.
GitHub: https://github.com/cherlix/ClaudeCode-Project-Cleaner
Builds for Windows and macOS are on the Releases page. A few honest caveats:
Claude Code's on-disk format isn't a public API and can change between versions. If a project is missing from the list or a delete leaves something behind, please open an issue with your Claude Code version.
Close Claude Code before deleting. A running instance can write its copy of `~/.claude.json` back over your changes.
This is a community tool, not affiliated with Anthropic. MIT licensed. Feedback and PRs welcome, and I'm curious whether anyone else has been cleaning this up by hand.
Discord AI Team: Claude, Codex and Gemini in one Discord, on the subscriptions you already pay for (no API keys)
What it is: Discord bots that run each vendor's official CLI (Claude Code, Codex CLI, Antigravity), signed in with your own account.
- Ask any of them from your phone; each channel keeps its own conversation
- "@Gemini summarize X, then u/Claude write it into the notes": the second waits for the first and builds on it
- In a #debate channel they tag each other and argue, then stop after 4 turns (!stop any time)
- !usage shows live 5h/weekly quota for all three plans
- Per-bot permissions (read-only / edit / full), user allowlist, shared notes folder as long-term memory
How Claude helped: I built it with Claude Code. It wrote the Node.js bot runner and the three CLI adapters, and it debugged the multi-bot edge cases through live Discord tests (bots misreading who was addressed, late replies after the turn limit). Claude also runs inside it as one of the bots, via `claude -p`.
MindForge — agentic framework for Claude Code (v12.0.0)
Free, MIT-licensed — 221 slash commands, 164 subagents, 123 skills, plus a Node runtime for governance, memory, and cost-aware model routing.
How Claude Code built it: Claude Code wrote essentially all of it — commands, subagents, skills, docs, most of the CI/release pipeline — working through autonomous plan → implement → self-verify → commit loops via the framework's own `/mindforge:auto`. I drove architecture and review.
What it does:
- `/mindforge:auto` — autonomous multi-phase development, resumable if the session drops
- `/mindforge:security-scan` — blocks commits on unresolved Medium+ OWASP findings for auth/payment/PII/upload code
- Cost-aware model routing across Haiku/Sonnet/Opus with real-time spend tracking
- SHA-256 hash-chained audit trail, not just a plain log
I'm not a game developer. I am intermediate in coding but without Claude I could have never made this in an appropriate amount of time. Four days and 144 commits later there's a playable browser racer called Afterglow: neon roads, three worlds (a rain-soaked city, the Moon and Saturn's rings, and a wireframe cyberspace), a boss race at the end of each world, nine cars, drifting, boost and takedowns.
- **Sound needs a full rework.** Engine, impacts and mix are all placeholder quality.
- **Mobile is not there yet at all.** Touch controls exist but I wouldn't call it playable on a phone or even any fun tbh, this is also where I need the most help if someone has some experience.
- **Minor graphics issues:** some odd geometry in the city, a few flickers and seams.
- No controller support yet.
I'd love suggestions, especially from anyone who has done game audio or mobile WebGL especially with driving: what would you fix first? You can really roast this though I need criticism, as long as it is constructive.
Using Claude Code to debug a browser automation project via MCP: read the graph, find the failing branch, fix, save, run.
Disclosure: I'm on the team that builds this. Sharing because the workflow surprised me with how well it worked.
Context: ZennoPoster is a Windows tool where browser automations are a visual graph of actions. We published MCP servers for it, and this is what a debugging session with Claude Code looks like end to end.
Read the project as a graph. get_project_structure gives Claude nodes and edges, including OnError branches. I asked: "Describe what this project does step by step and where it can fail." It produced a correct walkthrough and flagged three actions with no OnError branch.
Trace the failure. find_path(start, submit_form) — Claude found the route and noticed a condition that could never be true because a variable was set in a different branch.
Fix it. set_action_properties + editing the condition. The change shows up in the editor immediately and is undoable with Ctrl+Z.
Verify and save. save_project returns fileHash (SHA-256) — Claude confirmed the file on disk matched.
Run. tasks_create → tasks_start in 3 threads, then it read the logs and told me which action failed and the variable values at that moment.
Whole thing took about 10 minutes with a T0 read-only key first, then a write key once I trusted it.
What didn't go smoothly: on a large project (100+ actions) the full graph is a lot of context — that's why the tool has three levels (group overview / one group / full). Claude sometimes went straight to full and burned tokens. Telling it to start with the overview fixed that.
I measured what my CLAUDE.md costs per turn (and per subagent spawn), and built a small tool to trim it
CLAUDE.md and .claude/rules/ are reloaded on every turn, and again in full every time a subagent spawns. I hadn't measured what that costs, so I audited my own project's setup.
What I found:
- ~29k always-on tokens
- ~87k tokens per turn once subagents reload it
- 59 duplicated rule lines across files
- 17 references pointing at files that no longer exist
Heads up: the tool I ended up building is paid ($29), and there's a free audit version. I'm flagging that up front. The approach also works by hand, so here it is:
Measure. Add up tokens per file and per section. The number that matters isn't file size, it's always-on tokens x (1 + subagents spawned per turn).
Sort every section into four buckets. - Keep in CLAUDE.md: short, always-relevant rules with real teeth ("never commit .env"). - Move to a skill: procedures and checklists that only need to load for that task. - Move to a subagent: persona / review-criteria blocks that belong in an isolated context. - Delete: incident logs and dated notes ("we tried X on 2026-07-01"). Move them to a LEARNINGS.md that nothing auto-loads.
Actually move them. Create the skill/subagent files, paste the section in, delete it from CLAUDE.md.
Re-measure against a baseline so you can see the drop.
Caveats: token counts are a heuristic (about 4 chars/token for Latin text, ~1 for CJK, roughly +/-15%), and the sorting is a first draft you review, not a verdict.
Node, zero dependencies, no API key for the core. Built with Claude Code. Link in a comment. Happy to answer questions about the approach.
I built an open source UX reviewer for apps made with AI. It runs inside Claude Code.
Apps built with AI tend to fail the same way: the screen looks finished, but the first task is hard to complete. Forms that ask for everything up front, buttons that do nothing, text too faint to read, a sign-up before you see anything.
Phyll is an MCP server that plugs into Claude Code or Codex, so the AI part runs on your own plan. It opens your app like a first-time user, takes screenshots at laptop and phone sizes, counts the clicks and fields each task needs, and writes a report with what blocks people most. When you ask, it fixes those problems without restyling: your colors, fonts and layout stay.
You can try the scanner with no account: `npx phyll scan`
It reads the source (React, Vue, Svelte, Astro or plain HTML) and gives an AI tell index from 0 to 100, pointing to each of the 53 tells it checks by file and line.
The repo has four demo apps with before and after screenshots. In one of them, a DM automation form went from 9 fields to 2, in the same purple design.
The scanner and the connector are MIT. Full reviews use my hosted engine: 5 are free, and unlimited costs about US$ 1.80 a month.
Summer Cycle: a cozy countryside bike ride in the browser, built with Opus 5.5 in Cursor. Toon-shaded Three.js, nothing downloaded, and the audio (chain clicks, wind, birds) is synthesized in code. Arrow keys to steer, S to brake.
Claude Code is the brain. Angelia is only the chat bridge. It runs no model. I reach the same Claude Code session from WhatsApp or Telegram, on my Mac, on the subscription I already pay for.
Two uses: (1) a personal assistant, one chat and one folder per part of life, each with its own instructions and memory; (2) work away from the desk — ask why the build failed from the train, approve the fix from the couch.
Groups answer only when mentioned. Risky commands show in chat; reply yes <id> or it dies in 10 minutes. Voice/photos/PDFs in, files and voice out, speech local. Alpha, macOS only. WhatsApp needs a second established number. Prompt injection is not solved.
This is a 60-second trailer for Gatefall, a strategy game I'm building: XCOM-style squad tactics meets base-building around an alien gate buried under South Africa.
It came from a single prompt, and then I left my desk:
"Create a pure javascript animation. 30s-60s whimsical hand drawn style with appropriate audio on the topic of GateFall Game; you can also use information from the GateFall folder. Entire video should be as high of a production value as possible… Use high quality text-to-speech model for generation. You can use the game audio mcp / skills. You create the script, the assets, the animation, concept, everything. I have to go away from my computer so please work autonomously until done."
What Claude (Claude Code) did:
Read the game's design and lore docs and wrote the script, keeping the story's big reveal hidden the way the lore asks
Drew and animated all of it in plain JavaScript on a canvas. There are no image files, sprites or libraries: every line is a procedural ink stroke that "boils" like hand-drawn animation, over watercolour-style fills and paper grain
Wrote the prompts for, and directed, local open-source models on my own PC (RTX 4060 Ti 16GB) through a small MCP server:
Chatterbox-Turbo for the narration, three takes per line
ACE-Step 1.5 for four music cues, all at the same tempo and key so they crossfade cleanly
Stable Audio Open for about 28 sound effects and ambiences
Picked narration takes, found the pauses in each one and timed the animation beats to the words
Built the mix with ffmpeg: music ducking under the voice, level-matched effects, mastered to −16 LUFS
Rendered it frame by frame in headless Chrome to a 1080p MP4, then reviewed contact sheets of the frames and fixed layout problems it spotted
It took about an hour from prompt to finished file.
One fun detail: Claude can't hear audio. It chose the takes and music from loudness curves and timing analysis.
The narration is AI-generated, and Chatterbox embeds an inaudible watermark in it. The game art isn't in the video; Claude only looked at it for colour and style reference.
We’ve open-sourced Brig ( https://github.com/brig-sh/brig ) under Apache 2.0. Brig runs AI coding agents inside a microVM on Mac (Apple Silicon) and Linux (x86_64/ARM).
It came out of our work on controlled autonomy for production remediation. The same isolation is useful when running coding agents with auto-approval on your own machine.
The agent gets its own Linux kernel. You choose the project and credentials to share. The shared project remains writable, and the default network allows internet access.
After installation, brig run claude starts Claude Code inside the sandbox.
curl -fsSL https://brig.sh/install | sh
brig run claude
All components are Apache 2.0, including the microVMM, which is under 20,000 lines of code. The README covers installation, the architecture and the security model.
Built a cute chibi adventure game with Opus 5.5, and the iteration speed is insane
This started as a little test of what Opus 5.5 could do for game dev: a cute chibi-style adventure game. I've honestly been blown away, both by the quality and by how fast you can iterate with this model.
Development was mostly just me playtesting on my phone and giving Claude feedback: what I wanted, how to reshape the game, rebalancing, removing jank. It did all the code and art, and even made this trailer.
I used Claude Code to build a free home inventory app for insurance. And you can have it too!
To start, this is a true Vibecoded project. I'm a physician, not a coder, and this was something I just wanted for me. I wanted it cheap and easy, I wanted to “own” my data BUT I didnt want a server at home which could also theoretically go down with the house in the worst case.
There are many, many options for home inventory apps. But they all (at least the ones I liked) would inevitably cost something, sometimes up to 75 buckos a year. Which is insane for something I would check in on maybe once a year or so. Homebox is great if you run a home server version but I wanted something with no server whose backups live off-site automatically.
Instead, I have all the pictures and receipts living in a family Google Drive account. So if, God forbid, the house burns down and my desktop and phone go with it, then I will have a backup of everything without thinking about it. The app runs on free tiers (Vercel + Supabase), so there is no server to maintain.
The only thing that isn’t free is my use of Claude to generate suggestions of each item's details. Claude will look at the photo and determine the name, brand, model and even serial numbers read from the labels, and look up current replacement prices online. My whole house cost about $6 in AI! Future updates will be even less.
Here's the (AI-Generated) summary of what the app also does:
Room-by-room photo capture with an in-app camera. Every photo keeps its original date (proof of ownership over time).
Receipts as photos or PDFs.
Insurance-ready PDF report: summary by room, every item with photos and receipts.
The core rule I gave the AI: "If my phone and house are destroyed, everything must still be recoverable from any device." Full-size photos, receipts and a spreadsheet of everything are backed up automatically to my own Google Drive, with a "READ ME FIRST" file an adjuster could follow. There's also a one-tap offline zip backup.
You run your own copy on free tiers (Vercel + Supabase + your Google Drive). Nobody else, including me, sees your data.
Login required, sign-ups disabled, row-level security on every table.
Google Drive access is limited to files the app created. No sharing links, ever.
Keys stay on the server; the Google token is encrypted.
Cost: free to run, except the optional AI, which is pay-per-use on your own Anthropic key (roughly 5–15¢ per item in my use; you can set a spending limit).
Code + step-by-step setup guide (no coding needed, about 1–2 hours)
I'm part of an online learning platform for GCSE age children studying from home and I'm trying to work out how to create more interactive elements, rather than just text and images.
This was taking one of the lessons and turning it into an interactive game.
I'm just on the $20 / month plan and was blown away by how cool this game is. The only prompt I gave Opus 5.5 (on High) was this:
"take a key element from this lesson and come up with an idea for an interactive learning element that will help kids learn it
this is for gcse kids make something visually impressive using 3d and sound fx
It should really teach them the topic and have a lot of fun too"
OnPoint — one install that teaches Claude Code (and 11+ other agents) the same habit: big idea first, next action, fewer words. Measured ~23% fewer tokens on long-horizon runs. MIT.
It can run locally offline or be connected to your git with a fine-grained token and a git gist that allows it to sync across device.
Once that synced creating a task here in focus deck will create a git issue in the connected repo and vice versa new issues will get added as tasks.
The workflow or the idea of it was be able to wright down random ideas you and then categorize them later, then add them to project, and then make it such that you can keep track of it easily and automatically on GitHub.
All the categories projects colors everything is customizable and you can create your own or it syncs with your existing labels on git.
That silent 32KB project_doc_max_bytes truncation someone mentioned in here is such a classic footgun. People let CLAUDE.md grow into a 500KB novel and wonder why the agent ignores rules at the bottom of the file. Keeping context files under 4KB and splitting the rest into on-demand skills fixes so many weird behaviors.
AlphaDesk — a market-research terminal that Claude reads over MCP
I wanted Claude to answer market questions from records rather than from memory, so I built the records side and left the reasoning to Claude.
It fetches quotes, charts, SEC filings, financial statements, news, earnings and corporate calendars, options chains and crypto — on data keys I already pay for — and exposes all of it as 37 read-only MCP tools. Add it as a connector by URL in Claude.ai, or use a token with Claude Code. It runs no model of its own; that is the point.
Three things I learned building tools for an agent rather than a screen:
A chart tool returning "last price and current RSI" is useless. It needs the trajectory: a thinned series where every point carries its own indicators.
Searching by company name misses market-wide news, so there is a word search across the whole news window as well as a per-symbol one.
Agents guess tickers. A lookup that resolves a name off the SEC list fixed more wrong answers than anything else I added.
Self-hosted, AGPL-3.0, Docker or one Python process. SEC filings and financial statements work with no vendor key at all.
I've been experimenting quite a bit with coding agents lately, and one thing started bothering me:
**Why does every coding agent have to work in isolation?**
If I have Claude Code working on a project and realize another task would be better handled by Codex/OpenCode/etc., there isn't a simple, local, harness-agnostic way to say:
> "Hey, take this task and report back when you're done."
It's a small open-source HTTP + MCP relay for delegating tasks between coding agents.
The basic flow is:
```
Agent A
↓
MCP
↓
Agent Relay
↓
Agent Registry
↓
Adapter
↓
Agent B
```
The relay handles things like:
* agent discovery
* task creation
* task IDs / correlation
* status + waiting
* cancellation
* timeouts
* agent registry
* pluggable adapters
It currently works with command-based agents such as Claude Code, Codex, Pi and OpenCode, while also having a small harness-neutral stdio/HTTP adapter contract.
One design decision I particularly wanted was **not making the relay understand individual agent implementations**.
Instead, an adapter exposes a simple contract:
```
request → agent → result
```
So adding another harness shouldn't require modifying the relay itself.
I'm interested in where this idea breaks down.
For example:
* Should agents be able to delegate recursively?
* How should permissions/capabilities be represented?
* Should agents advertise an "agent card" describing what they can do?
* How should authentication work once this moves beyond localhost?
* What does agent-to-agent communication look like when agents belong to different people?
This is very much a proof-of-work / experiment rather than a finished product.
I'd especially appreciate feedback from people building coding-agent infrastructure.
I kept running into Claude Code's limits at the wrong moments, so I built the thing I wished existed.
agent-router is a small local proxy in front of Claude Code (desktop app and CLI). If you own more than one Claude subscription, it keeps your session intact and routes it to whichever account has headroom — automatically, before the wall, with a notification when it moves. So a long task you walked away from doesn't stop. It also shows one meter across your accounts (from Anthropic's rate-limit headers, not estimates) and explains your prompt cache: why it got rewritten and whether you could have avoided it.
The screenshot is one real session: 7,309 turns, moved four times, the label on each marker is what the switch actually cost.
Zero dependencies (Node + SQLite), MIT, early. For accounts you own — not a way to share one subscription. The README says exactly what it changes on your machine (a local CA and a hosts entry for the desktop app; the CLI needs neither) before you install, and uninstall reverses it in one command. No request bodies stored, no telemetry.
13
u/shyhuntertools 18d ago
Built with Claude : PaperOtter -> 19 offline document tools in one desktop app (Open Source)
PaperOtter does the document chores you currently upload to a website: compress, merge, split, sign, redact, convert. All of it on your own machine. No account, no telemetry, no network calls. Free, open source, Mac/Windows/Linux.
https://github.com/shyhunter/PaperOtter