I was recently looking for a new personal finance app. Nothing fancy, just something to track income, expenses, and give me a clear picture of where my money goes each month.
Ever since I got my ThinkPad, I've been on a bit of an open-source roll; I switched to Linux, installed LibreOffice, and I self-host my task management with Vikunja. Once you start pulling that thread, it's hard to stop. So naturally, whatever finance tool I picked had to be open source too.
That's how I found hledger.
hledger is a terminal-based, plain-text accounting program. There's no flashy dashboard, no cloud sync, and no monthly subscription. You write your transactions in a text file, and hledger reads that file to generate reports, balances, charts, whatever you need. Both the settings and the data are stored in plain text.
And honestly? It's one of the best pieces of software I've ever used. It got me thinking about why we abandoned text-based programs in the first place, and whether, in the age of AI, it's time to bring them back.
Why text-based programs are underrated.
They're AI-native by design.
Let's start with the obvious: plain text is the perfect format for AI. Large language models don't understand dropdown menus, they can't click buttons, and in general, have trouble using GUI's, but they can read and write text files all day long.
When I set up hLedger, I needed a rules file to tell it how to parse my bank's CSV exports. Instead of spending an hour reading documentation, I pasted a sample of my bank statement into Gemini and asked it to write the boilerplate. It did — correctly, and on the first try! There was no API to figure out, no GUI to screenshot and explain. Just text in, text out.
This is a massive deal. As AI agents become a bigger part of how we use computers, the programs that will work best with them are the ones built on formats that AI already understands natively.
Screenshot of an hLedger Journal text file. You can just open this in your text editor.
True Ownership and Portability
When your data lives in a plain text file, you own it in the most literal sense possible. There is zero vendor lock-in because any program on any operating system can read a text file. You could open your financial records in Notepad if you wanted to.
This means there's no risk of losing your data if you stop paying — because you're not paying for anything in the first place. There's no risk of losing your data if the developer abandons the project because your data doesn't live inside the project. It lives in a file on your hard drive. You can see exactly what happens to your data at all times because you can open the file and read it. And if you want to run the whole thing offline, disconnected from the internet entirely, you can. Nothing stops you.
Compare that to most modern finance apps. Your data is on their servers, in their proprietary format, behind their login wall. If they shut down, raise prices, or get acquired by a company you don't trust, your options range from limited to nonexistent.
Radically Lightweight
hledger is about 40 megabytes. Forty. Most mobile apps are bigger than that, even some websites are bigger than that.
It barely uses any energy, it doesn't need a GPU, it doesn't need 16 gigs of RAM, and it doesn't need a persistent internet connection phoning home to some server farm. It runs on essentially anything: an old laptop, a Raspberry Pi, a decade-old ThinkPad you bought refurbished for $150.
There's something genuinely democratic about software this light. It doesn't demand that you buy expensive hardware. It doesn't punish you for not having the latest machine. It just works, quietly and efficiently, on whatever you've got.
Endlessly Customizable
Because everything is plain text and command-line driven, you can build whatever you want around it. Write a shell script that automatically imports your bank statements every morning. Pipe the output of one command into another. Build a custom report that does exactly what you need and nothing else. There are no walled gardens, no plugin marketplaces, no waiting for a feature request to get upvoted enough for the developers to notice.
The program does what you tell it to do. If it doesn't do something you want, you can make it do that thing. That kind of flexibility has always been the promise of the command line, and it remains unmatched.
This is an example of a rules file in hLedger. This is all you need to automate a big part of your workflow. As you can see, this can easily be generated using LLMs.
And let's be honest — it looks cool.
I'm not going to pretend this isn't a factor. There's an undeniable aesthetic to terminal workflows. Green text on a black background, cleanly formatted tables, no visual clutter — just information, presented plainly. The hacker mystique is real, and it's a perfectly valid reason to enjoy using these tools.
Why we left the terminal behind.
So, if text-based programs are this good, why did we move away from them?
Two reasons, and they're both legitimate.
First, they're hard to navigate; you have to know the commands, you have to remember flags and options, there's no menu to browse, no tooltip to hover over, no undo button that's clearly labeled, and no visual cues to point you in the right direction. The learning curve is steep, and for most people, that curve was never worth climbing.
Second, they're slower for casual use. If you just want to check your balance, opening a terminal, typing a command, and reading the output is objectively more steps than opening an app and glancing at a number. GUIs won the usability war, and they won it for a good reason. Pointing and clicking is intuitive in a way that typing commands is not.
For decades, these two drawbacks were enough to keep terminal programs in a niche, beloved by programmers and power users, ignored by everyone else.
Why AI changes everything.
Both of those drawbacks, the navigation problem and the speed problem, are exactly the kind of problems that AI is good at solving.
You don't need to memorize commands if you can describe what you want in plain English and have an AI figure out the right command for you. You don't need to learn the syntax of a rules file if you can paste an example and ask an AI to write it. The learning curve doesn't disappear, but it flattens dramatically. AI becomes the translator between your intention and the program's interface.
And the speed problem dissolves, too. AI agents can read, write, and manipulate text files faster than any human can click through a GUI. When an AI agent is managing your workflow, the most efficient format isn't a graphical interface designed for human eyes; it's a plain text file designed for machine readability.
The old trade-off — power versus ease of use — was real for a long time. Terminal programs gave you power at the cost of accessibility. GUIs gave you accessibility at the cost of power. But when an AI sits between you and the program, that trade-off collapses. You get the power of text-based tools and the ease of use of natural language. You get both.
It's already happening with markdown.
In fact, we're already seeing this shift happen with markdown. A few years ago, markdown was mostly a developer thing, and now, it's everywhere! AI chatbots respond in markdown by default, note-taking apps have rallied around it, and documentation platforms are built on it.
People are quietly moving away from proprietary document formats and back to plain text with simple formatting, because it's easy for AI to read and write, it's easy for humans to read and write, and it opens in literally anything. Markdown didn't suddenly get better; the world just caught up to what plain text always had going for it.
Where Is This Heading?
In the AI age we are entering, there is undoubtedly a case to be made for text-based or text-focused applications. However, I understand that the switch back to terminals would be too daunting for a lot of people, and GUIs are just a really nice and intuitive way to interact with an application.
That's why I want to propose something in between: applications that are text-first but have a GUI option. You also see this with hLedger, the default way to use this program is through the CLI, which, in turn, uses the plain text files with settings and records; the engine is fully text-based. However, there is an option to launch an easy-to-use GUI.
So everything can be done through solely text and the CLI, but you don't have to; the best of both worlds. Agents can use their preferred method of interaction (text), while we humans can use ours (GUIs), while keeping all of the benefits of text-focused.
If you haven't revisited the terminal lately, now might be a good time to start. Not because you need to become a command-line wizard, but because you might not need to be one anymore.
Want to read more of my thoughts? Visit my blog!