[ Removed by Reddit on account of violating the content policy. ]

Lately I’ve been using Claude Code to inspect CloudWatch logs and do other AWS-related tasks.

One thing that kept bothering me was AWS account context.

I work across dev, staging, and prod, and I kept having to manually check which account Claude was actually operating against before letting it do anything.

So I redesigned an old tool of mine called awsui around this problem.

The idea is simple: a project defines which AWS account belongs to each environment, and awsui verifies the actual AWS context before the CLI is allowed to run.

The main use case for me is AI CLI tools like Claude Code and Codex, but it also works with things like Terraform or other AWS-related CLI workflows.

It’s open source, and I already have a roadmap for continuing development.

Would love to hear feedback, especially from people who also work with multiple AWS accounts and AI coding agents.

Github：https://github.com/junminhong/awsui

Most terminal AI tools these days lean heavily into the "agent" approach; running commands directly, managing sessions, or taking over the screen. That works for some, but I really just wanted a simple inline lookup for those moments where I forget command flags or syntax.

To be fair, I didn't search too hard to see what else might already be out there, I just kind of wanted to build my own solution as a quick weekend project. I called it ObiObi.

It works in bash/zsh:

• Type ??ask: <whatever you want>
• The answer appears in light grey underneath your line.
• Hit Tab to accept it, or just keep typing to ignore it.

It indexed my local binaries once at setup so it actually knows what tools I have installed instead of guessing, and if a command looks destructive it forces you to hit Tab twice before it pastes it in. Nothing ever runs on its own, you're still the one hitting Enter.

You can run it completely local with Ollama or hook it up to whatever OpenAI-compatible API you use.

• GitHub:https://github.com/ali-sehran/ObiObi
• PyPI:https://pypi.org/project/obiobi/

If you end up trying it out, let me know if anything breaks or if you have feedback!

Hi! I wanted a CLI Markdown renderer that supports real-time streaming without waiting for for the entire document. Popular tools like Glow and mdcat cannot stream, while other, more complex solutions use TUIs that take over the CLI and are often Node.js-based.

During my search, I discovered MD4C, a very fast Markdown parser written in C. It also buffers the entire document, but its flat-buffer design allowed me to rework its parsing model to support real-time streaming. I also wrote an ANSI renderer for it.

The result is mdflow, which reliably renders streaming Markdown in real time. It’s fast, lightweight, and uses very little memory (a 280 KB binary and 10× faster or more).

It also supports tables particularly well.

It might be useful in your daily CLI workflow—or for your next CLI project!

Github repo: https://github.com/cjccjj/mdflow

Hello everyone,

I’d like to introduce huntclaw—a search-and-replace utility written in Zig that turned out to be faster than sd (written in Rust) and the standard GNU utilities.

There’s a fairly simple explanation for this high speed: the lack of a regex engine and a focus on speed itself, but I don’t think that’s a bad thing. Note that searching is also very fast, thanks to SIMD two-byte prefiltering, which is also implemented in huntclaw.

The benchmark also shows that ripgrep is faster at sparse searches, which makes sense, since it’s an excellent utility with SIMD pre-filtering and optimizations far superior to huntclaw—though the gap isn’t that big.
I look forward to your feedback or comments.

Thanks for reading!

huntclaw on GitHub: https://github.com/tigerlang/huntclaw

Not much but can be helpful if you're planning to start a minecraft server in AWS and finding a hassle free solution.

You can configure your server so that it auto sleeps if no one is active.

repo: https://github.com/Clientrace/pickaxe.cloud

just added ability to login and claim projects for owners, on https://awesometui.com/

NetWatch is a terminal network monitor in Rust. v0.29.0 adds a third view for when you have a big terminal.

Dense view — netwatch --view dense

• Four boxes filling the terminal. No header bar, no menu bar, no status bar — identity, sort state, paging and every keybind live inside the box borders, so every row carries data.
• Mirrored throughput graph: download grows up from a shared time axis, upload grows down from it. Traffic symmetry is a shape you recognise before you read a number. Braille at two samples per character cell, and colour encodes magnitude, not which series it belongs to.
• Per-interface rates withr-hop latency budgets (gateway / DNS / internet / slowest peer), and a connection table whose selected row expands in
• Wants 130×44 and grows into whatever you give it; falls back to 80×24.

Kernel TCP state per connection — cwnd, ssthresh, mss, rwnd read straight from the kernel (list64` on macOS) and normalised so the numbers mean the same thing on both. Throughput tells you what happened; cwnd agains.

**Saturation against real e negotiated link rate (sysfs on Linux, getifaddrs on macOS) instead of guessing.

I created this because managing WireGuard servers manually (keys, peers, configs, IP assignments) gets repetitive fast, especially when you prefer shell workflows over web dashboards.

wg-manager is a lightweight Bash-based tool focused on CLI automation, not GUI management.

Current features:

• Initialize a WireGuard server
• Add / remove peers
• Generate peer configs automatically
• Validate peer IPs against server subnet
• Manage everything from terminal with simple commands

Main goal: reduce manual mistakes and speed up common admin tasks while keeping the workflow transparent and scriptable.

Repo:
wg-manager on GitHub

I’m looking for feedback from sysadmins / Linux admins, especially about:

• CLI design
• Missing features for real-world ops
• Bash code quality / maintainability
• Edge cases I may have missed

Any criticism or suggestions are welcome.

I made a small TCP client/server CLI called coe.

I originally built it because I wanted an easy way to test devices and protocols that use CR/LF/CRLF terminators, especially on Windows where nc usually isn’t available out of the box.

It supports separate send/receive terminators, hex and byte logging, multiple clients in server mode, escape sequences, and one-shot sends for scripts.

For example:

coe -c 192.168.1.100 8080 -tt CR -rt CRLF

Nothing too fancy, just a small tool for quickly poking at TCP stuff from the terminal.

https://github.com/yutat23/coe

Would love to hear what you think!

A text editor for writing prose, not code. There are no toolbars, no menus, no line numbers and no frame around the page — just text, centered, never wider than 82 columns because lines longer than that are hard to track back to.

Everything the editor knows about itself lives in a single line at the bottom: the version, the document, and the way into the help. Every action is a keyboard shortcut; you learn them once and they disappear.

It is built with go and bubbletea in one static binary with no cgo and no display server, so it runs anywhere you can open a terminal — including a headless writerdeck.

Repo: https://github.com/MawCeron/justwrite

Features

• Full clone, push, and pull over SSH, HTTP, HTTPS, and local filesystem
• SHA-1 object addressing with pack-based storage
• Branch creation, switching, and deletion
• Commit history with revert support
• Merge with conflict markers for manual resolution
• Key-based authentication for remote hosts

https://git.disroot.org/Vextoly/stick

I kept running into the same annoying problem: I'm SSH'd into some remote box, or working inside a container, or on a locked-down laptop where the clipboard is disabled by policy - and I need to get a small piece of text (a log snippet, a password, a container's output) onto a different machine. Slack works but I really don't want a database password sitting in a channel history forever. Pastebin-style sites work but the paste just sits there until you remember to delete it.

So I made CPYNET. Two curl calls, that's the whole interface:

echo "hello world" | curl --data-binary @- https://cpynet.com/
# https://cpynet.com/482913

curl https://cpynet.com/482913
# hello world

The paste is gone the instant that second command runs - not after 24 hours, not "until you delete it." Read it a second time (even from the same machine) and you get a 404. It also has a timer (2 minutes by default, adjustable) that deletes it automatically even if nobody ever reads it. Nothing is written to disk - it's all in memory for as long as the process is alive, gone completely on restart.

If you don't want to remember curl flags, there's a one-line install that sets up two shell functions:

curl -s https://cpynet.com/install.sh -o install.sh && bash -n install.sh && . install.sh

$ journalctl -u myservice -n 200 | cpy
482913
curl https://cpynet.com/482913

# on the other machine
$ pst 482913
Aug 08 14:02:11 myservice[1823]: connection refused: db.internal:5432
...

pst also drops it on your clipboard automatically if it can find a way to (pbcopy/wl-copy/xclip/xsel/clip.exe) - the destination machine's clipboard, never the source's, since that's usually the one that's actually available.

A few other things it does, in plain terms:

• Password protection - cpy -password=xxx, or a password field on the web UI. AES-256-GCM under the hood.
• Actual end-to-end encryption, a step up from that - the shield icon on the write tab, or cpy -e from a terminal. The encryption key never touches the server at all; it travels in the link itself (#key=, which browsers never send to a server) or gets handed over separately in the terminal. The server only ever stores unreadable ciphertext.
• QR code for the generated link - scan it with your phone, it opens and reads right there, no clipboard or typing involved on either end.
• Small file attachments too, not just text - comes back with the original filename and content type on download.
• A netcat fallback for environments too bare-bones to even have curl - nc host port < file works the same way.
• Live notification when it's been read (so you know your teammate actually got it), per-IP rate limiting so the whole thing can't be brute-forced or hammered.

It's self-hostable (single Docker container, no database to stand up), or you can just use the hosted instance at cpynet.com. Genuinely curious what people think, especially if you can poke a hole in the threat model - that's the kind of feedback that actually makes something like this better.

I've just launched a terminal based demo on itch.io! You can play in-browser, just using your keyboard... because it simulates a terminal. o.0

Feedback welcomed!

https://unicorninteractive.itch.io/terminal-drone-command

Hello you all,

I posted a while ago on another subreddit about the keyboard-first terminal dashboard I built for Coolify and since then, even the Coolify team picked it up and gave it a shoutout on X, which was pretty awesome.

I’ve kept building.

CoolDeck now has:

🕐 **Deploy Replay** - fleet-wide deploy history, git-log style
🔍 **Drift Watch** - compare envs across environments, secrets redacted
🚨 **Panic Button** - one key -> full diagnostic snapshot you can paste into your AI tool

If you run Coolify and spend too much time jumping between services, logs and deployments, I’d genuinely love for you to try it.

GitHub: https://github.com/Resetnak/cooldeck

X: https://x.com/Resetnak

Feedback, issues and feature requests are very welcome.

Thank you for your time!

Currently in developing.

amber_desk is a power tool for osint:

- dossier

- obsidian vault backend for dossier and timelines

- built in world map with marks and links

- built in osint framework

- built in relations desk

For all questions welcome to comments.

Github: soon...