New Age Tools

📖9 min read

Developer tooling that goes beyond the basics, and what I've used for over a decade.

Developer tooling that goes beyond the basics, and what I've used for over a decade. The tools I use aren't new, or super fancy or anything explicitly tied with AI. But I've found them very effective and use them on all my machines. Recently, I started re-building my dotfiles repo, and it made me realize that going over my current "terminal workflow" might be an interesting read, as its very unique to me. So lets hop in and see what tools I've been using to help me stay productive and look cool in the terminal hehe, but first lets jump back to my college days.

Origin story

Back in 2015, I was a few years into college working on my computer science degree. I was through a few classes and wanted to get more "involved" with development and technology in general. One thing I thought would help me accomplish this was to move completely to linux. The had another benefit in that the laptop I was using at the time was aging, and feeling pretty slow day to day. So the hope was wiping out windows and installing Linux would give it a little more legs.

So I grabbed my old 15 inch "Samsung MK1 brick", and a spare USB and went through some tutorials for installing Ubuntu and didn't look back. After a weekend of troubleshooting, I was completely on Linux. I didn't realize at the time, but this experience would indirectly lead me to all sorts of things I'd need to learn and use in the future, simply by forcing myself to pick it up due to the switch. It was "basic" stuff like learning how to use the terminal for basic day to day tasks like moving around the file system and writing and editing files.

After essentially forcing myself to learn linux or "drown", I shopped around different distros, different terminals and different tools. All to find stuff that not only looked cool, at least to me, but to also learn what was out there. I spent a good year using terminator and transparent terminals to take notes and review the slides on my laptop at one time. Eventually I was able to upgrade away from my "Samsung brick", and again made it a goal to use linux full time with my newer laptop. I stuck with Linux for a number of years until wanting to simplify my life and moved to Windows 10/11 with WSL2. I've kept linux around in dual boots but found I never entered them enough to justify it. That said, with WSL being mature enough to work more or less full time in it, while still having access to a linux environment, its a nice "best of both worlds".

Around the time I got this newer laptop, I ran into some of the "core tools" I started to pickup that I still use today.

Those tools are:

• Vim
• Tmux

To be completely honest, I felt like a hacker using a multitude of terminals with all these fancy gizmos. I even used it heavily during my on C programming class, and felt not only like a real coder, but a "cool" one lol. It was useful to get used to these sorts of tools, even for basic usages like what I was doing, but I wasn't actually doing much more than just leveraging the terminal for tasks I could use a GUI text editor for. I like to compare the level of commitment to that of using something like notepad—useful but nothing fancy.

Inbetween years

I eventually moved on from these tools for anything but basic usage. My Tmux and Vim setups were never too fancy or tricked out. There was a point where I had tmuxline+airline configured, but one problem I always ran into was integrating it with my different computers I'd use. Even in college I had 3 different laptops I'd use ("the brick", the main laptop, and in my last year I purposefully swapped to a chromebook), this didn't include any of the random raspberry-pi I'd buy to play around with as a basic server/terminal, or my main desktop computers, which I didn't do much development on, but sometimes did. The end result was either trying to share a common config between all of them through a dotfiles repo, and then dealing with it exploding on my newly minted raspberry-pi, or trying to configure each manually.

Because setting up and integrating these tools was too annoying between these different systems, I kept my Tmux and Vim setup pretty small, I never even made the jump to Neovim until a few years ago for a similar integration issue. So my config stayed more or less the same for about a decade (!) I only used Tmux to run dev servers, or individual tasks like git, and use Vim kind of like a notepad, only for basic edits like git commit messages. I was using Atom and later VSCode once I got into TypeScript development, and I never really looked back. VSCode did all the "actual work", up until I started gaining access to "agentic IDE" tools such as cursor (which is honestly just VSCode with some other features).

Jumping to today

So this brings us to today. I finally have invested some time into my setup, and like most things, this has been largely possible only because of AI helping me grind down on some common issues, and saving the "brain juice" for the direction, rather than the syntax. That said I had a heck of a time with the current setup, even with it being only a week or so old. That said, I enjoy it thus far. So here it is:

• Tmux - still going strong!
• Helix - replaced Neovim, more user friendly, easier to tweak and jump between files, still using as a reviewer
• bash - I tried out zsh and fish shortly but I never could justify it enough

A few other things I've integrated into the "terminal tooling flow" I picked up over the years are:

• github-cli - work with git without leaving the terminal
• copilot-cli - leverage AI/copilot without leaving the terminal
• starship - cross platform prompt, useful out of the box without me tweaking anything

tmux today

Tmux does the same job as it did years ago, with it being one area that I've invested the most into as of late. The job is the same, but how I went about it is completely different. Namely, I removed a bunch of stuff I had setup originally to focus only 2 things:

• window management
• session management

I have a few other things I'm currently looking into tweaking/improving, but I largely removed stuff like:

• hostname/user name (actually going to make a comeback!)
• git information
• computer information - I got fancy with battery level/CPU usage/time/etc
• random scripts for statuses - these broke when I jumped machines, and never bothered to fix them lol

Helix

I've used Vim for years, but never got pasts the basics simply because I could never devote enough time or effort to learn it and keep track of it. There was multiple times and attempts for learning and trying to go from "notepad" levels of usage to more and I just couldn't get over the hump.

I was suggested Helix by someone, as I was searching for newer age alternatives, and Helix fits the bill. It follows similar philosophy as Vim in usage, but the actual user experience is miles ahead. With the main "features" being forefront, such as file searching and finding, all with helpful popups showing what other options there are.

There's also pretty sensible defaults out of the box and a simple way to configure its status line. I mixed in some copilot magic to make the them almost match my new simplified Tmux config, and have been off to the races.

Sticking with bash

I tried out zsh, and even tried to use fish a few times over the years but I just don't see much benefit. I'm at a point where I want simplicity over any specific features.

AI is the reason

Like most posts I write about now, this all circles back to AI. On my personal machine I largely use just copilot-cli due to its integration with VSCode and github. With Helix managing the "review" and all this occurring in different Tmux windows/sessions, this setup runs great, while staying out of the way. That said if I need to code a lot myself, I still keep VSCode nearby.

But VSCode still is around

I still use VSCode for a majority of my personal work, and haven't fully moved away from it even with all these terminal tools. I go for it every now and then, but if I have a lot of work lined up, I stick with what I'm used to. That said, all the work I have for this blog is now being written in my new setup!

The tooling

The last thing I changed was I built my "installer" in native typescript+nodejs so I can review it easily. This installer is a CLI app that allows me to do stuff like backup, install, verify, and even see the difference between whats on the current system and what I have in the dotfiles repo. Its always a WIP like most of my projects, but thus far has been working great!

Wrapping up

Looking back at this decade-long journey, what started as a college experiment with Linux has evolved into a refined workflow that balances productivity with simplicity. The key lesson I've learned is that the "perfect" setup isn't about having the fanciest configuration or the most plugins—it's about finding tools that work reliably across your systems and get out of your way when you need them to. AI has been the catalyst that finally helped me invest the time to refine this setup, and I'm excited to see where it goes from here.

The dotfiles-2 repo

Here's the repo if you want to take a look! repo