Varun's Musings

Year of Varun #21 - A Retrospective

Sat, 19 Apr 2025 00:00:00 GMT

I’m 22 today. Happy one year closer to death¹ for me! I’m already a fifth of the way through my 20s, that’s wild to even think about.

I’ve wanted to start doing a retrospective (retro) on life each year, almost like a New Year’s post, but on my birthday. Kinda cliche, but it’s gonna be less “New Year’s Resolution” and more personal reflection.

My 21st year of life has somehow been both uneventful and eventful at the same time. Let’s look back on what’s been going on thus far.

Deconversion

This one’s probably the most important event to me, personally.

I formally renounced Christianity from my life on July 7, 2025, when I left my church. I had already been atheist for at least a year up to that point, but remained in the church out of fear that I would lose my job, since it was based on building a faith-based platform for connection. I didn’t agree with the objectives while I worked there, but I silently participated and just kept my mouth shut, so I could continue paying for school; it just became unbearable after a while.

Interestingly enough, almost no one has contacted me from there since then sans a few friends that I had already told the news to. It’s almost irritating (but also a little liberating) to realize that no one really cared, since it means I can cleanly put that era in the past. But it also means I was used; I volunteered almost every single week, you would think someone would notice. But nah. That was the irritating part; being a simple asset to them, and not a human² worth talking to outside of “serving”.

Sometimes I really do think about the times that I used to play drums with people that I loved talking to, and all the things that I believed. It only gets more nostalgic every time I drive by the place, since I haven’t really done many drum gigs since then. But more on that later.

You can read my deconversion post about it if you’d like to know about why I renounced my faith.

Burnout/Job Hell

I went through two large periods of burnout last year. It wasn’t fun at all; I’m sure most people that have gone through burnout, if not all, would agree with me here. My first one was right around this time last year from April-May 2024 at the end of my Spring 2024 semester, and I had another one that lasted much longer from November 2024-February 2025.

Burnout is hellish, especially when they last for extended periods of time like mine. I didn’t feel like getting out of bed, like eating, like doing anything at all, even though I knew I needed to. Tickets and fulfilling work tasks? Down the drain. Projects for school? Down the drain as well! Especially when ADHD paralysis hits, and you’re just sitting in bed, feeling like you’re enslaved by the grips of YouTube and Reddit and Hacker News on your phone, and you want to throw your phone across the room to stop. It’s genuinely claustrophobic at times, and it feels like nothing can help but escapism through various means³.

It doesn’t really help that I ended up basically quitting my church-based startup job at the beginning of August 2024. It was not working out financially anyway, and the faith issues I mentioned earlier only made it inevitable⁴. After that, I went through an unemployment stint until November 2024, and briefly worked at another startup until I lost my job yet again in January 2025. I have not been able to find a job since then (as of the time of this writing) because the job market is that hellish. Crazy, right? I like to think I’m a pretty competent person, but not being able to hold jobs because of burnout gives me massive bouts of impostor syndrome, and some days I feel like genuinely committing suicide because of it. But I digress; good times will come some day, right?

New Projects, New Friends

Not all has been bad, though.

I’ve made a ton of new friends, mostly at San Francisco State University (SFSU) through various classes and at their Computer Science Lab. While I was funemployed⁵, I managed to carry an entire semester’s worth of people on my back, running an underground tutoring service for an operating systems principles course that I was also taking at the same time in Fall 2025. I made almost $1,000 too! By far one of the best classes I’ve taken in a university setting, thanks to a great professor. I also started really talking to people working on various projects like a game engine from scratch, among other cool things. And I’m building a car right now with some of them for my embedded Linux class! Exciting stuff. And I’m not afraid of working on large projects that seem out of my pay grade anymore, especially after watching this great low-level source dive YouTube series, so that’s a plus.

I’ve been doing open source contributions as well. I’ve continued to work on my NixOS CLI, and am almost done with a full rewrite of it from Zig to Go that I’ve been doing solely while riding BART to/from university, so I’m not done yet. But I will be soon! I’ve also slowly been increasing my contributions to various Nix ecosystems such as nixpkgs and home-manager. My goal is to become a committer to these places in the future, and I would also like to participate in Summer of Nix this year, if possible.

Basically, all I’ve been doing is just improving the open source world, and honing my own skills while I’m at it! It’s really enlightening, and I hope that others can read from it.

Graduation

I’m a month out from graduating with a bachelors in computer science from SFSU. It’s surreal; I don’t plan on pursuing a master’s so this is gonna be my last month in school. While I’ve been working at various startups my entire time throughout college, I can’t imagine not going to school anymore.

Like, where the hell am I gonna make new friends? I sure as hell can’t do it from my computer, I tried making friends online during COVID and it didn’t fucking work at all.

What’s gonna happen to my old friends that I’ve been making? I don’t want to lose them because we’re not in the same place anymore.

Will I have time to start making a life for myself? Because hell if I want to move out, have you seen the fucking rent elsewhere? The Bay Area is a goddamn expensive place to live in, and I’m still looking for work! I’ll stay with my parents, thank you very much.

I plan on flying to India for a time, to see my family there. My grandparents and cousins are all over there, and I’ve never been able to see them for more than a month at a time. I’d like to change that. But what comes after that?

There’s a ton of questions I’m gonna have to answer, and rather soon. Because I definitely can’t deal with two more years of school, that’s for sure. But I’ll be sad when it happens.

What’s Next?

Well first off, I want a job, as I mentioned prior. It sucks being funemployed. Here’s my master resume, in case you’re reading this and you’re hiring. Plus, I would need money for all the things I’m about to mention next.

I mentioned earlier that I don’t play drums as much. That’s true, unfortunately. So it seems, that:

I’ve lost the plot.

I wanted to play drums for a living, but now I’m just stuck trying to make a career in tech. This sucks, and it genuinely makes me wonder what I’m doing it all for in the first place if I’m not gonna practice the one thing I’ve enjoyed my entire life.

It all went wrong when I left the church. I had already not been practicing, but that was because I was in a death spiral of using my church gigs as practice time, since I ended up playing so-called “contemporary Christian music” that I fucking LOATHED⁶. When I left the church, my practice came to a screeching halt.

I plan on doing better in this regard. Even though I’m busy now, I will have to force the time back in. It won’t be fun at first. I’ll be throwing my sticks at the wall, wondering why I don’t have the same speed, the same skill. But it’ll all be worth it in the end, I hope. Let’s see in next year’s retro if this is the case.

On a different note, one of the newest aspirations I’ve had recently is because of the 2024 US elections. I no longer want to stand back and see it all burn down while not lifting a finger to stop it. I’ll either see this through, or die trying.

I want to get into politics.

I don’t know how, or where I can get started, but I will, eventually. As much as I hate electoral politics, I see no other options for my political ideas to start reaching a wider mainstream. And the populace is hungry for fresh ideas, because the LORD knows that we have not had any in centuries, it feels like.

There’s a lot more I can say about this, and I’ll probably write a post about it too. But I’ll leave at that for now. The TL;DR: I have dreams, and I want to ensure that I can fulfill them reliably. Seeing how fucked the current state of politics in the US is, I fear that this may not be possible unless I do something about it. This requires candor. Revolutionary thought, even. Let’s go where no one has dared gone before. Think new thoughts that no one has ever thought. It’s all possible, we just need the time to see it through.

Here’s to a new year, and new aspirations.

Footnotes

I do this as a joke with my friends when I say happy birthday to them. Or “happy one year closer to the apocalypse!” A way to kill the mood, sure, but at least it’s different and turns some heads, right? ↩
Like “Human Resources” at a company. It seems uncanny to me that people would even refer to other humans as “resources”, but that’s precisely what it felt like at the church. I don’t think anyone likes being “used”, but a lot of religious people definitely are being used in a sense; that included me at the time. ↩
Oftentimes, I would smoke weed or have a little drink before working on things for an extended period of time. It would help me to not overthink or have anxiety about things, but I recognize it’s an extremely bad habit. I’m remaining sober and off drugs for the time being, so I am not addicted or anything. I just want to re-evaluate their place in my life after a break. ↩
Turns out that the company that I was working for previously has rebooted into some other faith tech thing called Seedling. Well, even though I can probably go back, I am not interested in this sort of thing in the least, and I have no desire to work on things I don’t agree with. Prayer is placebo, as far as I’m concerned. ↩
Yes, I call it funemployed instead of unemployed. I get to work on myself, and I also get to make things! Gotta make the most of having no obligations to some capitalist scum, right? ↩
Yeah, I hate playing this style of music. It’s so generic, South Park even made an episode about it. On the other hand, Loathe is an amazing band, listen to I Let It In And It Took Everything and be enlightened. ↩

Hello, World!

Mon, 01 Apr 2024 00:00:00 GMT

This is mostly a test to see if things are working. If things aren’t working, something is horribly wrong, so send me a message! Of course, I want people to read what I’m saying, right?

I love using Markdown for posts, but more often than not, it has its shortcomings as a language. I often use neorg inside neovim to write my posts, and then convert them to Markdown after that. It has great support for a lot of things, but it’s still beta-quality software. However, if you use neovim, it’s worth a try.

Code Blocks

{
   Damn = "you use Nix?";
   Yeah = "I use Nix";
   "That's" = "so cool!";
}

const std = @import("std");
const print = std.debug.print;
const testing = std.testing;

pub fn main() !void {
    print("Whoa, you use Zig?\n", .{});
}

test "1 + 1 = 2?" {
    const actual = 1 + 1;
    testing.expectEqual(actual, 2);
}

const eww: () => void = () => {
  console.log('Eww, TypeScript.');
  console.log("At least it's not JavaScript.");
};

Thanks

Thanks for reading this! Why did you read it though? Are you seriously that bored?

Do something better with yourself, haha.

Fin.

SourceHut: Git Done Right?

Thu, 25 Dec 2025 00:00:00 GMT

God, I’m sick of GitHub.

Where did it all go wrong?

I started coding professionally in 2020, and learned how to use Git for the first time the year before. As many new GitHub users think at first, I thought GitHub was the only way to use Git, and never even considered the fact that there are alternatives.

In September 2025, I had enough of this, and moved all my repositories to SourceHut.

But why would one even use an alternative Git hosting service?

Why I Switched

Consider 2020-2022 as my Git honeymoon. I used to create a GitHub repo for EVERYTHING. Hell, I still do. My CS homework? The very first thing I did at the start of each semester was gh repo create for each class. Like a madman, I even tried to use GitHub for versioning my music compositions at one point¹!

However, this honeymoon would only last a couple of years.

AI Bullshit

The first time I had started to realize that “maybe GitHub isn’t a good platform” was 2023, when GitHub Copilot usage started to increase and the hype creeped into my daily life.

I had never heard of Copilot until that point, and was not interested in most AI tools whatsoever. However, as more people in my life started to use it and professors told us that we would get extra credit for using these AI autocomplete plugins, I gave in. I signed up and integrated it into Neovim for a while².

The more I looked into and used AI autocomplete tools (not just Copilot, I used Codeium/Windsurf at one point), the more appalled I became. And it wasn’t just because the code completion wasn’t good. Even the way that they sourced data was deeply unsettling for me. My research into this yielded the following questions that I could not find adequate answers for:

Does training on GPL/other copyleft code make all generated code derivative works, or what I like to call fruit of the copyleft tree³?
Have authors/owners of code truly consented to letting their code be used for AI training? And no, IMO, a simple EULA is not enough for true informed consent.
Since code quality on GitHub can be rather questionable, is there any solution to Copilot potentially introducing vulnerabilities and other poor-quality code to a project?

These are just a few questions of many others in the legal gray areas GitHub is trotting in currently with all of their AI offerings. They only are digging themselves into deeper shit, considering that they likely use private repositories to train their models with without admitting so publicly.

Interesting unethical practices, to say the least.

Fun fact, companies used to take these concerns extremely seriously. Even large companies like Apple has restricted use of ChatGPT and Copilot in the past for the same reasons. Yet GitHub keeps peddling AI as a magic tool in many of its products and shoving Copilot into everywhere on the GitHub interface, including pull request reviews.

These aren’t the only problems with GitHub though. Far from it.

Work Gamification

Every company has to figure out some way of keeping retention numbers high, right?

Yes, including companies where more engagement with their software can drive down the quality of the content on it⁴.

Surprisingly, user retention methods can apply to things OUTSIDE the content creation space (i.e. YouTube, TikTok, the like). And GitHub has figured out a way to make this apply to the entire software development life cycle…

Behold: the contribution graph!.

My GitHub contribution graph for 2025

Christ, I used to be OBSESSED with this piece of shit. And I still am sometimes, but nowhere near the extent to which I was⁵.

Let me explain further.

GitHub incentivizes you to use Git in the way that they have intended. And frankly, that means using every single resource on their platform. Filing issues, making pull requests, and commits that land on default branches all result in so-called “contributions”. And WAY too much emphasis is placed on this stupid green graph by some people, including prospective employers. That’s just bonkers to me now.

This causes people to either spoof commit history, create small commits solely for getting darker squares on the graph, and even make AI-generated spammy pull requests⁶ for the resume’s sake. It makes maintainers’ lives hell, decreases code quality, and all for what? A green graph?

I do not like green graphs and ham, Sam I am.

This is definitely a smaller problem than the others, but it’s still something that has annoyed me ever since I noticed it in my own behavior. Something had to change.

Pull Requests: The Antichrist’s Git Workflow

Git branches originally worked best with local workflows.

GitHub changed that, and did so radically. No, radical does not necessarily mean good in this case.

They made branches the primary means of communication between developers, rather than the commits themselves (I’ll call commits “patches” and a series of them a “patchset” later on). I didn’t know when I first started using Git at first, but this was not the original way Git was designed to be used.

Linus Torvalds, the creator of Git himself, has historically LAID into GitHub for this branch-based contribution model, and they’ve simply ignored him and continued on with their ways⁷. Opinionated is good and all, but not when the opinions are just bad.

GitHub’s pull request UI is breathtakingly terrible once you start to see its flaws. First off: diff soup. Diff soup has genuinely made my life hell in many instances at work and in open source as well.

What is diff soup, you may ask? I define diff soup as large pull requests that make it extremely hard to find the context and/or history of a given patchset and the corresponding reviews/its evolution over time.

Let’s do a small case study.

Take a large pull request such as this one that introduces a C API to the Nix package manager. It went for more than a YEAR before getting merged, with hundreds of review comments in a flat thread. If we’re talking code smells, this is a fucking sewer.

Observation I: It’s basically impossible to find the thread of conversation, since many comments apply to code that simply does not exist anymore. Fun fact, GitHub oftentimes simply does not display some review comments when their corresponding diffs disappear. That’s because the whole diff is displayed as it was in its most recent form. You can’t view what the repository was like before, unless you stack your commits on top of previous ones. So if you want previous review comments, you basically have to say your farewells to rebasing.

Sure, there are “outdated” comments, but those get applied to different comments somewhat inconsistently and it’s irritating.

Observation II: Speaking of the actual diff view, some diffs can be MASSIVE. The GitHub UI is very limited in what it can show, and you can’t exactly slice up a diff and talk about suggestions outside of the changed code that may have been affected. So the code review process itself is also limited in that way.

Observation III: The very notion of “resolving” comments is overrated in its current form. They’re just a way to hide comments (both “outdated” AND “up-to-date” comments; “resolved” and “outdated” are too similar, to be frank). Just look at the PR and how many resolved comments there are; how many more are actually related to the up-to-date code on that branch anymore?

Also, pet peeve of mine: for some reason, an author can resolve comments without actually acknowledging or applying the reviewer’s requested changes. They really shouldn’t be allowed to do that; the original commenter should mark it as resolved after having the appropriate discussion or verifying the requested changes have been made.

Oh, and don’t get me STARTED on the terms GitHub uses for merging strategies for pull requests.

Create a merge commit :: this is the pull request merging strategy GitHub incentivizes, and these merge commits are ugly as FUCK.
Squash and merge :: this turns the whole branch diff into a single commit and fast-forwards the target branch with the new squashed commit. NO, it does NOT create a merge commit, as the name seems to suggest.
Rebase and merge :: God FORBID we use the right fucking terms for Git operations. THESE ARE CONTRADICTORY TERMS! IT’S JUST REBASING ON TOP OF THE TARGET BRANCH, YOU FUCKS!

As you can see from my sailor’s mouth, this is a subject that will ALWAYS cause me to crash out when it comes up.

As if we couldn’t have more problems with the pull request workflow, GitHub has no interest in preserving GPG signatures through the latter two strategies. In order for you to keep GPG signatures, you HAVE to use merge commits. And we already know how ugly those end up looking in the subsequent history⁸.

They put in all this work for showing GPG signatures alongside code, and they don’t even support it properly when merging a pull request into mainline branches? Laughably negligent and lazy on GitHub’s behalf.

And no, gh pr does not make using GitHub pull requests easier. If anything, it’s just a shitty replica of the web UI in CLI form.

The flawed pull request flow is ultimately what caused me to get so fed up with GitHub as time went on. I was curious about how projects like the Linux Kernel Mailing List (LKML) and PostgreSQL handle contributions, since they’ve gone on for decades without needing GitHub whatsoever. Not to mention Git was literally DESIGNED for the LKML, so I wanted to see how Git was originally meant to be used.

Enter SourceHut.

Getting Started

I saw SourceHut for the first time when looking at Zig, sometime in mid-2023. I noticed that some of their CI infrastructure ran on builds.sr.ht (specifically FreeBSD), and was curious about what SourceHut offered.

One of the very first things I saw was that it was created by Drew DeVault, and that got me very interested. While the dude is very polarizing, I tend to like a lot of his takes on software, and I also love using Wayland (using riverwm at time of writing).

I actually ended up purchasing a subscription to support his efforts in July 2023, but never used the platform until September 2025. That’s when I finally snapped, and GitHub had given me enough trouble. Diff soup was one thing, but I had finally come to the realization that until GitHub takes its head out of its own ass with regards to AI, I had no business of keeping my primary means of development there. Plus, I really badly wanted to learn how to use Git with email, and I figure diving into the deep end headfirst is the best way to do so⁹.

Hold On, Why Not GitLab/Forgejo/Gitea Or Something Else?

Some of the problems I have with these platforms are similar to the one with GitHub, minus the AI bullshit I suppose.

For them, it’s not exactly the project/entities behind them as much as they copy the GitHub model of pull requests that I have started to dislike.

Feel free to send me an email for further discussion.

Porting Repositories

I’m not gonna lie, porting repositories was literally seamless. After adding my SSH keys (both my gpg-ssh-agent key and a machine-specific one), I just ran:

$ git remote set-url origin git@git.sr.ht:~watersucks/<repo-name>

in each one of my repos and pushed them up. SourceHut automatically created a private repository for each of these, and then I toggled their visibility to “public” and voila! My repos were ported over.

Not so fast, what about discoverability?? Great question.

GitHub Mirroring

GitHub is popular because everyone uses it. Now, I don’t have to necessarily USE the GitHub facilities, but I can optimize my own projects for both drive-by GitHub contributors AND SourceHut users by mirroring my repository to GitHub on every push.

Here comes builds.sr.ht to save the day!

I created a (mostly) identical build manifest in each repository at .builds/mirror.yml:

image: alpine/edge

secrets:
  - <GITHUB_TOKEN_SECRET>

sources:
  - https://git.sr.ht/~watersucks/<repo-name>

tasks:
  - write-ssh-config: |
      cat >> ~/.ssh/config << EOF
      Host github.com
        IdentityFile ~/.ssh/srht_github_mirror
        IdentitiesOnly yes
        BatchMode yes
        StrictHostKeyChecking no
      EOF
  - mirror: |
      cd ~/<repo>
      git remote add github git@github.com:water-sucks/<repo>.git
      git push --mirror github

triggers:
  - action: email
    condition: failure
    to: 'Varun Narravula <varun@snare.dev>'

Once I pushed it up, SourceHut automatically ran this manifest and synced the repository to GitHub on every push. I put up a notice in the READMEs and on the GitHub repository description that the primary sources were at SourceHut, but that I would still accept pull requests and issues, and mirror them over into SourceHut when applicable.

Now, there are limitations to these build manifests, which I’ll go over later. But so far, this move was going pretty well.

Patch-Based Email Workflow

Now comes the hard part: figuring out the email-based workflow.

I had to create mailing lists for each project already, and followed the recommended layout of having three lists: <repo>-devel, used for development/sending patches, <repo>-announce for announcing releases/breaking changes and other such things, and <repo>-discuss for general discussion.

Now, I didn’t expect much engagement at all, and that’s fine. Most people are simply not going to know how to even interact with SourceHut properly, since the documentation is sparse¹⁰ compared to GitHub. But at the very least, I had to set something up in order to respond to these things/create patches myself for other projects on the platform.

To that point, I found aerc, Drew DeVault’s own email client¹¹. It seemed really cool to manage email through the terminal, so I picked it up, added it to my home-manager configuration, and watched a metric shit-ton of videos on how to do email-based workflows.

Basically, the idea is this when submitting patches:

Do development on a local branch, make your commits.
Once your commits are ready, run git format-patch on the patchset.
Send the patchset off with git send-email to the proper mailing list, optionally with a cover letter.
If changes are requested, then send another version of that same patchset after applying the requested fixes. git send-email and git format-patch support versioning patchsets like this, and even implement tooling around diffing between patchsets in the form of git range-diff. I’ll talk about my workflow around this in a later post, so stay tuned.
Otherwise, wait for the patch to get accepted and for a reply!

Branches in this flow are for local development organization only. This is a COMPLETE mindfuck compared to the GitHub flow, and took me a minute to get used to.

For my own projects, branch organization was still great, but all my commits simply ended up on main, since I was the trusted core maintainer. In GitHub land, I would not configure this sort of access, even to my own main branch. I’d always make pull requests to main and self-merge instead. I’m not gonna lie, this made much more sense than the GitHub way.

When you are accepting patches from a list, the flow goes like this:

Open aerc to find the patch email(s).
Check out the main development (trunk) branch.
Pipe the contents of the email(s) to git am.
Make sure shit works.
If good, then rebase it into your trunk and push it up, and reply back with a “Thanks!” and the new, merged commit ref.
Otherwise, slice up the diffs, and review them by simply editing the patch itself inline.

You wanna know something funny, dear reader?

My first contributed patch on SourceHut was to SourceHut itself.

At least one that wasn’t to my own project.

I ended up fixing a bug with the issue tracker todo.sr.ht itself that I found when attempting to resolve one of my issues automatically through email. This was super annoying at the time, but it does highlight the fact that SourceHut is not perfect.

Hear Ye, Hear Ye! What Problems Have Arisen, My Dear SourceHut?

Let’s talk about some other problems.

Fixing bugs with the platform itself is one thing. I like using alpha software and contributing fixes back, but this can interfere with my own project development. I am not employed by SourceHut, so any bugs with it that I must fix must come out of my own time.

GitHub’s Monopoly

I’ve mentioned this earlier, but I am still somewhat stuck in the GitHub ecosystem for multiple reasons.

First off, at the time of writing, I still use Nix and have many projects in the NixOS space. I maintain nixos-cli, and including a project in nix-community for visibility requires me to use GitHub for the upstream. I could develop it on SourceHut personally, but mirroring a repo like this seems like an unreasonable waste of SourceHut compute when I’m gonna contribute it to the GitHub upstream anyway.

Additionally, the Neovim plugin ecosystem often assumes GitHub as a default when using owner/repo style syntax for including plugins. My own darkrose.nvim colorscheme is mirrored to GitHub for precisely this reason, to make it easier to use.

Also, my workplace (Pangolin) heavily uses GitHub for its open source hosting and for free GitHub Actions compute. If I want my paycheck, GitHub it is when I’m on my 9-5.

builds.sr.ht Usability Issues

builds.sr.ht, while it is remarkable for what it offers, is missing some features that I sorely miss from GitHub Actions, such as cronjobs (i.e. for my weekly NixOS configuration flake updates)¹².

It’s also somewhat limiting to only be able to run 4 jobs on every push, but I understand this limitation; build compute cannot be free forever, think of the trees!

One more gripe with builds.sr.ht: for public projects, where do I send build failures? Does it happen automatically with CI? Mailing list CI is just very confusing, and I don’t get who receives the notifications. I don’t want everyone in a <repo>-devel list to receive notice of my own stupid mistakes, and I don’t want to see contributors’ CI failures either. Triggers aren’t very flexible at the moment, and I don’t know how to expand them properly. If someone knows how, send me an email, I’d appreciate it.

External Usability

This is always gonna be a fundamental problem with SourceHut, in my opinion.

The thing is, people have been so conditioned by GitHub to expect the contribution process to be streamlined for them. That’s because GitHub is HEAVILY optimized for drive-by contributions. Any stupid person can make a pull request without explaining the purpose of it properly. The very nature of sending patches over email is intimidating for many Git users, and will tend to invite more experienced developers rather than noob ones.

The analogy I make: since GitHub is optimized for drive-by contributions, SourceHut simply wants you to park your damn car and to be more persistent for a change. It’s a good attitude to have, and one that I share.

However, this drives down contributions massively. Even in my own GitHub repositories, I see people that fork them, have changes in separate branches, but have not made pull requests despite me saying that it is okay.

Some days, I fear that because of this barrier to entry, SourceHut may never gain popularity and be stuck in a forever cycle of this. But perhaps that is for the best; who knows?

I still do get quality contributions over email, just less of them than I would have otherwise received in the form of a GitHub pull request. And that’s fine for now.

What The Future Holds

In the future, I may have figured out my problems and gripes with SourceHut, and may write a future post about that as well. Stay tuned!

Fin.

Footnotes

Yeah, don’t do this. The file limits are rather low for GitHub and even with Git LFS, the actual size of the repo explodes and you won’t be able to host it eventually. Not to mention who cares about how music projects evolve? Most people just want the finished product, not shitty half-finished demos. ↩
I actually gave up using it. The signal-to-noise ratio was laughably low for completions, and even when I set Codeium off by default, I found that I would never really enable it. And not because I forgot it existed; I just didn’t care much for the output even when I enabled it. ↩
“Fruit of the copyleft tree” is a term I came up with to refer to code that should be available on request due to GPL/other copyleft licensing. It’s a play on “fruit of the poisonous tree” in legal cases. I really like this phrase, since I came up with it while stoned. ↩
My belief is that as the size of a platform grows, so does the amount of slop on it. With ALL of these big tech platforms, user retention tactics often end up assisting in the creation of more frequent trash content and end up tanking the signal-to-noise ratio for good content. Content in this case doesn’t only mean videos/other media, it also means project activity, like code contributions, bug reports, and documentation updates. ↩
I actually bought a domain, cgraph.dev, which I was gonna make a small platform-agnostic contribution graph for. However, I haven’t really worked on this at all, and have been considering just giving up on it for the same reasons I mention here. ↩
If you want to hurt yourself in confusion, see the following AI-generated merge request to the Mesa project on GitLab. Some idiot had the absolute fucking GALL to say they didn’t know what they were doing and were submitting a patch to a low-level Linux graphics stack ANYWAY. I wish I could throw people off building sometimes.

Side note: We should all aspire to be like Timur in that merge request. ↩
I don’t regard Torvalds as a god. I disagree with him on plenty of things, but agree with him in this instance about GitHub. Don’t come after me for citing his ethos. ↩
Yes, it is possible to merge without the GitHub UI. But then you don’t even get a way to automatically close the pull request with a “merged” status! Daniel Stenberg, the curl maintainer, has mentioned this on his own blog post on his own Git workflow, and you can see how stupid funny it looks by looking at the curl pull request list, where they all show up as closed. ↩
I did this with NixOS, all the way back in 2020 or so. Ended up wiping my Void Linux drive by accident from the NixOS installer ISO with dd and it’s now my daily driver. So I’m used to this kind of uprooting thing and learning the hard way :} ↩
I seem to have a fondness for cool projects with poor/subpar/sparse docs: Nix, Zig, and now SourceHut. I have a fucking problem. ↩
He apparently doesn’t maintain the project anymore, it’s someone else now. But still, cool fact I guess. ↩
I use cron-job.org to do this every Saturday, and all it does is use the SourceHut GraphQL API to send an ad-hoc build manifest that I have to MANUALLY keep in sync with what’s in the repo. Genuinely so stupid lol. ↩

realpath() Considered Harmful

Wed, 09 Apr 2025 00:00:00 GMT

Synopsis

Public service announcement for all programmers: stop using realpath(). The C function realpath(3) included in C standard library on most Unix-like operating systems, whatever equivalent there is for your programming language, just don’t use it in code in general¹.

But why?

Part I :: Where Did This Begin?

I stated down a rabbit hole of research on realpath() and its various incarnations when I ran into a bizarre problem while working on my reimagined NixOS CLI utility. This is a rewrite of various assorted scripts throughout the NixOS ecosystem in Zig², and these scripts often relied on the usage of absolute paths in order to function. I didn’t question this until I found out that my invocations of std.fs.realpath() were causing an instance of detectable illegal behavior³ that only occurred in ReleaseSafe mode, but not in Debug mode during development.

Interestingly, I have never been able to create a minimally reproducible example of this since then; I assume it has been fixed in some fashion. However, that doesn’t mean that its usage is not harmful. In fact, Zig is strongly considering outright removing this function from its standard library⁴. So, let’s research from what depths of hell realpath() came from.

Part II :: Abstraction Does Not Mean Portability

realpath() is not a portable construct in most places. The system realpath() will have vastly different behavior depending on how a language standard library implements it.

`glibc` Implementation

Let’s investigate how glibc implements it. This is the implementation details, slightly editorialized from the glibc source code⁵.

// Return the canonical absolute name of file `name`.
//
// A canonical absolute name:
//   - Must be an absolute path.
//   - Cannot contain any "." nor ".." components
//   - Does not contain any repeated filename separators ("/") or symbolic
//     links (symlinks)
//   - All filename components must exist.
//
// Implementation details:
//   - If `resolved` is NULL, the result is malloc()'ed. Otherwise, if the
//     canonical name is PATH_MAX chars or more, return NULL with `errno` set
//     to ENAMETOOLONG.
//   - If the name fits in fewer than PATH_MAX chars, return the name in
//     `resolved`.
//   - If the name cannot be resolved and `resolved` is non-NULL, it contains the
//     name of the first component that cannot be resolved.
//   - If the name can be resolved, `resolved` holds the same value as the value
//     returned.

char* realpath(const char* name, char* resolved)

Already getting into quite a lot of platform-specific details. But hold on; Linux has multiple libc implementations! What about those?

`musl` Implementation

On the same system, we have musl. How does musl implement the same type of functionality? The source code is here, but this is the summary of the assumptions made and results returned:

// Resolve a canonical name from a filename.
//
// A canonical absolute name:
//   - Must be an absolute path.
//   - Cannot contain any `"."` nor `".."` components
//   - Does not contain any repeated filename separators (`"/"`) or symbolic
//     links
//   - Not all filename components and ancestor directories need to exist; only
//     symlinks need to be resolved to existing places.

char* realpath(const char* restrict filename, char* restrict solved);

Do we see any differences here? Well, yeah! Apparently, two different libc implementations on the SAME platform will determine if filename components exist differently! So realpath() now doesn’t have an invariant decreeing that filenames need to exist if they can be resolved by realpath(). Great, now try compiling the same application that relies on this supposed glibc “invariant” for Alpine Linux, and watch as you get "error: file not exists" when your application should have manually been ensuring their existence after resolution anyway. Amazing! Not. That is insanity that can only be resolved by a night out drinking your sorrows away at 3:30 in the morning once you run into it in a Docker container randomly.

Other Language Standard Libraries

How do other languages do it then, you may ask? Often times in the WORST fucking ways possible.

Take Zig. As new a language as it is, the way that it implements realpath() on POSIX systems is just insane. Here’s the source, for reference, yet again.

I don’t even want to give this the time of day, to be frank. It’s genuinely that bad. Here’s a snippet from the relevant code, with portions omitted for brevity.

switch (native_os) {
    .windows => {
        var wide_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
        const wide_slice = try windows.GetFinalPathNameByHandle(fd, .{}, wide_buf[0..]);
        const end_index = std.unicode.wtf16LeToWtf8(out_buffer, wide_slice);
        return out_buffer[0..end_index];
    },
    .macos, .ios, .watchos, .tvos, .visionos => {
        // On macOS, we can use F.GETPATH fcntl command to query the OS for
        // the path to the file descriptor.
        @memset(out_buffer[0..max_path_bytes], 0);
        switch (posix.errno(posix.system.fcntl(fd, posix.F.GETPATH, out_buffer))) {
            // ...
        }
        // ...
        const len = mem.indexOfScalar(u8, out_buffer[0..], 0) orelse max_path_bytes;
        return out_buffer[0..len];
    },
    .linux, .serenity => {
        var procfs_buf: ["/proc/self/fd/-2147483648\x00".len]u8 = undefined;
        const proc_path = std.fmt.bufPrintZ(procfs_buf[0..], "/proc/self/fd/{d}", .{fd}) catch unreachable;
        const target = posix.readlinkZ(proc_path, out_buffer) catch |err| {
            // ...
        };
        return target;
    },
    .solaris, .illumos => {
        var procfs_buf: ["/proc/self/path/-2147483648\x00".len]u8 = undefined;
        const proc_path = std.fmt.bufPrintZ(procfs_buf[0..], "/proc/self/path/{d}", .{fd}) catch unreachable;
        const target = posix.readlinkZ(proc_path, out_buffer) catch |err| switch (err) {
            // ...
        };
        return target;
    },
    .freebsd => {
        var kfile: std.c.kinfo_file = undefined;
        kfile.structsize = std.c.KINFO_FILE_SIZE;
        switch (posix.errno(std.c.fcntl(fd, std.c.F.KINFO, @intFromPtr(&kfile)))) {
            // ...
        }
        // ...

    },
    .dragonfly => {
        switch (posix.errno(std.c.fcntl(fd, posix.F.GETPATH, out_buffer))) {
          // ...
        }
        // ...
    },
    .netbsd => {
        @memset(out_buffer[0..max_path_bytes], 0);
        switch (posix.errno(std.c.fcntl(fd, posix.F.GETPATH, out_buffer))) {
            // ...
        }
        // ...
    },
    else => unreachable,
}

Can you tell what’s wrong? The TL;DR: it just gives up and relies on extremely platform-specific ways to retrieve an absolute file path given a file descriptor (fd).

What the fuck??? Who thought of this monstrosity? Apparently we just don’t care that file descriptors don’t necessarily refer to file paths on disk anymore. Apparently shared memory and pipe() don’t exist either. Jesus Christ. Indeed, they recognize the error of their ways with the following comment:

/// Calling this function is usually a bug.

Even they know that this shit is stupid as hell! I mean, just look at the implementation for Linux, SerenityOS, and Solaris. They construct a link to /proc/self for the fd in question, and they evaluate the symlinks from there. Genuinely disgusting, since it also doesn’t necessarily take into account higher process ulimit values for file descriptors that can overflow the buffer. But oh well, who cares? I like my buffer overflows!

At least the other POSIX-compliant OSes use fnctl() macros properly, but that will always depend on if the underlying OS libc will even expose these operations. At least for those OSes, their libc is the only way to access these types of things, so maybe it’s a little more consistent, but hello??

And not to mention, fun fact, this functionality simply DOESN’T EXIST on some platforms; OpenBSD is one of them. “Who uses OpenBSD?”, you may ask. That’s not the point! The point is that the fucking functionality isn’t available on all platforms, so basically, when you don’t have a path, and just have the fd, you’re shit outta luck.

So, here’s the real question: why does realpath() even exist????

Part III :: Rationale

There are two primary use cases that I can see for realpath() being a potentially useful function, at least from looking around on Google at links like this:

To ensure the existence of a path and that it is resolvable (i.e. no symlink loops)
Displaying the full file path for a given relative path, for clarity in logging and/or displaying.
To prevent path traversal attacks.
Your software relies on an assumption that the cwd is unreliable or can change in certain instances (i.e. going up directories to find the root of a Git repository or a Nix flake).

All of these are potentially useful, but also…they can be achieved in a variety of ways that don’t need to rely on the underlying operating system for any assumptions or assumed invariants.

Part IV :: What Should I Use, Then?

OK you big baby, you want realpath() and you’re throwing a big fucking tantrum about it. Cry harder.

But really, what should one use in place of realpath() then?

To be quite frank, realpath() usage can be avoided entirely in most instances. How, you may ask? Just maintain the reference to the filename in the first place, first off. If you are using a language like Zig or Python and are trying to call realpath() on some sort of Path-like data structure, you had to have been given a path to the file to call realpath() on it in these instances. So, why don’t you just use that reference? Don’t even think about reifying a filename given the file descriptor, or I will personally find your address and annoy you to hell about it until you damn well stop. That filename will have enough context for you to construct the real path to the file in a manual fashion, if you so please.

As far as I can tell from reading standard library code from various other languages (including the prior libc examples), the general way to look for canonical paths on any given system given some path is to do the following steps:

Resolve any .. and . links.
Evaluate any symlinks (and resolve their . and .. references as well) if needed.
Continue doing this until a file path that is not a symlink is reached (it may not necessarily exist, do not assume this is the case ever).
Append the current cwd to the path if relative, or leave it alone if it is absolute.

This approach is much more portable. You can use a stack to resolve . and .. references and checking for the presence of a prefixed .. after to prevent said path traversal attacks can absolve the usage of realpath() entirely in most cases. This is especially true when the cwd of a process doesn’t need to change at all.

There is one important caveat though; this is indeed another reason that realpath() functionality just shouldn’t exist. It’s step #2: since most realpath() implementations work by evaluating symlinks until a canonical path is realized, what happens if the symlink changes in the middle of evaluation? Simple. You’re fucked. You’ll end up with behavior that can vary depending on how the symlink was changed: at worst, you may end up getting a path that you will assume doesn’t exist when it does, and end up overwriting information irreversibly. Now granted, it may not be as fatal as that, but the point is realpath() is extremely susceptible to race conditions due to underlying filesystem changes. If you’re confident enough that symlink changes won’t happen, that’s on you. But this should not be something that is encouraged, especially not by a language standard library.

So, based on that, who will write this code, you may ask?

You. You’re smart. You can write this cross-platform path resolution code on your own if you need it. Needing to assume absolute paths is a fairly uncommon scenario, and to be frank, IMO it should not be a standard library function in general because people will end up reaching for it and run into these OS-specific footguns. realpath() itself is more an operating system-specific construct, and should be treated as such.

I would write this code for an example, but to be honest, I’m lazy. And I also try not to rely on realpath()-like functionality anymore, and just enforce absolute paths whenever I need them, and manually evaluate symlinks if needed. Go has a nice, deterministic EvalSymlinks() function that does this, so that’s what I’ve been resorting to in most of my Go code, and equivalent functions elsewhere. Farewell, realpath(). Rot in hell.

Footnotes

I am not quite sure about usage of the realpath command in shell scripts. Since shell scripts usually tend to not be as cross-platform as programs written in more general-purpose programming languages, I’ve found that usage of the realpath command can be quite useful when running commands ad-hoc. But I’ll come back to this later and add an extra section about it if I change my mind. ↩
I’m rewriting this in Go for many reasons. I’ll probably end up writing a blog post about this too. ↩
“Detectable illegal behavior” is not quite the term that the Zig community or documentation has solidified on yet, but there is a good amount of discussion on it in a GitHub issue. ↩
Thanks to @matklad on the linked GitHub issue for providing the inspiration for really writing a post on this topic in this comment. ↩
Well, I kinda just took a comment from the source code and I reworded it to make more sense. ↩

The Book of Neo

Fri, 21 Mar 2025 00:00:00 GMT

Prologue: Assemble, NeoVimmers!

Hail, all ye that can see and hear! The NeoLORD¹ hath spoken to me upon Mount Joy², and hath given me instructions for all to follow, lest they be slaughtered by proprietors and condemned forever to the unfree software of their fellow slaves’ toils. The future does not need us³; let us heed these commands written upon this buffer and treat our present days with the dignity they deserve.

The Zen Commandments

Thus saith the NeoLORD:

Thou shalt abide by the philosophy of my right hand⁴: “Thou shalt do one thing, and do it well.” The $EDITOR is a craft, created to create. It is the crafter of crafters. Do not fall into the traps of the cursèd devil which shall not be named, and do more than is intended. I am the NeoLORD.
Thou shalt not use editors other than the venerable Neovim; for I the NeoLORD am a jealous God, and will destroy all that create with no regard to their true creator. I am the NeoLORD.
Thou shalt abstain from usage of VimScript in favor of Lua. The venerable VimScript will be kept alive, since he is still useful, but beware; old wineskins will break eventually. I am the NeoLORD.
Thou shalt make the fullest use of the tools that the NeoLORD has graciously provided to you. Give LSP and Treesitter their due homage. I am the NeoLORD.
Honor plugin maintainers with the utmost respect. They are not subject to your fleeting whims, and are free to do as they please with the fruits of their labor. Must a conflict arise, thou shalt resolve thy disagreements through civil discussion. Take care, and wield the mighty fork⁵ with caution. I am the NeoLORD.
Beware the temptresses of useless plugins. Do not let them sour your desire to create. I am the NeoLORD.
Thou shalt respect Vim and its contributions to the world, and upstream any applicable patches, for the spirit of Bram shall live forever and ever. I am the NeoLORD.
Thou shalt not act in sloth, lest you perish in the bottomless pits of the lazy Inferno⁶. The NeoLORD your God is not a lazy⁷God; thou shalt instead weave thy configurations by hand. For the lazy folk are unable to partake in the NeoLORD’s wisdom, and their fingers will rot from confusion. I am the NeoLORD.
Thou shalt not blaspheme against the spirit of modality, for whoever disowns the other modes in favor of insert-only mode shall never be forgiven until they repent of their ways.
Do not distress over the transgressions of the ignorant, for everyone is a sinner in the NeoLORD’s presence. Instead, lead them towards repentance and the narrow gate of change. I am the NeoLORD.

The Simpleton’s Zen Commandments

To all Neovim programmers: follow these commands.

Do one thing, and do it well. Don’t be like Emacs.
Don’t use editors other than Neovim, or else.
Use Lua rather than VimScript.
Use the native LSP and Treesitter functionality.
Don’t be an asshole to plugin maintainers. If you don’t like what they’re doing, or they don’t do what you want, fork the damn thing and do it yourself if you must.
Don’t add more plugins than you need to. It’s easy to fall into config hell.
Upstream any patches that are in Neovim core to Vim if possible. Both editors are great. One is just better.
Don’t use Neovim distributions like LazyVim if you want to learn Neovim functionality properly. Make your configurations yourself.
Use the modes to your advantage! Normal mode and visual mode are much more powerful than you give them credit for.
Lots of people don’t use Neovim. It’s fine, you didn’t know what Neovim was for a while either. Spread the good news and tell them to use it too!

Epilogue

This is just a joke that my friends and I wrote in a Discord voice call. Don’t take it too seriously.

Credit to Zachary Howe for co-authoring some of these commandments with me.

If you want to see more content like this, send me a message! I’d love to hear more ideas for niche, satirical content. Maybe the NeoLORD’s commission is in need of writing.

Footnotes

The NeoLORD is T.J. DeVries (aka Teej). Teej, if you’re reading this, I don’t know why my friends and I made you the NeoLORD. But you were the funniest to reference. ↩
A reference to Bill Joy, the creator of vi. ↩
A reference to The Future Does Not Need Us, a publication, also authored by Bill Joy. ↩
The UNIX Philosophy. ↩
Forking plugins and/or maintaining patches for the same plugins is a good idea when you’re in complete disagreement with a maintainer over something large and highly technical. Neovim itself is a fork of Vim, so they can be successful in practice. But just wield caution when doing so. ↩
Dante’s Divine Comedy. Yes, the hell references are definitely good for this. ↩
This refers to Neovim distributions such as LazyVim. ↩

The Unchristian

Sat, 08 Jun 2024 00:00:00 GMT

Part 0: Hi there.

Disclaimer: If you’ve come here from the random depths, hello there. This is one of my more thought-out pieces that is filled with a considerable amount of personal details, so if you feel uncomfy, it’s fine to click off. I don’t mind at all. If you’re still here, I’m glad you want to know more about the particular struggles I have had with faith, namely of the Christian variety.

First off, if you’re a Christian, or even simply a person of faith of some sort other than that, I implore you, please don’t click off this page. I know deconstruction is a rather scary word for many, but please give this a try; it took a lot of effort for me to even gather the courage to speak about this.

My goal is not to convince you of anything. Instead, I aim to simply tell a story, or more aptly for this context, a testimony. My testimony. This isn’t clickbait, I can promise that, so please, humor me, and feel free to contact me to talk about it after.

My journey through faith has been something that has followed me my entire lifetime. It’s been a wild ride, really, filled with ups and downs that are only matched by ungodly creations like the Euthanasia Coaster. Well, that may be hyperbolic, but I digress. Not only has it been wild, it has been a long time coming, and I think it’s time I talked about it.

This is a piece about my journey as someone who was raised in the Christian church. Over a long period of time, I’ve started to question the value of it all, and why I believe what I believe. This lead me down a painful journey of deconstruction that was almost 6 years in the making, and eventually led to my deconversion.

Part I: Faith

I was raised a Christian by my family. My mother was (and still is) a devout Christian, having converted when she was living in India along with her older sister; however, my dad was not. My older sister and I were raised in the church, and we were exposed to all the doctrines from early age; in fact, my mother even told me that the first book I learned to read was the Bible (I had a children’s version of it and would read it all the time; I even have vague recollections of doing this). I was fascinated by all the stories, and when I was told they were true and without errors, I believed it wholeheartedly.

My mother even told me that I myself was a miracle when I was grown up, that I was diagnosed with a whole swath of developmental disorders, but most of them had disappeared by the time I was four years old. I had no reason to doubt that, especially when I was young; after all, I knew I could kind of interact with people in a semi-coherent way, even though I still had problems with it.

From the beginning, I was taught to read my Bible. In fact, it was a fixture of my daily routine; in the morning, drink some warm water, brush your teeth, and open your Bible. Read one chapter per day, learn something new, every day. As a child, I did complain about this routine, but I later on grew to love it. It was my bread, just as the Lord’s Prayer spoke of; I lived by its words. It could speak of no wrong in my eyes, it was that foundational. After all, I read the magical words, “You shall love your neighbor as yourself” (Matthew 22:39), and I was entranced in this moral direction; it can’t be wrong, can it? With all the things it gets right, I couldn’t even comprehend the idea that this could have been wrong; in fact, I never did for most of my life.

I went to a single non-denominational church for most of my life, and attended almost every week with my mother and sister. Since I was taught about the faith from an early age, I was already convinced of the idea that Jesus had died and resurrected for my sins. In fact, after I understood what a “baptism” was, and after my sister was baptized, I begged my mother for years upon years to do the same. Since I was in elementary school at the time, she simply told me “You’re not ready yet”; this cycle continued until 2016, when I was in middle school. I was baptized then, in an auditorium filled with people I knew.

At my baptism, I was asked a single question that many millions of people had been asked prior: “Do you believe Jesus Christ died for your sins and was resurrected from the dead?”

I replied, “Of course!” What, you think He didn’t?, I had in my mind. The auditorium laughed along in approval of my emphatic response. And underneath the water I went, and came back up to the sound of cheering. It felt magical, as if I had won the game of life while still being so young. Little did I know that my response to this question was one that I would laugh at myself for, given some time.

I really did feel like Jesus getting baptized by John at that moment

Regardless of that, after I came out of the water, I felt as if Jesus Himself had come down into the water and whispered into my ears, “Well done, my good and faithful servant!” (Matthew 25:23), and had opened a literal doorway in my chest. Nothing could replicate that. I was redeemed; a new child had been born out of the filth. It was time to rejoice in His presence!

Around this same time, I auditioned for my church’s worship band. I am an avid drummer, and contemporary Christian worship songs from artists like Hillsong and Elevation were extremely simple for me to pick up and learn on the drum kit. My worship pastor took me on, and I started playing music with them almost every single week. I connected with some people of faith that was almost divine in my eyes, and I was in awe of their abilities, as well as their disposition for faith, and aspired to be like them. Needless to say, I was a devout Christian for most of my young life, and there was no letting go of that, ever.

Or so I thought.

Part II: Doubt

Let’s rewind a few years back from here.

Around my fifth-grade year (2014), a close uncle of mine saw that I was a very curious person. I had always been since birth, asking questions about anything and everything, though unsurprisingly I never thought of doing the same thing in regard to my faith. He gave me a swath of books, all from an author named Ken Ham. I didn’t think much of this name, but I was addicted to reading, so naturally, I picked these books up after a while. I learned about the idea that there were people out there that didn’t have the same perspectives as me, and that I needed to defend myself against these people; I could defend myself using “knowledge!”¹ After all, there was a mountain of evidence for God’s existence, I needed just to “Fear not, for [He] is with me” (Isaiah 41:10).

I read these books front to back, arming myself with arguments against the people who dared to question God. How could these people question my faith?, I asked myself over and over again. Yet, it didn’t feel right as I was reading these books. Something was off. But I didn’t think much of it. Having been taught a literalist interpretation of the Bible, I regarded all types of doubt about my faith as demonic, and regarded Satan as a real, scary entity that could easily lead me to a cliff and throw me off into the valley of the shadow of death (Psalms 23:4).

Interestingly, this sentiment was not shaken even as I had my first encounter with an idea from the faith that I disagreed with. I listen to metal (and many other genres, check out my last.fm for some recs), and I first encountered it around my sixth grade school year (2014). When this same close uncle that gave me the Ken Ham books heard about this, he took me aside privately and started scolding me, telling me that “metal music was a way for the devil to find his way into my soul,” and that when the devil does that, his only goal is to “steal, kill, and destroy” (John 10:10). I took issue with this, as I loved my music, and was even listening to mostly Christian or Christian-influenced metal bands such as August Burns Red and Underoath (great bands, by the way; you should listen to them!). However, out of trust for this uncle, I tried to stop listening to my favorite bands, and transitioned over to other genres of music.

Spoiler alert: this transition to other types of music didn’t work; I still listen to metal today.

Yeah, it was definitely this dude that made me ditch religion.

Coincidentally, I discovered many other bands through this process, like Saosin and other bands that I still listen to today, so maybe this was a blessing in disguise. Regardless, I was disheartened by this blatant dismissal of my own feelings around the music I loved to listen to, but my faith was still strong in spite of that; I just pushed those feelings to the back of my mind and continued on believing.

I held fast to a creationist, literalist view of the Bible, and this was not shaken at all by any teachings about “unbiblical” stuff like evolution that I was exposed to in my science classes until around my freshman year of high school (2017). I was having a conversation with one of my best friends on the phone, and we were just talking about random things. We veered into religion sometime during this (for context, he was a casually-practicing Hindu), and I brought up the fact that I believed in creationism and that God created the Earth in six 24-hour days. He simply laughed at me, saying:

You seriously believe in that shit, Varun?

I fought back against this, saying I had evidence, and tried to bring up what I had learned from the apologetics books I was given. This was my first active application of those concepts; I had to know what I was talking about, right? I left that conversation thinking I had won my case, but that first little seed of doubt was planted in my heart right then and there, and I was not aware at all of what havoc it would end up wreaking on my life.

A few weeks later, I still found myself mildly shaken up at this conversation. I decided to go on Google and just start going down rabbit holes, searching for anything related to what we were talking about. I started with searches like:

“Why is evolution true?”
“Why is creationism true?”
“Why is evolution false?”
“Why is creationism false?”

But this eventually turned into more of the following searches:

“Contradictions in the Bible”
“Refutations of contradictions in the Bible”
“Why is the Bible true?”
“How was the Bible made?”

Cut me some slack, I don’t remember the exact keywords. I don’t think 15-year-old me would have understood what “refutation” meant, but I digress. You get the idea, hopefully. I would go down these rabbit holes for hours a day, just reading, absorbing whatever information I could find. But that hole still remained in my heart, and I couldn’t understand why this was the case.

I didn’t know it at the time, but these were the beginnings of doubt, and it was something I had feared for a long time in this realm. I had always regarded hell as a literal entity, and was scared shitless of it; after all, I was just a kid. What would happen if I doubted, and that led me to commit the worst of all sins, the unpardonable sin (Luke 12:10)? So I kept reading my Bible, and kept trying to be devout. I struggled heavily with my mental health throughout all of my high school years, and these seeds of doubt were one of the primary contributors towards it. I also struggled with suicidal ideation, and tried to publically commit suicide when I was around 16 years old, which eventually led to me being placed on medications. This didn’t exactly help the case for my doubt.

On a side note: I still struggle with depression and suicidal ideation today, although it has been quite a while since I’ve acted on those urges. I’ve learned some strategies to deal with it through therapy and other forms of support, which is nice.

I kept reading my Bible, which was an annotated version from a pastor named David Jeremiah that I was gifted. While I wouldn’t mark it up, I kept its additional commentary in the margins close to my heart. Many times passed where I would read it front to back; One year, I attended Alpha, a course targeted at Christians and unbelievers alike to teach the fundamentals of the Christian faith. I was in a group with my campus lead pastor as the leader of it, and we were discussing quite often the core tenets of the Christian faith. Anything to quell the very doubt that would send me to the abyss, I thought.

My personal Bible, with commentary from David Jeremiah

My beliefs bled over to my high school environment as well, also in particularly unlikable ways. While I was in marching band, I developed a budding friendship with someone from the color guard that also happened to attend the same church that I did. We talked a lot, and ended up vibing so much that I even developed some slight feelings for her. She eventually told me that she was lesbian, and I was mortified. I couldn’t even comprehend how someone could attend church and simultaneously be part of the LGBTQ+ community. I was taught that these people are to be regarded as sinners. We ended up going back and forth about this multiple times, and eventually I let my true feelings at the time slip: the age-old adage of “Love the sin, hate the sinner.” I wouldn’t know at the time (much less why it would be the case), but she was hurt by that, and our friendship wilted slowly.

This nagged me for a while. I didn’t know what I did to hurt her, but I was still under the impression that people like her just wanted to live a life of sin. This contributed more to the doubts in my mind. Would Jesus seriously condone what I did to her? I, myself, was also a sinner, yet I cast the first stone. I forced myself to look at different perspectives, the same way I forced myself to look at the theory of evolution online. That’s all I could find solace in: learning.

The thoughts, experiences, and consequences as a result of these could never leave me alone. I was constantly thinking about them, and the impact that they had on my life, and as this happened, I finally realized I needed to do one thing, more than anything else: I needed to dig into my foundations to see what was buried in it, and if it was worth believing.

Part III: Deconstruction

So begins the journey of the often ill-fated term, “deconstruction”. I was frankly terrified of this concept at first; in fact, I didn’t even know what it truly meant or what the word for the process even was until a year into the process of starting it. I simply knew that I wanted reassurance that what I believed in what was correct, and that I could apply that truth to my life.

At the time, I was on Reddit a considerable amount, and often used it as a central forum of resources I could gather from. Subreddits like r/OpenChristian, r/Exvangelical, among others caught my eye, and I made posts there regularly about different topics, like how I had stopped seeing the “magic” in contemporary Christian music and other worship music after having played it live for so long², and how I could have better beliefs in certain topics while still having it reconcile with the Bible that I had always known.

One day, I was helping my church build out a new stage for worship, and the conversation among us shifted to the topic of evolution. When this came up, I finally mentioned that I really wanted to know how I could reconcile the Bible’s claims and the reality of certain scientific concepts like evolution. When I said that, my worship pastor looked at me, not in disapproval, but with a face of happiness. I was confused; wasn’t I doubting something that shouldn’t be doubted? He told me this:

Doubting and asking is good for your faith, Varun. God is more than willing to answer your questions.

That wasn’t the exact quote, but that was the essence I took away from the conversation we had. He recommended me a book to read, namely Irresistible, by Andy Stanley, a pastor. I Googled it, and to my initial dismay, most of the searches that came up were write-ups by conservative and fundamentalist organizations like the Gospel Coalition that warned me about the heretical beliefs that are supposedly espoused by Stanley in this book. That made me more intrigued than ever; I knew about infighting between Christians, but had never seen such vehement dismissal of certain ones before. The Streisand effect had taken me over, and it made me that much more excited to read this. So I bought the book³.

When I finished reading, I noticed a sense of catharsis that was hanging over my mind. It was freeing, almost as if I could think for myself regarding my own faith for the very first time. However, I was almost angry at my church, at the surrounding Christians that told me there was only one way in which I could follow my God. The teachings of Jesus were infinitely more important for me to follow than any Old Testament teachings; after all, the carpet with all the uncleanliness has been rolled up into heaven (Acts 10:9-16)! I felt deceived with this newfound ability to think. Knowledge was a curse, I thought; that’s the way ignorance is bliss, right? This anger did eventually settle, and the only feeling I was left with was peace. My faith was changed forever, but for the better.

My interrogation of God was commencing.

After reading this book, I let go of the idea of Biblical inerrancy. I saw it for how limiting it was for my own knowledge, and even for my own faith. If the Bible was only inspired by God, but written by humans, the mistakes I saw from before actually make sense! I now understood Christianity through the lens of humanity, not just through the words of the Bible. Instead of reading the Bible in an eisegetical manner, I now sought to read it in an exegetical manner⁴. As for scientific concepts like evolution, I finally saw the evidence for them far outweighed the beliefs I had in the creationism and anti-scientific, fundamentalist variants of faith that I had once espoused. In summary, I was now a progressive Christian who deeply sympathized with the tenets of liberation theology. I even contacted the friend I had offended previously, and profusely thanked them for dealing with my own naivety with such a kind heart. I was ecstatic about all these developments; it meant a new era for my faith.

This did not spell the end of my deconstruction process, though. It was only the beginning.

At one point, I had to re-evaluate my perspectives on hell. I could not fundamentally reconcile this with the idea of a tri-omni God, and eventually I found the rationalizations for hell quite sickening and incoherent. There was no way in hell (pun intended) I could justify a God being simultaneously omnibenevolent and willing to judge an inferior creation of His to an infinite punishment for the finite crimes over less than 120 years, at maximum. After all, He will take care of us with more diligence so than He ever will for the simple sparrow (Matthew 6:25-34), no? Through more digging, I found the ideas of Christian universalism, and read about St. Augustine and his ideas surrounding the doctrine. I was again ecstatic to find that there were others out there that had the same ideas as I, and was convinced of the goodness of God once more. My mind was pliable, and ready to learn more and more.

The COVID pandemic only served to give me more time to ruminate about these ideas. With the many hours I had just lying around, I took the time to just research everything I possibly could. I found out about the Apocrypha, along with other non-canonical books such as the Gospel of Thomas and other Gnostic texts. My perspectives on faith were changing by the minute.

Around this time (c. 2020-2021), I graduated from high school, and I started to dig heavily into philosophy and other related subjects. I took a philosophy class at my community college, and it was radically eye-opening to the different epistemological perspectives that existed through the times, including those of non-Christian ones that I had not really familiarized myself with yet. I took the time to learn about Søren Kierkegaard, Albert Camus, Friedrich Nietzsche, and the likes of other existentialist philosophers, and held the reasoning of Descartes for why there was a good God dear to my heart, since it seemed like a bulletproof defense of the concept. However, the walls were falling down all around me as I was exposed to every single one of these ideas, and they were all so compelling in their explanatory power and prowess, without the ontological baggage of the Bible as a whole. I was at a crossroads⁵ for my beliefs, without even knowing it.

Part IV: End of an Era

I didn’t know it at the time, but I had subscribed to a “God of the gaps”-like theology⁶, and kept this way of thinking throughout my time at community college after I had graduated from high school. I couldn’t let go of the idea, even I knew in the back of my head this was a flawed presupposition to have. However, there was a big development that I had noticed over the times that my beliefs had changed. I found myself less convinced of some concepts that were in the Bible; there were parts of it that I had once accepted as being irrelevant to the current message that now seemed irreconcilable with the fundamental assumptions about the God I worshiped that I had:

If there is a benevolent God, why is there so much evil that comes to those who do not deserve it (i.e. children)?
If there is an omniscient and/or omnipotent God, how can he change His mind? Does that not make Him non-omniscient and/or non-omnipotent?
Where is God, and why won’t he talk to me, despite my cries out to Him?

As you can tell, these were the fundamental questions of old; the problem of teleological evil, the Epicurean paradox, the problem of divine hiddenness, and the like. They were now questions that seemed completely unanswerable with even the most convoluted of theodicies. I was wrapping my head over and out in cognitive dissonance about the very fundamentals of the things that I believed. Sixth-grade me would have been terrified; however, I now had the desire to question even that which I was not to question. The “God of the gaps” theology I had at the time was still there in my mind, but that gap was shrinking, and it was shrinking fast.

What was also fundamentally different was that I couldn’t even bring myself to talk about God as if I believed in Him anymore. I would keep my faith status private, and when people asked me about it, I would just say it was a private matter, without elaborating further. I still went to church (and in fact was volunteering in some capacity almost every single week, whether it was playing drums, or running camera equipment, or something else). It was a little draining, since I didn’t exactly listen to the preaching, and didn’t share many of the same beliefs as I used to; after all, it was still a non-denominational church with relatively conservative beliefs. For almost a full year between 2022 and 2023, I kept going to church like this with no further problems⁷. I called myself an agnostic privately, saying that I was unable to truly know if there was a God or not since that idea was unfalsifiable; however, I wanted for it to be true, so that I didn’t have to lose my faith of old. There was one person at the same church I was going to that I confided this in, who himself had a similar view.

The principal problem that I initially failed to see was that the “God of the gaps”-like theology that I held was a black box; it stifled the desire to learn. I would be held back by the assumption that something is because of God, without the desire to go learn why that was regardless of God. The phrase that captures this the most is likely the tired, old adage that many Christians and atheists alike have heard at some point in their lives:

God works in mysterious ways.

This phrase was straight-up painful to hear after a while; it was as mentally painful as running straight into a brick wall. The sheer NUMBER of times I’ve heard this phrase is astounding, and it’s such a damn cop-out. How can you simultaneously claim to know God’s intentions through the Bible, and only resort to this adage when you can’t explain something within the framework that you have adopted? It’s as if the person who lets this phrase slip has a fear of the unknown. It has to work in some way because of my convictions. God absolutely had some sort of intention or causation behind this; we just didn’t know it yet, and we will once we do meet Him.

I had trouble squaring this thought with myself, but I simply just did for years upon end while I was still a Christian. I did this at all phases of my faith journey; it didn’t matter when I was a full-on young-earth creationist and fundamentalist, or when I was someone who leaned more towards an agnostic Christian perspective later on. Anything that I didn’t know a reason for was sent to a black box of fundamental assumptions I had about the nature of the world, never to be seen again, for God simply had a reason that I could not fathom, either for my own good or because I was not powerful enough to know; I did this for many of the questions I raised above. For a while, that is.

Until I couldn’t.

Divine hiddenness was the problem that pushed me over the edge. I prayed constantly in my head, even when I was agnostic. I just wanted what I considered to be a quite low expectation of an omnipotent being: a convincing explanation or experience that would unambiguously show me that this God that I had believed in for almost my entire life had a real presence. If you’ve ever heard the quote from William Lane Craig, of “If there’s one’s chance in a million that Christianity is true, it’s worth believing,” that was exactly what I had in mind. I prayed for signs, held on to my confirmation biases, held on to what my mother had told me when I was young: that I myself was a miracle in God’s eyes. I did it all. You would think that as an all-powerful being, He would be able to do this without overriding free will or whatever the next theodicy will like to claim; to say that this God cannot do something was simply a poverty of imagination on behalf of the apologist making the claim⁸.

But He never did, and that only made me incredibly sad. In my times of weakness, in my times when I wanted to throw myself off a bridge, or commit suicide in other ways, He was the defining example of silence. No response for my earnest efforts for proof in my darkest moments, when I was about to succumb to the worst act in regard to existence; in any other realm, I would have abandoned that idea for good, but why was I not doing that in this instance, where this God was so simultaneously incontrovertible in my head, yet effectively nonexistent?

I don’t remember when this happened, but I consciously came to the realization I was just uncomfortable with the words, “I don’t know”. I can say this phrase for so many other fields; the scientific realm, as a developer, as a drummer, composer, you name it. The unknowable is just that: unknowable. There’s nothing you can do; every proposition that is unknowable is in a superposition of sorts, but what effect can it have on me if that superposition can’t collapse into something knowable? Simply put:

You don’t have to know everything.

Being able to say that about things is magical. It’s lifting an epistemological load that I had to bear for years trying to justify what I couldn’t through convoluted chains of theodicies. I started getting content on my YouTube feed from absolutely phenomenal creators such as Forrest Valkai who changed my perspective radically on what it meant to even know something, and the theodicies started fading into the distance; I now found solace in the great unknown.

And so concluded my journey. I couldn’t answer the theological questions I put forth precisely because they looked like contradictions. And well…if it looks like a duck, walks like one, and quacks like one, then what else could it really be? If I truly wanted to decrease the amount of assumptions I held about the world, I had to let go of this untenable divine solution to a problem that we humans have created. There was no concrete day when this became the perspective that I became convinced of; it was just a thought I had in the back of my mind at first around the beginning of 2022, but it became stronger in its convincing power gradually. And as you can tell by the nature of this post, it prevailed.

I no longer believed in God (2023). God was dead to me, and I had killed him with my own hands. I had ripped him out of my throat⁹ after a 6-year battle with my own thoughts, from the end of 2017 to the end of 2023.¹⁰

There’s an important note to consider at the end of this process. This was not a choice that I consciously made. I simply was less and less convinced of the reality of the Christian god over time. I do not believe that you can choose your beliefs. Ironic, but my belief in this concept is most succinctly captured by this quote:

A man can do what he wills, but he cannot will what he wills.

→ Arthur Schopenhauer

Part V: What Now?

Where do I go from here?

It’s not enough to say that I’ve stopped believing in the Christian god. This way of living had influenced my life for 20 years at this point, so how was I going to approach my newfound lack of faith that I had finally come to terms with in my own head?

That’s a hard question. I still don’t know¹¹, to be honest. I wish I had a simple answer, but there are quite a few circumstances I need to take into account.

For one, I’m already outing myself as an atheist on here. Since I live in the United States, and have many family members and friends that are quite devout Christians, this is more of a big deal than if I were to do this being raised in a primarily atheist environment like Germany or something like that. I’m sure that many of my relatives, including my mother and my sister, will be rather disappointed, and some may cry in response to reading this post. And for that, I’m truly sorry. But in truth, it’s better for both them and I to face reality than for me to keep pretending. It’s just kicking the can down the road. Maybe some of them will come to me and tell me to listen to their favorite apologists, or call me a fool for not believing (Psalms 14:1). However, it’s almost trivial to reconcile any contradictions in the Bible, or to come up with some sort of theodicy in response to a posed problem. The question is if it is tenable to hold this fragile stack of reconciliations and theodicies together, and I don’t think it is anymore. Feel free to converse with me if we want to have a productive conversation about this though, I’m always open to talk about faith even if it is not something I have anymore, and I will never, ever berate someone for being a believer like the atheist caricature depicts.

I am still playing in churches as a drummer, and still attend my first church almost every single week. Part of this is to keep up a ruse to my Christian loved ones, friends, and coworkers that nothing is wrong with my faith, but I will also be losing some relationships with people that I would prefer not to lose¹². I have come to terms with the fact that I will not be playing drums at churches anymore if I were to leave this church I attend, but I haven’t come to terms yet with potentially losing some of my friends that I still want to keep in touch with. Presumably, once I do come to terms with this, I will leave. I’ve already told myself that I want to leave at the end of the month twice in these past two months; perhaps the third time will be the charm. I will update this page once I end up leaving the church, but if you don’t see a notice below this paragraph telling you about this, I’m still going to church almost every Sunday because I don’t have the balls to end the relationship.

UPDATE: I have indeed left the church, on July 7, 2024. It took almost three months for me to pull myself together enough to do it. I guess I grew the pair of balls that I needed :}

Additionally, I’m working at a company right now whose express goals are to help churches, and most of my coworkers are all of Christian faith. I could potentially be losing out on relationships I’ve made at work, and I do have to keep in mind that I could be losing my job as well. So if you’re reading this, and you’re working at the same place as me, please don’t be alarmed by this post. I am still willing to work with anyone regardless of their faith and goals, provided I still see potential. My lack of faith should not hold you all back from being able to work with me to achieve your goals. If it does, then so be it, and I am sorry that this is the way it had to end.

There are many more external consequences for losing faith, but this is already long enough as it is. I also have to become comfortable with myself losing faith; after all, it took almost a year before I could come face to face with the thought that I had lost it in the first place. What are the frameworks that I will be using to continue living? Many religious people will often claim that as an atheist, I will have no moral framework, or that I will have no purpose in life, or other such claims. Unfortunately for them, religion does not have a monopoly on morals or meaning. How will I live my life then, you may ask? Great question.

As for morals, I’ve adopted a much more flexible look at them. Morals are an extremely nuanced subject; after all, we make moral decisions based on a large variety of factors, but they are still reasons for deeming something morally good or bad. I’m not going to deny it; emotions and rationality have everything to do with morality, and embracing that reality is only going to be a good thing. Doubting my own faculties for rationality is also a good exercise that I will continue to do. After all, the only thing I know is that I know nothing.

There are still some things I take away from my former faith. I am a huge fan of the idea that you should love your neighbor as yourself. However, now I don’t need to burden myself with the excess baggage of religious duties, faux humility¹³ in the whole “I am a sinner and not worthy” manner, and the historical and current atrocities done in the name of God; I can simply take the parts that are relevant and apply them to my life, just as we do with any other principle or situation we see in life. No need for special cases anymore and twisting my mind into a pretzel as to why God would allow slavery (Leviticus 25:44-46) or the killing of innocent children (Genesis 7:21-23, Numbers, 31:1-18, and many more), while forbidding genuine love (Leviticus 18:22, 20:13)¹⁴.

The second step I need to take is also going to be a lifelong process. You may have seen the little animated quote on the front page of this little place I write in:

I seek to be free from the concept of meaning, to carve my own reality.

But what does it mean to be free from meaning? I have yet to discover this, but as far as I know, I have abandoned the idea that there is any meaning that is prescribed to me by a divine being, or by the universe, or some other inconceivable thing. Instead, I want to free myself of the chains that society have placed upon me, that I must do something of “worth” in order for my life to have meaning. As for what that entails, I don’t know; I am simply willing to find out. I want to embrace my almost-lost inquisitiveness, the one I used to have as a child without any remorse, and let it take me on a journey.

“I don’t know” is indeed a beautiful statement. It’s not a cry to find out an answer, but only a gentle affirmation of the truth as it stands within a given context. I will be leaning back on this cornerstone for as long as I live.

I leave you with a quote that has influenced me through this entire journey:

Think about it, think! It ain’t illegal yet. Think!

→ Eddie Griffin

Footnotes

This wasn’t knowledge in the traditional sense of the word, but rather a strict regurgitation of arguments. I don’t think that most apologia is in good taste, and serves as post-hoc rationalization for pre-existing belief, rather than the primary reason for coming to faith. ↩
I really used to like playing contemporary Christian music and other worship music on stage. But after a while, I grew to hate the simplicity of it. It was just boring and felt uncreative. The “magic” I refer to here is the idea of feeling “the Holy Spirit” while listening to this music. The truth is, I felt much more emotion and much more alive listening to Pulse/Surreal by Lantlôs than I ever did to Christian music I played on stage, because I saw through the veil of how formulaic and uninspired it was. I could go on for days about this, to be honest. ↩
My sister bought the book for me. If you’re reading this, thanks dude. That was $15 that changed my life. ↩
It’s hard to draw the lines between what constitutes each one of these, which only adds to the cognitive turmoil I had. ↩
Ironically, the first church I went to was named Crossroads. Guess I really had it coming. ↩
In reality, “God of the gaps” is more a subset of the argument from ignorance logical fallacy. ↩
I don’t quite know why I kept going despite disagreeing with the faith. I was maybe interested in how people on the other side thought, and in how I myself used to think. Perhaps I was just trying to look through a window to the past. I’m not sure, even as of the time of writing. ↩
I mean this with full intention. Anyone saying that God does not have the power to do something, while simultaneously claiming said God is omnipotent simply does not know what they are talking about, or are loading their words with some other hidden connotations. I’d like to be proven wrong. ↩
I am a huge fan of Nietzsche’s story The Vision And The Enigma. There’s a depiction of a shepherd ripping a snake out of his throat, where the snake represented the eternal recurrence that the shepherd was scared of. I’m alluding to that here, since Nietzsche is one of the philosophers that most resonated with me post-deconversion. The prior “I killed him” reference is also from his writings. ↩
Notice the change in capitalization. Just a little Easter egg for you :}. ↩
I said “I don’t know”. That was the joke. Whoosh. ↩
Networking is already hard for software engineers, and I got my most recent connections through churches. Needless today, it’ll only become harder if I lose my existing connections. I would love to work for you if you are hiring, here’s my résumé just in case! ↩
If you have to express your humility in any way vocally that explicitly denigrates your own lack of worth or your own failings, it’s not humility anymore. It’s self-hate. Loving your own neighbor as yourself requires you to love yourself first; ironic coming from a dude who struggles with self-esteem issues, but that only makes it more poignant a point. ↩
I support the LGBTQ+ community. As an asexual dude, it’s hard not to. ↩

Zig Comptime Is Absurdly Cool

Tue, 13 Aug 2024 00:00:00 GMT

NOTE: If you’re on a mobile browser, I recommend reading this in horizontal mode or on a laptop for a better experience.

Part 0 :: Synopsis

You may have heard of Zig, a new (-ish?) systems programming language. It markets itself as being extremely simple, and its mission is to create a language where there is one obvious way to do things. Quite possibly the antithesis to C++ in its pursuit of simplicity.

I’ve been using it to write my own CLI replacement for NixOS tools, named nixos (boring, perhaps, but gets the job done). It’s been a pleasure thus far, despite the lack of an extant ecosystem for dependencies like Rust or Go. It’s forced me to solve problems that I would have otherwise reached out to dependencies for, and overall is making me better at software. I’ll probably save the personal glazing for another post, though.

Part I :: `comptime`

Compile-time semantics can be pretty hard to grok. More often than not, most languages that have some form of a strong type system will force you to learn the intricacies and limitations of said type system.

This is one of the biggest features that Zig has to offer: clear compile-time semantics without the usage of macros, code gen, or a weird in-between language like C++ templates. I use the word “language” liberally here; if we define language as a signal-based mechanism for communication, then C++ templates can quite possibly be the poorest way of expressing this concept¹. But I digress.

comptime in Zig is just a way of running normal Zig code at compile time. There’s no other language to understand, no preprocessor to fight with, just Zig code that runs when you run zig build. Basically, anywhere that requires a value be known at compile time (array sizes, types, etc.), you can pass a comptime value, and it should just work. This makes it extremely simple to do things like use types as normal values, reflection, generics, and many more features that are available only in higher-level programming languages or in lower-level languages with macros. Additionally, it’s much easier to read and write since LSP autocomplete exists already (it’s normal Zig code, after all).

Take for example the following piece of code:

pub fn runtimeOnlyDiv(comptime T: type, a: T, b: T) T {
  if (T == comptime_int or T == comptime_float) {
    @compileError("you big dumb dumb, don't use comptime values in this function!")
  }
  return a / b;
}

This allows one to divide numbers with this function, while restricting comptime types from being passed to the function. While being quite superfluous (like what the fuck would you even use this for?), this demonstrates the fact that types are values at compile-time, and can thus be operated on like any other value within that context. In fact, this is exactly how the ArrayList data structure is implemented!

pub fn ArrayList(comptime T: type) type {
  return ArrayListAligned(T, null);
}

A function that returns a type! How can this be? Well, an ArrayList is just a struct under the hood with the given type as its field. This function can be placed anywhere a type is expected, since it returns a type, and Zig will evaluate this so that it fills in the correct type. This is called monomorphization, and is more or less what C++ and Rust do with their templates and traits, but expressed as a simple function! I vastly prefer this form of generics over C++ and Rust since it reads much simpler to me. I don’t have to rip my brains out to understand it.

A trippy result of this is that even parameter types can be expressions that generate types!

pub fn set(self: Self, comptime T: ValueType, context: NixContext, value: (switch (T) {
  .int => i64,
  .float => f64,
  .bool => bool,
  .string, .path => [:0]const u8,
  .null => @TypeOf(null),
  .list => Value,
  else => @compileError("type '" ++ @tagName(T) ++ "' cannot be used for the set method"),
})) !void {
  const err = switch (T) {
    .int => libnix.nix_set_int(context.context, self.value, value),
    .float => libnix.nix_set_float(context.context, self.value, value),
    .bool => libnix.nix_set_bool(context.context, self.value, value),
    .string => libnix.nix_set_string(context.context, self.value, value),
    .path => libnix.nix_set_path_string(context.context, self.value, value),
    .null => libnix.nix_set_null(context.context, self.value),
    else => @panic("value cannot be of type " ++ @typeName(@TypeOf(value))),
  };
  if (err != 0) return nixError(err);
}

Even if you’ve never read Zig before, this is probably decently easy to read if you are somewhat proficient in programming.

Well, where does this really show its beauty? Generics, sure, but what about anything else? Well, I mentioned comptime can also be a solution for compile-time reflection that does not involve macros or code gen.

Part II :: The Situation

In my nixos CLI, I have a Config struct that is filled in from a TOML configuration file. It looks like this:

pub const Config = struct {
  apply: struct {
    imply_impure_with_tag: bool = false,
    specialisation: ?[]const u8 = null,
    use_nom: bool = false,
  } = .{},
  config_location: []const u8 = "/etc/nixos",
  enter: struct {
    mount_resolv_conf: bool = true,
  } = .{},
  init: struct {
    enable_xserver: bool = false,
    desktop_config: ?[]const u8 = null,
    extra_config: ?[]const u8 = null,
  } = .{},
  no_confirm: bool = false,
  use_nvd: bool = false,
};

Nothing too crazy, just a struct with some values. I left out some more complex types for the sake of simplicity.

A cool feature that I wanted to implement is setting configuration values using command-line arguments. git does this, where an invocation like git -c commit.gpgsign=false commit, will disable GPG signing for just that one invocation when committing your code. This enables flexibility for when misconfigurations happen with your GPG key, and you just want to create an unsigned commit without changing your configuration.

However, Git has a ton of options. Just tab through with git -c in zsh, and you get this:

$ git -c
zsh: do you wish to see all 621 possibilities (69 lines)?

Oh, hell no. There’s no way git parsed those options manually, I thought to myself. That 69 is just the number of top-level git options! The number of options in my Config struct seemed like they would only grow and get more nested. I don’t want to keep going back to that every time a setting is added!

I thought about how to solve this for a while. Then, all of a sudden, a lightbulb went off in my head. I could just use compile-time reflection to traverse the struct fields given a path.

The result:

fn setFieldValue(comptime T: type, path: []const u8, value: []const u8, ptr: *T) !void {
  switch (@typeInfo(T)) {
    .Struct => |structInfo| {
      inline for (structInfo.fields) |field| {
        if (std.mem.startsWith(u8, path, field.name)) {
          const rest = path[field.name.len..];

          if (rest.len == 0) {
            if (field.type == bool) {
              const parsed = blk: {
                if (mem.eql(u8, value, "true")) break :blk true;
                if (mem.eql(u8, value, "false")) break :blk false;

                return error.InvalidBoolean;
              };

              @field(ptr, field.name) = parsed;
            } else if (field.type == []const u8 or field.type == ?[]const u8) {
              if (field.type == ?[]const u8 and value.len == 0) {
                @field(ptr, field.name) = null;
              } else {
                @field(ptr, field.name) = value;
              }

              return;
            } else {
              return error.UnsupportedType;
            }

            return;
          } else if (rest[0] == '.') {
            return setFieldValue(field.type, rest[1..], value, &@field(ptr, field.name));
          }
        }
      } else {
        return error.NoPathExists;
      }
    },
    else => return,
  }
}

If you don’t understand this, don’t worry! I’ll walk you through this.

fn setFieldValue(comptime T: type, path: []const u8, value: []const u8, ptr: *T) !void {
}

These are the parameters:

T :: a type (the type of the struct we want to modify)
path :: a path to a potentially nested field in the struct, separated by dots (example: apply.use_nom)
value :: the string value from the command line
ptr: a pointer to the struct value to modify

Cool, right?

switch (@typeInfo(T)) {
  .Struct => |structInfo| {
    inline for (structInfo.fields) |field| {
      // ...
    }
  },
  else => return,
}

This might look weird at first. This just checks if the type provided is a struct, and then starts looping over the struct’s fields. Each field has certain metadata associated with it: a name, the type (which is itself a comptime value of type, and other things) Notice how this is an inline for loop; in comptime, loops are unrolled, since evaluation is strict inside comptime boundaries, and must terminate. After all, the compiler must strictly evaluate all of these values for them to make sense; type information cannot be available in the resulting binary.

The else => return makes sure to not do anything if the type is not a struct. This may be confusing (shouldn’t this be a compile error, right?), but I will come back to this later.

if (std.mem.startsWith(u8, path, field.name)) {
  const rest = path[field.name.len..];
  if (rest.len == 0) {
    // this is a valid config setting, parse and set the value
    return;
  } else if (rest[0] == '.') {
    return setFieldValue(field.type, rest[1..], value, &@field(ptr, field.name));
  }
} else {
  return error.NoPathExists;
}

This is the real meat; if we have a field that does match the start of the path passed in, then we check if there is more. If there is more (aka when there is a dot right after the field name), then we recurse into the field where that exists. And if there is no dot in that first index, then we just continue on and no field matching that will be found. If there is no more (we have reached the field we need to modify), then we have reached the field that we want to modify and can access it with @field(ptr, field.name) in that block with the comment, and execution can end once we set the value.

The else => return in the switch case is required due to this recursion. Since the compiler will always hit a case where the nested field is not a struct in order to terminate evaluation, we make sure to not emit a @compileError() in the default case.

if (field.type == bool) {
  const parsed = blk: {
    if (mem.eql(u8, value, "true")) break :blk true;
    if (mem.eql(u8, value, "false")) break :blk false;

    return error.InvalidBoolean;
  };

  @field(ptr, field.name) = parsed;
} else if (field.type == []const u8 or field.type == ?[]const u8) {
  if (field.type == ?[]const u8 and value.len == 0) {
    @field(ptr, field.name) = null;
  } else {
    @field(ptr, field.name) = value;
  }

  return;
} else {
  return error.UnsupportedType;
}

This final snippet runs if the path to the field exists. It checks the field type, validates it if needed, and sets the value based on that. Pretty self-explanatory code when you read it; it trivially parses booleans for bool fields, or shoves the value into a string ([]const u8) slice, accounting for potential empty values by treating them as null.

This took an hour to implement. I now had dynamic field-setting code that I probably won’t have to touch for a good long while as I add more configuration options, all because of Zig’s comptime. At most, I’ll just need to add more types to check for like integers or dates, if they crop up. Amazing!

Part III :: Conclusion

What is the point of this post, besides glazing over a programming language like every other Rust fanboy out there (IYKYK)? The point is that I’m learning new things every day, and this is one of those things that just blew my mind away, even though I’ve been using Zig for around a year to this point.

No matter what, there’s always new stuff to learn. And Zig is fun to use. Go try it out, and keep doing fun shit!

Footnotes

I don’t like C++ very much, as you can tell by the tone of this post. It’s just not fun for me to read or write. I’ve only used it for university projects thus far, and I don’t really want to fan the flames of the language wars, but it’s just my opinion. Don’t take it personally. Nix is written in C++, after all, and I love Nix. It is what it is. ↩

Freecoding - An Alternative To Vibe Coding

Fri, 20 Jun 2025 00:00:00 GMT

Knowledge is power. Especially in an age where knowledge is being outsourced to entities that we don’t even know much about yet.

A very American mentality, to say the least.

What the fuck are you talking about, Varun?, you may ask. Great question.

I’m talking about large language models (LLMs) and their widespread effects on society, and especially on that of tech workers. Actually, let’s zoom in on our target: so-called “vibe coding”. A term that was only coined four months ago by a really damn smart guy, but with the AI bros frothing at the mouth following close behind. That Twitter thread is genuinely sickening to read. As members of the post-industrial world, we have taken many steps backwards, convincing ourselves that LLMs and their sycophants are the sole way forward towards some Wall-E-esque goal¹.

This all sounds the ramblings² of a man who’s gone slightly insane, right? I think I have in this regard, but for damn good reason. Many tech workers have utilized AI in this way, and justified the terrible tradeoffs that this brings about by mindlessly quoting “efficiency” and “productivity”; they are collectively paying the price of not learning for some minimal, short-lived success.

I’d imagine the following words have probably been spoken somewhere in a nondescript office building’s coffee break room in San Francisco:

Oh my, Jared³, look at the new application that’s on the front page of Hacker News and Reddit this week! It’s vibe coded, and probably made up of piles of shit-tier spaghetti code that even an Italian will gawk at. Another money-maker, successfully come to fruition with just the power of imprecise thoughts and contrived delusions of grandeur!

To be frank, I’m APPALLED at the state of post-LLM programming these days. It’s genuinely disgusting to me that people will literally give up thinking about system design and architecture, reduce it all down to the pure essence of “It’s just computer code!” without regard to how it works. And after they adopt this insulting attitude, they then spit out complete trash and dress it up like a pig with lipstick, and then make MILLIONS off their trash, all without due respect to the sources of their material.

It’s as if drop-shippers have found their new grift. Like they’ve turned to vibe coding to make a quick buck off some bullshit B2B SaaS product that’ll die in the next 2 years after they get their venture capital money and disappear off the face of the Earth. What a terrible way to live life.

So, on my never ending quest for knowledge, I decided to move in the opposite direction: something that I now call freecoding :: like free climbing, but for coding;

freecoding :: an approach to producing computer programs by usage of minimal tooling needed to get the task done, which often involves the constant questioning of what is truly “necessary” in a programmer’s workflow

And yes, I’m coining this term in direct opposition to vibe coding.

Let’s learn⁴.

A Swing And A Miss

My experience with vibe coding was atrocious. Think about vibe coding this way. Every time I tried it⁵, it felt like I was picking up a large multi-dimensional hammer, swinging it at a nail the size of a few atoms, and somehow missing. Because that’s basically what it is.

The very first time I tried to vibe code, it was in April 2025 at a university hackathon; my first one, too. Hackathons are supposedly the best environment for this sort of “style” of coding, if you can call it that. The goal? Shit out a proof-of-concept product over a weekend that does something that would have otherwise taken a much longer time to spec out code for.

It went horribly.

We were building a CLI in Go for a new version control system, and I thought it would be a cool time to try vibe coding. I didn’t want to scaffold out a whole web application AND a large CLI boilerplate, since I wanted to show off our product’s functionality! Focus on the business logic, rather than the routine boring stuff, right? So I installed a Copilot-like plugin into my Neovim environment, pulled up a ChatGPT tab, and went off to the races. And from that point on, I was more dumbfounded than impressed.

Because nothing worked at all!!! Well, that’s a bit of an overstatement, but when things didn’t work, shit hit the fan real fast.

Unless I (and my hackathon buddies) went into an astounding amount of detail in order to describe the application requirements, our LLMs would confidently shit out command scaffolds that were just wrong. When I tried to lead it down the path to the actual that requirements I wanted, they would initially agree with me, as if they were repenting of their sinful ways. But to my dismay, they would stubbornly continue down the same paths they initially came up with. Like a fucking donkey, begging for water even as the trough is right in front of him!

Using the wrong command scaffolding and names? Contriving different ideas for our version control strategies that were blatantly ripping off Git (which we were explicitly trying to avoid)? Fucking up styles and not using Tailwind and resorting to terrible CSS that made no sense? You name it, the LLM would fuck it up!

In the times that it was successful, it was always with some hidden cost. Usually, it was countless minutes of getting frustrated at output that just was not useful, along with the lack of the euphoria that a programmer usually gets from, you know, actually doing something!

At the very least, if I wrote code that did not work with my own hands, I would learn more about why the code I wrote was bad, and how to design my systems better. Instead, I was spending my time chasing bugs that I would have never created in the first place if I had just spent the damn time creating the code.

I was replacing personal growth with laziness, and that’s just not acceptable. Nor should it be treated as such.

Cue a few little snippets of my ranting over those few cursed days:

No, I don’t want to pull in random-ass React dependencies just because! Fucking hell, Gippity⁶, do you really want another left-pad incident or something?

Huh? Stop trying to combine these two unrelated pieces of code because you think “don’t repeat yourself” is divine command⁷!

What the fuck??? Who thought it was a good idea to keep checking for the HTTP method being called like 5 different times? Oh right! Copilot DOESN’T KNOW WHAT THE FUCK IT’S DOING! SINCE WHEN DID IT EVER????

Not to mention the fact that since LLMs don’t always search the internet for documentation, we would sometimes get old, deprecated, or removed APIs in our code that were replaceable by better patterns. It almost felt like my group and I were at slot machines, just hoping to hit the jackpot by hitting the “Generate” button again and again and again⁸.

Guys, this is not what people meant when they said to “program by wishful thinking”! We’re supposed to be LEARNING from our mistakes, not just praying for dear life that the next time we “prompt engineer” our badly-phrased requirements, we get useful output! Have we heard of the colloquial definition of insanity⁹, people?? That’s exactly what’s happening here! Yet it’s as if Jesus himself had come down and enacted Isaiah 6:9-10 on just programmers¹⁰.

We must, and can do better than this.

Oh, That’s What The Hammer Is For?

So, instead of attempting to get the AI to swing the fucking hammer for us, let’s, I don’t know, try doing it ourselves! That was my first thought after this absolutely horrid experience.

However, I decided to go one step further. I asked myself this question:

How did the programmers of old learn the lessons they did?

Oh! They DID IT THE HARD WAY. If they didn’t have the tools they needed, they did the hard work of researching requirements, figuring out a PLAN OF ACTION, and just fucking doing it themselves. Hardcore as fuck, and I love it. Because they had no other choice.

Old programmers, such as my OS principles university professor, are almost always remarkably amazing at what they can do, since they understand the fundamentals of programming from first principles. So I wanted to emulate their ways of thinking.

To test this out, I stripped out as many tools as I thought were possible to strip out of my setup, and to work on a Go application for a few days, to see how it would go. The project in question, nixos-cli, was rather large, but organized well, so I thought it would be the perfect way to dip my toes into this intimidating way of creating code without much assistance.

The only tools I had on hand? My text editor (Neovim) with a mostly vanilla configuration (no LSP/autocomplete though, just Telescope and few plugins to make navigation slightly easier), go, make, my terminal (kitty), some small command-line tools like fzf and such, my web browser¹¹, and that’s it. Nothing else.

Swinging The Hammer Myself

Let’s start freecoding!

I was in the middle of a rewrite of this project from Zig to Go. As such, my goal for this freecoding session was to port the nixos option command’s TUI, but only using documentation, as well as occasionally resorting to browsing issue trackers and examples to get a feel for dependencies I was using.

Oh man, I struggled at first.

I didn’t realize how much I relied on LSP and such to move around badly-organized codebases. Not to mention, how did I even look for invocations and other such things?

Simple: use grep/rg and name variables better so that they’re more “grep-pable”!

What about errors? How would I know if my code had errors? How would I start testing my code?

My process of writing code started to change after asking these questions: I started recompiling quite frequently to check for errors, and was writing less useless code and testing it more frequently as a result. I even started mocking out my desired behavior in comments and in super rough design documents, rather than just diving in headfirst.

I seemed to have forgotten that source code is communication between not just the developer and computer, but between developers as well. And once I realized this, it all clicked, and my world exploded for the better.

Navigating around package names and functions forced me to think about how I was organizing my code better, and made me create better abstractions around my screens and program state. Not to mention that it helped me research different solutions to problems that I ran into, since I was finally asking the correct questions about my own code before I even typed it into the buffer. This was looking good!

I had the nixos option rewrite complete in a week, all while going to and from my university and working on it during classes. Even though this was much slower than I would have liked it to be, I learned a ton throughout the process about many things. Some things like how the Elm architecture translated to a much more imperative programming language, how to mimic Rust-style enums with interfaces, and many other fruitful revelations came from just turning the fucking autocomplete off.

Just think about that for a second. This is a great source of knowledge! And it just came from turning my tools off and understanding why they were there in the first place. And now, hell, I can probably work more effectively in more restricted environments and am more adaptable to shitty situations thrown at me.

One of my friends mentioned this same phenomenon too in different ways. Quote from one of our conversations about this (with some editorializing for clarity):

Yeah, I actually did the whole “freecoding” thing subconsciously during our filesystems¹² project. There’s I think some mechanism in my brain where I try to make code more readable when I’m not using an LSP or have legitimate syntax highlighting. The process of “paper and pen” compilation in my head as I’m writing code is valuable, since the best way to not get compiler errors when writing with 0 tooling is to just not write any fucking compiler errors (5head, etc.).

Let’s be frank for a second. This doesn’t seem like some big realization!, you may be thinking. And you’re right. It’s the way that most fruitful learning happens: by understanding from first principles why you need the tools you do. You’re not gonna know what a hydraulic press is for if you don’t know what the fuck the term “pressure” is.

So now the question arises: regardless of the fact that I had this enlightening experience from programming with minimal tooling, why should people not use LLMs for code? Are LLMs not just another tool in the box, just like LSP and code autocomplete? Are they really as damaging as I claim they are to programming knowledge?

The Beasts That Cannot Comprehend

LLMs are fundamentally just next-word-predictors with a decently high degree of accuracy. While this seems like a rather reductive view of the amazing technology behind them like the transformer architecture, the whole idea is that with a high degree of accuracy, they are able to simulate intelligent output.

This next-token tech has existed for a while in the form of other precursors, such as Markov chains. So this isn’t a new, groundbreaking concept, it’s just an evolved version of it.

However, this means that no real semantic information is being encoded about tokens, but rather LLMs will be learning about how likely one token is to follow another.

Think about it this way: I want an LLM to evaluate the expression “1 + 1 =”. However, the LLM only knows what the token “1” is in relation to other tokens, since it sees it as an “embedding” (aka some numerical value in a multi-dimensional space). It may predict that “2” is the next token after this, due to the fact that it’s probably seen this relation in its training data.

That’s INCREDIBLY wasteful calculations to predict what the next token is when it comes to mathematical expressions, simply because the LLM has no idea what a “number” even is definitionally. It only sees what the number token is in approximation to other tokens in its datasets. Not to mention that a nonzero chance of being wrong should never happen when attempting to evaluate expressions. You don’t expect a fucking calculator to be wrong, right? So why should we suddenly start trusting the output of something that has the potential to be confidently wrong by its own core design principles?

Let’s take this concern, and apply it mathematically with some basic statistics. Since an LLM is a token predictor, it has some nonzero chance of generating incorrect predictions. Let’s see how this can spiral during a prompt-based conversation; assume a flat per-token accuracy rate of 99.99% over a wide variety of situations, so a 0.01% chance of error for the next token. This is probably more generous than I can give most LLMs credit for, but I digress.

The possibility that all tokens are theoretically correct assuming this flat per-token accuracy relies on the probability of purely independent events all following a predicted outcome, as represented in the following formula, where n is the number of events:

Pallcorrect=pn=0.9999nP_{all correct} = p^n = 0.9999^nPallcorrect=pn=0.9999n

Interestingly, in this formula, since I am treating each event as purely independent, this is probably the highest rate of accuracy that could be achieved for this hypothetical LLM in particular. But I’ll get into why that’s a problem later.

The expected number of errors is linearly growing, would then follow this formula:

E(n)=n∗(1−p)=n∗(1−0.9999)=n∗0.0001E(n) = n * (1 - p) = n * (1 - 0.9999) = n * 0.0001E(n)=n∗(1−p)=n∗(1−0.9999)=n∗0.0001

With some more realistic numbers of tokens:

1000 tokens :: E(1000)=1000∗0.0001=0.1E(1000) = 1000 * 0.0001 = 0.1E(1000)=1000∗0.0001=0.1
10,000 tokens :: E(10000)=10000∗0.0001=1E(10000) = 10000 * 0.0001 = 1E(10000)=10000∗0.0001=1
100,000 tokens :: E(100000)=100000∗0.0001=10E(100000) = 100000 * 0.0001 = 10E(100000)=100000∗0.0001=10

10 errors over a 100,000 token conversation? Doesn’t seem like much at first. But here’s the real kicker: semantic drift.

Remember what I said earlier about treating each event as purely independent? Well, that’s just not the way models work. A next-token predictor is always generating dependent events by definition!

This leads to all sorts of cascading errors, and thus error probability is no longer linearly growing, but rather exponential. One “error” could easily be a categorical one that shifts the entire conversation in a completely unwanted direction with even more “errors”, especially ones generated early on in an LLM prompting session. Models don’t recover from this easily without some re-grounding, either in the form of introducing new/better context or just a full blown new prompting session without the previous errors (aka putting in more coins spinning the wheel again).

Programs usually have tons of moving parts to them, so mistakes can very easily compound to give you a terrible developer experience. One variable name that didn’t get translated over? Oops, sorry! Time to look through and replace it. Misleading comments that go unnoticed since they don’t interfere with code execution? You betcha! A logic bug in one small place that you didn’t think there should be one? Have fun drinking away your sorrows at 3 AM wondering why something broke because it was a > rather than a >= sign!¹³ Because the LLM is so smart, apparently.

Not to mention the fact that if one relies on AI for test generation, and is the type of developer to have the mental binary between “It works!” and “Why no work?”¹⁴ and nothing else in the brain (cue: aka vibe coders), they run into another problem. Their tests might just straight-up be wrong, and it’ll slip right past their empty brain and into code that I’ll have an aneurysm looking at two years later.

And the most insidious of all: generating code that works, but is complete fucking spaghetti that is so tangled that even Mario himself would struggle to eat it. Tech debt is very real, and someone ends up paying the price for it down the line. And it sure as hell isn’t the AI that generated the slop.

The Heroes They Could Not Comprehend

This mountain of problems is why I massively respect the programmers of old and the people that are willing to dive into unknown topics without the comfort of an LLM.

To be quite frank, I probably would have fallen into the same hole, had I not been interested in the likes of Zig and Nix. Two of my favorite pieces of tech in existence as of the time of writing; both were focused on very different realms, but they oddly had one thing in common in 2022.

Both had a terrible lack of datasets and resources for LLMs to train on.

And oh boy, was that a fucking blessing in disguise for me.

I remember there were countless times that I tried to generate Nix code for my system, thinking that it would find the right options in the module system and correct configurations to create for me. That it would come up with the right abstractions. Nah, it just generated nonexistent module options and blatantly told me false things about how the Nix module system worked to merge modules together, and caused me to go down rabbit holes for days on wild goose chases.

I tried to do the same things with Zig, but oh my God, it was somehow worse. Because it wouldn’t just come up with nonexistent APIs from the standard lib or try to hallucinate terrible-performing code that would throw instances of very obvious detectable illegal behavior or not use the language effectively.

Nah, it would just throw out invalid syntax. And trust me, it took everything in me to not crash out and shut down in the middle of physics class when that happened¹⁵.

Who the hell is this pipe dream of vibe coding even fooling? Tons of people, unfortunately. Just look at tech bro LinkedIn. Or maybe listen to an investors meeting at YCombinator when they are deciding who to fund in their next batch¹⁶. Or actually, don’t. Save yourself some sanity.

The Fool Says In His Heart: I Can Vibe Code!¹⁷

Ah, the ones that refuse to learn, and thus cannot even see that they are the fools in this game. Fools don’t know that they are fools, right? They think that they’re wise.

So how is it that despite my massively positive experiences with the lack of AI in my programming career, that vast swaths of programmers and tech CEOs are enamored by their siren-like singing? Why were they fooled by the fancy weighted billion-side dice?¹⁸

The real answer? The fools have always existed when it comes to new tech.

Every single time another SF-based AI CEO floats another promise of an “artificial general intelligence” (AGI), another piece of my soul leaves my body out of sheer cringe. Since somehow the next iteration of a fancy next-word predictor is the sign of ultimate intelligence for our species. Give me a fucking break.

Not only do we have AI CEOs blatantly lying about their products’ capabilities in an unprecedented way, the drop-shippers and tech bros EAT THAT SHIT UP. They shill the ever-living FUCK out of Claude and the like, and it’s like they can never shut up about their latest course on how to utilize it “properly”. The middle managers hear “We can hire less developers!” and go straight for layoffs, thinking that the cost for fully AI-assisted coding will be less than hiring junior developers. Then startup founders follow after this example, thinking “Maybe I don’t need to hire a developer and I can make this idea myself!”

Can you? You can, but for a price. And a very hidden one. There’s no such thing as a free lunch, you’ve heard this thousands of times!!! Why do you never learn??? Have you seen the prices for tools like Cursor IDE and the like? They’re fucking outrageous.

At the time of writing, there is a Free plan that allows 200 requests per month. That’s pure gambler’s fallacy, a pure distillation of that “Just one more prompt, bro!” attitude, so pure that it looks blue¹⁹! Oh, but it gets worse.

Pay $20 per month, and you get 500 requests! Hell yeah, more tickets for the slot machine! Not to mention as long as you wait in line for a little longer each time, you can actually spin the wheel as many times as you want! Because you technically get unlimited “requests”, just on a much slower mode. Because that’s economically sustainable, right?

Well, OK, hold on. What if you use another model? “Bring your own model”, just like you’d BYOB some moonshine to a house party or something, except much worse. Well, it’s charged per request.

But what’s a request even? As per documentation:

A request represents a single message sent to the model, which includes your message, any relevant context from your codebase, and the model’s response.

One request is $0.04.

WHAT??????

25 requests is 1 dollar????

“Hit me. Hit me. Hit me. Why no work? Fuck, I guess hit me again!”

That’s exactly what I imagine vibe coders saying when they are in front of this absolute fucking Ponzi scheme of an application that is Cursor, or any other so-called “agentic coder” or whatever memetic juice they’re on again.

And the even more outrageous thing about it? When investors eventually get tired of sinking trillions of dollars into AI for massively diminishing returns, AI companies will charge out their ass to break even and not die. And then these vibe coder fucks will pay even MORE just to get the same shit-tier output, all because they are not willing to learn the fucking tech themselves.

This is pure, out-in-the-open vendor lock-in, just like Apple would have done. They reel you in like a fish, hoping you become reliant on their tooling, and then eventually extort you for what you’ve got. And vibe coders will happily pay these exorbitant fees, smugly thinking that they’ve successfully put us real engineers out of a job like the fools they are. Steve Jobs would be so proud of Cursor and OpenAI. And no, that’s not a fucking compliment, as some tech bros would have you believe.

Reconciliation?

Is it possible to reconcile vibe coding with freecoding? More specifically, can they coexist?

Possibly.

As much as I bash on AI dumbing down the general populace, in the hands of master craftsmen it can take them quite far. While I am no master craftsman, I can very confidently say that liberal usage of AI has helped me learn how to utilize complex systems such as Kubernetes quite quickly. Hell, I used ChatGPT at work to help me put together a GitHub Actions actions-runner-controller setup with self-hosted Nix caching and other tools, despite never having worked with Kubernetes in any meaningful capacity beforehand. But the key is that I’ve learned how to utilize it while doing so, and will absolutely remember the concepts and mistakes that I have made and learn from them, even with that liberal AI usage.

Remember low-code tools? I put vibe coding squarely in the same place. It’s for the people who don’t have an innate desire to learn how complex computer systems work in order to bring their ideas to life. Or, more crassly, the ones that simply don’t regard code as the art form that it is.

Actually, hold on. Let’s generalize that a step further. Vibe coding is for the people that want to profit off the work of others without actually doing any of the work themselves, or at least the most minimal amount possible. Like people that don’t want to pay artists properly for their work, and instead remove watermarks from stock photos and pass it off as real in their games and media.

A remarkably simple analogy, right?

My goal for writing this piece isn’t to be critical of AI. Many people far smarter than I am have done so with far more compelling points. I am a fan of what AI can bring to the table, but it sure as hell isn’t this trash that is vibe coding. Us humans, we can be far more effective when we use the generative capabilities of AI with correct context from our own sources of knowledge, rather than offloading the knowledge itself to the machines and reaping the limited profits until it’s too late.

Just remember: when vibe coders hit that “Generate” button, they utilize the massive amounts of work that went into making the data for these models to consume. All with nothing but that disrespectful “Just one more prompt, bro!” attitude. They pay massive amounts of money to companies instead of doing themselves a favor and learning the technology for themselves, or at the very least, God forbid, stimulating the economy by creating a job for someone.

Respect the process or not, it’s your choice at the end of the day to vibe code or not. It’s not like you can gain muscles by having an industrial machine doing the lifting for you, but I have no say in whether or not you’ll choose to put in the work or not. I can only rant about how bad it is for you, and hope you see the same way I do afterward.

Fin.

A special thanks to my friends Zachary Howe and Vignesh Guruswami for reading my article before publishing it and for suggesting improvements.

Footnotes

Yes, this does remind me of the movie Wall-E. In Wall-E, the whole reason that the world turned into a landfill was in the name of human progress. I highly recommend watching Zoe Bee’s video In Defense of Inefficiency for more on the topic. ↩
Bear with me here. Simply put, I can’t really stand here anymore and claim that the people that have fully embraced AI are somehow in the right anymore. IMO, the usage of AI in such a way that it becomes core to your workflow is a disservice to your own cognitive abilities, and that’s not something I can excuse as just a valid “tradeoff”. ↩
I don’t know why I used the name Jared. If your name’s Jared and this doesn’t apply to you, sorry. ↩
Please. Let’s learn. It’s good for you. I swear. Unless you’re too brain-rotted by LLMs to understand what the concept of real learning means. ↩
Admittedly, after this this experience, I never tried to vibe code again. Terrible developer experience, to say the least. ↩
“Gippity” is the endearing term that my friends and I have started to use for ChatGPT. Other LLMs have their own: Gemini is “Jiminy”, so on, so forth. Thanks, ThePrimeagen, for being such a terrible influence on us. Also, “SQL” is now pronounced “squeal”. Crucify me. ↩
Yes, it’s very possible to overdo the Don’t Repeat Yourself (DRY) principle. And LLMs are very prone to this, since they have limited knowledge about your systems that you are designing. ↩
Funny enough, the “Just one more prompt, bro!” attitude is something that I found about while reading this great article that made the connection click for me. Amazing read, give it a go. ↩
The “definition of insanity” as mentioned here is “doing the same thing over and over again and expecting a different result”; this is often mis-attributed to Albert Einstein, but regardless of the origin, it’s a damn good quip on being adaptable instead of banging your head against the fucking wall. ↩
“Be ever hearing, but never understanding; be ever seeing, but never perceiving. Make the heart of this people calloused; make their ears dull and close their eyes. Otherwise they might see with their eyes, hear with their ears, understand with their hearts, and turn and be healed.” ~> Isaiah 6:9-10. ↩
Don’t you dare say it. A browser is a critical part of using the Internet and viewing documentation, especially in Go when looking for dependencies and such, so I don’t want to hear anything about “Oh but you can just search up answers to questions!” Because no, I didn’t. Trust me on this, that would have defeated the whole point of the exercise; ego lifting/programming is bad for everyone involved. ↩
For context, both him and I had to write a full-blown FAT-style filesystem with a Linux-like shell for our OS principles class. It was really fun, and I learned quite a lot. Thanks to my friend Vignesh for this quote, by the way. ↩
I was stoned while writing this, so I definitely could have thought of better examples. But I feel like this catches my emotions about the subject better. ↩
Hi Matt. Why no work? ↩
Crashing out here is definitely a symptom of the “Just one more prompt, bro!” attitude I just mentioned in the earlier footnote. Very telling. Funny enough, LLMs will still struggle with Zig, since it’s such a moving target. It even struggled in a recent interview that I had with Bun, where I decided to try it out due to a terrible time constraint of implementing find in 1 hour with nothing but the C stdlib in Zig. Sometimes, hell, it’s even struggled with Go when I’ve attempted to ask it for advice, since it didn’t know the reflection APIs very well and thought that integer range syntax was invalid despite being in the latest version (1.24 at time of writing). ↩
Because LOOK AT HOW MANY AI COMPANIES are funded by YCombinator! Scrolling down this genuinely gave me whiplash, and makes me wonder what will happen to all that money when this bubble pops. They shoulda given it to me, at least I would have bought a better drum kit and made some music or some shit. ↩
A reference to Psalm 14:1: “The fool says in his heart, there is no God!” I’m atheist, so I don’t believe this, but still funny to reference regardless. ↩
Because damn, it really does feel like rolling dice sometimes. Just one that has millions of “weights” (parameters) in some multi-dimensional directions that I can’t even comprehend. ↩
Yes, this is a vague Breaking Bad reference to the blue sky they sold. Because vibe coding is basically a drug. ↩

Varun's Musings

Year of Varun #21 - A Retrospective

Deconversion

Burnout/Job Hell

New Projects, New Friends

Graduation

What’s Next?

Footnotes

Hello, World!

Code Blocks

Thanks

SourceHut: Git Done Right?

Why I Switched

AI Bullshit

Work Gamification

Pull Requests: The Antichrist’s Git Workflow

Getting Started

Hold On, Why Not GitLab/Forgejo/Gitea Or Something Else?

Porting Repositories

GitHub Mirroring

Patch-Based Email Workflow

Hear Ye, Hear Ye! What Problems Have Arisen, My Dear SourceHut?

GitHub’s Monopoly

builds.sr.ht Usability Issues

External Usability

What The Future Holds

Footnotes

realpath() Considered Harmful

Synopsis

Part I :: Where Did This Begin?

Part II :: Abstraction Does Not Mean Portability

glibc Implementation

musl Implementation

Other Language Standard Libraries

Part III :: Rationale

Part IV :: What Should I Use, Then?

Footnotes

The Book of Neo

Prologue: Assemble, NeoVimmers!

The Zen Commandments

The Simpleton’s Zen Commandments

Epilogue

Footnotes

The Unchristian

Part 0: Hi there.

Part I: Faith

Part II: Doubt

Part III: Deconstruction

Part IV: End of an Era

Part V: What Now?

Footnotes

Zig Comptime Is Absurdly Cool

Part 0 :: Synopsis

Part I :: comptime

Part II :: The Situation

Part III :: Conclusion

Footnotes

Freecoding - An Alternative To Vibe Coding

A Swing And A Miss

Oh, That’s What The Hammer Is For?

Swinging The Hammer Myself

The Beasts That Cannot Comprehend

The Heroes They Could Not Comprehend

The Fool Says In His Heart: I Can Vibe Code!17

Reconciliation?

Footnotes

`glibc` Implementation

`musl` Implementation

Part I :: `comptime`

The Fool Says In His Heart: I Can Vibe Code!¹⁷