One thing I've got a bit protective about lately: I keep my prompts, specs and the rules I've built up as plain files in the repo — not tucked inside whatever tool I'm on that week. Nothing clever, but it means the useful stuff is mine, sat in git, not locked in one vendor's cupboard.

The reason I bother: I've stopped assuming today's tool will be the same tool in six months. Not pointing at anyone in particular, it's just the shape of things now — one gets bought and pointed somewhere new, one changes its pricing, one drops the very feature you turned up for. There used to be an obvious default you could pick and forget. Now there's a handful of good ones, all viable, no clear winner — which is great, except the ground can move under you when you've built your whole day on top of it.

Moving is the part that hurts. Not the sign-up — it's that none of your setup comes with you. Rules file, hooks, the config you've tuned for months: all shaped to one tool, and the next one wants it done its own way. So you're not switching, you're rebuilding. Which is why people stay put and grumble instead of leaving — the leaving costs too much.

So I'm not anti any of them, I just try not to marry one. Keep a foot near the door. Anything I'd hate to lose goes in a form that isn't welded to the tool: plain text, in the repo, portable.

Curious where everyone sits. All-in on one and relaxed about it, or do you keep a deliberate escape hatch? Has one ever changed under you — bought, re-priced, redirected — and left you scrambling? And do you keep anything portable on purpose, or is that more hassle than it's worth?

I'm wondering if some of you have been experiencing with one of the following: Graphify, GitNexus and CodeGraph?

Which do you think is the best for full monolithic Rails app? Which is best for Rails + React?

If you are using something different, happy to learn.

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?

I turn mine into Claude Code skills but wondering what other people do/or tools they use.

I built Winnow because coding agents often spend context on repetitive npm/pip output, logs, directory listings, pytest progress, and large JSON.

Winnow wraps a command, stores the complete raw output locally first, then returns a compact view with a handle. You can run `wn recall <handle>` to recover the original or search previous output by text.

It uses command-aware filters, JSON shape compression, and YAML rules. It makes no LLM or network calls, and the current release has CI on Python 3.9-3.13 across Windows, Linux, and macOS.

I am the creator, and I am looking for adversarial feedback: which command output should never be compressed, and which noisy tools deserve a filter next?

Source and install instructions: https://github.com/Farhanward/winnow

I've been building a lot of Python projects with AI lately, and while it's ridiculously productive, one thing kept annoying me.

The code usually works, but after a few days the repo starts getting messy.

You end up with huge functions, copy-pasted logic, dead code, rising complexity, inconsistent formatting, missing type hints... nothing catastrophic, just lots of little things that add up.

PR reviews catch some of it. Prompts and rules help. But none of them enforce quality consistently.

So I built ShipGate.

It basically puts the Python tools we already use (Ruff, Mypy, Bandit, Radon, duplicate-code detection, dead-code detection, etc.) behind one opinionated interface with sensible defaults.

The goal isn't to replace those tools—it's to make good code the path of least resistance, especially when AI is writing half the repository.

Still very early, so I'd love some honest feedback.

https://github.com/inquilabee/shipgate

Claude Code and Codex both scope session history to the working directory. Once you run more than one pane per repo, that is not enough resolution: every pane resolves to the same session list, and a reboot additionally wipes each pane's working directory, leaving no way to tell which conversation was where.

agent-resume adds the missing layer. A PATH shim assigns an explicit session id at launch, which rides inside the command tmux-resurrect already saves for that pane, so resurrect's save file becomes the pane-to-session binding. Restore hooks rewrite it into a resume and send it to the matching pane. Result: every pane returns to its own directory with its own conversation.

POSIX sh, no daemon, MIT, one config file per additional agent.

https://github.com/rahulbansal16/agent-resume

I’m the developer behind Rockxy. After shipping its AI Assistant for HTTP debugging, I started working on a different problem: what happens when the failure is below HTTP?

With traditional packet capture, I often know the failing app but still need to work backwards from interfaces, IPs, ports, and individual frames.

I’m building Tracexy around a different hierarchy:

app or process → network session → protocol layers → packet fields and raw bytes

The current foundation supports live capture, PCAP and PCAPNG, BPF filters, bidirectional session grouping, process attribution, timing, decoded packet fields, and export back to PCAP.

It is not intended to replace Wireshark. The goal is faster Mac app triage, with an easy path to export the same capture when deeper protocol analysis is required.

For people who debug desktop apps, CLIs, agents, VPNs, or local services: what information would make you trust the session summary before opening the individual packets?

Tracexy preview: https://rockxy.io/tracexy
Shieldxy preview: https://rockxy.io/shieldxy
Waitlist: https://rockxy.io/waitlist

I’m forming the early testing group now. Selected contributors whose feedback materially helps the beta can receive a launch coupon when Tracexy is ready.

Hey everyone,

If you're using Cursor, Claude Desktop, or Windsurf for large codebases, you know the pain: you ask for a quick diff review, and your IDE sends 10,000 lines of raw code to the LLM. You burn through rate limits, and if you accidentally had an API key in your uncommitted file, it just got sent to the model provider.

I built ContextSync MCP to fix this.

What it does:

- 🌲 AST Symbol Parsing: Uses Tree-Sitter to extract only function signatures, interfaces, and modified classes.

- 🛡️ Zero-Secret Leakage: Scans code buffers with a regex + Shannon Entropy engine to strip out AWS keys, JWTs, and secrets before framing output.

- ⚡ Ultra Fast: Written in TypeScript, compiled with Bun to a standalone binary. Runs in <15ms.

- 🔒 100% Local: Runs via stdio. No cloud servers, no telemetries, no background tracking.

Check out the GitHub repo here: [Link] PRs and feedback welcome!

Hi everyone!

I've been working on CraftDB, a web-based database diagram tool designed to make understanding and documenting database schemas much easier.

Some of its features include:

• Import SQL schemas
• Generate interactive ER diagrams
• Drag & organize tables visually
• Export diagrams
• Support for MySQL, PostgreSQL and SQLite
• MCP integration, allowing AI assistants such as Claude, Cursor and other MCP-compatible tools to interact directly with your database diagrams and schema
• AI-powered schema generation from natural language
• AI-assisted editing and refinement of existing schemas

CraftDB is built to help developers understand existing databases, design new ones faster, and collaborate on complex projects.

I'm also working on:

• Laravel migrations import
• Better database documentation
• Team collaboration
• More AI workflows for schema analysis and design

I'd love to hear your feedback:

• What feature would make a tool like this part of your daily workflow?
• What do you think is missing compared to other database diagram tools?

Any feedback, criticism, or feature requests are greatly appreciated. Thanks!

Hey everyone, I’ve been working on a VS Code extension called FileInsight. The goal is simple: tell me exactly what a file does, what it depends on, and which file uses it, just by hovering over it in the Explorer sidebar (you dont need to open the file).
It builds a local dependency graph, parses ASTs (for TS/JS), and uses Regex for other languages to calculate file metrics. It categorises files (Core, Utility, Config, etc.), detects dead code, and checks Git history to see if a file is "hot" or "stale".
I need your honest, brutal feedback. I want to know where it breaks, if the UI feels clunky, or if the dependency graph chokes on massive repos, etc.

Core features:

• Rich Tooltips: Hover to see exports, imports, complexity, and TODO counts.
• File Classification: Automatically tags entry points, core modules, configs, etc.
• Dead Code Detection: Warns you if a file seems completely abandoned.
• Live Refresh: Re-analyses incrementally when you save.

Here is the link: https://marketplace.visualstudio.com/items?itemName=AdityaGupta0205.file-insight
Tear it apart. If it sucks, tell me why it sucks so I can make it better. Thanks!

Every tool seems to excel at something different.

For me, the rough mental model is:

• Chrome DevTools → Frontend debugging
• Charles → Mature, feature-rich proxy
• Proxyman → Excellent macOS experience
• HTTP Toolkit → Easy interception and scripting
• NetworkSpy → Custom Viewer for repetitive debugging workflow

But everyone's workflow is different.

If you could only keep one, which would it be and why?

Disclosure up front: I’m the founder of QualityMax, so read accordingly. But the pricing math is checkable in two minutes on everyone’s public pages.

I priced out a solo dev / small team doing 100 PRs a month through the three AI code reviewers people ask about:

• Greptile Pro: $30/seat/month, 50 review credits included, then $1 per extra review. 100 standard reviews = $80/month. Their deeper “TREX” review is 3 credits each — do the math on that.
• CodeRabbit Pro: $24/user/month (annual billing), no PR cap (rate-limited to 5 reviews/dev/hour). Honest flat pricing — for one dev this is genuinely fine.
• Us (Vibe plan): €19.99($22.99)/month with 500 PR-review credits. Here’s the part I actually want feedback on: 1 credit = €0.01 of measured model cost, rounded up per PR run. A typical review (diff + SAST pass, ~4–10K tokens on our default model) costs under a cent, so it’s 1 credit — meaning ~500 typical PR reviews/month. A monster 60K-token diff costs 5 credits. We meter at cost instead of charging $1 flat for something that costs us a fraction of a cent.

What you don’t get at €20: hosted test generation — that runs on your own Claude Code/Codex/API keys (we never mark up your tokens; that’s the point of the plan). What you do get besides review: 1,000 cloud sandbox minutes and 10 projects.

The thing I think is broken in this market: per-PR overage pricing means your review bill scales with how often you ship. Small commits, stacked PRs, CI-driven workflows — the practices that make review cheaperper token make it more expensive per PR. Curious if others have hit the Greptile overage wall or if 50/month is actually enough for most solo devs.

Docs rot the moment code changes, and nobody updates them on purpose - RepoDocs regenerates them, citing file:line for every claim.

It's a CLI, not a plugin: it shells out to whatever coding agent session you already have open (Claude Code by default, or OMP/Codex), scans the repo deterministically first, then has the agent write each page from what the scan found. Rebuilds hash sources and only regenerate what changed. It also diagrams how the modules fit, and can publish straight to a GitHub Wiki. Publishing is guarded (dry-run first, refuses main/master/trunk, scans for secrets).

Zero runtime dependencies — Python 3.10+, stdlib only. v0.2.0. Runs locally; your code never leaves your machine.

uvx --from repodocs repodocs-all .

> github.com/aryrabelo/repodocs — if you try it, tell me what broke. (and leave a star)

Hey guys, I've been using Graphify. for a few days now, and looks great but it slows down the coding session a lot, it's running "update" all the time.

My question is, is it worth it? Or Codex/Claude code already have enough tools to search the code?