Making d actually usable by ai

[monkyyy]

When writing full ai code ive been going with odin, it just keeps 
being the right choice, the reason is extremely simple odin is 
correct on lib management d is not.

They ship raylib, if I were to ask ai to make a raylib project, 
take a wild geuss how its gonna do that; its going to grab dub 
and get into an npm mindset which is bad enough for a human, an 
unsupervised ai? No, it will do oo it will grab endless 
depencies, nononono; it will make a horrible mess. It will pick 
up the bad habits of an npm mindset, it will destory the file 
structure, and the good compiles times of the compiler wasted.

Instead of the good dependable raylib binding, our std has 
*checks notes* std.json

Ive now looking at the problems with string management in no-gc 
languages, its painful. Can we just clean up the language std and 
not infect the new users and the ai's *who cant learn better* 
with the worthless npm culture?

I repeat the ai's cant learn, they are the median opinion for 
whats around and what they "did", when they call dub they will be 
thinking like a js programmer, who outnumber us many many times 
over, thats going to be the sum of the vectors is their shitty 
taste. "Should I go import left-pad or write it myself beep boop 
its best practices to use the package manager".


```
> I want to make a raylib project in odin write the first 5 steps 
> and a style guide

Exploring the integration of raylib within Odin's ecosystem.
I am considering how Odin's foreign function interface and vendor 
management system facilitate access to external libraries like 
raylib.
The presence of a vendor directory suggests a structured approach 
to third-party dependencies, possibly including raylib through a 
dedicated module.
---

odin-raylib-game/
   main.odin
   assets/
   bin/
```

---
```
>I want to make a raylib project in dlang write the first 5 steps 
>and a style guide

Establishing a structured foundation for a D language game 
project leveraging raylib
I am defining a cohesive development environment by integrating 
essential system libraries and ensuring cross-platform 
compatibility through appropriate build tools.
I am organizing the project with clear module boundaries, 
consistent naming conventions, and a disciplined approach to code 
organization, error handling, and resource management.

---

my-raylib-game/
├── dub.sdl
├── .gitignore
├── .editorconfig
├── assets/
│   ├── textures/
│   ├── fonts/
│   ├── audio/
│   └── maps/
└── source/
     ├── app.d
     ├── core/
     │   ├── game.d
     │   ├── window.d
     │   └── assets.d
     ├── entities/
     │   ├── player.d
     │   └── enemy.d
     ├── states/
     │   ├── main_menu.d
     │   ├── gameplay.d
     │   └── pause.d
     └── rendering/
         ├── camera.d
         └── palette.d
```

look at the file structure, it thought dub and instantly made 
3-depth folders *before a line of code was written or goal 
stated*. To make ai behave better, we would need to implement 
some of the go/odin "programming language for a bad programmer" 
advice and extremely strong defaults is part of that. Arguing 
with an ai is like pushing water uphill; why should I start a 
project only to instantly need to fight with a idiot about file 
structure?