Ogni settimana nasce un nuovo “AI Agent Framework”.

Uno promette agenti autonomi.
Uno orchestration.
Uno memory persistence.
Uno multi-agent swarms.
Uno dice addirittura di “pensare come un team”.

Nel frattempo, il 90% degli sviluppatori sta ancora cercando di capire perché il proprio chatbot abbia appena cancellato mezzo database dopo aver letto un prompt ambiguo scritto alle 2:13 di notte.

Benvenuti nella nuova era dell’informatica.

La verità è che stiamo osservando qualcosa di molto più grande del semplice “prompt engineering”.
Gli AI agent stanno lentamente diventando un nuovo paradigma software.

Non un’app.
Non una feature.
Non un wrapper sopra GPT.

Un sistema operativo.

Sì, sembra una frase da keynote motivazionale con musica ambient sotto. Purtroppo è anche vera.

Il Grande Errore: Pensare agli Agenti Come Chatbot

Per mesi abbiamo trattato gli LLM come:

• assistenti conversazionali,
• generatori di testo,
• autocomplete molto costosi.

Ma un agente moderno non è semplicemente un modello che risponde.

Un agente:

• mantiene contesto,
• usa strumenti,
• prende decisioni,
• delega task,
• segue regole,
• conserva memoria,
• interagisce con ambienti esterni.

A un certo punto smette di sembrare una chat.
E inizia a sembrare… software.

Software probabilistico, caotico e leggermente sociopatico.
Ma sempre software.

Il Prompt Engineering Sta Morendo? Povero prompt engineering

La fase:

"scrivi il prompt perfetto"

sta lentamente collassando.

Perché i sistemi complessi non scalano con prompt più lunghi.
Scalano con architettura.

La vera evoluzione è questa:

Da:

Un mega prompt gigante

A:

Memoria + Skill + Tooling + Guardrail + Delegation

Che è esattamente ciò che facciamo da decenni in software engineering:

• separazione delle responsabilità,
• modularità,
• middleware,
• policy layer,
• orchestrazione.

Gli LLM non stanno sostituendo l’ingegneria software.
La stanno rendendo ancora più importante.

Ironico, considerando quanti tweet annunciavano “la fine dei programmatori” scritti da persone incapaci di centrare un div con CSS.

---

The Agent Development Kit

CLAUDE.md + Skills + Hooks + Subagents + Plugins

agent-dev-kit/

|-- CLAUDE.md/                  # Layer 1 — Livello Memoria
|   |-- architecture.rules
|   |-- global.md
|   `-- project.md
|
|-- skills/                     # Layer 2 — Livello Conoscenza
|   |-- SKILL.md
|   |-- scripts/
|   `-- context.md
|
|-- hooks/                      # Layer 3 — Livello Guardrail
|   |-- PreToolUse.sh
|   |-- PostToolUse.sh
|   `-- SessionStart.sh
|
|-- subagents/                  # Layer 4 — Livello Delega
|   |-- code-reviewer.md
|   |-- test-runner.md
|   `-- explorer.md
|
`-- plugins/                    # Layer 5 — Livello Distribuzione
    |-- manifest.json
    |-- marketplace.url
    `-- team.install

---

I Cinque Livelli

Layer 1 — Livello Memoria (CLAUDE.md)

Regole persistenti e convenzioni architetturali.

Responsabilità

• Convenzioni di naming
• Struttura repository
• Comportamenti globali
• Istruzioni di progetto

---

Layer 2 — Livello Conoscenza (skills/)

Capacità modulari e competenze riutilizzabili.

Responsabilità

• Skill auto-invocabili
• Script di riferimento
• Template
• Context injection

---

Layer 3 — Livello Guardrail (hooks/)

Sicurezza deterministica dell’esecuzione.

Responsabilità

• Validazione comandi
• Blocco azioni pericolose
• Logging
• Enforcement policy

Esempi

• Bloccare rm -rf
• Validare deploy
• Auto-format
• Integrazione Slack/GitHub

---

Layer 4 — Livello Delega (subagents/)

Agenti specializzati e isolati.

Responsabilità

• Parallelizzazione task
• Isolamento contesto
• Specializzazione
• Riduzione complessità

Esempi

• Code reviewer
• Test runner
• Security auditor
• Research explorer

---

Layer 5 — Livello Distribuzione (plugins/)

Packaging e distribuzione condivisa.

Responsabilità

• Bundling capacità
• Versionamento
• Marketplace integration
• Installazione stack condivisi

---

Flusso Architetturale

[ Memoria ]
      |
      v
[ Conoscenza ]
      |
      v
[ Guardrail ]
      |
      v
[ Delega ]
      |
      v
[ Distribuzione ]

---

Gli Agenti Stanno Reinventando Unix

Osserva qualsiasi stack agent moderno e troverai sempre gli stessi elementi:

• memoria persistente,
• tooling modulare,
• orchestrazione,
• permessi,
• processi isolati.

In pratica:

• Skills –> librerie
• Hooks –> middleware
• Subagents –> microservizi
• Plugins –> package manager

Gli AI agent stanno lentamente convergendo verso qualcosa che assomiglia terribilmente a:

un sistema operativo cognitivo.

Gli informatici hanno passato decenni a costruire astrazioni sopra Unix e adesso stanno ricostruendo Unix sopra i transformer.

Magnifico. Disturbante. Inevitabile.

---

La Differenza Tra Demo AI e Sistemi Reali

Le demo AI fanno sempre colpo.

“Guarda! Ha creato una landing page!”

Fantastico.

Poi lo metti in produzione e scopri che:

• rompe cose casualmente,
• allucina API inesistenti,
• dimentica istruzioni,
• entra in loop,
• installa dipendenze nate in un forum di terrapiattisti nel 2017.

Il problema non è il modello.

Il problema è che i modelli da soli non bastano.

I sistemi affidabili emergono quando aggiungi:

• osservabilità,
• controllo,
• memoria,
• validazione,
• isolamento.

In altre parole:
ingegneria architetturale.

Che pacco allucinante. Eppure incredibilmente necessaria.

---

L’Era Post-App È Già Iniziata

Sempre più software verrà usato tramite:

• linguaggio naturale,
• workflow dinamici,
• agent orchestration,
• sistemi contestuali.

Non aprirai più “app”.
Coordinerai capacità.

L’interfaccia non sarà il bottone.
Sarà l’intenzione.

E questo cambierà:

• UX in primis,
• sviluppo software,
• automazione,
• organizzazioni,
• lavoro cognitivo.

---

La Domanda Vera Non È:

“GPT Sostituirà i Developer?”

La domanda vera è:

quali developer sapranno progettare sistemi agentici robusti?

Perché costruire un buon agente richiede:

• product and design thinking,
• architettura,
• tooling,
• sicurezza,
• orchestrazione,
• design cognitivo (questa sembra sempre una super-cazzola!).

Non basta “parlare bene ai modelli”.

Bisogna progettare ecosistemi.

---

Gli AI agent non sono chatbot più evoluti.

Sono il primo tentativo serio di trasformare i modelli linguistici in infrastruttura computazionale generale.

Siamo ancora nella fase caotica.
Quella in cui tutti stanno improvvisando framework con nomi aggressivamente futuristici e README pieni di parole come:

• autonomous,
• cognitive,
• swarm,
• recursive.

Ma sotto il marketing sta emergendo qualcosa di reale.

Una nuova astrazione software. E probabilmente, tra qualche anno, guarderemo ai prompt singoli come oggi guardiamo agli script shell senza version control:
con un misto di nostalgia, orrore e vergogna professionale.

L’umanità ha passato 50 anni a costruire astrazioni sopra i computer e poi ha deciso:

“Sai cosa manca? Un computer probabilistico con problemi di contesto.”

Visionario. Discutibile. Inevitabile. Sciallo.