Joe

73 feature branches in active development (most for several months), and one intern (currently on m/paternity leave) responsible for merging them. Check! In the meantime, several branches deployed to prod behind a reverse proxy with feature flags.

salutes

It’s accelerating trends that have already been well underway in the world, with the US leading the pack, and doubling down on its own demise (and apparently also working toward the active demise of European Democracy and Freedom) under trump and jd vance.

The analogy I always think of is: We’ve got shovels and we are in a big hole … which way are we going to dig? In my experience, most people keep digging down because it seems easier now, and eventually find themselves in a deeper hole.

The author gets it. In the right hands, productivity gains can be (and increasingly will be) incredible, and the structure of effective teams can and will change.

The ability to start thinking about generated code as temporary is a mindshift change, helping to minimize the problem of “all code is tech debt”. This pushes the design aspects to the forefront, where we can iterate in the much more important design phases, because downstream costs are much reduced.

Proposed new term: AI(gile)/agile codefall, where the iteration is on the design, while the code falls into place.

What he didn’t address is the systematic risk to training new developers and experts, but this is covered extensively elsewhere.

That this is and will be abused is not in question. :-P

You are making a leap though.

While this is a popular sentiment, it is not true, nor will it ever be true.

AI (LLMs & agents in the coding context, in this case) can serve as both a tool and a crutch. Those who learn to master the tools will gain benefit from them, without detracting from their own skill. Those who use them as a crutch will lose (or never gain) their own skills.

Some skills will in turn become irrelevent in day-to-day life (as is always the case with new tech), and we will adapt in turn.

Indeed… Throw-away code is currently where AI coding excels. And that is cool and useful - creating one off scripts, self-contained modules automating boilerplate, etc.

You can’t quite use it the same way for complex existing code bases though… Not yet, at least…

Finally we can put to rest the laughable chinese disinformation campaigns about well documented historical fact and instead focus on china’s prospects to be responsible world power/leader in the many fields where the US is failing the world right now.

looks at lemmy.ml commenter … oh right, never mind then.

Tl;dr guy finally discovers a reason to document his codebase

The upside: It can help people too, especially as these docs typically undergo a form of self-review, where clarity matters.

Interesting fact: You can use an elephant’s trunk as a low-resolution 3D printing nozzle

Requiring only two out of three keys leaves the system open to straightforward collusion. A threshold like three out of four, or three out of five, would raise the bar to something more like a coordinated conspiracy. There are likely additional human roles involved in the process as well (mitigating the risk), though I’m not fully familiar with the complete setup.

My assumption is that these keys are meant solely to control the timed release of the data, not to serve as the ultimate source of authority. The encrypted ballots are probably disclosed to the keyholders at the same moment the keys themselves are published.

It reminds me of a pet project I want to complete: An automated online timed release keymaster, publishing future-dated public keys, then publishing the secret keys on that date. One day soon… edit: it already exists, https://timelock.dev/

Hah, yeah. Vibe coding and prompt engineering seem like a huge fad right now, although I don’t think it’s going to die out, just the hype.

The most successful vibe projects in the next few years are likely to be the least innovative technically, following well trodden paths (and generating lots of throwaway code).

I suppose we’ll see more and more curated collections of AI-friendly design documents and best-practice code samples to enable vibe coding for varied use-cases, and this will be the perceived value add for various tools in the short term. The spec driven development trend seems to have value, adding semantic layers for humans and AI alike.

Yeah - there’s definitely a GIGO factor. Throwing it at a undocumented codebase with poor and inconsistent function & variable names isn’t likely to yield great revelations. But it can probably still tell you why changing input X didn’t result in a change to output Y (with 50k lines of code in-between), saving you a bunch of debugging time.

Most code on the planet is boring legacy code, though. Novel and interesting is typically a small fraction of a codebase, and it will often be more in the design than the code itself. Anything that can help us make boring code more digestible is welcome. Plenty of other pitfalls along the way though.

I have a suspicion that the guy took issue with my use of “one” instead of “you”, more-so than the content. Maybe it came across as uppity.

It’s a changing world, and there is going to be an ever increasing amount of AI slop out there, and even more potential programmers who won’t make the leap due to the crutch.

At the same time, there are always people who want to and will learn in spite of the available crutches the latest tech revolution brings.

There will also be many good engineers who will exploit the tech for all its worth while applying appropriate rigour, increasing their real productivity and value manyfold.

And there will be many non-programmers who can achieve much more in their respective fields, because AI tools can bridge gaps for them.

Hopefully we won’t irreversibly destroy ourselves and our planet while we’re at it. 🙈

Hm? Oh, I obviously misread the room. It seems I interrupted a circle jerk? My apologies.

No, but it can help a capable developer to have more of those moments, as one can use LLMs and coding agents to (a) help explain the relationships in a complicated codebase succinctly and (b) help to quickly figure out why one’s code doesn’t work as expected (from simple bugs to calling out one’s own fundamental misunderstandings), giving one more time to focus on what matters to oneself.

deleted by creator

You made your point, and it was clearly understood the first time. Perhaps you don’t understand my point?