I have definitely witnessed very specific cultures around languages I really like that I generally just don't vibe with. The author creates something brilliant, but there's a cadre of early adopters that shape a political and somewhat egotistical community that rubs me wrong. Once I spot them, I don't engage with the community. And it's not even that I disagree with the politics they espouse... I'm usually on the same page, but it's just kind of exhausting and a little over the top.
I'm old-ish though and grew up apolitical, so I'm sure it's just a me problem.
That's true and interesting. Personally I've been rebuilding an application in Rust, learning Rust at the same time and leaning heavily on AI agents for both the building, but also the learning. I've been at it for a few months now (large application) and should be done pretty soon. I'm fairly comfortable with ML languages, and Rust has felt pretty good.
It's been an experiment to see how much more performance I can squeeze from a Rust version (spoiler: it's a lot), how well the agents code in Rust (pretty great and seems idiomatic AFAICT), and if this is a good way to learn a new language (I'm learning, but the verdict on how efficient is still out).
I might be self deluding, but I do think it's been productive, even though I'm intentionally moving slow with small TDD vibe spikes followed by completely reading over everything, adding more guard rails if necessary, refining requirements and tests, sometimes ripping it out then and have the agent rewrite it more iteratively with meticulous reviews, etc. Honestly, I have the time to do this right, so I've been focused on correctness and making it enjoyable to avoid burn out... but what I find enjoyable, won't be the same thing others find enjoyable. I also have the autonomy and financial security to adopt entirely new workflows and do rewrites of my own products, which not everyone has. I would absolutely hate being forced to token max or w/e that insane BS is all about.
Maybe famous last words, but I'm not buying the hype that the "clankers" will take over. I suspect reality will catch up soon and we'll be left with a set of pretty powerful but still limited tools. I see no evidence to the contrary, just investment hype on one side and sky is falling on the other.
100% this is what I've done. I sucked it up and adapted myself to the tool (agents) by having as many implicit guardrails (static typing, functional, no nulls, great linting) and then layering on explicit guardrails (TDD) on top. I also want my workflow to be portable because I don't really trust the frontier model providers.
It is different though. Basically a lot of what I do has changed over the last 2 years. I totally get that a lot of people won't want to adapt though.
Good to know. I built https://github.com/pairshaped/hypertea to get some of Elm's safety in typescript while being easy for LLMs to use (this is basically just hyperapp in TS, with added elm-like guardrails). Maybe I'll go back to Elm now that LLMs are handling it better.
I was already working with elm (have been since Signals) and I was very disappointed in what agents (CC) produced. In contrast, I was pleased with the Rust code they produced.
It's crazy to hear someone think games in the 80s were more creative than they are today. That's taking nostalgia to a whole new level! Indy games today are amazing. When you lower barriers the ratio of good to bad probably tilts more towards bad, but the absolute number of good still increases.
There's going to be reams of AI slop (already is), but I bet the amount of amazing games will also (more slowly) increase due to AI tools. The trick is in how well we can filter.
I think we're in the early stages and being overwhelmed by low quality production. We'll find ways to filter, and find some real bangers.
Maybe it's improved, but I was very disappointed to find agents constantly tripping over significant white space with Elm (Claude Code). Always struck me as strange since they are very proficient with python... and Elm has been one of the most stable modern languages (so stable that people complain about it never changing!). I think the last time I tried was a year ago though, so I assume it has improved.
Miller is the Antichrist, but I don't buy Elon as a victim for a second. I suspect he'll be spending some of that wealth on image rehabilitation and political influence though as the turns tide. The retcon will be entertaining at least.
Per sf comparisons blatantly ignore the bonkers increases in land prices. Good luck finding a 1500 sf house, let alone one with a backyard that hasn't completely outpaced inflation.
Highly recommend exerting the extra effort it takes to remain portable with your AI workflow. Not just to workaround typical Google shut downs, but also the incoming price hikes.
This is kind of what coding with LLMs feels like. Gradually increase guard rails "outside of it's context (automated)" to get the results you want out of it. Static typing, quick compilation, not having nulls, and lints are a great start (I would also argue for managed side effects and functional, but to each their own).
It gets pretty far to the solution on it's own and quickly, but then you spend time adjacent to the problem, building out it's cage while iterating through the remainder of the solution.
I think the issue is that a lot of concerns that appear to be "cross-cutting" at first glance, don't hold true to that design... but teams will try to stay the course, possibly due to existing debt, and it goes south pretty quickly from there. That's what I mean when I say there are some patterns that are obvious and proven cross cutting concerns (like logging), but there's really not a ton of them IMO, and if you're going to experiment with new potential concerns, then you must be ready to rip it up when it proves not to be the shape you thought it was.
I always thought AOP was super cool, but also that it completely destroys readability and the ability to understand a codebase. I also think it's probably one of the worst concepts to embrace in the age of agentic coding. That would be like a foot missile.
There are a limited number of patterns that absolutely do benefit from AOP though. The obvious one is logging. I don't think there's many though.
Regardless, AOP is the last thing I'll be using these days. With LLMs I've been moving in the opposite direction with a focus on explicitness and correctness. Typed, compiled, non-null languages with clear, obvious, and well documented conventions.
Microsoft SSO does exactly this. They let you pretend to be someone else's email, making their SSO service pointless since you still need to do email verification anyways (at which point, just send a login token to sign them in, instead of using SSO).
Hard to convince users that they need to be using a password manager if you run a SaaS. Also when things like LastPASS getting hacked are on the front page... imagine advising people to use that one! (I'm guilty of recommending LastPASS many years ago, before their first breach).
I'm old-ish though and grew up apolitical, so I'm sure it's just a me problem.