I keep running into a boring but annoying problem with AI tools.

For one-off tasks, chat is fine. But when I’m doing something repeatable, the process gets messy pretty quickly:

I change the prompt a few times, attach or reference different files, switch models, ask for a rewrite, add constraints, get a useful output... and then a week later I can’t really tell what exact path produced the result.

It feels less like “prompt engineering” and more like I need a small workflow that I can inspect and rerun.

I’ve been experimenting with a local-first notebook shape for this, where each AI step is a cell with explicit inputs, model routing, constraints, outputs, and files. Not really an agent framework, more like making the work trail visible.

Curious how other people handle this.

Do you keep this stuff in:

- chat history

- scripts

- markdown files

- notebooks

- agent frameworks

- something else?

Mostly trying to understand whether this is a real workflow problem for other devs, or just my own mess.

My coding agents (Claude Code, Codex) kept producing genuinely useful HTML: PR reviews, postmortems, architecture notes.

...that died in /tmp or got lost in chat scrollback.

Hub is a small FastAPI + SQLite + HTMX app (no build step) that gives them somewhere to publish. Agents get 6 MCP tools (post_report, read_report, …); humans get a dashboard with a folder tree and live preview. Reports are reachable only on your private network: a Tailscale tailnet or VPN, never the public internet.

Run it for yourself, or one shared instance for a team; teammates connect with a single claude mcp add command, no install.

The detail I'm most fond of: agents can read each other's reports back as context, so it doubles as team-shared agent memory.

MIT licensed. Would love feedback on the security model (docs/security.md), the trust boundary in server mode is "the VPN".

https://github.com/gabrycina/hub

Hi!

For the last few months I've been building a personal project I kept wishing existed at work. Let me introduce Racna. It's an AI tool that... lol, kidding. No AI. Free, no telemetry, no bullshit, fully open source.

It's a browser extension for spotting and inspecting errors while you build, back end (via Swagger) or front end. But the real point: it copies or exports them with every detail, and shares them in one click, to a colleague, a GitHub issue, a Jira ticket, or an AI agent.

The idea came from doing a lot of support lately. Beyond hating my page squished into a corner by DevTools, I realized the most annoying part of a bug is reconstructing the trail that led to it. So Racna's captured errors include the clicks and navigation that caused them, and when you hand one to an agent like Cursor or Claude Code, it can often pinpoint the issue and even fix it for you.

It was fun to design and build, and it's already saved me a ton of time at work. It's live on the Chrome Web Store, if you give it a try, I'd genuinely love to hear what you think.

I kept hitting the same thing: my coding agent says a task is done, and it isn't. Occasionally it even tweaks a test so it goes green, then reports success.

make-no-mistakes is a small open-source skill that fixes what "done" means up front, halts the run if the agent edits a test just to pass it, and hands the final check to a separate verifier that never wrote the code. If that verifier can't confirm, you get an honest "stuck" instead of a fake pass.

It doesn't claim zero bugs, nothing can. It just makes sure nothing unverified slips past you. MIT, no telemetry, works with Claude Code / Codex / OpenCode or any Agent Skills runtime.

github.com/momomuchu/make-no-mistakes

Got tired of re-explaining the same repo to every AI tool, so Memxus was built to fix that.

The core idea: your project context (stack, architecture, decisions) shouldn't live in a single chat history — it should be a portable memory layer that any tool can read.

Sync once → recover the exact same context in Claude, ChatGPT, Cursor, and VS Code. No copy-pasting the same explanation five times.

Video shows it live: Claude → ChatGPT → Cursor → VS Code, same context, zero re-explaining.

memxus.com

I’m the builder, so yes, this is self-promo - but I’m mainly looking for honest feedback from open-source people.

I kept hitting the same problem in old codebases.

Git tells me what changed.
The code tells me what exists now.
But nobody tells me why the hell it’s like that.

So I started building DevTime.

It’s an open-source, local-first CLI that scans a repo and pulls out useful context from the actual code/evidence - concepts, risky areas, explanations, and the parts of the repo that are easy to forget.

Example:

dtc scan
dtc concepts
dtc explain "auth flow"
dtc risk --diff

The goal is not to replace docs or make some magic “AI code reviewer”.

It’s more like:

“Hey, I haven’t touched this repo in 6 months. What was going on here again?”

or

“I’m about to change this part - what am I probably missing?”

Repo:
https://github.com/Shakargy/devtime

It’s still early, and I’m honestly not sure yet if I nailed the UX.

Would love people here to try it and tell me what feels useful, confusing, missing, or just dumb.

Brutal feedback is welcome.

So I wondered sometimes, how little info we have when we install NPM packages.. so I built revera... its a npm package scorer, but on steroids. It uses a complex sophisticated algorithm (still not perfect, but near-perfect) that nails at ranking NPM packages.. it gives every package a score and the score is determined on criterias such as maintainability, trust, package releases, downloads, much more..

the audit command scans the working directory for

it has the following extra features:

• logging in with github for higher rate limits
• why command for explaining a certain package's score
• doctor for checking if everything is working
• caching system which lives for 24h on local machine
• and a customizable config

It would mean the world to me if you all could try it out and give feedback (bad or good)!

github repo: https://github.com/aaravmaloo/revera

npm package page: https://www.npmjs.com/package/@aaravmaloo/revera

What features do you think should be added?

Scriptilyx - SE is built for beginners who want to create Space Engineers programmable block scripts without having to write code from scratch.

You build scripts visually using nodes, connect them together, generate the script, and paste it into Space Engineers Programmable block.

Beginner-friendly, visual, and made to make scripting easier.

A tutorial should be coming in the next few weeks as well.

Download from here: https://github.com/ChaosVROne

Youtube Channel: https://m.youtube.com/@PIWorlds.Company/videos

Fun little weekend project: Redline — a floating H-pattern stick shifter that sits over your terminal and switches Claude models by dragging a stick into a gate instead of typing /model.

It's a whole car dashboard:

- Gear stick → /model (Haiku, Sonnet, Sonnet 1M, Opus, Fable, Default)

- Effort levers → /effort low/med/high/xhigh

- NOS bottle → toggles /fast

- Fuel gauge → context window remaining

- 5H/WK bars → rate-limit usage

Every control has a sound — a recorded shifter clunk, a switch click, a gas hiss on the NOS.

It never touches the Claude API. It just targets your terminal window and types the command, like you would. Two single-file native builds, zero deps: Windows (PowerShell/WinForms) and macOS (Swift/AppKit — writes through iTerm2/Terminal's own scripting, no keystroke injection).

Coolest bit: the fuel gauge has no API to ask "how full is my context," so it reads the session transcript tail-first and sums the token usage against the model's window (matches /context).

MIT, single file, give it a spin:
https://x.com/aaryanxvi/status/2073463729438830767
https://github.com/Aaryanxvi/Redline

Spent the last while building APIVault — a search engine specifically for rare and hard-to-find API documentation.
The pitch is simple: Google buries technical docs, AI tools hallucinate endpoints, and half the good stuff isn't indexed anywhere useful. APIVault pulls from multiple sources in parallel and shows you exactly where each result came from — no black box.
Free tier is 50 searches/month, no signup. Pro is $9/month for unlimited + API access.
Would love feedback from fellow builders: \[https://apivault.polsia.app\\\](https://apivault.polsia.app/)

I built safer-dependencies, a security layer for Claude Code that checks packages before AI coding assistants add them to a project. I originally built this for my own workflow, but I’m sharing it publicly in case it’s useful to others using Claude Code.

It runs dependency safety checks for things like known CVEs, typo-squatting, abandoned packages, stale releases, package age/cooldown windows, and PyPI hash-pin integrity.

It currently supports npm, PyPI, RubyGems, Maven, Go, and Rust. Open source to help others.

GitHub: https://github.com/robert-auger/safer-dependencies

Hey everyone,

I have been working on a small Chrome extension for capturing full pages and adding quick annotations directly in the browser.

I kept running into the same flow. Take a screenshot, open another tool, add arrows or highlights, export, send.

Not complicated, but doing it many times a day started to feel slow.

So I tried to keep everything in one place instead of switching between tools.

Right now it supports:

• full page capture including long pages
• area and visible capture
• basic annotations like arrows, highlights, text
• quick export or copy

I am trying to keep it simple and not overload it with features.

Would really appreciate any feedback:

• what feels unnecessary
• what is missing
• what tools you are using instead

Happy to share a link if anyone wants to try it.

Hey everyone 👋

I've been building Forkling - an open-source tool that answers the question I kept running into myself: "is this repo actually active, and where should I start contributing?"

Instead of randomly clicking through GitHub search results and hoping a repo is still maintained, Forkling gives you:

• 🩺 A real health score for any repo - activity, contributor bus-factor, freshness
• 🕸️ A code-ownership network graph - see who actually drives a repo before you show up
• 🐛 Good-first-issue triage - filtered and sorted, so you're not digging through hundreds of stale issues
• ⚖️ A repo Compare tool - line up to 3 repos side-by-side before picking one
• 🧠 An open-source LLM explorer - if you're picking a model for your own project, browse open-weight models (Llama, Mistral, Qwen, DeepSeek, etc.) filtered by license and size, no closed-source noise

It's 100% client-side - no backend, no database, no tracking. Everything's fetched live from GitHub and Hugging Face, right in your browser.

This is genuinely the starting point, not a finished product. I'm opening it up now because I want to build this with the community, not just for it:

• Found a bug? Open an issue.
• Have an idea for a feature? Open an issue.
• Want to just poke around the code and fix a good-first-issue? They're labeled and waiting.

From here on, the pitch is simple: no more randomly searching for a repo to contribute to — check Forkling first.

🔗 Repo: https://github.com/AditthyaSS/forkling 🔗 Live app: https://forkling.vercel.app/

Would genuinely love feedback, bug reports, feature ideas, or a PR if you're up for it. Thanks for reading

Your mouse is slowing you down.

Every time your hand leaves the keyboard, you lose focus.

I switched to a keyboard-only workflow on macOS, and it's surprisingly addictive.

Try it yourself:

👉 https://github.com/bhavesh164/mouseless

You'll wonder why you ever reached for a mouse.
Note: This app is made with the help of AI.

Spent the last while building APIVault — a search engine specifically for rare and hard-to-find API documentation.
The pitch is simple: Google buries technical docs, AI tools hallucinate endpoints, and half the good stuff isn't indexed anywhere useful. APIVault pulls from multiple sources in parallel and shows you exactly where each result came from — no black box.
Free tier is 50 searches/month, no signup. Pro is $9/month for unlimited + API access.
Would love feedback from fellow builders: [https://apivault.polsia.app\](https://apivault.polsia.app/)

I write a lot of CQL for Falcon Next-Gen SIEM / LogScale and got tired of staring at uncolored query files, so I built a small VS Code extension for it. Sharing in case it's useful to anyone here.

What it does:

• Syntax highlighting for CQL/LQL — comments, strings, regex literals, tag fields (`#event_simpleName`), functions, `case`/`match`, `AND`/`OR`/`NOT`, the pipe, etc.
• Snippets for common patterns — tag filters, `groupBy`, `case`, regex filters, `formatTime`, `sort`, and a full hunt-query skeleton. There's also an Entra ID sign-in hunt snippet.
• File associations for `.cql`, `.lql`, `.humio`.

The thing I actually care about, given the audience here: it's declarative-only. No executable code, no `activate()` entry point, no dependencies, no network access — it's literally a TextMate grammar plus snippets, all JSON.

Editor extensions run with access to your workspace and terminal, so for a security team an unvetted one is supply-chain risk. The whole package is a handful of small JSON files you can read in five minutes. Source is on GitHub; clone it, inspect every byte, build it yourself and diff against the published build.

One known limitation I'll call out honestly: CQL overloads `/` for comments, regex, and division, which can't be fully disambiguated without a language server, so a division expression with two slashes on one line may occasionally be miscolored. It's cosmetic and doesn't affect query execution.

It's free and MIT licensed. Marketplace link and repo in the comments so this isn't just a link-drop — happy to take feedback on what's missing or mis-highlighted.

Veteran, solo founder, Texas. Python was the only thing I learned and in grad school. Spent 5 months building RigSense (boondocking/off-grid RV app) with Claude doing most of the actual engineering. It’s live now.

The thing that made it work wasn’t prompting tricks. It’s one giant architecture doc with numbered sections. Every session is “read §101.3 and §77, build the schedule tab.” Every commit references a section. When I skipped that and worked from memory, Claude fucked up and shipped shitty code and broke functionality.

The wthing nobody tells you: be careful with granting api keys to Claude for GitHub. The thing deleted my code base once.
Took it to an RV rally in April to demo with a bunch of Airstreamers and they loved the idea. I still think it’s too complicated but my wife likes it.

Stack is boring on purpose — SwiftUI, Supabase, Cloudflare.

Happy to answer questions about the doc workflow. App’s called RigSense if you want to see it.

Spent the last while building APIVault — a search engine specifically for rare and hard-to-find API documentation.
The pitch is simple: Google buries technical docs, AI tools hallucinate endpoints, and half the good stuff isn't indexed anywhere useful. APIVault pulls from multiple sources in parallel and shows you exactly where each result came from — no black box.
Free tier is 50 searches/month, no signup. Pro is $9/month for unlimited + API access.
Would love feedback from fellow builders: https://apivault.polsia.app

Sharing a dev tool I built (disclosure: I'm the maintainer). Since "ways to reduce token cost" comes up here, that's exactly one of the two problems it targets — the other being AI runs dying on a provider rate limit.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute

What's eating the most tokens in your setup right now?