The fact that we're getting to where hobbyist devs can't create software independently is by design. Most people who use computers will be shuttled so consumption boxes, while those who show coding aptitude will be pushed to use libraries and code from those corporations, almost like a slightly more advanced consumer.
While I completely agree with your sentiment that corporations and monocultures would love to eradicate programming independence, what is happening right now is absolutely the fault of programmers (hobbyist or otherwise) trading control and independence for immediacy. It has never been easier to get the information and build the skills required to develop a project of any level at any depth. The fact that FOSS and software in general is in a state of decline is because programmers are actively refusing to care about the art of programming. I'm not talking about the scripting dilettantes who exclusively use glue languages and argue about the legitimacy of dynamic madness writ large -- this is a problem that extends all the way down to systems programmers. Look at all the new languages: monocultures with a single compiler and a common mantra: pointers are dangerous, you can't outsmart the compiler, and don't reinvent the wheel (NIH is the devil!) because you can't make an implementation better than X because X was made with Y authority figures. It's absolute horseshit, but the seduction of immediacy coupled with laziness gets you with things like Electron ubiquity or std::function usage.
In the future it's highly possible that the monocultures / corps will start to actively hide information, but for now the onus is entirely on the programmers to stop making deals with the devil for some fast action and get back to the "tedium of implementation" (viz., the art of programming). C/C++ are the only ideological bastions left wherein the programmer is trusted and free to go as low as they wish,
and aren't monocultures (if there are any other languages, please let me know) so I'll use them as the example. Systems documentation for any major OS is a few search engine queries away; compilers are well documented and often OPEN SOURCE; tools like Compiler Explorer allow you to easily disassemble source code on any relevant compiler and on any sane hardware target; Intel supplies you with the entire set of x86-x64 for free (I don't know about AMD but I'm sure they do something like that); there are many open source graphics libraries available if you don't want to write your own; there are countless books on math for applications / game programming (usually with actual C++ examples) that teach you the core set of LinAlg / Calc you'll need to navigate through most situations (they'll even skip over those "nasty" proofs in case you were having trouble concentrating!); You can always start with a bit more abstraction via some framework like SFML, and then you can even make quick and dirty prototypes or tools with Dear ImGui at a speed that would make Electron blush (and they'll look a hell of lot better than base QT). The amount that a single, untrained person can achieve is insane provided they care enough to spend a bit of time developing skills. Learning the fundamentals might be a bit tedious or boring, but they're not hard. You don't have to have the IEEE 754 memorized before you get a general sense about floating point representation and the various challenges and pitfalls.
The knowledge is not only out there to support any project idea at any scale, but it's practically begging people to read it and yet no one seems interested; the only thing left they could do is pay you to care. Safety nets are everywhere with places like stackoverflow. Any person with a pulse can download an entire,
active professional game engine like Unreal and dissect the thing at their leisure to find out all sorts of tricks. Unreal has fantastic internal documentation in most areas and is a wonderful educational resource even if you never use it; you can also do the same with graphics libraries like OpenGL or even the framework wrappers like SFML. There has never been a time when so much information has been so easily accessible and just available for any programmer with a drive to take advantage of. You can even tear apart clang and LLVM and see how modern compilers are made. The mystery is no longer hidden behind closed source, proprietary fog. Talks from professionals sharing valuable developments in all fields from conventions like CPPCON are free and readily available. Now think of how easy it is to find other programmers with similar interests; it should be common for small groups of all skill levels to form to create elegant, fantastic, interesting, or strange FOSS competition everywhere. We should be in the middle of a software renaissance, yet instead we're mired in the sludge of glue languages and kernels that exist primarily to fulfill the insatiable malloc demands of browser tabs. At some point in the distant future, it really might be the fault of some shadow corporation; for now, though, the only reason programmers "can't" develop software independently is because they don't have the willpower to sit down and read some useful text in their ubiquitous browser.
