From VBA to Claude Code

Introduction

This article is the travel log of a self-taught programmer who switched careers from manufacturing into tech.

From the day I wrote my first Excel macro, through discovering Python, the shock of ChatGPT, a tour of countless AI tools, to finally landing on Claude Code — this isn't a technical tutorial. Read it as one person's ten-year growth story.

Chapter 0 — Where It All Started: VBA and 7 Years in Manufacturing

Before we talk about ChatGPT, let me start at the beginning.

About ten years ago I was working on a factory floor. Every day: the same tasks, the same reports, the same spreadsheet work. One day I thought — "can't I automate this?"

That's when I discovered Excel's macro recorder.

Step 1 — Record & Watch

Press record, do your thing, press stop. Open the VBA editor and stare at the generated code.

Sub Macro1()
    Range("A1").Select
    Selection.Copy
    Range("B1").Select
    ActiveSheet.Paste
    Range("A2:A100").Select
    Selection.Sort Key1:=Range("A2"), Order1:=xlAscending
End Sub

It looked like a spell at first. But after recording and re-reading it dozens of times, patterns emerged. Range means a cell. Sort means sort. One by one, the meaning became clear.

Step 2 — Optimise What You Recorded

Macro-recorded code is verbose — it selects, then acts on the selection. You can write it far more concisely:

' Recorded (verbose)
Range("A1").Select
Selection.Copy
Range("B1").Select
ActiveSheet.Paste

' Optimised
Range("A1").Copy Destination:=Range("B1")

This record → read → optimise cycle was my entire VBA curriculum. Excel itself was my teacher.

Step 3 — Write It Yourself

Eventually I needed things the recorder couldn't produce: If branches, For loops, Do While conditions. Real programming.

Sub ProcessData()
    Dim i As Long, lastRow As Long
    lastRow = Cells(Rows.Count, 1).End(xlUp).Row
    For i = 2 To lastRow
        If Cells(i, 3).Value > 100 Then
            Cells(i, 5).Value = "Needs Review"
            Cells(i, 5).Interior.Color = vbYellow
        End If
    Next i
End Sub

7 Years of Builds

Daily report automation — a 30-minute morning chore became a single button click
Inventory management mini-system — Excel-based, but it worked on the floor
Month-end aggregation macros — hours of work cut to minutes
Simple dashboards — "visibility" for management
UserForm input screens — friendly GUIs for non-technical colleagues
Boss's workflow semi-automated — a multi-day task reduced to a few clicks

English as a Superpower

One big advantage: I was good at English. The highest-quality programming information — Stack Overflow, official docs, GitHub issues — is written in English. Being able to read it directly multiplied the information available to me many times over.

Advice for self-taught engineers: Learn English alongside coding. The two together accelerate independent learning dramatically.

The Excel Tetris Story

At some point I found myself building Tetris inside Excel. Cells as pixels, VBA handling the game loop — it actually worked. The code was awful (meaningless variable names, deep nesting, logic copy-pasted five times, GoTo spaghetti), but it ran.

Nobody writes perfect code from day one. What matters is shipping something that works. Refactor later. Ship first.

That success — building Tetris from scratch, alone — became the fuel for everything that followed.

Chapter 1 — Discovering Python: 3 Years of Apprenticeship

VBA's limits became clear over time. It lived inside Excel. It couldn't scrape the web, call APIs, or talk to other systems. It was a powerful spell locked inside one box.

Then I found Python — three years before ChatGPT arrived.

The world Python opened up was enormous. But the self-taught walls were high:

Three days lost to environment setup (what is pip? what is venv?)
Tutorials that refused to run despite following them exactly
Long English error messages with no obvious starting point
VBA habits bleeding into Python style

I kept writing every day regardless — after work, late at night, weekends. Alone. My version control was embarrassing:

my_project_v1.py
my_project_v2.py
my_project_v2_final.py
my_project_v2_final_FINAL.py
my_project_v2_final_FINAL_this_is_really_the_last_one.py

I knew Git existed. branch, merge, rebase were alien vocabulary.

Chapter 2 — ChatGPT Arrives: Everything Accelerates

November 2022. ChatGPT launched. I signed up on day one.

For someone who had spent a decade learning alone via Google and documentation, it felt like a revolution. Seven years of VBA, three of Python — and suddenly a turbo engine had been bolted onto my workflow.

"Translate this Python snippet into VBA" — instant comparison
"What does this error mean?" — 10 seconds instead of 30 minutes on Stack Overflow
"Can this be written more efficiently?" — immediate refactoring suggestions

After ten years of fighting alone, I finally had something I could hold a conversation with. Early responses were still error-prone and needed verification — but it told me what to search for, which was half the battle.

Chapter 3 — The AI Tool Odyssey

Once ChatGPT had me hooked, I tried everything:

Google Gemini

Strong on recent information due to search integration. Good at explaining code. Tended to drift in long, deep conversations.

Qwen

Alibaba's multilingual model. Handled English, Japanese, and Chinese mixed queries well. I actually built the foundation of my largest project with this tool.

DeepSeek

Excellent for algorithm-heavy code generation. Consistently produced "oh, nice" moments for competitive-programming-style problems.

HuggingFace Models

A different world entirely — hundreds of models to experiment with (Llama, Mistral, Falcon…). Running models locally deepened my understanding of how AI actually works.

Key lesson: Every tool has a specialty and a ceiling. No AI is universal. Knowing each tool's strengths compounds your learning speed.

Chapter 4 — First Contact with Claude: Great, But Unusable

I tried Claude early. My honest verdict: "impressive, but impractical."

The conversation quality was high — thoughtful, logical, with a depth other models lacked. But the free-tier limits were brutal. A few exchanges and you'd hit the wall. For a self-taught engineer who needs to ask questions when the questions come, "come back tomorrow" is a dealbreaker.

I filed Claude under "great but can't use it" and went back to ChatGPT + Gemini as my main stack.

Chapter 5 — Sonnet 4.5: Claude Had Changed

Time passed. Then Claude Sonnet 4.5 launched.

Tech communities were buzzing. I tried it sceptically. I was stunned.

This was not the Claude I remembered. Code comprehension had jumped to another level. Long context retention was solid. And the ability to write code was in a different league entirely. Same name, completely different tool.

Chapter 6 — The Pentagon Moment: Values as a Deciding Factor

Then I heard a story about Anthropic's CEO Dario Amodei declining a contract with the Pentagon.

Many companies will sell their most advanced technology to defence departments without hesitation — profit justifies it. Anthropic said no. Dario has placed AI Safety at the core of the company, taking the position that technology does not exist purely to generate revenue.

When I heard that, something clicked.

ChatGPT and Gemini are technically brilliant. DeepSeek's code generation is hard to beat. But the philosophy behind the tool you use every day — that matters too.

I resonated with Anthropic's values. I chose Claude.

Note: Details around the Pentagon story may vary — please fact-check with current sources. This reflects my understanding at the time of writing.

Chapter 7 — Claude Code: Learning Changed

Claude Code was fundamentally different from any AI chat tool I'd used.

ChatGPT and Gemini are conversation partners: ask a question, get an answer, copy it, paste it into your editor. Claude Code is a colleague working beside you: it reads your actual project files, edits them directly, runs terminal commands, handles Git with you.

The Old Way (Chat-Based AI)

1. Google the problem
2. Ask the AI chat
3. Copy the answer
4. Paste into editor
5. It doesn't work → back to chat
6. Copy-paste → doesn't work → back to chat
7. Three hours later, you've forgotten the original problem

The Claude Code Way

1. Ask inside your own project
2. Get advice grounded in your actual code
3. Edit files together in real time
4. Ask "why does this work?" and go deeper
5. See the result immediately
6. Understanding sticks

The shift is from being given answers to building things together while learning.

Chapter 8 — Learning Git: From Shame to Shipping

My first major project with Claude Code was learning Git properly. I had to escape the filename-versioning era.

I asked Claude Code everything:

"Explain git rebase vs git merge using a factory assembly-line analogy"
"Walk me through resolving a conflict step by step"
"How do teams name their branches in real projects?"
"I accidentally pushed. Can I undo it?"
"What is git stash and when do I use it?"

Coming from manufacturing, abstract explanations didn't land — I needed concrete analogies. Claude Code delivered.

The result: 📖 The Complete Git & GitHub Guide — a person who versioned files by appending dates to filenames now publishes on GitHub Pages.

Chapter 9 — AI as a Learning Tool: Using It Right

Let me be clear: Claude Code is one learning method among many, not a replacement for learning itself.

Strength	Description
Instant feedback	Code review on the spot
Context awareness	Advice grounded in your actual project
Gradual depth	Start beginner-level, go deeper on request
Multilingual	Ask in English, Italian, Japanese — it adapts
Hands-on	Edit real files as you learn

Limitation	Description
Fact-check everything	AI answers must always be verified
Fundamentals still matter	Textbooks and official docs are irreplaceable
Team experience	Real collaborative development can't be simulated
Community	Human interaction and meetups still count
Don't over-rely	Keep training your own thinking

Core principle: AI accelerates learning. It does not replace it.

Chapter 10 — Manufacturing to Tech: Skills That Transferred

I thought my factory background was a liability. I was wrong.

Manufacturing mindset	Tech equivalent
Quality Control (QC)	Code review, testing
Standard Operating Procedures	Documentation, README files
Kaizen (continuous improvement)	Refactoring, optimisation
5S (workplace organisation)	Clean code, file structure
PDCA cycle	Agile sprints
Defect root-cause analysis	Debugging

Taking process seriously — something drilled into me on the factory floor — is, if anything, rarer among developers. It's a genuine edge.

Chapter 11 — Before & After

Before

Version control = appending dates to filenames
No idea what a commit was
Opening a terminal was nerve-wracking
Error messages made me close the window
GitHub was something you put on a CV without knowing how to use it
Copy-pasting AI output without understanding it

After

git branch, merge, rebase — understood and used daily
Site published on GitHub Pages → rikiza89.github.io
Terminal: comfortable
Error messages: read and debugged alongside Claude Code
AI: a dialogue partner, not a copy-paste machine

The Road Ahead

Join a team project — move beyond solo development
Contribute to open source — starting with small issues
Keep publishing my learning — to help others in the same position
Keep trying new AI tools — stay curious, never settle

10 Years — The Lessons

Self-taught is slow but durable — knowledge you fought for doesn't leave you
Try every AI tool — each one teaches you something different
Tool selection isn't only about capability — the values behind the tool matter too
AI accelerates; it doesn't replace — always fact-check, never depend blindly
Career changes aren't weaknesses — factory experience is a weapon in tech
You can grow from _final_FINAL_this_is_really_the_last_one.py — Git is learnable by anyone

This article was written with the assistance of Claude Code. All facts were verified by the author.
AI and human collaboration — this is how I believe we learn best going forward.

Introduzione

Questo articolo è il diario di viaggio di un programmatore autodidatta che ha cambiato carriera, passando dall'industria manifatturiera al mondo tech.

Dal giorno in cui ho scritto la mia prima macro Excel, alla scoperta di Python, allo shock di ChatGPT, al tour tra decine di strumenti AI, fino ad approdare su Claude Code — questo non è un tutorial tecnico. È un semplice percorso di crescita nel corso di dieci anni.

Capitolo 0 — L'inizio: VBA e 7 anni nell'industria

Prima di parlare di ChatGPT, partiamo dall'inizio.

Circa dieci anni fa lavoravo in un'azienda manifatturiera. Ogni giorno: le stesse attività, gli stessi report, lo stesso lavoro su foglio di calcolo. Un giorno ho pensato — "non si può automatizzare tutto questo?"

È lì che ho scoperto il registratore di macro di Excel.

Passo 1 — Registra e Osserva

Premi Registra, fai le tue operazioni, premi Stop. Apri l'editor VBA e guarda il codice generato.

Sub Macro1()
    Range("A1").Select
    Selection.Copy
    Range("B1").Select
    ActiveSheet.Paste
    Range("A2:A100").Select
    Selection.Sort Key1:=Range("A2"), Order1:=xlAscending
End Sub

All'inizio sembrava un incantesimo. Ma dopo aver registrato e riletto decine di volte, i pattern emergevano. Range indica una cella. Sort significa ordinare. Pezzo per pezzo, il significato diventava chiaro.

Passo 2 — Ottimizza ciò che hai registrato

Il codice generato dal registratore è ridonadante: seleziona, poi agisce sulla selezione. Si può scrivere in modo molto più conciso:

' Registrato (ridondante)
Range("A1").Select
Selection.Copy
Range("B1").Select
ActiveSheet.Paste

' Ottimizzato
Range("A1").Copy Destination:=Range("B1")

Questo ciclo registra → leggi → ottimizza era il mio intero curriculum VBA. Excel stesso era il mio insegnante.

Passo 3 — Scrivilo da solo

Col tempo avevo bisogno di cose che il registratore non poteva produrre: condizioni If, cicli For, loop Do While. Vera programmazione.

Sub ProcessData()
    Dim i As Long, lastRow As Long
    lastRow = Cells(Rows.Count, 1).End(xlUp).Row
    For i = 2 To lastRow
        If Cells(i, 3).Value > 100 Then
            Cells(i, 5).Value = "Da verificare"
            Cells(i, 5).Interior.Color = vbYellow
        End If
    Next i
End Sub

7 anni di progetti

Automazione report giornalieri — un'attività da 30 minuti ogni mattina ridotta a un click
Mini sistema di gestione magazzino — basato su Excel, ma funzionava sul campo
Macro di aggregazione a fine mese — ore di lavoro ridotte a minuti
Dashboard semplici — "visibilità" per il management
Interfacce di input con UserForm — GUI intuitive per colleghi non tecnici
Workflow del responsabile semi-automatizzato — un'attività che richiedeva più giorni ridotta a pochi click

L'inglese come superpotere

Un grande vantaggio: sapevo l'inglese. Le informazioni di più alta qualità nel mondo della programmazione — Stack Overflow, documentazione ufficiale, issue su GitHub — sono scritte in inglese. Leggerle direttamente ha moltiplicato le risorse disponibili.

Consiglio per chi studia da solo: Impara l'inglese insieme alla programmazione. Insieme, accelerano l'apprendimento in modo drastico.

La storia del Tetris su Excel

Ad un certo punto mi sono ritrovato a costruire Tetris dentro Excel. Celle come pixel, VBA per il game loop — funzionava davvero. Il codice era orribile (nomi di variabili senza senso, nesting profondo, logica copia-incollata cinque volte, spaghetti con GoTo), ma girava.

Nessuno scrive codice perfetto fin dall'inizio. L'importante è creare qualcosa che funziona. Il refactoring si fa dopo. Prima si consegna.

Quel successo — costruire Tetris da zero, da solo — è diventato il carburante per tutto il resto.

Capitolo 1 — La scoperta di Python: 3 anni di apprendistato

I limiti del VBA sono diventati evidenti col tempo. Viveva dentro Excel. Non poteva fare web scraping, chiamare API, parlare con altri sistemi. Era magia potente rinchiusa in una scatola.

Poi ho scoperto Python — tre anni prima che arrivasse ChatGPT.

Il mondo che Python apriva era enorme. Ma i muri dell'autoapprendimento erano alti:

Tre giorni persi per configurare l'ambiente (cos'è pip? cos'è venv?)
Tutorial che non giravano nonostante li seguissi alla lettera
Messaggi d'errore lunghi in inglese, senza un punto di partenza ovvio
Abitudini VBA che si infiltravano nello stile Python

Ho continuato a scrivere ogni giorno — dopo il lavoro, a tarda notte, nei weekend. Da solo. Il mio controllo versioni era imbarazzante:

mio_progetto_v1.py
mio_progetto_v2.py
mio_progetto_v2_finale.py
mio_progetto_v2_finale_FINALE.py
mio_progetto_v2_finale_FINALE_questa_e_davvero_lultima.py

Sapevo che Git esisteva. branch, merge, rebase erano vocabolario alieno.

Capitolo 2 — Arriva ChatGPT: tutto accelera

Novembre 2022. ChatGPT viene lanciato. Mi sono iscritto il primo giorno.

Per qualcuno che aveva imparato da solo per un decennio con Google e la documentazione, è stata una rivoluzione. Sette anni di VBA, tre di Python — e all'improvviso al mio workflow era stato aggiunto un motore turbo.

"Traduci questo codice Python in VBA" — confronto istantaneo
"Cosa significa questo errore?" — 10 secondi invece di 30 minuti su Stack Overflow
"Si può scrivere in modo più efficiente?" — suggerimenti di refactoring immediati

Dopo dieci anni di lotta solitaria, finalmente avevo qualcosa con cui potevo dialogare. Le risposte iniziali erano ancora imprecise e richiedevano verifica — ma mi diceva cosa cercare, e questo era già metà del lavoro.

Capitolo 3 — L'odissea degli strumenti AI

Una volta preso dalla febbre di ChatGPT, ho provato tutto:

Google Gemini

Forte sulle informazioni recenti grazie all'integrazione con la ricerca. Buono per spiegare il codice. Tendeva a divagare nelle conversazioni lunghe e profonde.

Qwen

Il modello multilingue di Alibaba. Gestiva bene le query miste in inglese, giapponese e cinese. Ho costruito la base del mio progetto più grande con questo strumento.

DeepSeek

Eccellente per la generazione di codice algoritmico. Produceva regolarmente risposte che facevano pensare "oh, bello" sui problemi di tipo algoritmico.

Modelli HuggingFace

Un mondo a parte — centinaia di modelli da sperimentare (Llama, Mistral, Falcon…). Eseguire modelli in locale ha approfondito la mia comprensione di come funziona davvero l'AI.

Lezione chiave: Ogni strumento ha una specialità e un limite. Nessuna AI è universale. Conoscere i punti di forza di ciascuno moltiplica la velocità di apprendimento.

Capitolo 4 — Primo contatto con Claude: ottimo, ma inutilizzabile

Ho provato Claude presto. Il mio giudizio onesto: "impressionante, ma impraticabile."

La qualità della conversazione era alta — riflessiva, logica, con una profondità che gli altri modelli non avevano. Ma i limiti del piano gratuito erano brutali. Pochi scambi e si raggiungeva il muro. Per un autodidatta che deve fare domande quando le domande arrivano, "torna domani" è un dealbreaker.

Ho archiviato Claude sotto "ottimo ma non utilizzabile" e sono tornato a ChatGPT + Gemini come stack principale.

Capitolo 5 — Sonnet 4.5: Claude era cambiato

Passò del tempo. Poi arrivò Claude Sonnet 4.5.

Le community tech erano in fermento. L'ho provato scettico. Sono rimasto a bocca aperta.

Questo non era il Claude che ricordavo. La comprensione del codice aveva fatto un salto di livello. La gestione del contesto lungo era solida. E la capacità di scrivere codice era in un campionato completamente diverso. Stesso nome, strumento completamente diverso.

Capitolo 6 — Il momento del Pentagono: i valori come fattore decisivo

Poi ho sentito una storia: il CEO di Anthropic, Dario Amodei, aveva rifiutato un contratto con il Pentagono.

Molte aziende vendono la loro tecnologia più avanzata ai ministeri della difesa senza esitazione — il profitto lo giustifica. Anthropic ha detto no. Dario ha posto la sicurezza dell'AI al centro dell'azienda, sostenendo che la tecnologia non esiste solo per generare fatturato.

Quando l'ho saputo, qualcosa ha scattato.

ChatGPT e Gemini sono tecnicamente brillanti. La generazione di codice di DeepSeek è difficile da battere. Ma la filosofia dietro lo strumento che usi ogni giorno — anche quella conta.

Ho condiviso i valori di Anthropic. Ho scelto Claude.

Nota: I dettagli sulla storia del Pentagono potrebbero variare — verifica con fonti aggiornate. Questo riflette la mia comprensione al momento della scrittura.

Capitolo 7 — Claude Code: l'apprendimento cambia

Claude Code era fondamentalmente diverso da qualsiasi strumento di chat AI che avevo usato.

ChatGPT e Gemini sono interlocutori: fai una domanda, ricevi una risposta, la copi, la incolli nell'editor. Claude Code è un collega che lavora al tuo fianco: legge i tuoi file di progetto reali, li modifica direttamente, esegue comandi nel terminale, gestisce Git con te.

Il vecchio metodo (chat AI)

1. Cercare su Google
2. Chiedere alla chat AI
3. Copiare la risposta
4. Incollarla nell'editor
5. Non funziona → tornare alla chat
6. Copia-incolla → non funziona → tornare alla chat
7. Tre ore dopo, hai dimenticato il problema originale

Il metodo Claude Code

1. Fare la domanda dentro il proprio progetto
2. Ricevere consigli basati sul codice reale
3. Modificare i file insieme in tempo reale
4. Chiedere "perché funziona così?" e approfondire
5. Vedere il risultato immediatamente
6. La comprensione si consolida

Il cambio è da ricevere risposte a costruire insieme imparando.

Capitolo 8 — Imparare Git: dalla vergogna alla pubblicazione

Il mio primo grande progetto con Claude Code è stato imparare Git sul serio. Dovevo scappare dall'era del versioning-con-nomi-di-file.

Ho chiesto tutto a Claude Code:

"Spiega git rebase vs git merge usando l'analogia di una catena di montaggio"
"Guidami passo per passo nella risoluzione di un conflitto"
"Come nominano i branch i team nei progetti reali?"
"Ho fatto push per errore. Posso annullarlo?"
"Cos'è git stash e quando si usa?"

Venendo dall'industria, le spiegazioni astratte non mi arrivavano — avevo bisogno di analogie concrete. Claude Code le forniva.

Il risultato: 📖 The Complete Git & GitHub Guide — una persona che gestiva le versioni aggiungendo date ai nomi dei file ora pubblica su GitHub Pages.

Capitolo 9 — L'AI come strumento di apprendimento: usarla bene

Chiariamo: Claude Code è uno dei tanti metodi di apprendimento, non un sostituto dell'apprendimento stesso.

Punto di forza	Descrizione
Feedback immediato	Code review sul momento
Consapevolezza del contesto	Consigli basati sul tuo progetto reale
Profondità graduale	Parti dal livello base, approfondisci su richiesta
Multilingue	Chiedi in italiano, inglese, giapponese — si adatta
Pratico	Modifica file reali mentre impari

Limitazione	Descrizione
Verifica sempre	Le risposte AI vanno sempre controllate
Le basi contano ancora	Libri di testo e documentazione ufficiale sono insostituibili
Esperienza in team	Lo sviluppo collaborativo reale non si simula
Community	Le interazioni umane e i meetup contano ancora
Non dipendere eccessivamente	Continua ad allenare il tuo pensiero critico

Principio chiave: L'AI accelera l'apprendimento. Non lo sostituisce.

Capitolo 10 — Dall'industria al tech: competenze che si trasferiscono

Pensavo che il mio background manifatturiero fosse un limite. Mi sbagliavo.

Mentalità manifatturiera	Equivalente tech
Controllo qualità (QC)	Code review, testing
Procedure operative standard	Documentazione, file README
Kaizen (miglioramento continuo)	Refactoring, ottimizzazione
5S (organizzazione del posto di lavoro)	Clean code, struttura dei file
Ciclo PDCA	Sprint Agile
Analisi causa radice dei difetti	Debugging

Prendere i processi sul serio — qualcosa che mi è stato trasmesso in fabbrica — è, se possibile, ancora più raro tra gli sviluppatori. È un vero vantaggio competitivo.

Capitolo 11 — Prima e dopo

Prima

Controllo versioni = aggiungere la data al nome del file
Nessuna idea di cosa fosse un commit
Aprire un terminale era fonte di ansia
I messaggi d'errore mi facevano chiudere la finestra
GitHub era qualcosa che si metteva nel CV senza saperlo usare
Copia-incolla di output AI senza capirlo

Dopo

git branch, merge, rebase — compresi e usati ogni giorno
Sito pubblicato su GitHub Pages → rikiza89.github.io
Terminale: zona di comfort
Messaggi d'errore: letti e risolti insieme a Claude Code
AI: un partner di dialogo, non una macchina copia-incolla

La strada davanti

Unirsi a un progetto di team — uscire dallo sviluppo solitario
Contribuire all'open source — partendo dalle issue più piccole
Continuare a pubblicare il mio percorso — per aiutare chi è nella stessa situazione
Continuare a provare nuovi strumenti AI — restare curioso, non accontentarsi mai

10 anni — Le lezioni

L'autoapprendimento è lento ma solido — la conoscenza conquistata con fatica non te la porta via nessuno
Prova tutti gli strumenti AI — ognuno insegna qualcosa di diverso
La scelta dello strumento non riguarda solo le capacità tecniche — anche i valori dietro contano
L'AI accelera, non sostituisce — verifica sempre, non dipendere ciecamente
I cambi di carriera non sono debolezze — l'esperienza in fabbrica è un'arma nel tech
Si può crescere partendo da _finale_FINALE_questa_e_davvero_lultima.py — Git è imparabile da chiunque

Questo articolo è stato scritto con l'assistenza di Claude Code. Tutti i fatti sono stati verificati dall'autore.
Collaborazione tra AI e essere umano — questo è il modo in cui credo si impari meglio d'ora in poi.