Can anyone identify the tool for SSH, the icon looks like >

I'm building Cloady at NeptoLab. The developer-tooling problem I'm working on is the gap between "the app deployed" and "I can actually operate this thing."

Take a small API with PostgreSQL and file uploads. A failed request might mean an environment variable is wrong, a database migration hasn't run, or an upload landed on ephemeral storage. Those are different problems, but debugging them shouldn't require losing track of which project you're inspecting.

Cloady groups the app, database, and persistent storage in a workspace, with Terminal, Files, Database, Git, and Monitor tools in the browser. The intended workflow is simple: inspect logs, check the files or database, and use a terminal when you need to investigate further. Deployment can start from a GitHub repo, Docker image, folder upload, or template.

There are also CLI, REST API, Terraform, and MCP interfaces. The point is to make the same hosted project usable from a browser, a scripted workflow, or a compatible AI client. That doesn't make application migrations or recovery automatic: you still need to understand your data and test your recovery path.

One design tradeoff is explicit resource allocation. You choose CPU, RAM, and SSD capacity, so paid resources remain billable while idle. That is useful for planning, but it isn't a substitute for measuring the application's actual resource needs.

I'd appreciate feedback on the tooling itself: which task still sends you out of your hosting dashboard most often, and what context do you lose in the process?

Project: https://cloady.com

Short visual introduction: https://www.youtube.com/watch?v=ctBCeewIin0

Our Discord for technical questions and feedback: https://discord.gg/3ZNVyUGse

Running a few branches or AI agents in parallel worktrees? They all fight over the same ports and database. wtc reads your existing compose file and gives each worktree its own ports, containers and volumes, with zero config.

New in 1.0: ports stay stable when you remove a worktree, Podman support, a clean that keeps uncommitted work, and an MCP server so agents can run their own stacks.

npm install -g worktree-compose, then wtc start

GitHub: https://github.com/mostafasudo/worktree-compose

\*\*🚀 Introducing Archi — Your Local Code Architecture Mapper (Graphify-inspired, but fully offline & LLM-free!)\*\*

Tired of feeding massive codebases to cloud LLMs just to understand your own project? Struggling with legacy systems that no modern tool handles well? Meet \*\*Archi\*\* — a fast, local, zero-dependency codebase visualization and architecture intelligence tool.

\### Why Archi?

\- \*\*No external LLMs or cloud needed\*\* — Pure local parsing with ASTs and static analysis. Runs instantly on your machine.

\- \*\*Inspired by Graphify\*\* but lighter and more private: No token-heavy LLM calls, no vendor lock-in.

\- \*\*Saves tokens & works great with LLMs\*\* — Export rich JSON graphs that you can feed to any local or remote model for ultra-efficient context (perfect token optimization!).

\- \*\*Beautiful Obsidian integration\*\* — Generates a full visual knowledge base with rich connections, notes, and graphs. Turn your codebase into an interactive second brain.

\- \*\*Legacy system friendly\*\* — Excellent support for older codebases, multiple languages, and frameworks.

\### Key Features

\- \*\*Multi-language support\*\*: Python (AST), JavaScript/TypeScript, Go, Protocol Buffers, and more.

\- \*\*Rich architecture graphs\*\*: Files, classes, methods, call graphs, imports, inheritance, DB tables, etc.

\- \*\*Smart framework detection\*\*: Deep understanding of FastAPI, Django, React, gRPC, and others.

\- \*\*God Nodes & Communities\*\*: Automatically spots critical/highly-connected parts of your code.

\- \*\*Semantic search\*\*: Query components naturally (e.g., \`archi /path/to/project --search "user authentication"\`).

\- \*\*Obsidian export\*\* + JSON output for easy integration and persistence.

\### Quick Start

\`\`\`bash

git clone https://github.com/abdelbar472/Archi.git

cd Archi

pip install -e .

\# Scan any project

archi /path/to/your/project

\# With search

archi /path/to/your/project --search "your query here"

\`\`\`

The output includes interactive graphs, Obsidian-ready vaults, and clean JSON artifacts you can version-control or pipe into your favorite LLM setup.

\*\*Perfect for\*\*:

\- Solo devs and teams wanting privacy & speed

\- Legacy code maintenance

\- Building maintainable knowledge bases with Obsidian

\- Token-efficient workflows with local LLMs

Check it out and star the repo if it helps you:

👉 https://github.com/abdelbar472/Archi

Try it on one of your projects today — especially those dusty legacy ones — and let me know what you think! Feedback and contributions welcome.

Built to make codebase exploration local, visual, and actually fun again.

(Shoutout to the Graphify project for the inspiration!)

When delegating work to an LLM, one can easily lose overall codebase understanding.

Personally, I like to be in control of the code I ship, so I read every file that was changed before shipping the change. The problem with this approach appears when many files change. Regular git clients show the files as a list of alphabetically sorted entries.

However, to properly understand the changes, I need to keep in mind all code dependencies. If an interface was changed, I either need to go straight to the implementation file, which might not be the next in the list, or I have to remember that the interface was changed while I'm reading other files, until I open the implementation file.

There are tools that link changed files by dependency. This helps substantially; now instead of reading files in alphabetical order I can read real dependency graphs. However, this helps only with direct dependencies. What we do in our heads is conceptually grouping changes into clusters. Even if there is no direct code dependency, changes could be grouped into "logical cases", inside of which there could be multiple changes from multiple projects.

Why not utilize what LLMs do best: gathering context. That's why I vibecoded a DiffHacker - to help software engineers like myself maintain knowledge about the codebase more easily.

So instead of this

I have this

C-Coretex/diffhacker: A cross-platform desktop application that turns local Git changes into a directed, LLM-generated review graph instead of a file list.

**Files sync fine.** Local-first dies on everything that lives outside the repo: tokens trapped in your OS keychain, extension state buried in \~/Library or \~/.config, toolchain versions you installed at 2am and never wrote down, that one auth flow that quietly needs the cloud. Most of it never makes it into a dotfiles repo.

When you move machines, what breaks first? I keep hearing "just use Docker," and every time a GUI tool or a license server disagrees.

Second question, the one I actually care about: you don't review your way into trusting AI-generated code. You review until you're tired and call it trust. Reproducible tests, clear diffs, type checks, benchmarks, scans — that's all after the fact, showing what happened, not what the agent knew. What I'd want is its paper trail: every file it touched, every assumption it logged, everything it chose to leave alone.

***What's the minimum evidence that gets you to not open the diff?***

The package tries to hold itself to the same standard. It builds with python3 build.py, standard library only, no dependencies, no network calls, no clock reads. Same inputs give byte-identical output every time.

Every source file is hashed into a seals ledger, and verify.py checks both the hashes and the rebuild, so the determinism argument in Volume II runs against the package itself instead of just sitting there as a claim. There is also a script that mints numbered ownership certificates sealed to the exact edition hash, which is personalization and not copy protection, and the docs say so.

It ships the two prompt patches I used to generate and audit the source manuals, so you can run the same process on your own projects. That may be the most useful part of it.

Free, no signup, reads in the browser, prints to clean PDFs.

https://shpbl.com

Your GitHub Issues as a live roadmap board in Claude Code.

Sideboard shows your repo's GitHub Issues as a live roadmap board that you and Claude Code drive together. Quickly log ideas for the backlog, start Claude on the next issue, and reason across your roadmap and codebase in context — no need to jump out of Claude Code to an external board.

https://github.com/mmyslin/sideboard

/plugin marketplace add mmyslin/sideboard
/plugin install sideboard@sideboard

I'm a backend dev who spends a lot of time on complex Stripe-based custom billing, and I always wanted a way to see what the Stripe libraries actually send over the wire in real time — to cut down the number of requests, read through deeply nested payloads, and debug failed calls without guessing.

stripeek is a framework-agnostic local proxy that logs all your Stripe API activity on the fly in a TUI built specifically for Stripe traffic. It never stores your keys and strips sensitive data out of the headers. Setup is a one-line change to your Stripe initializer in dev to pipe traffic through it — no other changes to your backend code needed.

It's not a replacement for the Stripe Dashboard, but it complements it well and saves a lot of time (and nerves) when you're trying to make sense of several levels of nesting in request/response payloads.

I've been experimenting with AI coding tools like Cursor and Claude Code, and one thing that kept bothering me was how difficult it is to get them to recreate an existing website's actual design.

You give an AI agent a reference website and ask it to build something similar, but it often ends up guessing:

• Colors are slightly off.

• Typography doesn't match.

• Spacing and border radii are inconsistent.

• The overall result looks like a generic AI-generated UI.

So I built styleprobe to solve this problem.

It's an open-source CLI that takes a website URL and extracts its visual design system.

A few things it can do:

• Extract colors and semantic design tokens.

• Analyze typography, spacing, shadows, and component styles.

• Crawl multiple pages instead of relying on just the homepage.

• Extract SVG logos and other brand assets.

• Export directly to Tailwind, shadcn/ui, Figma tokens, or AI-agent instruction files.

You can also try the web playground here:

https://styleprobe.vercel.app/

GitHub: https://github.com/spidervirus/styleprobe

It's MIT licensed and completely open source.

I'm still improving it, so I'd genuinely love feedback from developers:

1. Would something like this fit into your AI-assisted development workflow?

2. What other design information would you want it to extract?

3. What would make you actually use this regularly?

Would love to hear your thoughts!

I built Github merge gate which that checks whether developers understand their own code when they create a PR.

I kept getting sent PRs to review where it was obvious the author had pasted the ticket into an LLM and called it a day. Problem was: the PRs would often be massive 2K monstrosities that nobody could possibly review. As the team scaled up, this problem got only worse, and now we collectively have a system that no one understands and has bugs.

It works like this: when someone opens a PR, it posts a comment with a link. The author clicks through and answers a few technical questions about their own changes. If they can’t answer them, the PR can’t be merged.

It's self-hosted (so you can use it in your enterprise environments or privately)

It is BYOK (Anthropic) obviously.

Here is the source code, build instructions and how to deploy: https://github.com/bhurghundii/vibecheck.dev

I have two demos in the pull requests here: https://github.com/bhurghundii/vibecheck.dev/pulls - you can see what Vibecheck does (it blocks a PR for clearly showing no attempt vs a PR which gets it right)

I would love feedback, especially from anyone dealing with the same thing on their team. I do use it for my own projects a lot so expect improvements.

Guys! What’s the best way to gather early adopters to evaluate new dev tool that addresses gaps of REST, gRPC, Thrift, SignalR, DAPR and GraalVM in one shot?

The concept is to shift away from writing code to expose any business logic in any specific integration strategy like create REST controllers or provide proto interfaces or expose via subscription to queue events as well as avoid implementing the integration-specific client code to call that rest or gRPC endpoint.

Instead of that the question comes when I call “zip” module from Nuget in .net I just use its public methods and handle exceptions. Why if I want to use it remotely I should expose the same method via REST, map it to routes, strange parameters, http codes and next call that on other end? Wy I cannot just say it will be on this remote node so whenever I ca that method to “unzip” my intention just travel over network and execute there?

The potential solution is to bridge runtimes on native level. Think of it like intercepting developer intention at abstract syntax tree so when you perform operation in code before it gets executed and just send it to the remote runtime fulfill job there and return result.

Wouldn’t be beautiful if you could just call methods of any module regardless if it’s same tech or different and regardless of its in memory or remotely? Just by calling methods?

I know I know there are isolation interfaces etc… but if you apply those concepts design facade properly, decide what should be public, and allow to attach to those calls any headers (to still support JWT, NTLM, api Keys etc) and will add support that if method is static it goes stateless if it’s instance it goes stateful with sticky session and give the DevOps ability to change channel between WebSocket, http/2, tcp/ip or any message bus without touching code as it will be just pure method code. It could really work.

Think of it.

How clean your codebase would be, how much more design would fit your original uml, how much less code would be generated and maintained how much less ai tokens would be consumed and how much pull request would be easier?

Let me know if you think if it makes sense? And help me find devs who would like to evaluate it and support a growth of such free and open project!

Hope there are ninja guys here who grasp that concept!

It’s surprisingly easy to forget the end user when you’re deep in development.

Sharing localhost is solved now, but early feedback is still basically “looks good” and you have no idea what people actually did.

I built demotape.dev to make that part trivial — you share your local app and can replay exactly what the user did.

Curious how others handle early validation.

Hi everyone,

I’ve created a Windows CLI tool called RunIT. It’s a lightweight, open-source tool that turns your command prompt into a terminal assistant for developers.

Key Features:

Run files in Python, JavaScript, HTML, PHP, C++, Java, and more, with automatic interpreter detection.

Create files with language-specific boilerplate and templates.

Aegis Vanguard (AV) – Security Scanner Package: scan website folders for vulnerabilities, get risk assessment, and suggested fixes.

Host static websites locally and preview projects, with optional temporary public links.

Inspect files with statistics, code structure analysis, and metadata.

Packages Library: includes more than 5 specialized packages for extra functionality.

Continuous Updates: the tool and packages are updated regularly.

Example usage:

Run any file

run script.py

Scan a website folder for vulnerabilities

av <website_folder>

Xcode's .xcstrings localization workflow is basically copy-paste hell. You copy strings out, paste them into ChatGPT, fix the format specifiers it always breaks, paste everything back in. For one language that's annoying. For 17, there goes your weekend.

I built Polyglot for Xcode to skip all of that. It opens .xcstrings files directly, you pick target languages and an AI provider, hit translate. Everything saves back to the file.

What it does:

• Translates using OpenAI, Anthropic, Gemini, or DeepSeek

• Preserves format strings (%@, %d, %lld) and plural rules - the stuff ChatGPT loves to break

• Batch translates hundreds of strings with real-time progress

• Handles truncated AI responses (detects incomplete JSON, halves the batch, retries recursively up to 3 levels)

• BYOK option - bring your own API keys, pay API rates with no markup

The truncation thing was the fun part to build. Large translation batches sometimes get cut off mid-JSON by the API. The app detects this, splits the chunk in half, and retries each half. If one of those also gets truncated, it splits again. Ends up looking like a binary search for the right batch size.

Native macOS app. SwiftUI, not Electron. Free tier gives you 300 translation units/month.

Mac App Store: https://apps.apple.com/us/app/polyglot-for-xcode/id6752878510

If you localize apps and have a workflow that works, I'm curious what it looks like.

A small CS2 player-props watcher has been open-sourced.

It pulls current props into the terminal and can optionally send updates to Discord.

It is meant to be a starting point, not a finished product. Add filters, line-movement logging, a dashboard, alerts, model inputs, or whatever else would make it useful.

The code is here.

If anyone builds something from it, share it here. Would be interesting to see where it goes.

I kept re-applying the same filters, columns, sort and export on every new file, so I built "Automations" into a free browser-based data tool (Fomatix Data Explorer).

Set it up once, save it, then upload the next file and pick the automation. It reapplies everything and exports, and auto-matches columns even if a header shifts slightly.

It also shows a match report (how many columns matched on each run) and keeps run history, so you're not trusting it blindly.

Runs entirely in the browser, no signup, nothing uploaded.

Curious if others hit this problem, or if you already have a cleaner way (Power Query, Apps Script, etc.). Honest feedback welcome.

a while back ago i posted asking if anyone else was drowning in session data they never actually look at, fullstory, posthog, whatever, and whether automating the first pass would even be useful or if the real problem was just nobody prioritizing it

https://www.reddit.com/r/userexperience/comments/1t0hnvq/anyone_tired_as_hell_going_through_fullstory/

the responses kind of convinced me to just build the thing and see

so i did. been using it as an internal tool with a couple of engineers on my team for a while now (they didn't really have a choice tbh) and it's been useful enough that i figured i'd clean it up and put it out there

you drop in an short screen recording or a exported event log (PostHog, Mixpanel, GA4, custom JSON) and it gives you a plain-english breakdown, rage clicks, drop-off points, friction patterns along with timestamps you can click to, that kind of thing

you can also export it to pdf, no account needed to try it

curious if it holds up for anyone outside my team

lwk was thinking maybe adding some batch processing to detect patterns over say like 50 videos, but just want input before i have it generate 50 mid reports at a time 😭

https://ui-ux-autopsy.vercel.app/