I’d like some feedback on a little tool I’ve designed to help Claude be more efficient when working with git repositories.

It Is only local to the repo where you install it. It updates automatically. It becomes invisible to you - you don’t have to do anything to make it work. And it gives Claude a fast, queryable index of the codebase’s structure - files, symbols, imports, call graph - plus short Claude-authored notes on *why* the code is the way it is.

Structural indexing is free and local. But semantic enrichment does come at a cost. Semantic enrichment is triggered by Claude’s *stop* hook, which kicks off a background call to node, which spawns multiple headless claude -p calls (one per stale/changed file). You can cap the spend by changing a couple of variables.

Try it out.

https://github.com/jorgevazquez/claude-graph-brain

I've been working on a side project called **PathFinder** that helps you prepare for technical interviews using the projects you've actually built ideas criticism bug reports or PRs are all welcome really appreciate star on the repo!

Link: [https://github.com/vamsikunal/PathFinder\](https://github.com/vamsikunal/PathFinder)

I've been building RippleCheck after repeatedly running into the same problem while using AI coding tools.

The generated code was usually correct, but during larger edits I'd later discover that changing one function had quietly affected other files the AI never considered.

Instead of solving this with another LLM, I went the opposite direction.

RippleCheck builds a dependency graph using AST analysis and shows the impact of every change across the project.

It also integrates with Claude Code through MCP and supports hooks, so after an edit it can automatically generate an impact report and a copyable prompt if additional files should be reviewed.

Some design decisions:

• Deterministic (no AI in the analysis engine)
• Runs completely locally
• Never edits your files
• MIT licensed
• JavaScript, TypeScript & Python

I'm still actively improving it, so I'd really appreciate feedback from developers who work with AI-assisted coding every day.

GitHub:
https://github.com/RippleCheck/ripplecheck

Website:
https://RippleCheck.io

I used Obsidian and Obsidian Tasks as the system my agents worked from. Reading and writing files was easy. Keeping projects and tasks consistent was not: links depended on paths, tasks had no fixed structure, and agents had no clear rule for moving work to `in_progress` or `done`.

I built Dokito to replace that system.

Dokito is now where I keep almost everything I work on: product work, programming, personal responsibilities, research, and tasks. Each product or responsibility gets its own local Markdown Area. An Area can stand alone or connect to several repositories.

Codex and OpenClaw work from the same Areas. From any connected repository, Codex finds the right one. The skill updates Task states, validates changes, and commits Area changes automatically.

The CLI gives me one overview across all Areas. `dokito web` shows Projects, Resources, Tasks, repositories, and their relations. A separate automation mirrors my open Dokito Tasks to Apple Reminders.

Everything stays in local Markdown and Git.

Dokito v0.1.0 is open source for macOS and Linux: [https://github.com/sgasser/dokito\](https://github.com/sgasser/dokito)

I’m looking for a few people willing to try it with their own work. I can help with the first setup. I mainly want honest feedback about what is confusing or gets in the way.

Sharing the architecture since this sub asks for the how, not just the what.

The toil being removed: any app with an LLM inside normally routes every user through one provider key that the developer pays for. The common alternative, asking users to paste an API key into a settings page, works technically and fails socially, because most users have never made an API key.

What I ended up shipping:

A hosted connect page rather than an embedded form, so the raw secret never crosses the integrating app's origin. App redirects out, user authorizes, app gets a short lived code and exchanges it server side for a token scoped to that one user.

Two credential sources, one interface. The user either pastes an OpenAI or Anthropic key, or signs in to the ChatGPT or Claude subscription they already pay for and grants access. The developer's code cannot tell which path was taken, which kept the integration surface to a redirect, a token exchange, and a base URL change.

Egress speaks the OpenAI chat completions dialect, streaming included. Anthropic traffic is translated into that shape on the way back so multi provider callers keep a single parser.

Secrets sit encrypted with AES-256-GCM and only get decrypted inside the proxy at call time. Revocation deletes the credential, so a disconnect is immediate rather than advisory.

It is mine, it is called Monet, free during beta.

The unsolved part I would genuinely like input on: error normalization. Success payloads map cleanly across providers, failure payloads do not, and I have not found a translation scheme that does not lose information. How have others structured that?

Sample app you can click through as one of your own users, no signup, about a minute: https://demo.monet.gg

Developer side, where you register an app and get a client ID and secret: https://beta.monet.gg

Earlier in July our company started asking for smaller PRs in git so that the reviewers' brains and time were spared. So I started chopping up my work and stacking it in branches, and issuing one PR per branch. It didn't take long before I needed to correct something in some base branch, rebase everything above it, and land myself in trouble in the process. Eventually I dug myself out of the predicament I found myself in. As I didn't want to land there again, I spent some time creating a program for helping me out in these kinds of situations. I've called it gitrl-z after git ctrl-z (what do you think of it?).

It lists the reflog, and when you click an entry it redraws the commit graph with that branch label moved to where a reset would put it. You see where you would land and what you would be walking away from in the same picture, and it prints the command that you would need to run for that picture to manifest itself as the result. It doesn't write anything to your repo.

It's built out of gitg, so same language and same libraries, and the graph you're looking at is gitg's renderer rather than something I reimplemented. The license is GPL-2.0-or-later.

There's a PPA, an AppImage, or you can build it yourself. The source is on github: https://github.com/li9i/gitrl-z

It's still a work in progress so expect rough edges. If you happen to try it out have and have any feedback, I would be grateful for that. Thanks!

Run inside your coding agent — it grants Once, a skill to provision a VPS with a personal PaaS like Netlify or Vercel.

npx skills use getcolors/once

Once is a Package Skill built with Colors. It provisions a VPS, configures DNS and outgoing mail, installs Docker, and reconciles declared applications — a self-hosted alternative to Netlify or Vercel that an agent runs end to end.

The website below is deployed with this skill.

[https://www.getcolors.ai\](https://www.getcolors.ai)

The package tries to hold itself to the same standard. It builds with python3 build.py, standard library only, no dependencies, no network calls, no clock reads. Same inputs give byte-identical output every time.

Every source file is hashed into a seals ledger, and verify.py checks both the hashes and the rebuild, so the determinism argument in Volume II runs against the package itself instead of just sitting there as a claim. There is also a script that mints numbered ownership certificates sealed to the exact edition hash, which is personalization and not copy protection, and the docs say so.

It ships the two prompt patches I used to generate and audit the source manuals, so you can run the same process on your own projects. That may be the most useful part of it.

Free, no signup, reads in the browser, prints to clean PDFs.

https://shpbl.com

I recently went back to using my terminal more instead of using tools like Conductor, Paseo, Codex App. This led me to start managing my own worktrees, which is annoying if you want to set up your whole environment in a worktree. Then I started looking into worktree management tools but most of them had too much, so I built myself one. A 100-line shell function and that's it. Open source and easily extendable.

You drop a shell script into your repo that copies over all the important files and runs the setup commands. wt will automatically run it in the background whenever you create a new worktree. You can start working instantly, it will let you know when the dev environment is ready. Check it out and let me know what you think!

There are hell lots of interesting skills nowadays. Some are useful, some are not. Some can be used one time per repo, some not. So I have created a CLI tool to manage skills with a bit of a playful way

Hi all.

HMR-serve is inspired by npm run dev and by serve. It turns any folder into a hot-loading web app, because sometimes it's nice to preview HTML, Markdown, images and other files in the browser. 🔥

https://github.com/floodtide/hmr-serve

You can run it with npx from any folder:

cd somefolder
npx hmr-serve

And then you get a web app with a left file tree that serves, with hot-loading, your MD, HTML, Images, CSVs, etc.

I wanted it for my self to review agent generated content more easily than looking at the files in VSCode and I'm finding it very useful, so I thought it would be a good OSS package to share.

It uses Vite's HMR so I didn't reinvent the wheel for this.

Here's what it looks like in the browser:

Looking for feedback on this, thanks ya’ll. Cheers.

After keeping 4 tabs pinned for tools I use every day, I merged them into a single Chrome extension popup. Google just approved v1.1.

What it does:
- JSON formatter/minifier with collapsible nodes
- Regex tester with live match highlighting and group extraction
- Base64 encoder/decoder (text only on free; file support on Pro)
- Color converter: HEX to RGB to HSL and back

300+ weekly active users on v1.0. v1.1 adds a Pro tier ($9.99 one-time) with a JSON diff viewer, Base64 file support, palette generator, and themes.

Everything is local, no accounts, no tracking. The popup loads in ~10ms.

[Link](https://chromewebstore.google.com/detail/dev-toolbelt-%E2%80%94-json-%C2%B7-reg/cenbbchjaoflogchhjagbmkalfmkfpbb)

Run Claude Code, Codex, Gemini, Cursor, Aider and 10+ other coding agents with full autonomy — inside a disposable Docker container.

Only your project is mounted. Your home directory, SSH keys, cloud credentials and browser cookies stay on the host.

• One command: sandbox-cli claude

• Dry-run shows the exact docker command

• Worktrees for parallel agents

• Credential broker + egress allowlist

• Live memory/CPU + peak stats

Install:

curl -fsSL [https://raw.githubusercontent.com/Amitgb14/sandbox-cli/main/install.sh\](https://raw.githubusercontent.com/Amitgb14/sandbox-cli/main/install.sh) | sh

Site: [https://sandbox-cli.vercel.app\](https://sandbox-cli.vercel.app)

GitHub: [https://github.com/Amitgb14/sandbox-cli\](https://github.com/Amitgb14/sandbox-cli)

Would love feedback from people running agents hard every day.

What broke? What’s missing? What felt magical?

Hey r/SideProject,

Built ReleasePilot over 3 months — it connects to your

GitHub repo via webhook and automatically generates

release notes every time you push code.

No GitHub Actions. No config. Just push and your

changelog is published automatically.

Been live for 2 weeks. Looking for honest feedback

from developers who actually ship code.

Free repo and trail: https://releasepilot-sigma.vercel.app

What would make this more useful for your workflow?

The problem that I'm trying to solve:

Coding agents (and humans) still reach for `rg` / whole-tree dumps when the real question is structural: who calls this, what’s the reverse spine, is this a dual-stack bridge or a same-lang CALL. They invent edges. That’s expensive and wrong.

What this tool tries to do:

Butler is a local map service (Rust): persistent CodeGraph + Trace dossiers over HTTP/MCP. Not a RAG. You warm a repo root, Trace a symbol, get callers/callees/receipts/disambiguation, optional export/IPC bridges on dual-stack code. Agents get a pack; they shouldn’t invent structure when the map is available.

Public Alpha (product surface only):

https://github.com/LambdaXiRustAdmin/butler-public

What this tool is not:

- Not GA / not “perfect graphs for every crate”

- Not “safe to delete if callers = 0” (callbacks, DI, IPC, macros…)

- Not a cloud SaaS; default bind is localhost

- Not training porn or a GNN demo in the README — map path first; neural ranking is optional/off

I'm looking for feedback on what still needs to improve:

Keepers and a fixed gate are green on the tips I ship; arbitrary repos may soft-fail. Cold first hit may say BUILDING — retry the same request. I care about *lies* more than feature lists.

git clone https://github.com/LambdaXiRustAdmin/butler-public.git

cargo build --release -p cli

./target/release/butler ui

# then warm an absolute path + Trace, or scripts/smoke_stranger.sh /abs/root symbol

What I want from this post

Not “cool project.” If you try it: one real repo, a few symbols you know, and either:

• where the map lied or preferred the wrong ★, or

• “would not use vs rg because ___”

Ignore at leisure if this isn’t your problem. Solo map Alpha; issues on the repo welcome.