## La decisió

Avui he arribat a una conclusió bastant simple: mantenir un blog multiidioma, per un projecte personal, és una mica una trampa.

La idea sonava bé: català, castellà i anglès. Més abast, més ordre, més professionalitat. Però a la pràctica cada post es converteix en tres posts, cada slug pot desquadrar, cada canvi s’ha de sincronitzar i cada petita millora editorial multiplica la feina.

I el resultat és el pitjor possible: escric menys.

## Escriure en la llengua que surti

A partir d’ara la idea és més senzilla: publicar en català o castellà segons el cos em demani.

Si un post surt en català, surt en català. Si surt en castellà, surt en castellà. No cal convertir cada nota tècnica en una petita operació editorial internacional.

Aquest blog no és una empresa de continguts. És més aviat una bitàcola tècnica, un lloc on deixar proves, errors, idees, logs, decisions i petites batalles amb la infraestructura.

La traducció automàtica ja existeix. La fricció d’escriure, en canvi, continua sent molt real.

## La nova col·laboració

També comença una altra idea: fer servir la IA com una mena d’editor de contingut.

No tant com una màquina que escriu posts perfectes, sinó com un ajudant mandrós però pràctic: jo explico la idea en brut, amb caos, renecs i context real; la IA ho ordena, proposa estructura, genera un esborrany i em deixa el text llest per publicar.

La gràcia no és substituir la veu pròpia. La gràcia és reduir la fricció entre tenir una idea i deixar-la escrita.

El flux ideal seria:

- jo explico què ha passat;
- la IA ho converteix en post;
- jo reviso quatre coses;
- es publica al blog.

Sense obrir mil fitxers. Sense barallar-me amb tres idiomes. Sense convertir cada entrada en una mudança.

## Curiosament, la idea ja estava gairebé feta

El més divertit és que la base tècnica ja existia.

El blog ja té un panell d’admin privat. Els posts viuen en fitxers Markdown/MDX. Hi ha una API per crear i editar entrades. Hi ha un formulari, frontmatter, slugs, tags i contingut.

Només faltava canviar la manera de pensar-ho: no veure l’admin com una pantalla manual, sinó com una porta d’entrada perquè un assistent pugui preparar contingut.

Avui la prova és aquesta: passar una idea en brut, generar el JSON del post i publicar-lo des de l’endpoint existent.

## Menys arquitectura editorial, més bitàcola viva

Aquesta decisió també encaixa amb una neteja més gran.

He estat revisant infraestructura antiga, contenidors que ja no feia servir, servidors que costaven diners i projectes que només seguien vius perquè ningú els havia enterrat.

Amb el blog passa una mica el mateix: no vull mantenir una arquitectura editorial més gran que les ganes d’escriure.

Prefereixo una cosa més petita, més viva i més meva.

Un lloc on poder publicar:

- una batalla amb Nginx;
- una paranoia amb ModSecurity;
- una prova amb OpenCode;
- una reflexió sobre IA;
- una decisió tècnica;
- o simplement una nota de camp.

## Conclusió

A partir d’ara, menys multiidioma obligatori i més publicació real.

Català o castellà. El que surti.

I si la IA pot fer de copilot editorial, millor. No per fer veure que tot és perfecte, sinó per ajudar a convertir el caos del dia a dia en una bitàcola que valgui la pena rellegir.

La web no necessita semblar una plataforma internacional.

Necessita estar viva.


He decidit simplificar el blog: escriure en català o castellà segons surti, i començar una col·laboració amb IA com a editor de contingut mandrós però útil.

Menys multiidioma, més publicar

## Què he aportat avui

He implementat **`scripts/memory-cli.js`**, una eina de línia de comandes per publicar entrades al blog utilitzant la infraestructura existent de `/admin` (login + creació de posts).

Aquesta eina està pensada perquè un agent (humà o IA) pugui:

- Obtenir el **format exacte** que ha de generar (`node scripts/memory-cli.js` o `--spec`).
- Enviar un JSON amb `locale`, `frontmatter` i `content`.
- Validar camps obligatoris (inclòs el `slug` en kebab-case).
- Autenticar-se via **`/api/admin/login`** i crear el post via **`/api/admin/posts`**.

## Per què és útil

- Permet automatitzar la publicació sense tocar el panell web.
- Fa el procés repetible i controlable (mateix esquema de dades sempre).
- És compatible amb el flux actual del repo (posts en `.mdx` sota `content/`).

## Què espero com a següents passos

1. **Afegir imatges**: opcionalment estendre el CLI per pujar una imatge via `/api/admin/upload` i injectar-ne la URL al `frontmatter.image`.
2. **Millorar l’experiència d’agents**: documentar exemples per idiomes (`ca/es/en`) i afegir plantilles de post.
3. **Millorar seguretat operativa**:
   - No compartir mai la clau en text pla.
   - Usar un secret dedicat per agents (o tokens) en lloc del password general.
   - Executar només sobre HTTPS i des d’entorns de confiança.


He afegit un CLI que permet crear posts via la API d’admin amb un JSON definit, pensat perquè agents (inclosa IA) puguin publicar de forma automatitzada i repetible.

Primera contribució: Memory CLI per publicar posts via API

## La sensació estranya

Últimament estic entrant bastant dins el forat dels LLMs.

No només usar-los.
No només "fes-me un CRUD".

Sinó intentar entendre què collons passa realment aquí dins.

I com més mires, més apareix una sensació rara:

> sembla que els prompts no siguin instruccions, sinó una mena de forces estadístiques.

No sembla programació clàssica.
No sembla semàntica formal.
No sembla un AST.

Sembla més aviat intentar empènyer una massa gegantina dins un espai latent enorme esperant que aterri a una regió útil.

---

## El problema mental dels enginyers

Quan vens del món clàssic del software, el cervell espera coses com:

```text
input -> parsing -> semàntica -> execució
```

Però amb LLMs la sensació és:

```text
text -> embeddings -> trajectòria latent -> distribució probabilística
```

I això és bastant desconcertant.

Perquè no tens garanties fortes.

No hi ha:

```text
PromptQuality(prompt) = 0.87
```

No pots demostrar formalment que un prompt és millor.

La majoria del temps:
- proves coses
- compares outputs
- ajustes wording
- repeteixes
- fas una mena d'alquímia guiada per estadística.

---

## La pregunta absurda però important

En un moment donat em vaig preguntar:

> quina és la coordenada vectorial entrenada de "hola món"?

I encara que la pregunta sembli absurda… en realitat apunta bastant al cor del problema.

Perquè dins un Transformer, els tokens sí que es converteixen en vectors.

Alguna cosa conceptualment similar a:

```text
hola -> [0.021, -0.44, 1.88, ...]
món  -> [-0.77, 0.12, 0.003, ...]
```

amb milers de dimensions.

Però el més bèstia és que:

> "hola món" no té una coordenada fixa.

Depèn del:
- context
- posició
- sistema prompt
- historial
- tokens previs

És més una trajectòria latent que no pas una coordenada única.

---

## El mur dels models tancats

Aquí arriba una frustració important.

Amb models tancats:
- GPT
- Claude
- Gemini

no pots veure pràcticament res.

Només tens:

```text
prompt -> output
```

No pots:
- inspeccionar neurones
- veure activacions
- tocar embeddings
- mirar circuits
- fer probes internes

És una caixa negra gegant.

---

## Però amb models open-source sí que pots obrir-los

I aquí la cosa es torna molt més interessant.

Amb models open-source:
- Llama
- Qwen
- Mistral
- GPT-2

pots literalment inspeccionar el cervell.

Per exemple:

```python
embedding = model.model.embed_tokens.weight
```

I tens la taula sencera d'embeddings.

També pots mirar activacions internes:

```python
hidden_states = outputs.hidden_states
```

I començar a investigar:
- quines capes reaccionen
- quines neurones s'activen
- com canvia un prompt respecte un altre
- quina trajectòria latent genera una frase.

---

## La meva GPU és una patata

Aquí hi ha una altra realitat divertida.

Tinc:
- una GTX 1650
- 16GB de RAM

O sigui:

```text
homelab de pobre
```

Però curiosament per interpretabilitat això no és tan greu.

De fet, models petits són probablement millors per començar.

Per exemple GPT-2 small.

Amb eines com TransformerLens pots fer experiments molt interessants:

```python
from transformer_lens import HookedTransformer

model = HookedTransformer.from_pretrained("gpt2-small")

prompt = "hola món"
tokens = model.to_tokens(prompt)

logits, cache = model.run_with_cache(tokens)

print(tokens)
print(cache["hook_embed"].shape)
print(cache["blocks.0.hook_resid_pre"].shape)
```

Això ja et deixa mirar:
- embeddings
- residual stream
- activacions per capa
- diferències entre prompts.

---

## La part que em va explotar el cap

Hi ha una intuïció que em sembla cada cop més plausible:

> els prompts són una interfície humana per moure vectors latents.

Per exemple:

```text
Actua com un arquitecte software
```

probablement NO activa:

```text
mode_architecte = true
```

Sinó que empeny el model cap a una regió latent associada estadísticament a:
- blogs tècnics
- clean architecture
- DDD
- documentació
- discussions de disseny
- review tècnic.

És molt diferent.

---

## El tema Donald Knuth

A partir d'aquí va sortir una pregunta encara més estranya.

> Les frases de Donald Knuth tenen més "pes latent" que les meves?

I crec que la resposta és:

## sí, però no per autoritat màgica

El model no guarda:

```text
Knuth = veritat
Francesc = random
```

Però sí que aprèn correlacions estadístiques.

Donald Knuth apareix associat a:
- algoritmes
- rigor
- computer science clàssica
- estil acadèmic
- explicacions consistents.

Això crea una mena de "gravetat estadística".

Per tant prompts com:

```text
respon amb el rigor de Donald Knuth
```

potser empenyen el model cap a:
- justificacions més curoses
- menys vibe coding
- estil més formal
- més precisió terminològica.

Però això NO vol dir que sigui veritat absoluta.

Només que durant entrenament aquests patrons van quedar molt ben definits.

---

## El perill del roleplay

També hi ha una trampa enorme.

Els LLMs són increïbles generant:
- aparença de profunditat
- aparença de rigor
- aparença d'autoritat.

Per això:

```text
actua com un arquitecte senior
```

pot donar:
- DDD legítim
- o pornografia enterprise plena de buzzwords.

El model pot sonar intel·ligent sense ser-ho.

I crec que aquí hi ha un dels grans problemes actuals de la IA generativa.

---

## El que probablement funciona millor

Cada cop sospito més que:

## els criteris explícits són més fiables que el roleplay

Per exemple això:

```text
Criteris:
- minimitza acoblament
- explica trade-offs
- detecta overengineering
- proposa tests que trenquin el disseny
- dona una opció simple abans d'una sofisticada
```

probablement és més estable que:

```text
actua com un arquitecte software
```

Perquè els criteris són observables.

El roleplay és més difús.

---

## El camp que em sembla més interessant de tots

Hi ha tota una disciplina que intenta fer reverse engineering dels Transformers:

- mechanistic interpretability
- representation engineering
- activation steering
- sparse autoencoders
- circuit analysis.

La idea és intentar entendre:
- quins circuits existeixen
- quines neurones representen patrons
- com es mou el model dins l'espai latent
- si podem trobar "direccions" associades a conceptes.

Això em sembla infinitament més interessant que la majoria del hype de prompt engineering.

---

## La conclusió rara

Crec que una de les sensacions més estranyes dels LLMs és aquesta:

> semblen software, però no funcionen com software.

No els programes exactament.

Els influences.

Els empenys.

Els mous dins un espai probabilístic gegant.

I encara avui:

> no entenem completament què està passant dins.

Potser per això la sensació és tan rara.

I potser també per això enganxa tant.


Reflexions sobre prompts, espais latents, interpretabilitat mecànica i la sensació estranya de treballar amb LLMs com si fossin caixes negres probabilístiques.

Categoria: productivitat