<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Simone Giusti - Blog</title>
    <link>https://www.simonegiusti.it/blog</link>
    <description>Articoli su Laravel, Vue.js, architettura software e best practice per lo sviluppo web moderno.</description>
    <language>it-IT</language>
    <lastBuildDate>Wed, 15 Jul 2026 07:05:05 GMT</lastBuildDate>
    <atom:link href="https://www.simonegiusti.it/rss.xml" rel="self" type="application/rss+xml"/>
    <item>
      <title>Claude Code vs Codex: quale scegliere per programmare?</title>
      <link>https://www.simonegiusti.it/blog/claude-code-vs-codex-quale-scegliere</link>
      <guid>https://www.simonegiusti.it/blog/claude-code-vs-codex-quale-scegliere</guid>
      <description>Confronto reale tra Claude Code e Codex su due task: sviluppo, architettura e code review. Quando usare Claude, quando Codex, e perché la review resta umana.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Segnali che un progetto software fallirà prima di iniziare</title>
      <link>https://www.simonegiusti.it/blog/segnali-progetto-software-fallira</link>
      <guid>https://www.simonegiusti.it/blog/segnali-progetto-software-fallira</guid>
      <description>Molti progetti software falliscono per segnali chiari fin dal primo incontro. Quali sono, come riconoscerli, perché quasi nessuno li prende sul serio.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Quando dire no a un progetto software (e perché conviene a tutti)</title>
      <link>https://www.simonegiusti.it/blog/quando-dire-no-a-un-progetto-software</link>
      <guid>https://www.simonegiusti.it/blog/quando-dire-no-a-un-progetto-software</guid>
      <description>Un progetto può essere tecnicamente fattibile e comunque una pessima idea. Perché dire no al momento giusto conviene sia al cliente che al fornitore.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Segnali che un progetto software fallirà prima di iniziare</title>
      <link>https://www.simonegiusti.it/blog/segnali-progetto-software-fallira</link>
      <guid>https://www.simonegiusti.it/blog/segnali-progetto-software-fallira</guid>
      <description>Molti progetti software falliscono per segnali chiari fin dal primo incontro. Quali sono, come riconoscerli, perché quasi nessuno li prende sul serio.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Successione tecnica: cosa si può davvero trasferire a chi viene dopo</title>
      <link>https://www.simonegiusti.it/blog/successione-tecnica-conoscenza-tacita</link>
      <guid>https://www.simonegiusti.it/blog/successione-tecnica-conoscenza-tacita</guid>
      <description>Documentazione, delega e bus factor aiutano. Ma il gusto tecnico non si trasferisce del tutto. Cosa puoi davvero lasciare a chi viene dopo di te.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Con l&apos;AI il codice diventa commodity: la documentazione è l&apos;asset</title>
      <link>https://www.simonegiusti.it/blog/ai-codice-commodity-documentazione</link>
      <guid>https://www.simonegiusti.it/blog/ai-codice-commodity-documentazione</guid>
      <description>Con l&apos;AI il costo di scrivere codice crolla. Quello che resta davvero raro è il perché delle decisioni: architettura, trade-off, vincoli, contesto.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Quando dire no a un progetto software (e perché conviene a tutti)</title>
      <link>https://www.simonegiusti.it/blog/quando-dire-no-a-un-progetto-software</link>
      <guid>https://www.simonegiusti.it/blog/quando-dire-no-a-un-progetto-software</guid>
      <description>Un progetto può essere tecnicamente fattibile e comunque una pessima idea. Perché dire no al momento giusto conviene sia al cliente che al fornitore.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Bus factor reale: come misurarlo davvero e costruire un secondo</title>
      <link>https://www.simonegiusti.it/blog/bus-factor-reale-come-misurarlo-e-alzarlo</link>
      <guid>https://www.simonegiusti.it/blog/bus-factor-reale-come-misurarlo-e-alzarlo</guid>
      <description>Il bus factor apparente quasi sempre inganna: nella maggior parte dei team è 1. Come capire quello reale e alzarlo senza allargare il team.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Successione tecnica: cosa si può davvero trasferire a chi viene dopo</title>
      <link>https://www.simonegiusti.it/blog/successione-tecnica-conoscenza-tacita</link>
      <guid>https://www.simonegiusti.it/blog/successione-tecnica-conoscenza-tacita</guid>
      <description>Documentazione, delega e bus factor aiutano. Ma il gusto tecnico non si trasferisce del tutto. Cosa puoi davvero lasciare a chi viene dopo di te.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Con l&apos;AI il codice diventa commodity: la documentazione è l&apos;asset</title>
      <link>https://www.simonegiusti.it/blog/ai-codice-commodity-documentazione</link>
      <guid>https://www.simonegiusti.it/blog/ai-codice-commodity-documentazione</guid>
      <description>Con l&apos;AI il costo di scrivere codice crolla. Quello che resta davvero raro è il perché delle decisioni: architettura, trade-off, vincoli, contesto.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Il codice funziona. Non significa che sia una buona idea.</title>
      <link>https://www.simonegiusti.it/blog/codice-funziona-non-significa-buona-idea</link>
      <guid>https://www.simonegiusti.it/blog/codice-funziona-non-significa-buona-idea</guid>
      <description>Con l&apos;AI i team chiudono più ticket e producono più PR. Ma &apos;funziona nei test&apos; non dice se la decisione architetturale era quella giusta — e il conto arriva in produzione.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>L&apos;AI progetta il software in cinque minuti. Costruirlo richiede ancora sei mesi.</title>
      <link>https://www.simonegiusti.it/blog/ai-progetta-software-costo-reale-sviluppo</link>
      <guid>https://www.simonegiusti.it/blog/ai-progetta-software-costo-reale-sviluppo</guid>
      <description>Farsi progettare un software dall&apos;AI oggi costa cinque minuti. Perché il costo di sviluppo non è sceso con la stessa proporzione del costo di disegnarne l&apos;architettura.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Bus factor reale: come misurarlo davvero e costruire un secondo</title>
      <link>https://www.simonegiusti.it/blog/bus-factor-reale-come-misurarlo-e-alzarlo</link>
      <guid>https://www.simonegiusti.it/blog/bus-factor-reale-come-misurarlo-e-alzarlo</guid>
      <description>Il bus factor apparente quasi sempre inganna: nella maggior parte dei team è 1. Come capire quello reale e alzarlo senza allargare il team.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Troppi ruoli su una persona: il rischio organizzativo nascosto</title>
      <link>https://www.simonegiusti.it/blog/troppi-ruoli-una-persona-rischio</link>
      <guid>https://www.simonegiusti.it/blog/troppi-ruoli-una-persona-rischio</guid>
      <description>Se una persona sola tiene insieme tecnica, progetto e prodotto, l&apos;organizzazione accumula un rischio che non si vede finché non esplode.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Outsourcing software in India: perché finisce quasi sempre male</title>
      <link>https://www.simonegiusti.it/blog/outsourcing-software-low-cost</link>
      <guid>https://www.simonegiusti.it/blog/outsourcing-software-low-cost</guid>
      <description>Outsourcing software in India a un terzo del costo: il modello produce codice scollegato dal business, con incentivi sbagliati. E con l&apos;AI ha ancora meno senso.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Quanto costa un software custom? Differenze tra 5K, 18K e 50K</title>
      <link>https://www.simonegiusti.it/blog/quanto-costa-un-software-custom</link>
      <guid>https://www.simonegiusti.it/blog/quanto-costa-un-software-custom</guid>
      <description>Tre preventivi da 5.000 a 50.000 euro per lo stesso software indicano approcci molto diversi. Come capire cosa compri davvero e quale ha senso per il tuo caso.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Digitalizzare i processi aziendali: prima fai ordine, poi il software</title>
      <link>https://www.simonegiusti.it/blog/digitalizzare-processi-aziendali</link>
      <guid>https://www.simonegiusti.it/blog/digitalizzare-processi-aziendali</guid>
      <description>Digitalizzare i processi aziendali senza prima fare ordine produce solo un sistema più rigido. Perché il software amplifica quello che già esiste.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Semplicità nel software: perché costa più di quanto sembri</title>
      <link>https://www.simonegiusti.it/blog/semplicita-nel-software</link>
      <guid>https://www.simonegiusti.it/blog/semplicita-nel-software</guid>
      <description>La semplicità nel software è il punto di arrivo, non di partenza. Un prodotto dove basta un click richiede analisi, decisioni e gestione degli scenari.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Codice perfetto vs pragmatico: quando migliorare il codice ha senso</title>
      <link>https://www.simonegiusti.it/blog/codice-perfetto-vs-pragmatico</link>
      <guid>https://www.simonegiusti.it/blog/codice-perfetto-vs-pragmatico</guid>
      <description>Codice elegante che non risolve un problema di business è un costo, non un valore. Meglio un codice pragmatico che funziona, senza cadere nel caos.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Hai speso tutto il budget nel prodotto. E nessuno sa che esiste</title>
      <link>https://www.simonegiusti.it/blog/budget-software-go-to-market</link>
      <guid>https://www.simonegiusti.it/blog/budget-software-go-to-market</guid>
      <description>Un prodotto ottimo che nessuno conosce resta isolato dal mercato. Come distribuire il budget tra sviluppo e go-to-market a seconda della fase del prodotto.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Quando lanciare un prodotto: meglio piccolo e funzionante che perfetto</title>
      <link>https://www.simonegiusti.it/blog/quando-lanciare-un-prodotto</link>
      <guid>https://www.simonegiusti.it/blog/quando-lanciare-un-prodotto</guid>
      <description>Aspettare che il prodotto sia completo aumenta il rischio di costruire la cosa sbagliata. Come lanciare piccolo ma solido, raccogliere feedback e iterare.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Come assumere sviluppatori bravi: perché non rispondono al tuo annuncio</title>
      <link>https://www.simonegiusti.it/blog/come-assumere-sviluppatori-bravi</link>
      <guid>https://www.simonegiusti.it/blog/come-assumere-sviluppatori-bravi</guid>
      <description>Assumere sviluppatori bravi è possibile anche in un mercato competitivo. Il problema spesso è nell&apos;offerta: stack, flessibilità, processo di selezione.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Comunicazione tra team tecnico e business: come ridurre le incomprensioni</title>
      <link>https://www.simonegiusti.it/blog/team-tecnico-business-due-lingue</link>
      <guid>https://www.simonegiusti.it/blog/team-tecnico-business-due-lingue</guid>
      <description>La comunicazione tra team tecnico e business è piena di equivoci che costano sprint interi. Le frasi ricorrenti e come costruire un linguaggio comune.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Agenzia che abbandona il progetto: come proteggersi e ripartire</title>
      <link>https://www.simonegiusti.it/blog/agenzia-abbandona-progetto-software</link>
      <guid>https://www.simonegiusti.it/blog/agenzia-abbandona-progetto-software</guid>
      <description>Quando un fornitore software si ferma a metà progetto, il danno va oltre il ritardo: è la perdita di controllo. Come proteggersi prima e cosa fare quando succede.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Software fragile: ogni modifica rompe qualcos&apos;altro. Come uscirne</title>
      <link>https://www.simonegiusti.it/blog/software-fragile-regressioni</link>
      <guid>https://www.simonegiusti.it/blog/software-fragile-regressioni</guid>
      <description>Software dove ogni modifica rompe qualcosa: il team evita di deployare e lo sviluppo rallenta. Perché succede e come ridurre gradualmente la fragilità senza bloccare il progetto.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Costi di manutenzione software: quanto mettere a budget ogni anno</title>
      <link>https://www.simonegiusti.it/blog/costi-manutenzione-software</link>
      <guid>https://www.simonegiusti.it/blog/costi-manutenzione-software</guid>
      <description>Il software non è un acquisto una tantum. Sicurezza, aggiornamenti, bug e compatibilità costano. Come quantificare il budget annuale di manutenzione e perché 15-20% è realistico.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Scope creep nei progetti agile: come riconoscerlo e contenerlo</title>
      <link>https://www.simonegiusti.it/blog/scope-creep-progetti-agile</link>
      <guid>https://www.simonegiusti.it/blog/scope-creep-progetti-agile</guid>
      <description>Lo scope creep mascherato da agilità è tra le cause principali di progetti software fuori budget. Come riconoscerlo e quanto costa cambiare priorità.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Preventivo software: perché conviene partire dal budget</title>
      <link>https://www.simonegiusti.it/blog/preventivo-software-partire-dal-budget</link>
      <guid>https://www.simonegiusti.it/blog/preventivo-software-partire-dal-budget</guid>
      <description>Chiedere un preventivo software senza contesto porta a stime fragili. Partire dal budget rende la conversazione più utile: cosa costruire prima, cosa rimandare, come evitare le sorprese.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Se il tuo miglior developer se ne va domani, il prodotto sopravvive?</title>
      <link>https://www.simonegiusti.it/blog/bus-factor-developer-indispensabile</link>
      <guid>https://www.simonegiusti.it/blog/bus-factor-developer-indispensabile</guid>
      <description>Bus factor: cosa misura, perché un bus factor vicino a 1 è un rischio serio, e come distribuire la conoscenza critica nel team senza rallentare lo sviluppo.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Ogni interruzione costa 23 minuti. Fai il conto a fine giornata</title>
      <link>https://www.simonegiusti.it/blog/ogni-interruzione-costa-23-minuti</link>
      <guid>https://www.simonegiusti.it/blog/ogni-interruzione-costa-23-minuti</guid>
      <description>Il costo delle interruzioni per gli sviluppatori è enorme: 23 minuti di concentrazione persa ogni volta. Con 5 al giorno perdi 2 ore. Ecco come ridurle.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Clean Code: guida utile (non dogma)</title>
      <link>https://www.simonegiusti.it/blog/clean-code-guida-pratica</link>
      <guid>https://www.simonegiusti.it/blog/clean-code-guida-pratica</guid>
      <description>Le regole di Clean Code salvano progetti dal caos. Ma applicate senza giudizio generano complessità inutile. Dove sta il confine pratico.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Design pattern: perché contano più del linguaggio che usi</title>
      <link>https://www.simonegiusti.it/blog/design-pattern-oltre-il-linguaggio</link>
      <guid>https://www.simonegiusti.it/blog/design-pattern-oltre-il-linguaggio</guid>
      <description>I design pattern restano rilevanti anche quando l&apos;AI scrive codice. Perché la progettazione pesa più del linguaggio, e cosa significa per sviluppatori e team.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Aggiungere sviluppatori a un progetto in ritardo: perché rallenta</title>
      <link>https://www.simonegiusti.it/blog/aggiungere-sviluppatori-progetto</link>
      <guid>https://www.simonegiusti.it/blog/aggiungere-sviluppatori-progetto</guid>
      <description>Aggiungere sviluppatori a un progetto in ritardo spesso lo rallenta. La Legge di Brooks e cosa fare invece per rispettare le deadline.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>AI nello sviluppo software: cosa cambia per chi guida un&apos;azienda</title>
      <link>https://www.simonegiusti.it/blog/ai-impatto-business-software</link>
      <guid>https://www.simonegiusti.it/blog/ai-impatto-business-software</guid>
      <description>L&apos;AI riduce il costo di sviluppo software, ma aumenta il peso delle decisioni. Cosa cambia per chi guida un&apos;azienda: budget, scelta dei fornitori, priorità.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Separare backend e frontend: quando ha senso (e quando no)</title>
      <link>https://www.simonegiusti.it/blog/backend-frontend-separati-costi</link>
      <guid>https://www.simonegiusti.it/blog/backend-frontend-separati-costi</guid>
      <description>Separare backend e frontend con API REST: quando ha davvero senso per il tuo progetto e quando un monolite moderno (Laravel + Inertia, Rails) costa meno e scala uguale.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Test coverage al 100%: cosa misura davvero (e cosa no)</title>
      <link>https://www.simonegiusti.it/blog/test-coverage-cosa-misura</link>
      <guid>https://www.simonegiusti.it/blog/test-coverage-cosa-misura</guid>
      <description>Test coverage al 100%: cosa misura davvero e cosa no. Puoi avere numeri altissimi e non testare nulla di utile. Come capire quali test proteggono il prodotto.</description>
      <category>Testing</category>
    </item>
    <item>
      <title>Cos&apos;è un MVP software: significato, esempi e come farlo bene</title>
      <link>https://www.simonegiusti.it/blog/cos-e-un-mvp-software</link>
      <guid>https://www.simonegiusti.it/blog/cos-e-un-mvp-software</guid>
      <description>Cos&apos;è un MVP software e come svilupparlo senza bruciare i primi utenti: significato reale di &apos;minimum viable product&apos;, esempi, principi di qualità e trappole.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Stime di sviluppo software: perché sbagliano e come migliorare</title>
      <link>https://www.simonegiusti.it/blog/stime-sviluppo-sbagliate-perche</link>
      <guid>https://www.simonegiusti.it/blog/stime-sviluppo-sbagliate-perche</guid>
      <description>Le stime di sviluppo software falliscono per motivi strutturali. Cosa chiedere al team al posto di &apos;quanto ci vuole&apos; e come pianificare con meno sorprese.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Dipendenze open source: il costo nascosto che non vedi nell&apos;invoice</title>
      <link>https://www.simonegiusti.it/blog/dipendenze-open-source-costo-nascosto</link>
      <guid>https://www.simonegiusti.it/blog/dipendenze-open-source-costo-nascosto</guid>
      <description>Le dipendenze open source nel tuo progetto costano più di quello che pensi: manutenzione, sicurezza, rischio abbandono. npm install è gratis, il resto no.</description>
      <category>DevOps</category>
    </item>
    <item>
      <title>Riscrivere un software da zero: quando ha senso e quando no</title>
      <link>https://www.simonegiusti.it/blog/riscrivere-software-da-zero</link>
      <guid>https://www.simonegiusti.it/blog/riscrivere-software-da-zero</guid>
      <description>Riscrivere un software da zero costa più del previsto e spesso non risolve il problema reale. Quando conviene davvero, quando no, e le alternative che funzionano (strangler pattern, refactoring incrementale).</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Monolite vs microservizi: quando servono davvero i servizi distribuiti</title>
      <link>https://www.simonegiusti.it/blog/monolite-vs-microservizi</link>
      <guid>https://www.simonegiusti.it/blog/monolite-vs-microservizi</guid>
      <description>Monolite vs microservizi: perché la maggior parte delle startup non ha bisogno di un&apos;architettura distribuita e come un monolite ben fatto scala.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Web app lenta: perché il collo di bottiglia è quasi sempre il database</title>
      <link>https://www.simonegiusti.it/blog/web-app-lenta-problema-database</link>
      <guid>https://www.simonegiusti.it/blog/web-app-lenta-problema-database</guid>
      <description>Web app lenta e costi server che crescono? Spesso il collo di bottiglia è nel database, non nell&apos;infrastruttura. Come misurare e ottimizzare.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>React, Vue o Angular: come scegliere il framework JavaScript</title>
      <link>https://www.simonegiusti.it/blog/quale-framework-javascript-scegliere</link>
      <guid>https://www.simonegiusti.it/blog/quale-framework-javascript-scegliere</guid>
      <description>React, Vue, Angular (+ Svelte): come scegliere il framework JavaScript giusto. Costi reali, ruolo del team, ecosistema e impatto dell&apos;AI sulla decisione.</description>
      <category>Architettura</category>
    </item>
    <item>
      <title>Sviluppare con l&apos;AI: come cambia il lavoro (e i rischi)</title>
      <link>https://www.simonegiusti.it/blog/sviluppare-con-ai</link>
      <guid>https://www.simonegiusti.it/blog/sviluppare-con-ai</guid>
      <description>L&apos;AI accelera lo sviluppo software ma aumenta il peso delle decisioni. Cosa cambia per chi gestisce team, budget e roadmap, e come evitare errori costosi.</description>
      <category>Sviluppo</category>
    </item>
    <item>
      <title>Sicurezza del backend: tre errori comuni e come mitigarli</title>
      <link>https://www.simonegiusti.it/blog/sicurezza-backend-produzione</link>
      <guid>https://www.simonegiusti.it/blog/sicurezza-backend-produzione</guid>
      <description>Sicurezza backend: vulnerabilità nelle dipendenze, secrets esposti e debug in produzione. Guida pratica per proteggere il tuo server.</description>
      <category>DevOps</category>
    </item>
    <item>
      <title>Sito web senza server: perché scegliere Nuxt e Cloudflare</title>
      <link>https://www.simonegiusti.it/blog/sito-web-senza-server-nuxt-cloudflare</link>
      <guid>https://www.simonegiusti.it/blog/sito-web-senza-server-nuxt-cloudflare</guid>
      <description>Sito web senza server con Nuxt e Cloudflare: costi contenuti, affidabilità, niente manutenzione. Quando conviene scegliere questo approccio e quando no.</description>
      <category>Architettura</category>
    </item>
  </channel>
</rss>