
🌊 | Co-founder, CTO @papercompute | 🎤 Hosting @opensourceready | 🐹 maintaining spf13/cobra
Joined October 2018
- Tweets7.8K
- Following980
- Followers7.3K
- Likes7.4K
John McBride retweeted
Here's a fun bit of Go trivia for y'all which I believe perfectly demonstrates how, despite the absolute power of AI, it still codes like a over-eager-junior engineer straight out of CS 201 writing completely unmaintainable code.
This was generated with GPT 6.1-sol while working on some experimental flag stuff akin to spf13/pflag:
A "Count" type is defined like so:
```
// Count is an integer flag that increments 1
// when used without an argument.
// With an argument, increments that amount.
type Count int
```
And in the following "Set" method, a "+1" sentinel increments the counter flag (this is basically straight out of spf13/pflag)
```
// Set increments the count for "+1"
// or sets it to the parsed integer.
func (c *Count) Set(s string) error {
if s == "+1" {
if *c == Count(int(^uint(0)>>1)) {
return fmt.Errorf("count overflows int")
}
*c++
return nil
}
value, err := strconv.ParseInt(s, 0, strconv.IntSize)
if err == nil {
*c = Count(value)
}
return err
}
```
This path guards integer overflow and immediately made me raise an eyebrow:
```
if *c == Count(int(^uint(0)>>1))
```
Step by step: by taking a zero value uint, flipping all its bits to 1, shifting it to the right by 1 (effectively removing the signing bit), then casting it to a Count, finally checking if it's equal to the current count -- we can effectively check if the count is at the given system's maximum signed int value and should error to prevent an overflow. On a 64 bit system, this is 2^63−1 (a massive number).
... this is all good except the agent completely ignored Go's "math.MaxInt" (I wouldn't even consider this "modern Go" since it's been around since Go 1.17) -- the complexity can be drastically reduced by simply doing:
```
if *c == math.MaxInt
```
This compiles without a "Count(...)" cast since, under the hood, this is an untyped const in the math package (essentially exactly what this std lib const is for).
The complexity in understanding a one liner bit shift vs. just using the standard library cannot be over stated: even for agents, I'd argue that this exits the domain of "easy to maintain with agents" and would require lots and lots of resources (on the GPT 5.x tokenizer, the first implementation is 13 tokens and the second is 7 !!! )
Software engineering has always been about correctly combating and harnessing complexity in language, semantics, abstraction, construction, and creative expression. Using LLM tools did not change that and there's a very compelling argument to be made for beautiful, elegant, and correct code that enables BOTH the engineer and the tools to work better.
On episode 46 of @opensourceready, Brian Douglas (@bdougieYO) and John McBride (@johncodes) speak with JT Archie. He introduces Steps, his local-first workflow tool for combining predictable automation with AI agents. They discuss why agents shouldn’t improvise routine operations, where AI fits into software maintenance, and what software factories still need from human engineers.
hubs.ly/Q04F3Nh90
John McBride retweeted
"Seventeen years in, Go is thriving because of the people who use it, build with it, and contribute to it every day." go.dev/blog/17years < indeed. @golang has an excellent, forward-thinking community of builders who enjoy writing fast, secure, and maintainable code.
Go 1.28 では、型が文脈から分かる場合、複合リテラルの型を省略できるようになります。 #golang
var p Point = {1, 2}
var ptr *Point = {1, 2}
2015年に提案された issue が、11年越しにクローズされました。
github.com/golang/go/issues/…
John McBride retweeted
We're proud to announce the launch of CS Learn, a new online learning platform that offers free access to select courses from Carnegie Mellon University’s top-ranked computer science program.
Check out the course offerings: bit.ly/4C4770z
Very strong co-sign
evanxmerz.com/post/ai-usage-…
John McBride retweeted
Anthropic is using nix in prod. Docker was too slow.
youtube.com/watch?v=iPoL03tF…
John McBride retweeted
Goodbye map[string]struct{} 👋
Go's generic set proposal was just accepted. set.Set is still a map underneath, so range just works, but you get Insert, Contains, Union, Difference and more.
It lands first in golang.org/x/exp/collection/…
go.dev/issue/69230
John McBride retweeted
Sorry guys. Software engineering and programming are dead. You just need to have perfect specs, unchanging requirements, an agentic deployment framework for high frequency releasing, and engineers with good taste and judgement.
John McBride retweeted
The bug is like a joke.
On Alpine Linux, type 257 to 1024 characters of anything and you get root. 💀
‼️ BREAKING: OpenSSH has rushed out a fix for a critical flaw that lets attackers log into some Linux servers without the right password.
The team learned of the bug a day earlier. OpenSSH's Damien Miller says long embargoes now mostly help attackers, because AI agents rediscover bugs, sometimes within hours.
It hits Linux systems on the musl C library with PAM off, such as Alpine Linux. Miller told admins to disable password logins or SSH itself "IMMEDIATELY".
Version 10.6p2 works around it. Systems on glibc or PAM are not affected, and Miller says the root cause sits outside OpenSSH.
Readers added context they thought people might want to know
Exploitation requires specific conditions, not just typing a long string anywhere on Alpine: sshd built without PAM, password auth enabled, a target account with a '*' password field, and another local account with $5$/$6$ hashes. Root login also must be explicitly permitted. alpinelinux.org/posts/2026-11-… openssh.org/releasenotes.h…
John McBride retweeted
New video🎬 Effective Neovim setup for agentic coding towards 2027
@Neovim @AnthropicAI
John McBride retweeted
nyc friend: how was sf
me: i liked it (shamefully)
nyc friend: i can see that for you (derogatory)
John McBride retweeted
need infra engineers who’ve specialized in inference. team is still pretty small so you’ll own a significant part of the product roadmap. closed a round a few weeks back, already closing term sheets for the next round
On episode 45 of @opensourceready, Brian Douglas (@bdougieyo) and John McBride (@johncodes) sit down with @dotta of @papercliping to discuss the coordination problem behind increasingly capable AI agents. Dotta explains Paperclip’s approach to organizing tasks, controlling access, and connecting different agents under one roof. They also examine why faster development raises the stakes for craftsmanship and open-source maintenance.
hubs.ly/Q04BXDx60


























