rygo6

Regularly now, for any thought about politics or general worldview, I will paste my notion into AI and ask it to critique it. To which rarely does it validate it. It typically tear it down, or highlights things that make me re-think something. Sometimes I present these thoughts or arguments to other people. Also mentioning that I use an AI to validate my thoughts and perspective. To which a common response is that AI is sycophantic and it will just validate whatever your predisposition is. I always ask back, what would you ask the AI? Not everyone has a subscription to run endless queries on supergrok or whatever. Which they might respond. Or just give me back an argument. To which I copy/paste that to the AI and give them the link back. Never has it actually validated any such persons argument. In most cases it completely tore it apart for being factually incorrect and logically inconsistent. At which the exchange goes from, "You are wrong because you used an AI to sort through your reason and AI just validates anything because it is sycophantic". To, if you believe that is true. Well then. Here is your argument given to the AI which it thinks is nonsensical. Which means you have to consequently believe you are severely incorrect if you cannot even get a supposedly sycophantic AI on your side. I am sure this depends on the exact model but the latest ChatGPT thinking and SuperGrok thinking models. Any question which can factually validated in anyway, or relies on any kind of sound logic, they can be absolutely brutal if you ask for a simple 'Critique' of some thought of yours. Even if they are sycophantic. People going from worldviews so distorted that not even a sycophantic AI will validate them, to worldviews at least in the ballpark of reality such that a sycophantic AI might be able to validate them. That seems like a collective upgrade to me. Everyone should probably argue their worldview and politics with AI more.

One of the things I have always preferred to do is copy slimmed down versions of my dependencies into my project. If I can get away with forward declaring several types in my file directly, then linking, I'll do that. Or if I only need several methods, or a few files of something, I will copy them out. Or sometimes I might make an amalgam of the library if it can fit nicely in one file. I really don't like having lots of "Stuff" in the project. Aside from the potential it could bloat something in the project. Compile time or binary size. More so the reason is I want to keep a grip on it and keep the project minimal. It makes searching the project and relying on a LSP simply work better. It explicitly defines exactly what you are allowed to use from some third party dependency, and if it turns out a project needs more, then that is an explicit decision which must be made by pulling in more of the library. Less surface area is always better. If you are concerned with being judiciously anti-slop and wanting to keep a strong grip on your projects you should always consider doing this. There are some libraries I fully import or git submodule in simply because I use a lot from them and it's not worth the trouble. But I am always on the lookout to discern the absolute minimum I need to pull in. Because of this I am discovering that Claude Code is essentially the greatest packager manager to ever exist. I do not mean that jokingly at all. Because it can automatically do this. I can clone some library outside my project. Start building some things off of it. Then prompt claude to copy over the absolute minimal necessities to make it work with only what I utilized. Which it will do. Perfectly. Since it's not inventing or extrapolating into novelty. Such an operation is constrained within what is explicitly defined. Then if later on it turns out I need something more. Just another prompt to pull in the absolute minimum of only what I need. I've been leaning on this heavily for the past few weeks and it just works. Because your not creating code you are collating subsets of existing code. I'm starting to believe this is the better way to pull dependencies into a project. I never got how people can be comfortable with including chains of dependencies automatically through a package manager. It's one of the reasons I have been hesitant about rust. I expect cargo to turn into NPM in the long term. It's a major slop incentive inserted into the middle of an ecosystem which overtime compounds dependencies on dependencies on dependencies. While conversely the big struggle of not having a package manager is you then have to manually pull in and watch over your packages. The bigger pain of manually slimming them down, as I like to do, is then you encounter greater friction if you ever wanted to update them in the future or pull in more. It can be a time sink. But not anymore. Now its as automated and quick as an actual package manager thanks to AI.

@segun_os_ Catching all those weird esoteric technical nuances and quirks you'd never keep top-of-mind concerning compiler differences or ways to use C++ templates are one of the things LLM's are remarkably good at.

you literally cannot vibe code c++ char is an 8 bit string that can also be an unsigned 8 bit int depending on how you use it. the level of precision required to write c++ is too high for vibecoding. there are just too many quirks in the language.

A broken process going 10x faster sill doesn't make the process not broken. I believe this is the fundamental issue with a lot of corporate tech today. Even if it went 100x faster. That'd just be more spreadsheets, power points, emails, meetings and not-ship-worthy code cycling through faster. But whether or not an LLM can make a programmer more productive. I find it very hard hard to respect people who have not figured out at least one thing which an LLM can save them time with during their regular workflow. It may not be the writing of the actual code. But something. To have not found something so far is red herring you have serious lack of curiosity or some irrationally rigid nonsensical principle because I feel it's very easy to find valid usages of LLM's here and there which can easily save you an hour or two. Not necessarily on writing the actual code, but on peripheral related things. Once a good sense of a couple dozen of those things. You can easily start condensing chunks of work that would have taken you a week into a day. Again, not writing the actual code, peripheral things. Debugging some weird nuance of why a makefile isn't properly building on wayland. Quickly telling you exactly what takes the longest to compile in your project and why. Doing several spike project benchmarks of different approaches on a certain piece of hardware to find the most optimal approach. Some kind of comprehensive refactor which you could pull off with a set of shell scripts it can just auto-generate those shell scripts then double chunk everything was as expected. Validating that the assembly of some particular method in a whole compiled project did not do something wacky. Reading through the vulkan spec and cross-referencing supports extensions with various device profiles then give you succinct broken down chart of everything you need to know. Just a whole bunch of these little which may take you 30 minutes to an hour or two. Now it's just a 5 second prompt.

If LLMs really made workers more productive in a general way, as is claimed, and this had been going on for a couple of years, as is claimed, wouldn’t we expect to see a boost to the economy and an uptick in consumer sentiment, rather than like, historic lows?

Two short lists of compile settings that fix a good chunk of what is wrong with C++: CPLUSMINUSFLAGS := -fno-exceptions \ -fno-rtti \ -fno-unwind-tables \ -fno-asynchronous-unwind-tables CPLUSMINUSLD := -static-libgcc \ -nostdlib++

My first 3D printer product: printables.com/model/1725556-… I love how, with a 3D printer, instead of wasting an hour on amazon trying to pick out some laptop stand to buy. Instead, I can whip one up in shapr, print it, then upload it to the market for a small price. Framework16 with all the v2 revision parts I am also finding to be a great laptop.

Information wants to be free... ... and indexed in an Auto-Library to be maximally used by the greatest number of people in the greatest amount of variation.

The flip side of AI slop. Due to how easy it is to now look up technical subject matter and get very specific context aware example to learn. There is also simultaneously far less excuse for slop. With claude code you can prompt, "Compile and look at the assembly of ____ method. Is it properly inlining /vectorizing / compiling out / going off into some crazy chain of RAII that is doing way more than a minimal C equivalent?" Before it could be time consuming to catch every possible place you might be triggering the generation of an offensive amount of slop assembly underneath. Either you wrote everything in a strict pedantic manner which you knew didn't do that. Or you needed to constantly be making isolated tests to analyze compiler output. Or you needed to dig through large chunks of debug assembly. Now it is just a prompt to claude that takes a few seconds. Or you can now prompt Claude, "Compile this with compilation metrics enabled and give me a a breakdown of the headers which take the longest to compile and why." It can give you nice summarized chart to point out exactly what is making a compile take so long. There is no excuse anymore. If your code is generating abysmal assembly, or excessively slow to compile, or some other quality of slop that you'd typically overlook because obsessing about it took too much time. Now it doesn't. It's just a prompt that takes a few seconds. You just didn't want to take the time to be good at what you do.

@MaximumADHD Align those ='s

I'm starting to realize my coding style is probably a sign I have some kind of OCD. I always organize my variables and statements in pyramid shapes either by the length of the line, or alphanumerically, or both. I also put padding around statements where a new stack opens.

If you write everything to strict Vulkan 1.0 spec it will run on everything. But then you have to write the super verbose pedantic Vulkan from a decade ago. Vulkan 1.1 and 1.2 are pretty universal today. You go to Vulkan GPU info site and can tell you what devices support what. It’s only in Vulkan 1.3 do you start to get spotty support for certain things. Then you must check when loading extensions or write fallback paths. It’s better to think of Vulkan like a ‘throwbag of hardware vendor extensions’ that you pick and choose in your specific problem domain. If you use all the modern extensions like dynamic rendering, buffer device address, shader object, descriptor buffer and host image copy. After the initial setup the render loop can actually be significantly easier than anything else. You basically get a pointer to a chunk of GPU memory then memcpy a fat struct of everything you need at start of frame then index into it with push constants. You can write shaders in such a way that the same struct can be imported into C and GLSL. But this is where not everything supports it yet. You can go to Vulkan GPU info site, download the json spec of every piece of hardware you are concerned with running on. Then clone the Vulkan spec. Tell Claude code to read the Vulkan spec and all of the json profiles and give you a high level overview of all extensions and features that will work for your target hardware. I know you say you hate AI but this something it’s really good at and I’ve come to believe you need it for. Because it’s impossible for a human to read and grok every nuance of the Vulkan spec to then cross reference with dozens of hardware profiles. You will end up overlooking or missing some nuance if you don’t and not doing it as optimally.

@ecoezen @TheGingerBill @SaschaWillems2 Again, is driver reliability better? The API is terrible but secondary to my main concern, which is: if I build a binary, or ship source, what is the probability that the program works as-is on user machines? This basically disqualifies “modern” APIs.

Stop writing OpenGL state machine management bugs with this one weird trick

@nicbarkeragain Since setting this up for claude I cannot think of any time it was wrong about vulkan. I actually rely more now on claude to identify the issues in my vulkan code than the validation layers themselves. github.com/rygo6/Vulkan-C…

One of the biggest problems with using LLMs as a google replacement for programming, is that getting zero relevant results on google used to be a signal that you had the wrong idea about the root cause. Whereas LLMs will happily indulge any terrible idea you suggest.

I haven't seen anyone say this much but... The C-Style Single-Header style of programming I do find to be by far the code style which Claude works best with. Everything flattened in one big file with fewer layers of abstraction, less pointer indirection and minimal hidden control flow. It seems to do complex refactors with less struggle and do them correctly. When you have a system spread across many files and logic is dependent on complex features like virtual methods, or overrides, or non-explicit types. It seems to miss or mess up more often.

@rfleury @Celmaun @theo I stopped following that guy a while ago.

I hesitate to dogpile, but for as long as I have been exposed to him online, I’ve understood the guy as a bad actor who repeatedly attacks the work and character of programmers doing highly valuable and difficult work that I greatly respect. When this is clearly and calmly demonstrated in an argument, he deletes all of his tweets, despite not changing his mind or retracting anything he said. As a very straightforward example, here (youtube.com/live/QJGBypJdL…) is a recent clip of him repeating character attacks that were thoroughly demonstrated as incorrect and in bad faith in a thread months prior: x.com/cmuratori/stat…

the fall of @theo. from the highest signal to noise ratio on dev youtube to absurd and useless AI ramblings youtu.be/iFdTLLlby9E

For the purpose of high-performance code. Something I am finding absolutely invaluable with Claude Code. It is good at matching a compiled .s assembly file to the source file. So, if Claude can compile your project, you can ask it question about the assembly of a particular method. I try to make a point in hot path code to have a decent sense of all the assembly I am generating. Generally, this translates into me copy/pasting simplified snippets here and there in godbolt to analyze the assembly output if I am not sure. However, this is not very thorough. It's unrealistic to read through the compiled assembly of a highly complex hot code path, and it is also unrealistic to copy/paste out isolated simplified variations of everything. It takes too much time. However, with Claude I can just ask 'Does this method fully compile out at -O2?' 'Is this properly inlining?' 'Is this properly vectorizing?' Whatever. These patterns are formulaic and it knows how to check. I could 10x the time I'd spend writing out a hot path of code by manually checking the assembly. Now I can constantly check the generated assembly for everything, in a dozen different ways, as a background process that takes up little of my time. For areas where you really need to sure of the performance. Claude can even pull chunks of code out from your codebase, isolate them, add the boilerplate for them to run, add the measurement code, compile, run the code, aggregate the results and tell you. When it comes to writing intricate hot path code like this, I don't find Claude helps a ton with the writing of the code. It's more like a super-linter to check for Vulkan or syntax errors pre-emptively. However, all the 'other stuff' that can easily be more time consuming than the writing of the actual code? So much of that it can just automate and let me do even more thoroughly than I ever would do manually.

AI has reached a point of being good enough that it has become threatening to certain portions of the status quo. So it is going to go through much of the same cycle which crypto went through as it crossed a threshold of becoming a threat to certain portions of the status quo. It is not surprising to me how recycled it all is. "It's burning down forests just to ____!" "But the technology is fundamentally immoral!" "It scammed my Grandma!" I'm sure the media narratives around 'The Four Horsemen of the Infocalypse' are soon to follow: en.wikipedia.org/wiki/Four_Hors… It will end up the same as crypto. Everyone who was having meltdowns about blockchain several years ago now happily use blockchain. Just concealed behind the VISA brand as parts of the VISA settlement backbone. It has nothing to do with the technology. Some people just need it filtered through a big recognizable corporate brand in order to feel Okay about it. In five more years or so some big recognizable name like World of Warcraft or Fortnite or Roblox or whatever. They'll add a whole bunch functionality that rests on the same exact AI stuff that some are upset about right now. Except it'll be the 'In-Game Custom Clothing Tailor' or whatever. It will be concealed behind the big recognizable brand identity. And no one will say anything.

@rms80 I’ve found this very useful too. Old projects that I’d never touch because it take me a day at least to resurrect and compile it. Or sort through all changes needed for newer APIs or platform. Claude code can just do it in the background.

a nice thing about the coding robots is being able to resurrect old demos/etc. I've wanted to re-implement this decal-texturing interface from my SIGGRAPH 2006 ExpMap paper for ... holy shit ~20 years ... but never had the right place & time

I've been stoked about 3D printing for 15 years now. However for those 15 years I never bought a 3D printer because the quality was not good enough compared to mass manufactured items. Nor what you could get from the really fancy printers that shapeways.com had. Also you had to fiddle with the printers too much. But now I'd say that has changed in the past few years. The newer bambu printers with a 0.2mm head and PETG can print computer parts pretty much as good you could get them from shapeways. I just printed this with zero special knowledge of how to setup the printer. Only switched to the 0.2m head, fed in the PETG, used the default setting, imported the CAD and clicked 'print'. Everything self-calibrated. Active noise cancelling get the noise level manageable. Other brands are probably just as good but I decided get the p2s. Was like $700 total. Couple more years that will probably be half for comparable quality. Another 10 years I could see 3D prints of this quality coming out of $40 printers stocked on Walmart shelves. That scenario presents an interesting dynamic where you could make a lot of products cheaper if people printed the plastic parts themselves. If instead of spending $30 on a PC fan. I could instead buy a kit with the non-plastic parts for $5. Then let all the plastic parts cook on my printer over night. Then snap them altogether the next day to have a PC fan for a fraction of the price. I would do that. Most people would probably do that for a lot of stuff as long as they had an easy to 3D printer that made decent quality prints. I am already 3D printing all of my new computer cases. There is no reason to buy computer cases anymore. There is probably space for a novel kind of company which sells a lot of the typical commodity items you'd buy off amazon, or newegg, or wherever. But instead, it is not the whole item. It's a kit with all of the non-plastic parts. Then you scan a QR code and have it print all the plastic parts. Then snap, or screw, them all together. With some nice IKEA-like instructions.

The VR wave revealed who couldn't get over being some ultra-nerd and deep-dive into VR to really understand it's potential. The crypto wave revealed who couldn't let their mind think anything against an authority they perceived as too great. The AI wave is revealing whose technical habits and skills are too rigid, lacking curiosity and creativity.

@hasithad @iquilezles @straceX You don't hide control flow. You incentivize being more aware of what you are doing with the machine. ( why I don't like RAII )

@iquilezles @straceX I’m legitimately just curious, why do you prefer this over RAII?

goto in C gets treated like a crime in most tutorials. the linux kernel uses it everywhere for error handling. when you need to clean up multiple resources, it’s often the simplest way to keep things correct.