Hey @grok, guess the programming language. https://x.com/GithubProjects/status/2080046484184318151

Open-source apps for coders

https://kinetics.colorion.co/ - Open-source CSS/React motion effects with prompts
https://zrok.io/ - open-source secure local sharing/tunnels
https://scalar.com/ - modern interactive API docs
https://beszel.dev/ - open-source, lightweight server monitoring
https://pglite.dev/ - Lightweight Postgres running in WebAssembly.

It’s time. https://x.com/nikitabier/status/2080151882027442448

literally the only one article you need to master graph engineering at advanced level:

KIMI K3 VS OPUS 4.8, SAME PROMPT OF A ROMAN COLISEUM
 
gave both models the exact same brief: recreate a Roman coliseum surrounded by a small town, in 3D
 
→ K3: cleaner geometry, better lighting, arches and stonework actually read as stone
→ Opus 4.8: flatter result, less architectural detail, the town around it feels empty
 
K3: $3 in API. Opus 4.8: ~$6 for the same prompt

LLM quantization techniques I'd learn if I had to fit a 70B model on a single GPU:

(bookmark this)

A 70B model in FP16 needs 140GB for weights alone. At 4-bit, that drops to 35GB, which fits on one card.

But naive rounding fails on large models. Roughly 0.1% of hidden dimensions carry values up to 20x larger than anything else in the tensor, and they wreck the quantization grid for everything else.

Each of these 5 methods handles those outliers at a different point:

1. RTN: ignores them. Rounds every weight to the nearest grid level with no calibration data. Cheapest option, weakest at low bit widths.

2. GPTQ: repairs after rounding. Quantizes a layer column by column and adjusts the remaining weights to absorb the error before moving on.

3. AWQ: protects before rounding. Finds the ~1% of weight channels that matter most and scales them up so they survive quantization. Everything still ends up in plain INT4.

4. LLM. int8(): isolates at inference. Outlier dimensions run in FP16, the other 99.9% run in INT8, and the results are merged.

5. QAT: solves it during training. The model is fine-tuned with rounding baked into every forward pass, so it adapts to the damage before quantization is actually applied.

All five produce the same artifact, a model at a fraction of its trained precision. They differ only in where the outlier problem gets addressed.

The visual below nicely summarise these techniques.

There's a really good paper that provides a comprehensive study of LLM quantization techniques: https://arxiv.org/abs/2411.02530

---
That said, quantization shrinks a model, but fine-tuning is how it gets adapted to a specific use case in the first place.

I wrote a full breakdown on fine-tuning LLMs with RL in 2026, including how to skip manual reward engineering with automatic LLM-graded rewards.

The article is quoted below!

humalike soluciona uno de los mayores problemas de los agentes de IA.

no basta con que sepan qué responder.
también tienen que saber cuándo hablar.

con un solo comando, Hermes pasa a:
> Intervenir solo cuando aporta valor.
> Adaptarse al tono del grupo.
> Recordar el contexto y a las personas.
> Sentirse como un participante más, no como un bot que responde a todo.

este tipo de detalles son los que hacen que una IA sea útil.