r/devtools • • 21h ago

I built a React debugging overlay that lets you click an element and jump to its JSX

Thumbnail
2 Upvotes

r/devtools • • 6h ago

Tablo: Rust declarative admin panels

Thumbnail
gallery
1 Upvotes

I've been building Tablo on top of Toasty and Topcoat. It is a server-side rendered admin panel toolkit heavily inspired by Filament.

The idea is to declare the panels, lists, pages, actions, forms, permissions, and tablo gives you the back office. I made it fully featured (tenancy, auth, queue, themes, impersonation, localization, built-in audit log), maybe too much, but that is what allows you to have powerful panels with a minimum of code and time (you have your panels in minutes).

You can have multiple panels in the same Topcoat app: one for admins, one for customers, one for partners, etc. Tablo is experimental and largely AI assisted.

Website: https://y-l.fr/tablo

Repo: https://github.com/y-l-g/tablo

Demo: https://demo.tablo.y-l.fr/


r/devtools • • 8h ago

Auryn: an open-source code graph your coding agents query over MCP

Thumbnail
1 Upvotes

r/devtools • • 8h ago

Codex keeps per-reply token counts on your Mac. Here is how to see which session used the most.

Thumbnail
1 Upvotes

r/devtools • • 11h ago

How I made Claude Code, Codex and OpenCode share context without rebuilding any of them

1 Upvotes

I'm building Sokudo, a desktop IDE for running several AI coding CLIs as one team. The design choice I want to share is that I didn't rebuild any agent. Sokudo detects the CLIs on your PATH and runs the real binaries.

Why: every "agent UI" that reimplements Claude Code or Codex falls behind the moment the CLI ships an update. Running the real binary means you get every new model and flag on day one, and you stay logged into your own account.

The hard part was context. Separate CLIs don't share memory, so each one re-explores the repo from zero. What I ended up with:

  • a wiki engine that maps the codebase into readable pages + a dependency graph, which every agent reads before a task
  • project rules and a knowledge base layered on top
  • the ticket itself carries the task context, so handing work from one agent to another doesn't need a re-brief

On top of that: a kanban board where each ticket gets an agent with its own role, a lead agent that shows which workers it's coordinating, and a reviewer agent with its own shell so it can run the tests instead of just reading the diff. You approve every change before it lands.

Curious how others here deal with context across multiple agents. Shared docs, one long session, something else?

sokudo.dev


r/devtools • • 11h ago

I built a 56px always-on-top strip that shows which coding agent is waiting

1 Upvotes

I kept losing time on permission prompts while working in another tab. Several CLI agents would be running, and the one that needed me was invisible until I went looking.

So I made a narrow always-on-top strip. Each row is one session: the project, the state (working, thinking, waiting, error), and how long it has been waiting. Click the arrow and the terminal that owns that session comes forward. Click the project text and its path goes to the clipboard.

It is one Go binary, about 4.6 MB, with no runtime and no network calls. Host hooks write one JSON line to a local pipe; the panel reads that and paints itself. No account, no telemetry, so I have no idea how many people use it.

Two limits: the Windows installer is unsigned, so SmartScreen complains; the macOS window is built and tested in CI but has never been opened on real hardware.

Would you keep a 56px strip on screen all day, or is a tray notification enough?

Repo: https://github.com/jjjjjjjjnnjnn/ai-terminal-pet


r/devtools • • 13h ago

PatchScope: turn Git diffs into actionable code review checklists

Thumbnail
ibb.co
1 Upvotes

Large pull requests make it easy to overlook removed tests, broad CI permissions and destructive SQL.

I built PatchScope to flag these patterns and explain what a reviewer should inspect next. It runs in your browser, CLI or GitHub Actions and exports Markdown, JSON and SARIF reports.

Unlike AI-based review tools, it uses deterministic rules without model calls or remote code uploads. Findings are review prompts, not confirmed vulnerabilities.

Free and open source under the MIT license.

Source: https://github.com/brunnojob/patchscope
Demo: https://brunnojob.github.io/patchscope/
GitHub Action: https://github.com/marketplace/actions/patchscope-diff-review


r/devtools • • 15h ago

I built EnvGrave, a tiny CLI that finds unused and missing .env variables

Thumbnail
1 Upvotes

r/devtools • • 16h ago

Ever wondered what happens inside your code? 🤯

1 Upvotes

Ever wondered what happens inside your code? 🤯

You write a solution, hit Run, and see Accepted.

Great! 🎉

But have you ever stopped and wondered what actually happened between those lines of code?

  • How did your variables change at every step?
  • What happened inside the call stack?
  • How did your array, heap, or hash map evolve?
  • What exactly happens when a recursive function calls itself?

I've often found myself wanting to see these things instead of just reading through the code or manually debugging every step.

So, I decided to build something around that idea.

Meet AlgoLens ⚡

It's a code visualizer + debugger built for people solving LeetCode problems.

The idea is simple: Don't just execute your code. Visualize how it works.

With AlgoLens, you can:

  • 🔍 Trace your code step by step.
  • 🎯 Highlight the currently executing line.
  • 🧩 Track variable changes and call-stack activity.
  • 🌳 Visualize recursion.
  • 💻 Work with Python, Java, C++ and JavaScript.

I've also tried to make it feel a little more interactive — almost like turning the debugging process into a game. 🎮

See the full promo -> AlgoLens-promo

Wanna to try it?

AlgoLens is currently available as a free Microsoft Edge extension:

👉 https://microsoftedge.microsoft.com/addons/detail/jhhkkpabkoeaiajdilomalbmjdppcmcc

Don't use Edge? No problem!

You can also use it on chrome -> Watch video for reference[ AlgoLens - chrome ]

I'm still developing and improving it, so I'd genuinely appreciate feedback.

One thing I'd love to know: What's the one thing you wish you could visualize while solving a LeetCode problem?

Would love to hear your thoughts! 🚀


r/devtools • • 19h ago

Logging every Claude Code request showed me most usage spikes are cache rebuilds, not prompts

1 Upvotes

I built probe0, a local proxy that sits between Claude Code (or Codex) and the API on a Mac and logs every request: model, input, cache read, cache write, output, status code. After a few weeks of reading those logs, the same handful of patterns explain almost every "why did my usage just jump" moment, so here they are in case they help anyone debugging their own.

  1. The prompt cache is a prefix. Anything near the top of the request (system prompt, tool definitions, CLAUDE.md) that changes mid-session forces a full rebuild at cache-write price. Toggling an MCP server, editing CLAUDE.md, or updating the CLI in the middle of a session all do it.

  2. The cache goes cold after a few minutes idle. Come back from lunch and the next turn pays for the whole conversation again. On my own 12 days of traffic, cache timing alone was about 7% of the bill.

  3. Tool output is resent every turn. A long test log read once gets paid for on every later turn until the session ends. Folding it down after it has been read barely changed answer quality in my tests; when a detail was missing, the agent just re-ran the command.

  4. Subagents each start their own context and their own cache. Four in parallel means four cache writes before any real work happens.

  5. Errors still count. Failed and retried calls are billed, so a flaky hour looks like a spike with nothing to show for it. Logging the status code per request was the only way I found to separate real work from noise.

How it is built: a Node/TypeScript proxy that uses a local root cert you trust so it can read your own agent traffic, a replay harness that re-prices old sessions from the ~/.claude/projects logs at API rates, and blind-judged quality tests before anything that changes what the model sees gets turned on by default.

On my own traffic the defaults took 12.8% off the bill, and 41.8% with model step-down on (easy turns go to a cheaper model, off by default). That is one person's usage, so yours will be different.

Caveats: Mac only, free beta. Your prompts, code and responses never leave the machine; if you sign in it syncs hourly usage totals (tokens, model, cost), no content. probe0 uninstall removes everything, including the cert. Happy to go deeper on any of the cache behavior.

Numbers and method: https://probe0.xyz/benchmarks?utm_source=reddit&utm_campaign=devtools

Terminal install if you want to try it: curl -fsSL https://probe0.xyz/i/r | bash


r/devtools • • 19h ago

xcomm: I built a minicom replacement that lets an AI agent drive the board's console while you watch

Post image
1 Upvotes

I spend a lot of time on serial consoles: U-Boot, boot logs, a shell on the

board. I wanted something that keeps minicom's everyday keys and common options but

lets a script or a coding agent use the same console I am looking at, so I

wrote xcomm (Rust, Linux and macOS, GPL-2.0-only):

- `xcomm ctl` talks to a running session: send a command and wait for a

prompt with a regex, read output by offset, toggle DTR/RTS, send a break,

change the baud, run zmodem/ymodem/xmodem through lrzsz. What a client

sends shows in your terminal as a dim `[ctl]` line.

- It survives the bench: unplug the adapter or power-cycle the board and the

session waits and reopens the port (on Linux, by the USB port it is plugged

into).

- minicom's common options and everyday Ctrl-A keys (Alt-A inside tmux,

screen or zellij); Ctrl-A d and t toggle DTR and RTS.

- UUCP locks compatible with minicom on Linux, and an exclusive open

everywhere, so two programs never share a port by accident.

- It ships an agent skill (stop U-Boot, log in, run commands, parse the

output); a test runs every example in it against a real session.

Numbers, through a pty with the same harness for each tool (median of 9 runs;

method and command lines in the README): 434 MiB/s on 1.84 ms of CPU per MiB,

against minicom's 10.5 MiB/s on 95 ms. On a real UART the baud rate is the

limit, so what you get is CPU left free. Keystroke latency is level with

minicom (within a microsecond either way).

`brew install cantona/tap/xcomm` or `cargo install --locked xcomm`

(`xcomm man` shows the manual where cargo installs none).

GitHub: https://github.com/cantona/xcomm

Happy to hear what breaks on your adapters.


r/devtools • • 19h ago

I built Effectum, a free MIT-licensed TypeScript runtime for reified effects and MCP tools

Thumbnail gallery
1 Upvotes

Ever had code execute an action you couldn't easily inspect, test, or trace?

Effectum solves this differently.

Instead of executing operations immediately, it turns them into values developers can inspect, interpret, test, and record.

Why use it?

  • Test operations without triggering real-world actions.
  • Separate business logic from execution.
  • Run long workflows without stack overflows.
  • Trace execution with MindLog audit trails.
  • Integrate with AI agents through MCP tools.

The benefit: More predictable execution, easier debugging, and greater control over side effects.

Free, MIT-licensed, and open source.

GitHub: https://github.com/mwatso12026-bit/Effectum

https://effectum-pro.com

I'd love feedback from developers building TypeScript applications or AI agents.