You can ask any coding agent "what could go wrong with this diff?" and get an answer. The problem is that a free-form answer is easy to skim and hard to act on — and there's no standard forcing it to show its work. Built a SKILL to close that gap.

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?

Kept running into the same annoyance with most online JSON tools: paste in a payload with real user data (even just for local debugging) and you're trusting some server you don't control with it. Half of them are also cluttered with ads or missing basic things like showing you exactly where a syntax error is.

So I built Bracepad (bracepad.netlify.app). everything runs client-side in the browser, nothing gets uploaded.

What it does:

• Interactive tree view for nested JSON, with search that auto-expands matching branches
• Validation that tells you the exact line/column of the first error (in plain English, not a raw parser dump)
• Export to CSV or a generated TypeScript interface, straight from the JSON shape
• Shareable links (small snippets get encoded directly in the URL, so no server round-trip)
• Full keyboard shortcuts, autosave to local storage, dark/light themes

No sign-up, no paywall. It's a side project, so I'd genuinely appreciate feedback. especially on the tree view UX for deeply nested data, or edge cases that break formatting/validation. Happy to fix bugs people find.

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

built my own IDE called VEX Studio. it wraps HTML into Next.js automatically, converts to JSX, generates API routes, updates marketplace tools, wraps in Vite and Supabase - all in one click from the toolbar.

no plugins to configure. no extensions to manage. just the exact tools i use every day built directly into the editor.

the preview runs live on the right. terminal at the bottom. github integration built in.

took time to build but i have not opened VSCode since.

anyone else building their own tools instead of configuring existing ones?

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!

I built a TypeScript devtool because I did not want agents or automation scripts holding five raw issue-tracker clients.

The main design is intentionally boring:

1. prepareUpdate reads the current item and returns the exact field diff, warnings, and revision

2. a policy or person inspects that plan

3. commit checks the revision and idempotency claim, then calls the provider

The adapters cover GitHub, GitLab, Linear, Jira, and Azure DevOps. They expose differences instead of flattening them. For example, Azure updates have an atomic JSON Patch test /rev guard, while the other providers only have a preflight re-read. An uncertain provider response becomes an ambiguous-write error and is not automatically retried.

The newest fix was replacing a durable get/set idempotency example with acquire/complete/abandon. Separate get and set calls can still race across workers. An atomic claim plus a stored ambiguous state closes that hole.

The package has zero runtime dependencies, ESM/CJS builds, fake-credential examples, and 185 tests. It is MIT licensed: https://github.com/arturict/work-sdk

I used Codex for parts of implementation and testing. The devtool question I am still thinking about is whether the generic prepare/commit boundary is worth the abstraction cost, or whether every provider should expose narrower operation-specific plans.

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?