u/trmnl_cmdr

I've never met anyone who likes writing commit messages. I find it a drag and wish I never had to do it again. So I built a tool for automating commit message generation using your existing CLI coding tool. It supports Claude Code, Codex, Antigravity, Cursor CLI, Opencode and Pi.dev so you can use your coding plan quota. It will never ask you for an API key or to authenticate, it leaves all that up to your coding agent tool.

After my first attempt building it I quickly realized I was hamstrung by the time it took to generate each commit. Since the request required a round-trip to the LLM, I had to stage my files, wait for the commit message to generate, then stage the next files and do it again. So I refined the tool to snapshot the staging area before each commit, allowing me to continue staging more files while it worked.

The result is Stagecoach, a standalone tool written in Go and designed to do one thing well.

Stage some files, run `stagecoach` and watch them get committed. Keep staging in the interim while the message generates, then run it again for the next commit.

And if you don't want to stage your files, stagecoach will separate them into multiple commits for you. Just run stagecoach and watch your work tree changes get grouped into separate conceptual commits.

By default, the commit format is whatever your repo already uses, but you can specify "conventional," "plain" or "gitmoji" format. You can specify the number of commits you want it to make, and different models and providers for different operations too.

It automatically detects the tools you have installed and writes your config files with examples for those tools, and integrates seamlessly with Lazygit as you see in the demo.

I use this tool heavily and find it saves me a lot of time and brain power so I decided to harden it to share with the community. There are similar tools out there like opencommit and aicommits, but they take a different philosophy toward commit generation, owning the entire request lifecycle and ignoring the blocking problem on a local machine. I didn't find them very friendly or beneficial to my workflow.

I built this with DX as a top priority, if you try it out please let me know what you think!

Full docs are available here.

I run a lot of sessions and usually navigate between them using SessionX, but my brain isn't so great at associating session names with the actual work I'm doing. I really love the behavior that BufSurf.nvim gives me in Neovim - it's essentially a browser's back and forward buttons for the files I've visited - and I wanted the same thing in tmux, so I built it as a tmux plugin.

Assign a key to back and another to forward, and I recommend replacing your default Prefix+L (last session) with the plugin's toggle key. It tracks your relevant sessions and toggles between the last two. And if you close one of your toggle sessions, another one steps up to take its place.

It's a very simple plugin but it's now my main method of navigating sessions, let me know if you find it useful too, or if you hate the idea for some reason (it's reddit after all) just downvote the post into oblivion.

https://github.com/dabstractor/tmux-session-history

I've been using Neovim as Pi's external editor but I kept finding myself deciding between Neovim's raw editing power and Pi's in-context autocomplete, so I built a bridge to bring Pi's real autocomplete directly into Neovim. It's a Pi extension and a Neovim plugin. If you're using Neovim as your prompt editor for Pi, you owe it to yourself to try it out.

github.com/dabstractor/pi-nvim-bridge

The title, pretty much. I had some plugins to write so I did what I've been doing a lot lately, and pointed my coding agent toward the QMK docs and asked it to make an organized set of markdown docs and an agent skill that knows when to use them.

You can use it on any agent platform that supports skills, which seems to be basically all of them now. Just clone it to wherever you keep your skills, or directly into your copy of qmk_firmware and your agent can take it from there.

github.com/dabstractor/qmk-skill

I hope someone else finds this useful for building plugins or making a new board or just modifying your keymap. Let me know what you think if you use it!

And if you find this 6 or 12 months down the road and it's out of date, please file an issue and I'll update it right away.

I noticed that even small files referenced in pi like `@file.txt` weren't automatically entered into the context (a la claude-code), instead requiring the model to issue a tool call to read the file. This is fine for larger files, but for small files, that extra tool call means a whole new request is sent, which racks up cache tokens pretty quickly and wastes output tokens on the read call.

I understand why the devs took this stance, for a tool like Pi it makes sense to default to never including file content (unless driven headless by the CLI, as they have implemented), but sometimes I *know* that I can save tokens by just injecting the file right into my prompt. In fact, many or even most times I reference a file it would take fewer tokens just to inject its contents into the prompt than it would to ask the model to read even a small part of the file.

I looked around for existing solutions and surprisingly I hadn't found anyone who built them yet.

So I built pi-file-injector. When you know you want to include the file contents, instead of `@file.txt` you type `#@file.txt` and it automatically includes the contents of that file one time at the end of your prompt. And tab filename completion still works. It's just one more small way Pi keeps you in control of your token consumption.

https://github.com/dabstractor/pi-file-injector

pi install git:github.com/dabstractor/pi-file-injector

Do you know of other tools that do this? I still can't believe I couldn't find any, it feels like such an obvious benefit. Let me know what you think!

Well, I fell in. I upgraded to the latest end4-dots today because quickshell was acting up, and that was a mistake. It was just really bad timing and I was pretty frustrated for a while. And my dev agent didn't know what to do with a lot of my custom shell scripts, plugins and weird binds I had set up. I looked around for an upgrade guide, as I'm sure lots of you have, but the internet did not yield for me this time. So I decided to bite the bullet and be the change, and set my dev agent on the task of creating an upgrade guide from v0.54 to v0.55 for itself.

It worked very well and that was the end of my surprise upgrade headache. So I'm here sharing it with you other hypr-degenerates in the hopes it can save someone else a headache too. Just load it into your favorite dev agent tool and it will do everything else.

Let me know if it saved you any time, or if you wish I had done this 2 months ago :)

https://github.com/dabstractor/hyprland-lua-migration

Agents write a lot of markdown docs.

That's great for a project's long-term coherence but it's not so great for token consumption.

mdsel solves this by letting your agent search or select semantically from your markdown files. Your agent can request an indexed overview of the document then request only the sections it wants to read, nothing more.

Use it on the CLI, as an MCP or as a Skill. It's lightweight and built from the ground up for saving tokens.

https://github.com/dabstractor/mdsel
https://github.com/dabstractor/mdsel-mcp
https://github.com/dabstractor/mdsel-skill

❯ mdsel README.md
h1.0 mdsel
 h2.0 Demo
 h2.1 Installation
 h2.2 Quick Start
 h2.3 Usage
  h3.0 Index (files only)
  h3.1 Select (files + selectors)
  h3.2 Search (fuzzy matching)
 h2.4 Selectors
  h3.3 Syntax
  h3.4 Node Types
  h3.5 Index Syntax
  h3.6 Examples
  h3.7 Index Semantics
 h2.5 Output Format
  h3.8 Index Response Schema (JSON)
  h3.9 Select Response Schema (JSON)
  h3.10 Truncation
 h2.6 Error Handling
  h3.11 Exit Codes
  h3.12 Error Types
  h3.13 Error Response Example
  h3.14 Suggestions
 h2.7 Development
 h2.8 License
---
code:29 para:29 list:5 table:4

❯ mdsel README.md h2.1-2
heading:h2.1:
## Installation
...

```bash
npm install -g mdsel
```

**Requirements**: Node.js >=18.0.0
heading:h2.2:
## Quick Start

```bash
# Index a document to see its structure
mdsel README.md

# Select a specific section by index
mdsel h2.1 README.md

# Select the entire document
mdsel '*' README.md

# Select a nested element (first code block under second h2)
mdsel "h2.1/code.0" README.md

# Select multiple sections at once
mdsel h2.0 h2.1 README.md

# Select a range of sections
mdsel h2.0-2 README.md

# Fuzzy search when you don't know the exact selector
mdsel "installation" README.md

# Limit output to first N lines
mdsel "h2.0?head=10" README.md

# JSON output for programmatic use
mdsel --json README.md
```

So I'm working on a multi-platform tool and I'm currently running it on my macbook, sitting right here in front of me, while I run about 8-10 other sessions on my linux desktop.

The linux desktop has had ZERO rate limits in the last week or so, and I've been running at least 5 sessions at a time around the clock, many with lots of subagents. I seem to be "rate limited" but in the sense that requests take a long time to come back, which is fine.

But now I'm doing some macos dev and I'm hitting constant 429 rate limits, just like I used to back in the spring on my linux machine. Even when I rebooted my linux machine and was only running 2 sessions on the macbook, I was still getting hit with 429 rate limits that would kill my session.

I'm running the latest version of pi.dev on both systems. They're both on the same network, they should have identical IP addresses, the only difference would be the OS the harness is running on. But I can barely get anything done on the mac, and the linux machine has been pumping out frameworks and libraries all month.

Has anyone else had a similar experience? What could they be doing on their servers that makes them behave this way? Any ideas? Jokes at my expense are also welcome.

I built this tool after I kept losing track of what mode I was in and getting confused by what keybinds I had available at that time. I'd try to type into my editor and instead fire off a tmux command, sometimes I'd close an important pane in the process because I was still in prefix mode and didn't realize it. I kept zooming a pane to focus then I'd have to spend a minute flipping through every window looking for the pane I was just reading assuming it was somehow totally gone, when it was actually just right there the whole time, hidden behind the zoomed one. It happened quite a few times before I even thought of it as something I could fix. Once I started using dev agents it got worse, because I could no longer just spam Escape to make sure I wasn't in prefix mode without inevitably killing my agent stream.

At some point I tried prefix-highlight and really liked it, and honestly it made me realize tmux could be customized way more than I thought, which is when this started feeling fixable. The catch is that prefix-highlight just puts a little indicator in the corner, and I kept glancing up to check it. I had been using omerxx's catppuccin tmux layout for a long time, and its UX is obviously nice, but it didn't even try to solve this usability issue I was having. What I wanted was for each mode to look noticeably different without me reading anything or looking around so it settles as muscle memory. So I built Tubular to repaint the whole status bar, pane borders and pane backgrounds in bright colors showing the current mode, so prefix, copy, and zoom each have their own look, and you just feel which one you're in. No more losing panes to the zoomies. Check it out:

https://github.com/dabstractor/tubular-tmux

If you've already got your own way of tracking which mode you're in or if you start using Tubular for it, I'd love to hear whether a full-color bar actually helps or just turns into noise once the novelty wears off. I built this for my own setup and I've used it for most of the last year, and it still brings me a deep sense of joy to watch it work. I've tested it against quite a few configs but I'm honestly not sure where it stops being compatible. Well, except for powerline, if you have a powerline status line, integration is going to take more work but it's still doable. If you already solved this mode confusion another way, I'd love to hear about it.