What are some of your favourite developer tools?

50 points by dhruvp

Developers are so opinionated that it's difficult to pin down one favourite tool !

bugsmith

Helix is my choice of text editor. For me it hits the sweet spot of customizability and great out of the box experience.

Fish is my choice of terminal shell for the same reasons. It's fantastic out of the box and requires very little adjustment to work exactly how I want it.

As I get older I'm finding I'd rather adjust my preferences to match the defaults of tools with intentionally good defaults, rather than endlessly tweak things.

Atuin is a great tool for synchronizing shell history between remote machines as well as making history contextual based on current directory or git repo. It does other stuff too, but I only use these features.

I really like Mise for a plethora of things. But mostly it's my favourite tool version manager. It's replaced my need for direnv that I previously used, and for personal projects I've slowly started integrating it into my light CI workflow.

BenjaminRi

As I get older I'm finding I'd rather adjust my preferences to match the defaults of tools with intentionally good defaults, rather than endlessly tweak things.

You also run into less bugs, because you are on the most well-tested path. It's generally a wise thing to do.
- alper
  
  generally a wise thing
  
  Customization and ricing is a young person's game. I'm too old and tired to do any of that stuff.
  - rprospero
    
    I've seen the opposite effect. The older I become, the less patience that I have for poor defaults. When I was young and had fewer responsibilities, I was willing to treat each tool as a pet and carefully cater to its own idiosyncrasies. Being older and busier, I only use software that works for me, instead of the other way around. If I can't get it tweaked into a usable state in a few minutes, the tool gets replaced by one that can be simply tweaked.
    
    As an example, a couple of year ago, I tried out the Helix editor that @bugsmith mentioned. I quickly ran into the issue that, when changing commits with jujutsu, I would need to go through an manually reload every file that was currently open in Helix, or else I would wind up editing old data. My younger self would have spent the week training the muscle memory to make those changes. Older me spent five minutes trying to configure Helix to do this automatically, saw it wasn't possible, and abandoned Helix.
    
    senekor
    
    There is a (somewhat dormant) PR by a maintainer to implement file watching based on a new crate that was custom built for the job. I'm looking forward to it. In the meantime, I have a keybind for the :reload-all command. https://github.com/helix-editor/helix/pull/14544
  - facundoolano
    
    Customization and ricing is a young person's game. I'm too old and tired to do any of that stuff.
    
    That's why I'm stuck with younger me's emacs config from 10 years ago
    
    alper
    
    If young-you did a good job, you should be gucci with that for decades to come.
  - sunflowerseastar
    
    adjust my preferences to match the defaults
    
    endlessly tweak
    
    Just want to share that these are not the only two options. As an n of 1 anecdote, I tweaked and tweaked and tweaked and tweaked and tweaked...
    
    ...and then...
    
    ...I finally got to where I wanted to be. And I rarely tweak now. (A handful of times per year, if that.) My emacs is my own Studley tool chest.
  - hgrsd
    
    Helix is really nice; it's a shame I never managed to fully get used to its selection-first model, so I keep going back to vim. I wish there was a vim-like editor that had the same out of the box experience and curated approach to functionality (I know, I can curate my own with plugins but... I don't really want to!)
    
    cohix
    
    I’ll shamelessly plug something I’ve been working on in this vein that I’d love feedback on: https://github.com/prettysmartdev/ane
    
    The idea is one-shot chords for editing that are LSP-aware. Can be executed from the CLI directly or from the interactive editor.
    
    academician
    
    Instead of maintaining my own decades-old vim config, I've taken to installing a plugin "distribution", to let somebody else manage my OOTB experience.
    
    For the last year or so I was using LazyVim for Neovim, which is very complete. I do always have to make one config tweak, though, which is to remove LazyVim's flash.nvim keybinds, which override s/S/r/R....keys I use all the time. I've never gotten used to flash-style navigation, anyway.
    
    On my new machine I'm experimenting with AstroNvim, which is a bit more stripped down, and I don't hate it. If LazyVim is too heavyweight it's worth a try. There's also NVchad which I haven't played with yet.
    
    At the other end of the spectrum - I used Kickstart.nvim for a few years, which was just a great simple set of defaults meant to be customized, but it stopped being maintained for a while and rotted (weird errors with newer versions of nvim). Looking at it again today it looks like it's gotten a bunch of updates this year, so maybe it's worth revisiting. Looks like they updated it to use Neovim's new built-in plugin functionality instead of Lazyvim, which is neat.
  - Sanity
    
    Emacs
  - fazalmajid
    
    Emacs
    
    I don't use it often, but ragel is a joy to write parsers in
  - owent
    
    I have a sysadmin background and fall very much on the side of "use the good defaults with minimal config".
    
    Two things that have made me break my habit recently:
    
    jujutsu (jj): there have been many words shared about jj on this site but honestly, it's such a pleasure to use. I never thought I'd ditch the git CLI but here we are.
    
    I've avoided learning to use/configure nvim for many years: shout out to nvchad for getting me going. Terrible name, fantastic starter config that falls just far enough (for me) on the opinionated side of minimal. Of course, I'm now writing my own minimal config from scratch...
    
    Beyond that, I write a fair amount of Python and must mention the astral tooling for being consistently a pleasure to use. Look after it, Anthropic.
  - confusedalex
    
    Actually Emacs. I started slowly moving more of my computing stuff to emacs and embracing the defaults. Emacs is really easy to customize and many keybinds just do the right stuff in every mode. Here's an incomplete list of my slow transition.
    
    Git -> Magit Email -> mu4e RSS -> elfeed Notes/TODO/Calendar -> org mode Finder -> dired
    
    Quarto is also really nice to do some quick presentation in markdown.
    
    Nix and nix-darwin for all my dotfiles
  - alfie
    
    rr (https://rr-project.org/) is a magically good piece of software that I couldn’t live without.
    
    hoistbypetard
    
    There was a time when I'd have needed that every day. Nice find! (And I'm filing that away in my second brain, so I'll hopefully find it again when that day returns.)
  - facundoolano
    
    Emacs obviously, but specifically Magit.
  - Jan200101
    
    Sublime Text is definitely underappreciated by too many people
    
    hoistbypetard
    
    I wanted to like sublime text, but the vi mode for it didn't match my muscle memory from vim well enough for it to stick for me. (I think it was called "vintage" or something.) These days I use zed in the places where I wanted to like sublime text.
  - groctel
    
    I love how mini.nvim has helped me move my nvim configuration to a fairly minimal state sprinkled with some improvements I find useful. Plus, echasnovski is a super nice person <3
    
    Even though I live in the terminal, I will always use Meld to manage complex merges.
  - Shorden
    
    Maybe this is the Stockholm syndrome talking but Nix. It's certainly not perfect but it has effectively ruined other Linux distros and (meta) build systems for me because I can be more expressive and efficient using Nix instead.
    
    Edit: Also pwntools is just a delight to work with, even outside of a CTF context (e.g. bit-banging a socket from a Python REPL).
  - gspr
    
    Honestly, my biggest developer productivity boost in the last decade has probably been had from using fzf in my shell's reverse-i-search. My memory is horrible, and embarrassingly much of my workday involves my shell history. Fzf's right amount of fuzziness really helps!
  - adamshaylor
    
    Nushell.
    
    I think it’s really easy to obsess over tools. There are so many of them! And they inspire so many heated debates and endless configuration. It can be a bit of a distraction. There are several I can think to recommend to a general audience, but for this community specifically, I recommend Nushell. Basically, if you’ve ever drooled over PowerShell but didn’t want to admit it because you don’t particularly care for Windows, this is for you. It’s not exactly analogous, but there are some similarities. It’s one of those tools I’ve been taking regular little sips of over the last couple of years, each time finding it more and more helpful, until finally I wrote a behemoth of a script to automate some workflows converting GeoPackages to PostGIS tables and PostGIS views to PMTiles. Although I would try a more streamlined approach with DuckDB if I had to do it over again, I found Nushell scripting to be powerful, reliable, and a joy to write. Nushell is elegantly designed, and with every new release (from a very active community), a bit more refined.
    
    senekor
    
    Do they have a roadmap for 1.0 ? I remember trying it out one or two years ago and my scripts broke every other release. A huge pain, and one that grows linearly with the number of scripts you write. So I stopped, and actually converted most of them back to bash. Haven't touched it in a while, probably will have to relearn it from scratch after 1.0.
  - stip
    
    Sublime Merge is critical for me. It's "just" a gui layer over git (similar to gitk), but super well done and easily worth the money for me. The UI took a little while to get used to, and some of the scripting and customization could use some enhancement, but it's great.
    
    whereistejas
    
    sumblime merge is great; i really wish someone made something similar for jj
    
    offby1
    
    I use smerge all the time dealing with jujutsu merges. If it could handle octopus merges somehow it would achieve perfection.
  - radex
    
    Nix. Yeah, there is a learning curve (it took years of being around Nix users/evangelists before I gave it a serious shot), but in the end, it's nice.
    
    Working on a lot of different projects, I got fed up with all the different tools to manage system-level dependencies. One thing for Node versions, another thing for Python versions, and so on. I got fed up with incompatibilities causing hard to debug build failures between projects. $foo is broken for Project A? Okay, update with Homebrew. Great, now $foo is broken for Project B. I'm tired of a project failing to build for who knows what reason, because the build process has so many (often hidden) dependencies on stuff installed in the system.
    
    I moved everything I can to per-project nix shells. I keep my system-level packages as lean as possible, and the project has the exact tools (dependencies, runtimes, compilers...), pinned at exact versions, without polluting global PATH or other projects. If it works for me now, I have pretty high confidence it will work in a year or five. If I want to upgrade these tools, I can do so without worrying about affecting other projects. And if I find a regression, it's easy to roll back (or selectively pin just one dependency to the old version). This works even better in projects where my colleagues also use Nix - the additional time needed to set up and maintain a nix shell is shared, and we can have pretty high confidence that our dev setups are identical.
  - mariusor
    
    I use tig a lot for the bits of a regular git flow that would require some interactivity, mostly for staging related changes in separate commits. Sometimes for seeing the commit logs and checking past individual commits.
    
    Another thing that I'm using quite a lot, but probably serves a very niche purpose, is a script that helps with coordinating Go module dependency updates. Basically I maintain a library which is composed of a couple of individual modules that have some inter dependencies and usually it makes sense that when one of those that are at the bottom of the stack are updated I need to update the others. So the script checks the go.work file and extracts the last commit hash from the working trees of the directories mentioned as replaces. Then it tries to update the corresponding module to that specific hash if it's newer.
    
    woile
    
    I've moved to gitui, but my tig is engrained in my muscle memory, so I have an alias to gitui haha
  - hsivonen
    
    Pernosco (time-travel debugging with data flow analysis): https://pernos.co/
    
    Pernosco was especially important for getting focus handling to work with multiple content processes in Firefox and for making about:blank in Firefox Chrome-compatible.
  - e_terekhin
    
    saying "vim" would be a bit boring.. so I'll say ranger as a file browser for vim (via this plugin)
    
    also tig for "better git log"
    
    also asdf for installing languages that I usee only occasionally
    
    llimllib
    
    I recommend giving mise a try in place of asdf, it's strictly better in my experience
    
    it has other features, but you can just use it as a better asdf
  - loldot
    
    Swapping out cat with bat was a very simple, high qol change for me.
    
    My most used are probably curl, jq and vs code.
    
    edit: forgot to mention ghostty and zsh which I am very happy with as well
  - ibisum
    
    cscope, vim, silversearcher.
  - hoistbypetard
    
    I've become attached to JetBrains IDEs in general, and especially PyCharm. I'm particularly attached for django-y things. The debugger is very, very good. It even works in a django REPL. It gives me all of the html/css/js niceties in django templates. I like the way its git integration works, especially if I need to cherry-pick hunks. Jumping from pycharm to clion when debugging native extensions works well. And the IDEAVim plugin is a very competent vim.
  - LeahNeukirchen
    
    My essentials for debugging: strace, extrace, perf.
  - pyj
    
    septum for interactive code search. "Find me 'triangle', 'vertex', and 'mesh' within 7 lines but without 'physics' in those lines, and without 'third-party/' or 'physics' in the path."
    
    ripgrep when I expect things to be on the same line.
    
    neovim to replace vim. I started using VS Code for simplicity, but with tooling starting to fork this (Cursor, Antigravity, etc.) I'd rather just a simpler editor I can configure.
    
    perf for analysis on Linux.
    
    I'm happy with bash, though Mac and some Linux distros are pushing zsh, so maybe switching there.
    
    Sanity
    
    Septum looks very useful! I often do these annoying combinations of grep -C10 foo | grep -A5 -B2 bar | grep ... or awk '/foo/{p++} p&&/bar/{print} /fum/{p=0}' to grep for "blocks", enough that I should probably learn some better tools...
    
    (Doesn't seem to be packaged for nix yet?)
    
    I think there was also some Plan 9-adjacent tool that did regex search without being line based?
  - samebchase
    
    Emacs (magit, org-mode, use-package etc.)
    
    WezTerm as a terminal emulator
    
    Fossil as a Wiki
    
    Fish Shell
    
    Raku/Perl for productivity helper programs
    
    OpenCode an an agent harness
    
    fzf, ripgrep, App::Rak to find stuff
    
    choose, fd (as a replacement for cut and find)
    
    TreeSheets for mindmapping
    
    (Fountain) pen and Tomoe River paper for writing stuff
    
    Krita, Inkscape to draw stuff
    
    delta, difftastic for making sense of diffs
  - azimux
    
    Not strictly a developer tool technically, but a super simple one that I love is autojump. Just let's you change the working directory in a terminal emulator by typing j whatevs and it will do a fuzzy search on your past working directory history and change to the one that is the closest match. It's one of the first things I install on a new system.
    
    Sometimes when I'm pairing with folks and I use it they are like "whoa, what was that??" and then they install it.
    
    Probably most folks on lobsters already know about it but if not it can be found here: https://github.com/wting/autojump
  - HeliumMixOptimal
    
    Command line: zsh with ohmyzsh and fuzzy completion. I like combining this with fzf for fuzzy searches, primarily interactive, I use find more in scripting. For history, I use Atuin, it allows me to search in a couple of ways (substrings, fuzzy search) and keeps track of enough metadata should I ever need that. Grep, less, the classic Unix tools are classics for a reason, I sometimes use ripgrep for additional features and speed. I want to get into zoxide for more efficient navigation but I keep putting that off, I saw merit in the ideas from a couple of tries.
    
    SQLite for structured logs or any other use case when I need a database quickly.
    
    In the GUI, I would not be able to function without CopyQ. It's a clipboard manager, I keep around 2000 entries, this allows me to reconstruct what I did in case I forgot to take the right notes.
    
    I like JetBrains IDEs, although I'm having issues with them more frequently, crashes being the most annoying. I am happy with the navigation and refactoring tools. I am using the git integration more and more, the conflict resolution is nice.
    
    All of this is to keep my cognitive load low. The more I keep in my working memory, the more I lose track of things and make silly mistakes. Automatic captures of shell history metadata and clipboard copies are very useful when writing scripts from a manual, experimental process.
  - ryan-duve
    
    My text editor
    
    My terminal
    
    Alfred, for "snippets", clipboard management and parameterized web searches
    
    My container orchestrator
    
    My web browser
    
    Any interactive prompt for the language I'm using, e.g., iex, ipython, slime/slimv, erl
    
    curl
  - amoroso
    
    hexdump is underrated.
  - anordal
    
    git revise should have been part of git if you ask me.
  - untitaker
    
    forge is shaping up to become a good replacement for GitHub's CLI, it feels faster and less cluttered, and works with Codeberg, which I'm starting to use more.
    
    fzf is great for changing paths, building quick text selection UIs, and general file searching. I use rg '' | fzf (yes, empty string) to search for text patterns like struct Foo across the entire repo. It's integrated with my shell so selecting a match will immediately produce the file and line number back to the shell prompt: vim foo.rs +123 (link to dotfiles)
    
    fastmod is great for mass-replacing, though I'm using my own clone of it
    
    hexyl and delta for viewing hex and diffing.
    
    lspmux so that multiple vim instances (and claude code instances...) share the same rust-analyzer.
  - nick4
    
    I’ve been converted into a Jujutsu user recently, and I think it’s quickly become a favorite. It’s rare that a tool can be both easier and more powerful, but Jujutsu somehow pulls it off.
  - justsitandgrin
    
    I have always been a terminal guy, so I am enjoying the CLI renaissance. But typography is equally important to me, so I have some doubts that agents will remain CLI-first tools forever. It is simply much more pleasant to consume long agent / LLM outputs with good typography (in a web browser or even in a standalone apps like Codex App). Anyhow, about the tools:
    
    Ghostty is a very pleasant terminal to use. Everyone knows it is performant, but I choose it for different reasons: it feels & works natively on macOS. Simple things like Dictionary popover with Cmd + Control + D, drag & drop, native tabs, and almost everything else just work out of the box. Plus, the attention they (he?) pay to font rendering is on another level.
    
    Obsidian. I used Logseq for the last five years or so, but in the era of AI, it is so convenient to have your notes as pure Markdown documents. Pair that with a CLI & a simple skill, and you can collaborate very efficiently with LLMs / agents. From specs to notes, it just feels right in the current age of AI.
    
    The recent addition is hunk: a review-first terminal diff viewer for agentic coders. These days, I almost always keep it in --watch mode in a split next to the working agent.
    
    Pi is my go-to agent harness. Efficient, customisable, no magic (I do not like magic, I like predictable & stable things). Codex CLI is quite good too. I still think AmpCode is the best harness out there for something that works very well out of the box, but Pi lets you replicate something similar to your own taste.
    
    difftastic is a CLI diff tool that compares files based on their syntax, not line by line. This one is very powerful & enjoyable. I have a few shortcuts in my ZSH config to produce diffs with Alt + d / D, and no other tool gives me such an easy & focused way to review complex changes.
    
    The rest is typical: git CLI, (fzf, rg, fd), Helix or Neovim.
    
    UPD: How can I forget about the mise! This tool is amazing. Simple & solid. I abuse their tasks system for plenty of things as well (project specific actions, tasks on file changes & mise watch)
    
    mdaniel
    
    it is so convenient to have your notes as pure Markdown documents
    
    A shout out to Joplin (AGPLv3) which has apps for all the modern desktop and mobile OSes, and one can use your favorite file store backend (WebDAV, OneDrive, S3, etc) and they are also just .md files. I heart it bunches. While digging up these references, I also spotted that they have a web-app, too, but I just learned about it so I haven't tried it https://github.com/laurent22/joplin/blob/v3.7.1/packages/app-mobile/package.json#L12
  - kraxen72
    
    others':
    
    lazygit - ever since i started using it, i dare to do much more complicated/advanced stuff with git, like rebasing, reverting, saving/applying stashes, branches from branches from branches, several remotes per repo, ...
    
    delta - i set it as my git pager, in combination with lazygit, i can get super fast, syntax-highlighted diffs, and in lazygit i can toggle between a side-by-side / inline preset
    
    meld - solid, fast diff viewer. for code diffs that are a part of an actual project, i use vscode/lazygit, but to quickly diff two random files/trees, it's very useful.
    
    git tree compare and git blame annotations - recent additions to my vscode setup after uninstalling gitlens. git tree compare is awesome because it allows me to quickly and conveniently self-review a PR and clean it up right in the editor, withouh having to alt-tab to github's "changed" tab in the pull request and refreshing constantly.
    
    my own:
    
    i have a (private for now) python script called utilman. it's a cli for managing system-wide python scripts. it takes all python files from a particular folder, generates bash/binary shims for them and puts those into a folder which is in PATH. so, if i have a script called gdiff.py, i can call gdiff from anywhere and it works. all the scripts use click, and if they need more dependencies, they declare them in a PEP 723 comment and then utilman generates shims which run the script with uv. it also supports stuff like auto-registering .desktop shortcuts and usage statistics.
    
    gdiff (managed by utilman) get the diff against the main/specified branch, untracked changes or latest commit, and copy it to clipboard or save to downloads. pair with any code review claude skill (add it to claude.ai), and you've got AI code review for free.
    
    histprune (managed by utilman) basically fzf's Ctrl+R but with fzf options customized to my liking, and you can also delete history entries directly from it with alt+D (e.g. if you find typos in the history, and you don't want them to pollute the search results)
    
    dcman a python cli for managing the lifecycle of podman-backed devcontainers for agent sandboxing. work in progress but i use it almost every day. i have a mostly finished writeup about it. i've been working on it since march, i think. i'll probably publish the writeup soontm.
  - dpassen
    
    These are the core of my workflow
    
    helix
    
    fish shell
    
    jujutsu (jj)
    
    mise
    
    just
    
    zmx
  - offby1
    
    Gods, a huge list.
    
    jujutsu (jj) - has completely replaced my git CLI usage
    
    emacs for every editing task
    
    mise(-en-place) to install developer tools
    
    atuin to act as my self-hosted command memory
    
    fzf to cobble tools together
    
    python and uv for all the things
  - fedemp
    
    I guess the latest inclusion to my toolbox were jj and mise.
    
    jj has been talked about here very often so not much to say. Doing rebases and ammending commits is so much fun now.
    
    About mise, it helped ditch toolbox so now I work more close to stock Fedora Silverblue. nvim, node, ripgrep and fd are available in mise registry. Before this, I had to remember to enter my toolbox just to use nvim.
  - alper
    
    Gitup (and now gg). I can't use version control without a graphical viewer (terminal ASCII visualization does not cut it for me).
  - xq
    
    Parts of my typical stack:
    
    Visual Studio Code, as it's just exactly my style of editing
    
    ASCII text,Hex,Binary,Decimal,Base64 converter, which is way more handy than one might expect.
    
    SpeedCrunch, my go-to calculator. Fast, powerful and still easy to use
    
    Video Timings Calculator , which i'm using way too often when working on video-related stuff
    
    DiffChecker is a fairly good and fast-to-use diffing tool
    
    GCC and MSVC C++ Demangler can demangle C++ symbols online
    
    Regex 101 is a "Regex IDE" that supports many different regex dialects
    
    GraphViz for generating visualizations
    
    Sanity
    
    speedcrunch is great! Another good one is Qalculate! which does currencies as well. You can use it as a web app at https://qalculator.xyz/
  - dethos
    
    I guess recently the constants by choice in my workflow are git, uv, docker compose and ssh. Most others have more or less changed in recent times, so I wouldn't qualify them as favorites.
    
    Pretty boring, I know.
  - mikejsavage
    
    I spend a lot of time in RenderDoc/Tracy/RemedyBG.
    
    RenderDoc is a really nice jack of all trades. The XCode Metal debugger does a few things better than it, but is also missing so many basic things RenderDoc can do that I hate working in it.
    
    I'm pretty sure if you had unlimited resources to make a profiler you would just make Tracy.
    
    RemedyBG is probably not as good as raddbg these days but it's very easy to work with and good enough for me.
  - llimllib
    
    I wrote my toolset up as of the new year: https://notes.billmill.org/blog/2026/01/my_tools_in_2026.html
    
    It's changed a bit since then, but not much
  - madhadron
    
    Fork, a graphical git client is one of my favorites. Besides that all my tools feel temporary, honestly, especially since I’m developing on Windows at work now after decades of Unix.
  - isuffix
    
    Typst, Jujutsu, Fish, Ripgrep
    
    I also recently tried using T-for-text (previously, 26 comments) and found it delightful for a small text processing task that replaced piping through five unix tools. Especially the interactive mode (-i) is great for learning and data exploration.
  - cohix
    
    I’ve used VSCode for so long but it’s become so bloated and sluggish and hard to focus while using that I’m trying Zed (and also trying to build my own modal terminal editor because you can do those things fairly easily these days)
    
    For everything else, command line wherever possible. git, Go or Rust for almost everything, avoid Kubernetes unless it’s absolutely needed. trying out mise but it’s taking a while to get into it.
  - xavdid
    
    just as a make replacement. It's focused on tasks instead of builds so it's not 1:1, but it's great to have a consistent interface across all my projects (regardless of language). just lint always works no matter what's actually backing it
    
    in a similar vein, my universal-test-runner is probably the command I use most on a daily basis. It's a little script that guesses how tests are run in a repo and runs them. It also passes through extra args, so it's easy to filter / skip / configure your tests without thinking too hard about it. Like just above, goes a long way to providing a uniform interface across projects. Makes iterating fast!
    
    The thing I use the most on a daily basis is definitely my Ergodox EZ. Bought it nearly 10 years ago and it works as well today as it ever has. Super comfortable, customizable, and powerful without getting too into the weeds. I use the other tools a lot, but a good keyboard is worth it in the long run!
    
    And lastly, jq. If you work with JSON on a regular basis, being able to transform / edit / filter JSON is huge. Surface level usage is good, but do yourself a favor and read the manual and really see what it can do. Exercism (which is open source!) has a ful jq track as well, which will get you comfortable with advanced usage.
    
    mdaniel
    
    My favorite part of just is that one can toggle between make's "line at a time" mode or "oh, this is gnarly, I need a full shell/python/node" mode per target. The bad news is that (last I looked) it actually writes out the embedded script into $TMPDIR and executes it, but still better than having 800 scripts scattered across the repo
    
    I wish they had adopted any one of the infinite existing template libraries instead of rolling their own, because it makes the uncanny valley of "wait, what is fs.exists again?" needlessly hard
    
    At $DAYJOB there are a lot of folks who swear by Task (MIT) but I find its yaml to be one step removed from what I really want to happen, however it also seems to be more batteries included if that appeals to you e.g. https://github.com/go-task/task/blob/v3.51.1/Taskfile.yml#L188-L233
    
    mdaniel
    
    Also, a plug for gojq (MIT) which for me wins hands down over native jq in two ways: the error messages are night and day better, and gojq supports reading yaml so you get all the jq muscle memory you crave but can apply it to either tree without the context switch of learning how yq does things. Bad news, the yaml mode has an insane cli flag of --yaml-input which ... WTAF when -y was sitting right there
  - lukasl
    
    I made an experiment a few years ago, got myself a Chromebook as a backup device, and to my surprise, I'm quite OK with programming it. I guess that proves that the only tools I really need are vim, bash and the compiler for whatever language I'm using.
  - toastal
    
    Neovim for editing
    
    Fish for interactive shell
    
    Darcs as a version control system
    
    XMPP for communications (Biboumi as an IRC gateway)
    
    Topiary for formatting were supported
    
    Nix for building
    
    biased, but I truly do like Nixtamal for my Nix input dependency management
    
    I use all of these daily
  - paulocuambe
    
    Vim
    
    Tmux
    
    Both without plugins and elaborated configs. For Vim I just enable line numbers and relative line numbers. Vim is my favorite tool.
    
    I’m not old yet, but I share the sentiment from @bugsmith:
    
    I'd rather adjust my preferences to match the defaults of tools with intentionally good defaults, rather than endlessly tweak things.
    
    I want to touch any computer and be immediately productive in it, so these two for me work very well with the defaults.
    
    I know some people are anti terminal multiplexers, I’m sorry guys, I really love Tmux.
    
    One not so popular opinion is that I hate OSX for software development. If you give me one I will install a virtual machine and work in Unix environment other than OSX.
  - kingmob
    
    Jujutsu, mise, Sublime for fast text editing (or super-huge files), Raycast, Warp, Orbstack, Meld.
  - thasso
    
    My go-to dev toolchain for hobby projects is Vim (editor), Bash (shell), Grep (code search), GCC (compiler), and Make (build tool). It’s boring but dependable. Unfortunately, there are too many consonants in VBGGM to arrange it into an abbreviation that sounds nice.
  - JayGray
    
    notepad++
  - binjip978
    
    jfmt a small tool for printing unsigned numbers in binary https://github.com/dancrossnyc/jfmt