r/devtools • u/BossTriumph • 21h ago
I built a React debugging overlay that lets you click an element and jump to its JSX
r/devtools • u/BossTriumph • 21h ago
r/devtools • u/ylgdev • 6h ago
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
r/devtools • u/Sea-Broccoli6131 • 8h ago
r/devtools • u/Rickie_Lake • 8h ago
r/devtools • u/DeVoresyah • 11h ago
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:
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?
r/devtools • u/Visible_Swim471 • 11h ago
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?
r/devtools • u/onnatsari • 13h ago
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 • u/mu_bloxi_alt • 15h ago
r/devtools • u/SquashHot4348 • 16h ago
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?
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.
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:
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
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 • u/awesomebirder • 19h ago
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.
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.
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.
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.
Subagents each start their own context and their own cache. Four in parallel means four cache writes before any real work happens.
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 • u/Majestic_Tension_860 • 19h ago
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 • u/Alternative_Worry615 • 19h ago
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?
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
I'd love feedback from developers building TypeScript applications or AI agents.