Improved Git Diffs with Delta, Fzf and a Little Shell Scripting
nickjanetakis.com
nickjanetakis.com
Even better is using it via jjui, a fantastic TUI for jj vcs
ah, it's using tree-sitter to not bother reporting changes that have no effect.
That's very nice!
Now, of course, the biggest issue is that our DVCes still are from the paleolitic era and store source code as non-structured text files instead of trees, so we need to the proper thing "outside" the DVCS (which is using tools like diffstatic / tree-sitter: tools that have seen the light).
It's basically the old "tabs vs space" and "tabs = how many spaces?" and "bracket on the same line or not" discussions all over again. I'm pretty sure I've got comment from 15 years ago saying that in a proper world this shouldn't even be a concern because this should purely be a client-side concern, on the dev's machine. And that the DVCS should have a specific representation, not opened for discussion (a code formatter for example, but ideally just the source code already as a tree). And then no more bitchin' about tabs vs space, about how many spaces is a tab worth, on which line brackets should go, etc.
Don't get me wrong: it's great that people are doing the right thing. But it's still a kludge that's needed because the underlying tool were made by us and for us cavemen and really could have been oh so much better.
Also git can be made to ignore whitespace changes (a source of noise) and can refine a hunk to highlight what has changed. That’s plenty enough for most people.
Instead of showing you which syntax nodes changed, it shows you which functions, classes, and methods changed, classifies the change (text-only, syntax, functional), and walks a dependency graph to tell you the blast radius.
The delta + difftastic integration problem in that issue is interesting because sem already has the pieces both sides need, before/after content with full context for every changed entity, plus structured JSON output. The blocker in #535 is that difftastic's JSON doesn't include surrounding context. sem's output includes complete entity bodies by default.
Would love to collaborate on a common interchange format if anyone from the delta or difftastic projects is interested. Entity-level granularity sits naturally above AST-level diffs and below file-level diffs, and having a standard way to represent "what changed and what depends on it" would be useful for the whole ecosystem.
I love the simplicity of using existing tools in this post. It would be nice to have something similar that would allow for adding online comment threads on a diff, and output it to a simple markdown file. Of course, I'm thinking about a local agent workflow here.
Claude spawns the process, it pops open a browser tab. You review what is there and can leave line by line feedback. You click finish and your comments go to stdout for Claude to read.
We ask Claude to group changes and order them by importance to make reviews easier for us.
A lot of posts like this are making it to the front page of HN now that new people are exploring this world for the first time. That's great, the more the merrier, but gets a bit frustrating when a post title is written as if it's discovered some new awesome development tool or methodology, and it's just something people have been doing for years or even decades. This post isn't that big of an offender, but I'm thinking more of stuff like this [0] that it reminded me of.
I should try to be less grumpy about it, but I hope people also try to recognize how often these "new" tools they've been discovering have been routinely used long before LLMs. Maybe I'm just hitting my get-off-my-lawn stage, but it's a bit jarring to come to hacker news and see upvoted posts that are just "look, I can color the diffs in my terminal!". I'm glad this person discovered it, but I thought that was table stakes for the community here.
There are pros and cons to each. Vim can do some neat things, but GUI based IDEs are generally useful and easier to use out of the box for development.
The terminal tools are getting popular because people don’t need to do development. Claude is doing the development task. People just need to quickly review code in terminal.
Vim and other terminal tools make doing complex text manipulation easy, but I rarely need to do anything complex when writing code.
I also work from different machines and ephemeral vms regularly and don’t want to spend time setting things up each time.
I can install vscode and the one lsp plugin I need in under a minute. In contrast, Vim doesn’t even have line number enabled by default.
And I work on different types of systems, which have different requirements and different ways of installing these tools.
Yes, there are other tools to help automate this process as well, but vscode “just works”
1. You very frequently have to install your setup from scratch.
2. Preconfiguring something that aids in installing from scratch is not viable or sensible. (Perhaps you work in an environment where you're not allowed access to your personal dotfiles repo, for example.)
But I think most people will fail at least one of these checks.
This is true, they are much better for discovery and affordance, but as you progress with your tooling and tool usage there is a much higher ceiling on your productivity with other tools and their composability. In my opinion, not putting effort into learning tools ultimately holds a lot of people back from their potential.
They make some parts of text manipulation faster, but those parts of text manipulation take up less than 1% of my time spent working.
Things like debugging, which take up a large portion of my time, are not so nice in terminal based environments
But find a terminal first approach leads me to other tools like curl and jq usage as I go. I see coworkers using a ton of time trying to repetitively execute the code to see those spots in really inefficient ways. And end up completely lost when they could be using tools like git bisect.
Or another good example devops type support is if one web server out of many seems to be misbehaving, I can use aws command line to get internal ips behind the lb to curl to grep and find it in minutes after others have tried for hours. It makes it second nature if your mind goes there first.
As always, the “best” tool is the one your most familiar with that gets the job done. Text vs GUI doesn’t really matter at the middle of the bell curve.
What exactly is the "ceiling" for GUI based IDEs?
Versatility. In most TUI editors, running an external commands is easy, including piping a part of the text and receiving its output. As this is a fundamental unix principle, there’s basically no barrier between what you’re editing and other data on your system. In GUI, everything is its own silo.
Presentation. Code is not linear, but most gui forces use to use one window to see your text files. And when they allow splitting it’s cumbersome to use. Vim and Emacs has a easier way to divide you screen so that the relevant information can be presented at once. And there’s terminal multiplexers for simpler editors.
But, I think the main problem is that although there have been many attempts we have not gotten to a standard way to compose different GUI tools easily or repeat actions.
I would say that GUIs are superior for a few specific use cases, but otherwise sub par. Step through debugging comes to mind as a good GUI use case, but even that I'm not sure if it's because a GUI is inherently better, or making a terminal based debugger is harder and so nobody has made a good one yet.
What specific ways do you find boost your productivity the most?
For me, the things terminal workflows can do faster take up almost a negligible amount of my workday.
Curious to hear if I’m missing out on a terminal workflow, or if my workday is just very different from yours
Hi, I'm the author of the post.
I don't like replying to comments like this but I think it's important because of how "invasive" LLMs have become and how they might jade your opinion (not you specifically, but everyone) on any type of output such as blog posts, videos, code, etc..
I wrote about this because I've done contract work for lots of companies, spoken with lots of developers and every time they see the output of Delta they are like "how did you make your git diffs look so cool?", so I thought it was worth sharing because there's lots of folks out there who might not know about it.
By the way, this concept of having a terminal based workflow is something I've openly been using, sharing and writing about for around a decade. There's 500+ posts and videos on my site covering a ton of different topics.
You're more than welcome to explore any of the 70+ open source projects I maintain https://github.com/nickjj?tab=repositories, with git histories going back well before LLMs existed. Thousands upon thousands of human written lines of shell scripts, Python scripts, Docker set ups, etc.. Every readme file was written by hand and 99.999% of current day code is by hand too. I've been playing with AI to learn new languages like Lua to solve specific problems but I end up rewriting most of that code afterwards. You can view comments I've made on HN in the past in how I feel about LLM code haha.
On one hand I'm really glad more people are coming over. There's been an explosion in TUIs and it's helping that people understand how important UX and visual design is.
On the order hand I'm annoyed as things move from unix philosophy and it feels like people are just trying to make terminals GUIs. The beauty of the CLI is its power. I'll give up the UI because it is so powerful. The learning curve is steeper but it's not that bad once you get used to it. And since so many people go through the same experience there's a shared language across many different tools.
Maybe an obvious example of that is how people conflate "vim mode" with using hjkl for movement. Even `set -o vi` in bash is more rich of an experience than what many people think "vim mode" should mean, at least to a vim user. But lots of that shared unix language is getting lost and I'm not a fan of those tools
git config core.pager /usr/share/git/diff-highlight/diff-highlight