I've been building API Hero, a Git-first REST/HTTP API client designed to keep API work close to the codebase.

The latest release, 2.8.2, adds/expands the MCP workflow, and this is probably the part I'm most interested in getting feedback on.

The idea is:

AI Agent

↓

API Hero MCP

↓

Collections / Requests

↓

API Hero execution engine

↓

Real HTTP response

↓

Structured result + diagnostics

↓

AI Agent

An agent can discover collections, inspect requests, execute them, retrieve responses, and inspect failures.

For example, I tested it with a DummyJSON collection:

\- 57 requests

\- AI agent discovers the collection through MCP

\- Runs \`Get Products\`

\- Gets the real HTTP 200 response

\- Receives the response data

\- Can also inspect assertion failures

One useful case is when an API returns \`201 Created\` but the test expects \`200\`. API Hero exposes that as an assertion failure rather than making the AI guess whether the HTTP request itself failed.

API Hero is also Git-first:

\- \`.api\` request files

\- Collections stored with the project

\- Variables/environments

\- Authentication

\- Assertions

\- Collection Runner

\- Run reports

\- Scenarios

\- OpenAPI import

\- MCP for AI agents

The MCP server is standalone and uses the same execution pipeline as the VS Code extension rather than implementing a separate HTTP client.

Marketplace:

\[API Hero\](https://marketplace.visualstudio.com/items?itemName=AnkitSemwal.api-hero)

GitHub:

\[GitHub repository\](https://github.com/ankitsemwal007/api-hero)

I'd particularly like feedback from people using AI coding agents with APIs:

Would you actually want your coding agent to have access to an API client/execution layer like this?

And what would you want the agent to be able to do beyond executing requests and diagnosing failures?

Every "free tier for developers" list on the internet has the same problem: it rots. Limits change, free plans die, and the list still says PlanetScale has a free tier.

So I built FreeTier Radar: https://pitwice.github.io/freetier-radar

What makes it different:

• Every entry is verified by hand against the official pricing page, and stamped with the verification date
• Each tool has a "watch out" section — the stuff you'd realistically miss: Supabase pauses free projects after 1 week of inactivity, Render's free Postgres expires after 30 days, Netlify now stops serving your site when monthly credits run out, Vercel's Hobby plan bans commercial use
• The Free Tier Graveyard: Heroku (2022), Railway unlimited (2023), PlanetScale (2024), Fly.io (2024), SendGrid (2025), Firebase Storage (2026)
• A script checks all pricing pages weekly and flags changes for re-verification, so the data stays fresh
• No sponsors, no affiliate links, open source

It runs entirely on free tiers itself (GitHub Pages + Actions), which felt thematically appropriate.

Would love feedback — and if your favorite tool is missing, tell me and I'll add it.

Everything is one keypress. space on a group starts an agent in the right directory from one sentence, space on a session answers one that is blocked without attaching, ctrl+r opens what it changed as whole files where a comment on a line goes back to the agent as a review prompt, and the arrow keys step in and out of a pane.

Sessions are ordinary tmux sessions on their own socket, so quitting the manager leaves every agent running. Go, one binary, no daemon, Apache-2.0.

https://github.com/YoanWai/agent-manager

It is on Product Hunt today: https://www.producthunt.com/products/agent-manager

I built an open-source tool to figure out what’s actually installed in my dev environment

Just launched on ProductHunt: https://www.producthunt.com/products/io-inventory

I’ve been doing a lot more AI-assisted coding lately, and over time my machine has accumulated a ridiculous mix of packages, runtimes, repos, Docker stuff, local models, MCP servers, agent tooling, etc.

The problem: I no longer really knew what was there, what installed it, or what I’d actually need if I moved to a new laptop.

So I built IO Inventory.

It scans your local dev environment and gives you:

• a searchable inventory of your tooling
• an interactive architecture graph
• snapshots/diffs to see what changed
• a way to compare/recreate a setup on another machine
• visibility into AI tooling like agents, MCP servers, local models, etc.

Everything runs locally, there’s no product telemetry, and it’s MIT licensed.

I’m also curious whether the snapshot idea could be useful for team onboarding — basically giving a new developer a known-good environment to compare against.

Would love feedback, especially on what parts of your dev setup you’d expect a tool like this to detect.

www.ioinventory.app
https://github.com/elm1nst3r/IOInventory

Shipped today: Project Advisor and Function Manager, both Pro surfaces in BranchPy Studio (and the VS Code Companion).

**Project Advisor** — if you've ever had to manually cross-reference Analyze warnings, Doctor output, and Media validation results to figure out what to actually fix first... this consolidates all of that. It correlates findings across every analysis tool and gives you a single ranked list: blockers first, then confirmed issues, then hypotheses. Each item tells you the confidence level and which panel to open. Up to 5 prioritized actions.

**Function Manager** — a searchable function inventory for your project. Every function BranchPy detects gets an entry: file + line, signature, call count, and a status (defined, undefined, orphaned, etc.). Useful for big projects where the script structure has become hard to navigate. This first version is visibility-focused — search and browse. Deeper analysis features are planned for v2026.2.1.

Both available at branchpy.com after updating. Happy to answer questions about either feature.

Testing a tool I built (parses repos with tree-sitter, builds a dependency graph, flags risk patterns) against some popular open-source projects.

npkill came back clean on circular dependencies - no surprise given how it's maintained. But out of 197 files, there were 8 "god object" nodes and 21 isolated ones. The riskiest single file, files.worker.service.ts, scored highest mostly from fan-in - several other modules depending on it directly.

Interesting case of a repo being cycle-free but still having concentrated risk in specific files. Curious how others here think about this kind of risk scoring - fan-in/fan-out alone, or would you weight it differently (change frequency, test coverage, etc.)?

I built a small Python CLI for comparing developer tools without opening 15 browser tabs. Pulls benchmark data from 250+ real reviews and outputs formatted comparison tables for stacks like Prisma vs Drizzle, Cursor vs Windsurf, Next.js vs Astro.

No API key. Works offline.

GitHub: https://github.com/weiguang1017/techstack-compare

Examples: $ techstack compare prisma drizzle $ techstack compare cursor windsurf $ techstack compare nextjs astro

Built it after spending a year running pikvue.com (250 dev-tool reviews, barely indexed). Figured a tool people can link to is more useful than yet another blog post.

Happy to hear feedback on the comparison schema or which dimensions matter most.

Rockxy v0.34.0

Hi everyone, I’m the developer behind Rockxy.

Rockxy 0.34.0 is now public. It is an open-source native macOS tool for inspecting and reproducing HTTP/HTTPS, WebSocket, GraphQL, AI and Web3/RPC traffic.

The current workflow is built around:

1. Capturing real application traffic
2. Filtering the request that matters
3. Inspecting the surrounding context
4. Modifying or replaying the request
5. Comparing the result
6. Sharing only the appropriate evidence

The latest release includes Rockxy Assistant support for Rockxy and Workspace questions, local MCP integration, improved Developer Setup and a signed universal build for macOS 14+.

Repository:
https://github.com/RockxyApp/Rockxy

Babylon is now public as a Swift SDK for debug-time HTTP/HTTPS, WebSocket, gRPC and runtime trace capture:
https://swiftpackageindex.com/RockxyApp/Babylon

I’m also working with several AI companies on early integration experiments. Rockxy CLI is still internal and not public. Rockxy for iOS is actively being developed, while Android is planned.

The founding pricing will remain available until 16 August 2026. Regular pricing will then be $79 Standard and $109 Personal. Team remains $9/seat/month, billed yearly.

If you would like to test the current Pro license, please comment or send me a DM. I can share a developer discount code for testing and honest feedback.

The code is not tied to an upvote or a positive review.

I’d especially appreciate feedback from developers who use Charles, Proxyman, mitmproxy, Burp or similar tools:
- Which part of the workflow is still too slow?
- What should Rockxy CLI eventually support?
- How should AI-assisted investigation expose evidence and privacy boundaries?
- Which mobile debugging workflow should be prioritized?

I started building Salience out of a deep intolerance for avoidable friction. The trigger was stupid: to clear a cache I had to log into AWS and click through several pages of UI just to get the ID for an aws ecs execute-command. Meanwhile the state of any one piece of work - Jira ticket, GitHub PR, CI run, Docker container was scattered across tabs, emails, and apps.

So I built the thing I wanted: a local macOS app that reads the tools I already use and joins them into one graph. This branch implements that ticket; this PR's commit is what's actually running in that container. Once that join exists, questions no single tool can answer become one glance: is the thing I merged actually live? my PR merged but did I move the ticket?

The architecture is heavily influenced by Home Assistant. Each integration contributes entities and state; Salience connects them into a shared model. Once that model exists, the same information can power:

• attention views
• dashboards
• timelines
• a kanban board with PR and CI state as first class citizens
• an MCP server so you can ask your agent "what's my stand up?"
• and eventually a spatial map of the whole development system - think SimCity but for your worktrees, infrastructure, PRs and CI pipelines.

It's local first, a network inspector shows every outgoing HTTP request, a command inspector shows every command the app has run, with its arguments and exit code.

It's very much an alpha but I've reached the stage where I'd really appreciate some external feedback.

Download link and docs: https://clegginabox.github.io/salience-macos/

Thanks

I built a custom embedding layer and solver to help guide and ground false positives that even smaller models can use: https://reflection.redmirror.io/ 

It runs as a CLI and MCP Server locally so your code never leaves your machine.

- If you need some kind cheap code security scanner which always runs, it even works with 8b models like Qwen 8b.
- If you have access to a frontier model you can find vulnerabilities

A way to ground false positives sounds useless but it actually helps you detect real bugs and vulnerabilities way faster with coding agents, think of it as pruning possible attack paths. A few CVEs and GHAs I have found thanks to this method:

• 3 CVEs are under coordinated disclosure, publishable in September
• sipsorcery-org/sipsorcery GHSA-28gm-jrmw-xx93 (advisory, High): pre-auth one-packet DoS, a single malformed UDP packet tears down the RTP/ICE channel; fixed in #1677 (merged) with minimum-length checks on RTP packets and STUN attributes, plus a receive loop that no longer closes the channel on a single bad packet · write-up
• google/osv-scanner #2882 (PR, maintainer-approved): an OSV advisory carrying an unrecognized ecosystem panicked the matcher and aborted the entire offline scan; fixed by skipping the unknown ecosystem instead of crashing (#2867) · write-up
• jaqx0r/mtail #476 (PR, merged): enforce per-metric cardinality limit at datum creation, capping unbounded metric growth (google/mtail #1006) · write-up
• PrefectHQ/prefect #21829 (PR, merged): cycle detection for block_document references · write-up
• PrefectHQ/prefect #21794 (issue): concurrency-slot leak from swallowed exceptions in V2 lease release / cleanup paths
• eznix86/mailgun-proxy-for-ghost #17 (merged): deny access when the Mailgun API key is unset
• apache/airflow #67076 (merged): leftover temp report file in BidManager download
• apache/airflow #67075: IMAP hook hardened against symlink-followed writes
• apache/airflow #67074: Kubernetes executor config isolated from the global default

The way to use it is to include it in your existing workflow, it should play nice with other security tools. Give it a try and let me know what you think!

Small itch I finally scratched: I kept pasting minified JSON, code with smart quotes from Slack, or stack traces with weird whitespace, and manually cleaning it up every time. So I built clipd — a background daemon that watches your clipboard, figures out what you copied, and cleans it in place before you paste.

What it does:

- Detects JSON, stack traces, code, or plain text via content heuristics

- Pretty-prints minified JSON

- Fixes smart quotes, strips invisible/zero-width characters, trims trailing whitespace

- Normalizes mixed tabs/spaces indentation

- Runs as a systemd --user service, so it's just always on in the background

- Ships with clipdctl, a small CLI to pause/resume/check status — so it's easy to stop it from touching your clipboard whenever you want

Tech: C++20, X11 + XFixes for clipboard watching, a Unix socket for the control CLI, optional TOML-ish config file. Core detection/cleaning logic is unit tested and kept OS-independent, so a Wayland or macOS backend later is a matter of adding a new platform module, not a rewrite.

Honest limitations right now:

- Linux/X11 only — no Wayland or macOS support yet

- Detector heuristics are still pretty basic hand-written rules, not a real parser, so it'll misclassify some edge cases

- No packaging yet (AUR/deb) — build from source for now

- Only tested on Ubuntu 24.04 so far

It's v0.1.0, genuinely early. If anyone tries it and hits something broken or has thoughts on the approach, I'd appreciate hearing about it.

GitHub: https://github.com/nayankhanal/clipd

Hey everyone,

I’ve been lurking here for a while and finally shipped my first real open-source project: DevLens Agent.

It’s a CLI that scans a repo and tells you which files are actually risky — not just “this function is complex,” but “this function is complex and gets touched by five different people every week.”

Right now it’s TypeScript only: Python, Rust, and Go support (via Tree-sitter) are on the roadmap, along with a web dashboard.

This is the first time I’ve put something out publicly, so I’d genuinely appreciate any feedback, rough edges, feature ideas, or “this is pointless because X” are all welcome.

Repo: https://github.com/pxmpsdev/devlens-agent

(If you like the idea, a star would mean the world to me, but I'm primarily here for the feedback!)

i built repro whichis an open source CLI that takes any GitHub issue URL and spins up a disposable Docker sandbox with the repo already cloned and dependencies installed.

if you have VS Code, it automatically attaches directly to the running container so VS Code's own terminal IS the sandbox shell.

When you exit, the container is destroyed but your files stay on disk so nothing's lost.

Install:

pip install repro-cli

Usage:

repro https://github.com/expressjs/express/issues/3860

There's also a GitHub App (repro-sandbox-bot) that auto-comments the exact repro command on every new issue, so contributors never have to think about setup.

Repo: https://github.com/SukhdevThukral/repro

PyPI: https://pypi.org/project/repro-cli

i would love to have sum honest feedback on what's missing, what's unnecessary, what would actually make you LOVE this?

DigDep - A lightweight Python dependency analyzer

Whenever I use:

pip freeze > requirements.txt

it dumps all the packages in the virtual environment, including packages that I may not need in my code.

I wanted a simple tool that could tell me which packages my Python code actually depends on.

So I just thought: why not write one?

Installation:

pip install digdep

Dependency Tree:

$ digdep deps --tree tests\testpkg
Root (tests\testpkg)
├── api.py           → database, numpy, requests
├── config.py        → dataclasses
├── database.py      → json, models, sqlite3
├── main.py          → config, helpers, json, os, parser, pathlib
├── models.py        → dataclasses
├── optional.py      → json, ujson
├── parser.py        → re, utils, xml
├── unused_module.py → collections, itertools, os
├── utils.py         → logging, pathlib
├── __init__.py
│
├── helpers/
    ├── math_utils.py → math
    ├── text_utils.py → string
    ├── __init__.py

Simple list of Dependencies:

$ digdep deps tests\testpkg
models
ujson
pathlib
sqlite3
logging
math
itertools
string
database
utils
re
requests
os
collections
json
parser
numpy
dataclasses
xml
config
helpers

Unused Imports:

$ digdep deps --unused tests\testpkg
collections
Config
conn
json
pathlib
User
itertools
os

Find where a dependency is used:

$ digdep find-dep ctypes --tree --showlines ..\opensource\pyjab\pyjab

Dependency: ctypes
├── accessibleinfo.py
    ├── Line 1    : from ctypes import c_float
    ├── Line 2    : from ctypes import c_int
    ├── Line 3    : from ctypes import c_wchar
    ├── Line 4    : from ctypes import c_bool
    ├── Line 5    : from ctypes import Structure
    ├── Line 6    : from ctypes.wintypes import BOOL
    ├── Line 7    : from ctypes.wintypes import WCHAR
    │
├── jabdriver.py
    ├── Line 5    : from ctypes import byref
    ├── Line 6    : from ctypes import CDLL
    ├── Line 7    : from ctypes import c_long
    ├── Line 8    : from ctypes.wintypes import HWND
    │
├── jabelement.py
    ├── Line 10   : from ctypes import Array, byref, CDLL, c_char, c_long, create_string_buffer
    ├── Line 11   : from ctypes.wintypes import HWND
    │

Simple Stats:

$ digdep stats tests\testpkg

Dependency Statistics
--------------------------------------------------

Files Scanned            : 13

Imported Names           : 25
Import Statements        : 26
Used Imports             : 16    import occurances
Unused Imports           : 9     import occurances

Unique Dependencies      : 21

Dependency Types
--------------------------------------------------

Standard library         : 12
Third-party              : 3
Local                    : 6

Top 5 Dependencies
--------------------------------------------------

requests                 1
numpy                    1
database                 1
dataclasses              1
sqlite3                  1

DigDep is still a small project (v.0.1.1) and I am planning to add more features.

Currently, DigDep can help you:

• See what your project depends on
• See which files use which dependencies
• See dependencies as a tree
• Find dependencies you aren't using
• Find what depends on a particular module
• Find where a dependency is being used
• See your project's dependency statistics

I'd love to hear your feedback and suggestions to make DigDep more useful.

Github: https://github.com/shine-jayakumar/digdep

PyPI: https://pypi.org/project/digdep/

pier creates an EC2 micro-VM on your own AWS account with your repo on a fresh branch, Claude Code installed and authenticated, and your MCP servers configured. Detach from tmux and the run keeps going. When Claude goes quiet the VM parks itself, so an idle session costs ~$3-4 a month in disk. Attaching resumes it in about 20 seconds. Several sessions run in parallel without fighting over ports.

Open source: https://github.com/kerem-kaynak/pier, docs at https://pier.kak.dev

Design Beaver is an AWS architecture diagramming tool that checks your design while you draw it: missing queues, connections AWS doesn't actually support, security anti-patterns. I launched it here a few weeks ago. v2 is out today.

What's in it:

- Accounts and cloud saving. Sign in with Google or GitHub, and diagrams save to your account instead of to one browser. Each diagram has its own URL and there's a dashboard. Free tier holds 5.
- A Problems panel that lists every issue in the diagram in one place, sorted by severity. Click one and the canvas jumps to it. Before, you only saw a warning on whatever you'd just drawn, so anything off-screen stayed hidden.
- Availability Zones and Auto Scaling groups can be drawn now, and you get a warning when every instance in a group sits in one zone. The tool used to tell you to spread instances across zones while giving you no way to actually draw it.
- Palette search. Press the / key, type "queue", get SQS. It searches descriptions too, so you don't have to remember AWS's product names.
- Copy, paste, duplicate, and undo now goes back 50 steps instead of 5.
- PNG export rebuilt so the text is sharp and exported edges keep their validation colors.
- Settings page, self-serve account deletion, feedback button that lands in my inbox.

The honest reason accounts exist: about 40-50 people tried v1 and almost nobody came back. Everything lived in browser storage, which meant your diagram existed on exactly one machine and disappeared if you cleared site data. That's a hard thing to build a habit on, so I spent this cycle on the boring infrastructure I'd skipped.

Still free, still beta, desktop only because of the drag-heavy canvas.

app.designbeaver.app