social-app/CLAUDE.md at main · bluesky-social/social-app

The Bluesky Social application for Web, iOS, and Android - bluesky-social/social-app

GitHub
I mean when I check my feed much of the Bluesky eng team seems to be posting about how great Claude is all the time so I have been background wondering how common vibecoding is in that ecosystem
Let's see if anyone on Bluesky / the ATmosphere can say more https://bsky.app/profile/dustyweb.bsky.social/post/3mg6qipl6a22o
Christine Lemmer-Webber (@dustyweb.bsky.social)

Curious if vibecoding / AI agent assisted dev is currently common in ATmosphere dev? The feelings about AI generated code are def different on here than on fedi, so... I see a CLAUDE.md in bluesky-social/social-app https://github.com/bluesky-social/social-app/blob/main/CLAUDE.md

Bluesky Social

Example: https://bsky.app/profile/why.bsky.team/post/3meomclcfss2w

> Until December of last year I was using LLMs as fancy autocomplete for coding. It was nice for scaffolding out boilerplate, or giving me a gut check on some things, or banging out some boring routine stuff.
>
> In the past two months Claude has written about 99% of my code. Things are changing. Fast

Why (@why.bsky.team)

Until December of last year I was using LLMs as fancy autocomplete for coding. It was nice for scaffolding out boilerplate, or giving me a gut check on some things, or banging out some boring routine stuff. In the past two months Claude has written about 99% of my code. Things are changing. Fast

Bluesky Social

I have this suspicion that the ATproto stack, at least the stuff from Bluesky, is heading towards "majority-vibecoded" but that's mostly just from seeing a lot of posts from the Bluesky eng team rather than me having spent much time in the codebase

Why is def hugely responsible for much of Bluesky/ATProto's design and if *he's* mostly letting Claude write 99% of his code, the rest of the eng team is likely to be heading in that direction too?

@cwebber I'm hanging out there a lot and yes there is a lot of vibecoding. However, they don't seem to vibecode more than the average paid software dev.

In 2024, I'd say about 20% of my friends vibecoded. Today the number looks more like 90%. This is not specific to atproto, my understanding is that most people vibecode nowadays.

@res260 Sadly a likely observation :\

So many people just giving up on their craft.

@cwebber @res260 I feel like there's always been a lot of software development that isn't craft but it's just shuffling bits around.

I don't really know how to feel about a lot of it these days. I've played around with some of the tools for work and there's certainly a lot of areas where they can write basically the same code that I would have done with less tedium, and by some metrics they do a better job (mostly things that are good practice but I couldn't be bothered).

Is that abandoning craft or careful allocation of executive function? I don't know.

I definitely think these things aren't going away. The bubble will pop, it'll maybe kill the big AI companies, people will stop shoving chat bots everywhere, but I don't see any way that LLMs don't remain a fact of life, and I don't know what the long term implications are of this
@erincandescent @cwebber I agree, I think a lot of people don't consider their code craft, but maybe the final product more so

@res260 @erincandescent @cwebber if you care about the final product, surely you should care about how it’s made?

I see so many apologists for LLM usage recently trying to distinguish between the outcome and the process, as if the quality of the outcome isn’t defined by the process.

@benjamineskola @res260 @cwebber is this an argument of quality or of morals?

Because morals.. people can have different views on. But quality is very much about the end result
@[email protected] @benjamineskola @res260 @cwebber If the thing isn't "make once and forget" the process is very much part of quality, because it decides if the thing is maintainable.
@airtower @res260 @benjamineskola @cwebber two projects with identical code are, modulo institutional knowledge, equally maintainable; would you disagree?

@erincandescent @res260 @cwebber @airtower

'modulo institutional knowledge' is doing a lot of heavy lifting there since that's half the problem with LLM usage

and the other half of the problem is the assumption that an LLM will produce identical code

so I don't think there's a useful discussion to be had if those are your assumptions

@benjamineskola @[email protected] @res260 @cwebber Yeah, this. If I'm looking at a new tool/library to possibly use (and not do a hard fork on), a key question is: Are there people who understand and care maintaining this thing? Because if there aren't, eventually "hard fork" or "don't use it" will probably be my only choices.

And using LLMs to generate code points towards "no" (or at least "not much") for both understanding and caring. If someone skilled is actually putting in the effort to edit LLM output until it is no worse than what they would've written themselves (point for care at least), chances are it would've been faster (let alone other effects) to just do that.
@airtower @res260 @benjamineskola @cwebber I still see LLM related artifacts as a negative quality signal. There's lots of crap LLM aided code out there and there's lots of people slopping stuff together. The worst developers are disproportionality interested.

But I think there's a lot of stuff being written with LLM assistance these days where you'd not be able to tell
@[email protected] @res260 @benjamineskola @cwebber That might be, but as I wrote in that case I doubt there's any benefit (like faster progress) to the developer (even looking at code only, ignoring all the harmful side effects of LLMs).

@erincandescent @res260 @cwebber @airtower Given that every output of LLMs that I've seen that is identifiable as such has been mediocre at best, why would I assume without any evidence that there's a significant quantity of LLM-generated code that's actually good?

"There's no evidence of it but it's definitely there" is unpersuasive.

And I've also found that people's evaluations of LLM-generated code quality is wildly out of step with my own evaluations, so I would not automatically assume that because someone says it's good that it's actually good.

And then, even if the code was of acceptable quality, the negative effects on the process (increased difficult of reviewing ↔ decreased institutional knowledge, among other things) count against it too.

(And all of this is setting aside the ethical issues, which in practice I don't think we should do anyway. Like, even if LLMs produced good output they'd be ethically indefensible, and even if they were ethically acceptable the results are so poor that why would you bother with them?)