rednafi

I still see people doing "you are a world class distributed systems engineer" think. Never fails me to chuckle.

Shhh...you're only supposed to unilaterally praise it to get along with your clueless leadership.

Soon, we'll start seeing Claude certs getting listed on LinkedIn alongside Coursera courses.

People with titles like

Giga Chad, MBA, CSS, CKAD, XXX, PQRS

are gonna love this.

In no time, HRs will start slapping “10 years of certified Claude Code experience required” on job listings.

I use the enterprise plan for work and often burn ~150$ worth of tokens per day. I have noticed exhibiting similar behaviors here.

When you say nearly unlimited token, do you mean the 100 or 200$ subscription?

I have the enterprise plan and get to use it for both work and some personal stuff.

I mainly use it for side projects and doing research for writing stuff on my blog.

I use Opus 4.6 with claude code 1M context and consistently use up 150-200$ worth of token per day. I wonder how do you manage to do anything with a 10$/mo program.

AI just lowered the cost of replication. Now you can replicate good or bad stuff but that doesn't automatically make AI the enabler of either.

I think a lighter version of literate programming, coupled with languages that have a small API surface but are heavy on convention, is going to thrive in this age of agentic programming.

A lighter API footprint probably also means a higher amount of boilerplate code, but these models love cranking out boilerplate.

I’ve been doing a lot more Go instead of dynamic languages like Python or TypeScript these days. Mostly because if agents are writing the program, they might as well write it in a language that’s fast enough. Fast compilation means agents can quickly iterate on a design, execute it, and loop back.

The Go ecosystem is heavy on style guides, design patterns, and canonical ways of doing things. Mostly because the language doesn’t prevent obvious footguns like nil pointer errors, subtle race conditions in concurrent code, or context cancellation issues. So people rely heavily on patterns, and agents are quite good at picking those up.

My version of literate programming is ensuring that each package has enough top-level docs and that all public APIs have good docstrings. I also point agents to read the Google Go style guide [1] each time before working on my codebase.This yields surprisingly good results most of the time.

[1] https://google.github.io/styleguide/go/

Your example shows an ideal case w/o repetition. If every layer just wraps error without inspecting, then there will be duplication in the error string.

Damn. I missed that. But yeah OP didn't take it well when people poked hole into his proposed API.

But regardless of API ergonomics, I would love to have UUID v4 and v7 in the stdlib.

No worries. Your intent was clear. I don't mind the boilerplates if they were footgun free. Context requires you write a bunch of boilerplate where it's still really easy to make mistakes.

Then it results in an absurd amount of duplication. I regularly encounter error strings like:

error:something happened:error:something happened

In an HTTP server, top level means the handlers, is that so?

Author here. I absolutely hated writing this piece after shooting myself in the foot a thousand times.

Go's context ergonomics is kinda terrible and currently there's no way around it.

Basically one guy having a fit when people disagreed with him.

I work at one of those large companies where migration work never stops. We recently acquired a few other companies. To coalesce the platforms of multiple companies, we're rewriting a big chunk of our codebase in Go. The new platform itself is also being built from scratch in Go.

But the catch is we haven't historically been a Go shop. A lot of folks are coming from Python and Kotlin backends. So in our knowledge-sharing channel, we constantly see feature comparisons across these languages.

One thing that came up recently is how hard structured concurrency feels in Go. go func() is unstructured by default unless you wire it up with sync primitives like WaitGroup. A bunch of people also pointed out how Python’s TaskGroup or Kotlin’s coroutineScope make cancellation feel trivial. In Go, cancellation semantics require explicit context checking and manual bailouts.

We had some interesting internal discussions around this that I think would be valuable for others going through similar journey.

So I summarized some of the key points that came up and added a few examples. I’m curious how others approach structured concurrency in Go. How do you avoid the usual leaks that happen with manual plumbing?

I have a page on my site dedicated to list the blogs I frequent:

https://rednafi.com/blogroll/

Companies change T&C after locking in people all the time.

Maybe I am missing something but this still doesn't explain why Claude Code couldn't expose a flag and be done with it as the author mentioned.

Don't have that brainrot engine on your phone - problem solved.

Stoicism often gets conflated with apathy, which to some extent is a fair interpretation. But it’s not being indifferent to everything - rather, only to the things that disrupt your psychological stasis.

Then Silicon Valley ran with the idea and made it about tone-deafness. So now it’s almost fashionable to be intentionally cruel and tone-deaf, and then chalk it up to Stoicism.

Could have just said he joined for the money, which wouldn’t be the worst thing. Instead, we got this high-and-mighty mumbo-jumbo larp.

> Xi's already suggested making the Yuan a global reserve currency, and seeing as much debt they're holding, I'm a little worried they're able to make it happen if this is the US financial strategy.

I wonder why you’re worried. Regime’s change all the time. From a third party perspective, China is no better or worse than the US. Also, given how literally every country under the sun despises US now, this might just happen.

This is a wholesome job post. Reminded me there’s a human somewhere in the loop. I hope you find the right person.

In agentic workflows, Go’s fast compiler and simple syntax make things so much easier.

I no longer write Python or JavaScript, even for trivial scripts. Why suffer sluggish performance or tooling nightmares when choosing a typed language no longer costs much?

As for Swift, it’s a harder sell. The docs aren’t there. The libraries aren’t that great. Apple-ism scares away a ton of folks, and the alternatives create less friction.

Swift is a neat language, but it’s a hard sell for server-side software. The ecosystem is tiny, and there’s nothing you gain from using it instead of Go or Rust for infra / distsys.

Also, it works okay at best with VS Code, and you couldn’t pay me to use Xcode.

Kotlin tried doing similar things to gain adoption on the server side. But server-side programming is a crowded space, and people just don’t like writing distsys code in another JVM language. Swift’s story is a little better on that front.

If you want a quick-and-dirty language, Python and TypeScript do the job. For perf-sensitive, highly concurrent environments, Go is hard to compete against. A lot of ops tooling and infra code is written in Go. For systems programming and embedded code, Rust is a better choice.

So while it’s fun to think about what language X gives you in terms of syntax, in practice it’s rarely enough to pick a language like Swift for your next non-toy backend distsys work.

Also, Apple. Given their stance against free and open source software, I wouldn't be too thrilled to pick a language that works better in their walled garden.

Similar sentiment but I think opting for a debian based intro would have solved some of the hurdles.

"Oh, it's another tool in your repertoire like Bash" doesn't garner billions of dollars in investment. So they have to address it as the next electricity or the internet, when in its current form, it's much closer to a crypto grift than it is to electricity.

Yeah. I’m not saying software work needs to happen in a silo, but man, the politics at large companies - where a certain group of people are constantly trying to get "ahead" of everyone else by yapping and backstabbing - get really tiring after a few years.

I dearly hope so. Not that I am saying software development shouldn't be a social activity, but does it have to be this performative & toxic?

This resonates with me too. I’ve written some Rust and a lot of Go. I find Rust syntax distastefully ugly, and the sluggish compilation speed doesn’t bring me any joy.

On top of that, Go has pretty much replaced my Python usage for scripting since it’s cheap to generate code and let the compiler catch obvious issues. Iteration in Rust is a lot slower, even with LLMs.

I get fasterthanlime’s rant against Go, but none of those criticisms apply to me. I write distributed-systems code for work where Go absolutely shines. I need fast compilation, self-contained binaries, and easy concurrency support. Also, the garbage collector lets me ignore things I genuinely couldn’t care less about - stuff Rust is generally good at. So choosing Go instead of Rust was kinda easy.