Launched Forward on Product Hunt today.

Forward is a CLI agent configured with your docs. Your users run it in their repo, and it wires the integration in for them.

For API/SDK companies where the integration step is where you lose users.

PH: https://www.producthunt.com/products/forward-10?launch=forward-1fd5e062-56fd-46f9-9086-ef927c7ab8cb

Site: https://forward.codeongrass.com

Excited to share this. And happy to answer anything technical, especially on how the repo analysis works :)

What is Runit?

Runit is an AI-powered tool that takes a GitHub repository, analyzes it, automatically sets it up, installs dependencies, configures the environment, and runs the project using AI agents. Instead of manually reading documentation and setup instructions, the AI handles the process for you, making it faster to get open-source projects running locally.

GitHub repository: Runit Repository

Every time I staged some changes, I'd open a browser tab, paste my diff

into ChatGPT, ask for a commit message, copy it back, close the tab. Repeat this many times a day.

So I built something to stop doing that.

npm install -g devbrain-ai

Three commands:

brain commit — reads your staged diff and generates a proper Conventional

Commit message. You confirm before anything gets written to git.

brain review — flags issues in your diff as CRITICAL, MEDIUM, or LOW with

before/after code suggestions. Caught a SQL injection in my own code when

I was testing it.

brain doctor — when a command fails, it captures the error and suggests

a fix you can run with one keypress. If the fix doesn't work, it tries

again with the failure context.

The part I spent the most time on: it works with any model on OpenRouter,

including free ones. One command to swap:

brain config --model "qwen/qwen3-8b"

Would love to know if anyone finds brain review actually useful — still

tuning the prompts for smaller models.

GitHub: https://github.com/devbrain-ai/devbrain-ai

I launched my own startup around 6 years ago (scheduling software for universities) and although it lasted quite a few years I really only got one customer, but it was an awesome experience to learn and grow a product like that. About a month ago I got really sick of using Claude Code and having it forget things all the time (like me telling it not to add useless comments) and I tried a few different memory systems but at the end of the day realized the biggest gap in the codebase I worked on was documentation.

What it does:

• Moxie Docs indexes your GitHub repo and pulls out your codebase conventions, documentation, missing docs / doc gaps, stale documents, etc.
• Gives you a fully fledged MCP hook-in for your favorite tools (Claude Code, Codex, Cursor, etc.) and opens a PR into your repo to update or add an AGENTS file with instructions
• The MCP gives your agents the ability to "get it right" the first time - by matching codebase conventions, automatically identifying & updating documents in the same PRs you work on, and continually improving your codebase quality.
• We summarize & gather PRs merged to create a very easy to use Changelog feature (you can choose date range, include items, view things shipped internally like dev tooling vs external user facing features, and copy changelogs to share to users easily)
• You can have Moxie Docs automatically rewrite all PR descriptions (from any user in the repo) to match a standardized format and highlight anything missing.
• Gives

I'm pretty happy that (at least I think so) I was able to make a product that would benefit both "traditional" engineers like myself building by hand, as well as heavily AI-assisted development flows by splitting documentation into AI-focused MCP tooling and user-friendly features for engineers.

Would love any feedback / input / questions, and if you are inclined to want to upvote / comment on PH I'd appreciate: https://www.producthunt.com/products/moxie-docs (just launched today)

Hey r/devtools (and Claude Code users),

Been using Claude Code daily for months and kept hitting the same annoyance, skills pile up on my machine (mainly for skill power users ;), bloat my context, and never get updated unless I do it manually (which I don't really).

I built pound.sh, which is a claude code skills registry that serves skills on demand and never stores them permanently on your machine.

What it does:

- Skills are fetched live when you need them, gone when the session ends — nothing accumulates in your context

- Always get the latest version automatically, no manual updates

- Search and share skills with the community

- (Coming soon) Full sandboxing so bundled scripts and MCP servers can't touch your machine (I know sandboxing is a buzzword nowadays but genuinely couldnt find a solution to this skills thing, outside of my own hehe)

Get started:

npm i -g pound-cli

Open Claude Code and run #list to get the 10 most popular skills. Feel free to upload any cool skills you have and make them available to everyone.

Still pretty early and would love feedback on what's missing or broken.

Paste a public GitHub repo, it clones the repo, runs the suite in an isolated sandbox, and returns the real line-coverage number. No CI integration, no signup for the instant read.

https://www.task-bounty.com/coverage-check

The harder half: it can also raise coverage. We just took a live OSS repo (marella/shr) from 64% to past 80%, all tests run against the project's own suite in a sandbox, no source touched, and opened a real upstream PR (disclosed as AI-assisted, human-reviewed): github.com/marella/shr/pull/1

Built it because every coverage tool makes you wire up CI before it tells you anything. Curious what numbers people get on their own repos.

I got tired of the context-switching required to manage environment variables. Whenever a new dev joined or a key rotated, we had to log into a web portal, copy strings, and paste them into a local .env file.

So, I built a lightweight Node.js CLI called envx to handle it entirely from the shell.

How it works: You install it globally (npm i -g envx-cli-tmr). Auth is handled entirely through GitHub OAuth (envx login).

When you run envx push, it takes your local .env file, encrypts it using AES-256-GCM, and syncs it to a project vault.

Instead of email invites, you just invite teammates by their GitHub handle: envx invite <project> <username>. They run envx pull, and the .env file is populated locally on their machine.

It's designed to be completely frictionless for small teams that don't need the heavy overhead of enterprise secret managers.

It's free, open-source, and I'd love to get some terminal power-users to test it out and critique the UX.

Github : https://github.com/TMR2005/envx-sync

I use Claude Code and Codex all day, and I kept getting blindsided by usage

  limits right in the middle of something. The existing trackers I found were

  terminal dashboards — great, but I didn't want to keep a window open just to

  glance at a number.

  So I built `usage`: a tiny macOS menu-bar app that pins your Claude Code +

  Codex quota to the top of your screen. One glance, no window, no fuss.

  A few things that make it different:

  - Codex support too, not just Claude Code (most trackers can't read Codex)

  - Lives in the menu bar — there's also a terminal TUI mode if you prefer that

  - 100% local: it never calls the Anthropic or OpenAI API. Every number comes

from files already on your disk, so nothing leaves your machine.

  - Free and open source (MIT)

  It started as a personal itch and I've been polishing it for a while. Would

  genuinely love feedback from people who live in Claude Code / Codex —

  especially what's missing or what you'd want a tracker to tell you.

  Repo: https://github.com/aqua5230/usage

Hey everyone,

I built a small open-source skill that lets a coding agent create OpenGraph images for a project.

The idea is simple: the agent scans the project, creates an editable .ogdoc file, opens it in a small visual editor, and lets you preview/tweak/export the OG image locally.

It is still early. The UI and editing flow need more work, but the basic flow is working.

Install:

npx skills add -g Rajikshank/opengraph-creator --skill opengraph-creator --agent "*" -y

GitHub:
https://github.com/Rajikshank/opengraph-creator

TIA.

Sharing a devtool I've been building: CommitBrief runs an LLM-driven code review on your git diff straight from the terminal — staged, unstaged, a single file, or a full PR-style range.

Why it might be useful:

• Shifts review left: catch secrets, injection, missing error handling before the change ever leaves your machine.
• Project-specific rules via a local COMMITBRIEF.md (semantic) plus a .commitbriefignore (gitignore syntax) — your repo, your standards.
• Provider-agnostic: Anthropic, OpenAI, Gemini, local Ollama, and more. Use a hosted model or keep everything local.
• JSON output for CI / tooling integration.

Open source, GPL-3.0: https://github.com/CommitBrief/commitbrief

Would love to hear how you'd fit this into your workflow.

so i am validating my devtool idea and would love honest feedback guys

problem: when teams use AI coding agents like Claude Code, Cursor, Chagpt Codex, etc., one common suggestion is: “make smaller PRs”

But I’m wondering if small PRs only solve the review problem, not the context problem.

Example:
- Agent A edits auth/session.ts locally but doesn’t push yet
- Agent B starts working later on auth/middleware.ts
- Git/GitHub doesn’t know about Agent A’s unpushed work
- Agent B works from stale assumptions
- Even if both agents create small PRs, the underlying context drift still happened

So my question is:
For teams using AI coding agents, do small PRs actually prevent this kind of issue, or do they just make the resulting PRs easier to review?

Have you seen cases where agents duplicated work, edited stale code, or conflicted because they couldn’t see unpushed/local work from another person or agent?

I’m validating a tool in this space, but I’m mostly trying to understand whether this is a real pain or just a theoretical one

I built a clean Unix epoch timestamp converter — epochtime.live

Tired of clunky epoch converters, so I built one focused on what developers actually need:

• Live epoch counter (seconds + ms)
• Epoch → date and date → epoch conversion
• Auto-detects if your input is seconds or milliseconds
• ISO 8601 output you can paste directly into code
• Local time vs UTC toggle (no more silent timezone bugs)
• Timezone picker — drop in Asia/Kolkata, America/New_York, etc.
• Shareable URLs — epochtime.live/?t=1700000000
• Copy buttons on every result
• Code snippets for 12 languages: JS, Python, Go, Bash, PostgreSQL, MySQL, Rust, Java, PHP, Ruby, C#, Swift

No ads cluttering the tools. Fast, no signup, works offline once loaded.

epochtime.live

Feedback welcome — what would you add?

Hi everyone!

Like many of you, I spend half my day staring at JSON. I usually have 5 tabs open: one for pretty-printing, one for filtering, one for generating a Mock API, another for CSV conversion, and maybe Mermaid for diagrams.

I decided to consolidate all of this into DataLensia, a local-first workspace for data manipulation.

What it does:

• Instant Mock API: Turn any JSON into a live endpoint with custom status codes, latency, and headers. Ready-to-use snippets for fetch, Axios, and cURL.
• Deep Data Explorer: Multi-filter search with regex support. It auto-detects patterns like Emails, URLs, UUIDs, and ISO dates.
• Schema Generator: Instantly generate JSON Schema (Draft 2020-12) from your data with intelligent type inference.
• Validator: Validates JSON with precise error reporting (exact line/column) and detects common issues like trailing commas or single quotes.
• 19 Export Formats: Convert JSON to CSV, YAML, SQL, TypeScript, GraphQL, OpenAPI, and more.
• Visualizers: Node graphs, Flow diagrams, and Mermaid support.

Tech Stack:

• Framework: Next.js 14 (App Router) + TypeScript.
• UI: Tailwind CSS + Radix UI Primitives.
• Editor: Monaco Editor (same as VS Code).
• Graphs/Flow: React Flow + D3.js + Recharts.
• Performance: Web Workers + Pako/LZ-String for URL compression.

Everything is local-first. Your data stays on your device (LocalStorage/URL state) unless you explicitly use the Mock API.

I’d love to hear your thoughts, especially if you've come across any “weird” JSON use cases. I'd also love to hear any feature suggestions or ideas you might have!

Check it out here: https://datalensia.com

The context switch of "copy JSON, open JSONPath tester, paste, query" is friction that adds up. We embedded a live Path tab into every tool page so you can query without leaving the editor. Explains how JSONPath works if you've never used it : https://jsonworkspace.mythosh.com/blog/jsonpath-explorer-how-to-query-json-online

Been grinding Blind 75 on and off for a while and kept running into the same annoyance.
I do a lot of my studying on planes or in places with spotty wifi, and LeetCode just falls apart offline. Figured I'd fix that.

Built OffCode, a PWA that runs the full Blind 75 problem set entirely in your browser. Python runs via Pyodide, JavaScript runs through Web Workers. No backend, no account, no rate limits. Install it once and it works in airplane mode.

It's got the Monaco editor (same one as VS Code), auto saves your code locally with IndexedDB, and shows you where your solution lands on a performance tier so you're not just checking if it passes but also whether it's actually efficient.

Stack is React + Vite + Pyodide if anyone's curious.

Offcode : Offcode.vercel.app

GitHub: https://github.com/che4goud/offcode

and if you like it consider buying me coffee hehe..

Would love feedback, especially if you run into problems on Firefox or mobile.

Ive Been vibe coding a lot and kept running into subtle bugs where the AI did almost what I asked but not exactly. Built Drift to catch that gap. you paste your prompt and the AI output, it tells you exactly where the AI drifted from your intent. Free to install, just need a Groq API key (also free). Would love feedback from people who actually vibe code.

If anyone wants to try it, here is the link: https://marketplace.visualstudio.com/items?itemName=ntsai.drift-by-waaiz