r/devtools

Hey everyone,

Like most of you, I constantly need to format JSON, decode JWTs, check diffs, or encrypt strings during my day-to-day work. But pasting proprietary code or sensitive keys into random, ad-heavy websites always felt like a massive security risk.

I couldn't find a comprehensive, privacy-first solution, so I built CipherKit (cipherkit.app).

It’s a suite of 77+ developer and cryptography tools designed entirely around privacy.

The core focus:

• 100% Client-Side: Everything runs locally in your browser. I built it using vanilla JavaScript, HTML, and CSS to ensure there is no server-side processing. Your data never leaves your device.
• No Login & Free: No paywalls, no accounts required.
• Clean UI: Dark mode by default, built for fast keyboard navigation.

Some of the tools included:

• Crypto Hub: AES Encryption/Decryption, RSA, SHA Hash Generators.
• Encoding Hub: JWT Debugger, Base64, URL Encoding.
• Dev Hub: Interactive Text Diff & Merge, JSON Formatter & Validator.
• Converter Hub: CSV to JSON, DOCX to HTML.

I’m Jana, and I built this to scratch my own itch, but I’m hoping it helps some of you keep your workflows a bit more secure.

I'd love to hear your feedback on the UI, any bugs you find, or tools you think I should add next.

Link: cipherkit.app

Most second brain apps stop at storage. You capture a note, tag it, link it, and hope you find it again someday. NeverWrite is built around the idea that your second brain should actually help you think, not just hold your thoughts. It's a local-first desktop app for macOS and Windows where your notes are plain Markdown files on your machine. No cloud sync, no account required, no telemetry. Your vault is yours.

The part I'm most excited about is the AI layer. NeverWrite supports agents powered by Claude, Codex, Gemini and Kilo, that work directly inside your vault. You can ask an agent to help you synthesize notes on a topic, find connections you missed, or draft a new note from your existing material. The key thing is that agents propose edits and you review them before anything changes, it has inline review hunks like modern code editors. The AI helps you process and connect your knowledge; it never rewrites your vault behind your back. That felt like the only honest way to build this.

If you've been frustrated by second brain tools that are great at capture but useless at synthesis, or by AI tools that feel like a black box you can't trust, NeverWrite is trying to solve both at once. Happy to answer any questions about how the agent review flow works or anything else.

Also, is open source ;)

https://neverwrite.app/

https://github.com/jsgrrchg/NeverWrite

Have fun with your vaults!

I was never a fan of debugging production errors on axiom, sentry, or pretty much any other tool existent already, simple or not simple to setup, once i start receiving errors finding them in a multitude of dashboards, learning proprietary languages, writing sqli-ish queries to find logs just seems too much, i shall have it there, visible, yelling at me that there is something wrong and i have to fix it.

I started building this tool, Loguro, a few months back, put a lot of features on it, the principle was simple, be fast, reliable, no context switching and human queries, at least at the beginning.

Ingestion, Rust + Hono on top of bun as web server, multiple layers of compression, made sure no log is escaping and there is no hiccup, tested and tested and tested again and again, it was fast, 45k+ req/s in single and 500+k logs/s in batch, instant visibility in dashboard.

Dashboard, also had to be fast, like really fast, started pushing logs, milion after milion, 50M logs queried in under 500ms.

Filter bar, human syntax, very human, level:error message:"oops something broke" from:"yesterday at 10:05" to:"yesterday at 12" context.user_id:1009 this can go on, there are a lot, a lot of queries available, but... i couldn't stop there, i like human syntax, but i like also commands, i like my filter bar to do things, not only request data from the backend, so, plugins appeared.

Plugins are basically a way for me to expand all the main inputs i have in the app, command bar, filter input and filter on the log page. On each input we can run commands to create integrations with jira, github, linear, etc., create a ticket on jira without switching context, sending the ticket and log details to slack directly, lots of plugins like that but there are two of them which made my life waaaay easier, tested for 2 months already with a project for a client i was having some issues.

--investigate and --share:md are two plugins which work on this exact sequence, find an error, enter the log, type --investigate and hit cmd+enter, if github integration is configured and github codebase accepted the ai will analyze the log, fetch relevant data from github, try multiple times until it founds something and spits out the issue it found + a solution and where needed suggestions to improve the logging to make it understand more next time. Once investigation is done and you know what happened, --share:md will create a shareable link with a markdown and one with a html view(in case some human needs it), i personally, take the markdown URL, go to claude and give it the link directly, let him fix, review and test then push.

Now what? Hope that will never happen again? Nope, pin that log, i want to see and watch it permanently for few days, add the pin a note in case i forget what was about and leave it there, if the issue will come again i will see it in the dashboard(i can create alerts, but i don't like my hearth rate spiking)

If for that issue i created a task in jira from the app, in case the issue appears again i have a badge on it, showing me that this happened again, clicking on it i have the full details about what happened WITHOUT LEAVING TO JIRA, i am debugging, if i switch tabs i might get lost. Every logging system has a retention period, want more pay more, mine does not work like that, you get max 120 days on the scale plan, but all plans benefit of memory. What this means? If i create a task from a log and time goes by, 1,2,10 months, my noise logs are pretty much gone, but that very log that triggered the task will still be there. FOREVER.

All my servers are monitored through Loguro, it accepts json and OTLP, thus from all the servers i have and all the clients servers i manage are sending logs to it, failed ssh attempts, fail2ban bans, success attempts, memory/cpu/network spiex, again, EVERYTHING goest to Loguro, full visibility.

That's Loguro, a logging system i built to suit my needs as a developer in the new era of AI development.

I am the only user for now. If anyone is interested seeing it here is a link.

https://logu.ro

No vendor spam, but I keep seeing support and ops people adopt Cursor because their dev counterparts swear by it. It works, sort of.... but it's the wrong shape of tool for what most support work actually looks like.

Cursor is built for sitting inside a codebase for hours. Most support work isn't that. A normal day for a T2/T3 or escalation engineer is more like:

• Tailing logs across five customer environments
• Running ad-hoc DB queries to verify a repro
• SSHing into a box that's misbehaving
• Grepping traces, pivoting between tools, context-switching every few minutes

That workflow lives in a terminal, not an editor. So in comes building yaw.sh, a terminal with AI built directly in.

What that actually means:

• AI right at the prompt. Pipe a log, paste a stack trace, ask "why is this pod crashlooping" with the output you just pulled..... without leaving the shell or alt-tabbing to a chat window.
• Multi-provider. Claude, OpenAI, whatever. Switch per task instead of getting locked in.
• Encrypted connection management built in. SSH keys, jump hosts, per-customer creds, one pane, encrypted, no more hunting through ~/.ssh/config or pasting things out of 1Password notes.

Where it lands vs Cursor:

Cursor is the right tool if your day is writing features. Yaw is the right tool if your day is reading logs, running queries, and SSHing into systems you've never seen before. They don't really compete. They just both have "AI" in the description, so people lump them together.

If you're a support engineer who's been using Cursor as a glorified ChatGPT wrapper, you can probably get the same value (and a lot less context-switching) from a terminal that just has the model right there.

Available on macOS and Windows. Linux on the roadmap.

Hey folks,
I’ve always found UI testing painful, either you write brittle scripts or rely on tools that don’t really match how you use your app.

I built an open-source CLI tool where you can record your UI interactions and it generates comprehensive test suites automatically

It tries to cover: edge cases, different input variations, navigation paths, and failures you didn’t explicitly think of. Still early, but it’s already catching cases I’d normally miss.

I’m launching it on Product Hunt today and would genuinely love feedback from people here, especially if you’ve worked with Playwright/Cypress.

PH link: https://www.producthunt.com/products/kushoai/launches/kushoai-for-playwright

Happy to answer anything / take brutal feedback 😊

used to have my terminal on one side and a chat window on the other. constant switching. broke my focus every single time.

started using a terminal that has chat built right into it. same window, same session, no switching. ask something, get an answer, keep going.

sounds small but it genuinely changed how i work. way less friction. errors get fixed right where they happen instead of me copying them into a separate window.

if you spend most of your day in the terminal it is worth trying. yaw.sh is the one i landed on, free to use.

Built a native macOS app with SwiftUI for browsing Claude Code session history.

Uses GRDB.swift with FTS5 for full-text search across hundreds of JSONL session files. The architecture is pretty simple:

- SessionManager handles async file watching and indexing

- SearchView uses Combine for debounced search

- SessionDetailView renders conversation turns with syntax highlighting

Key features:

- Instant full-text search

- One-click session continuation in Terminal

- Pin and tag sessions

- Timeline view

Everything runs locally, no cloud required.

Open source (MIT): https://github.com/JosephYaduvanshi/claude-history-manager

Happy to answer questions about the SwiftUI patterns used.

I built a small open-source terminal plugin called Prompty while working on my own workflow.

The idea came from a simple problem — I often run commands during setup or debugging, but later I forget:

• what commands I ran
• in what order
• what actually worked

So I tried a different approach:

• Write commands on the left
• Execute them directly
• See output on the right
• Keep everything saved for future reference

Even after closing the terminal, the commands and steps stay saved, so I can revisit them later.

More broadly, I’m trying to keep everything related to a project in one place — that’s why I built DevScribe:

• LLD / HLD documentation
• Executable APIs
• Database queries
• Diagrams (draw.io, Mermaid, Excalidraw, etc.)
• Code snippets
• Terminal commands and setup steps

Download: https://devscribe.app/

Note: You need to install the Promptly Plugin in Devscribe editor, If you face any issue DM me

The workflow this solves: I want to contribute to open source, I check GitHub trending, I see what's popular, but I have no idea which of those repos has a contributor-friendly issue queue. So I open tabs, drill into Issues, scan for help-wanted labels, get tired, close everything.

This tool shows both axes in one view. Top 360 repos in AI/ML and SWE, sorted by stars / forks / 24h growth / momentum. Each row pulls live open-issue counts from GitHub split into features, bugs, and enhancements.

The pattern that emerges when you put both axes together:

• Megaprojects (Linux, React, transformers) are popular but have tight issue queues. Hard to break in.
• Stagnant repos have lots of open issues but no momentum. Your PR sits forever.
• Mid-size rising repos with healthy issue counts are the actual contributor sweet spot. Visible work, responsive maintainers, real entry points.

This tool makes that third category easy to find.

A few examples from today's data:

• openclaw: AI assistant repo, +572 stars in 24h, 913 open enhancements
• everything-claude-code: agent harness, +1.1k stars in 24h, 145 open enhancements
• ollama: +75 stars, 28 open issues, very active maintainer team

Project link is in the comments below 👇

Built by NEO AI Engineer. Posting here because the contributor-flow angle felt like a fit for this subreddit.

I'm the author. Here's how this started.

I was using Claude Code to generate E2E Playwright tests for a project. It worked, the tests ran green, but I couldn't really trust them. Each test case needed me to manually open the browser and verify it was actually doing what I intended, which kind of defeated the point.

I started thinking: what if tests were written in plain English so I could read them and know they're correct without running them? But fully natural language tests felt like a different problem. Too unpredictable, hard to assert against, not worth the instability tradeoff.

So I looked for something in the middle: keep Playwright's execution model, replace just the selectors with plain English. I found ZeroStep and auto-playwright, both abandoned, slow, and expensive to run in CI. There is also Midscene.js, which is active but relies on the full DOM combined with visual context, which adds latency and cost at scale.

So I built Qortest (https://github.com/vikas-t/qortest).

const t = qor(page);
await t.act("Click the submit button");
await t.act("Type <hello@example.com> in the email field");
const count = await t.query("How many items are in the cart?");

Under the hood: aria snapshot of the page (much smaller than the full DOM or a screenshot), LLM returns a structured locator like { role: "button", name: "Submit" }, Playwright executes it. Deterministic. No screenshots, no free-form JS generation.

The slow/expensive problem: I cache the resolved selector keyed by browser + URL + instruction. Subsequent runs replay the cache, zero tokens. Fingerprint-based invalidation handles page structure changes.

Numbers from a 25-test suite on the-internet, gpt-4.1-mini, 3 workers:

Warm is about 15% slower than raw Playwright. Thats the honest tradeoff.

A few other things worth mentioning:

• Drops into existing Playwright tests. One import, no new runner.
• Supports Chromium and Firefox.
• BYOK, any OpenAI-compatible endpoint.
• Configurable fallback model: if the primary model fails to resolve an element, it retries with a stronger one automatically.
• Ships a reporter that shows per-test LLM calls, cache hits, and cost, so you know exactly what you're spending and why.

Still in progress: vision fallback for icon-only UI with no accessible name, and WebKit is untested.

MIT licensed. Happy to answer questions.

GitHub: https://github.com/vikas-t/qortest