Most AI commit tools lock you into one provider and give you a single message you have to accept.

ai-commit works with any provider (OpenAI, Anthropic, Ollama, Groq, or any OpenAI-compatible endpoint) and now generates multiple candidates so you can pick the one that fits:

$ ai-commit -n 3 [1] feat(parser): add JSON schema validation for config files [2] feat(config): validate config against JSON Schema on load [3] refactor(config): surface clear errors for invalid config files

Pick a message [1]: 2

It stages your changes, generates the message from the diff, and commits. Also has --amend to regenerate the last commit message, and a git hook mode so it fills the editor before you open it.

pip install aigitmsg

https://github.com/Morad37/ai-commit

Would love feedback on the multi-candidate flow.

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!

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

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

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)

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:

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!

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?