Il Nuovo Paradigma dello Sviluppatore AI

Introduzione

Il contesto

La professione del programmatore sta venendo «drasticamente rifatta» dall'intelligenza artificiale. Il contributo umano nel codice diventa sempre più sparso e frammentario. Non si tratta più solo di scrivere codice, ma di orchestrare sistemi AI, gestire contesti, e verificare output stocastici.

La Visione: Software 3.0

L'evoluzione del software

Concetti Chiave

1. L'Autonomy Slider

Un concetto fondamentale: scegliere il giusto livello di autonomia dell'AI per ogni contesto. Non esiste un'unica modalità, ma uno spettro di autonomia.

1. Tab completion — autonomia minima, suggerimenti inline
2. Edit selection — modifiche mirate su selezione
3. File-level edits — modifica interi file
4. Multi-file composer — edit coordinati su più file
5. Agent mode — autonomia massima, delega completa

2. Generation-Verification Loop

Il nuovo workflow non è più «scrivi codice → esegui → debug», ma:

1. AI genera codice/soluzione
2. Umano verifica correttezza, sicurezza, coerenza
3. Iterazione rapida basata su feedback

3. System Prompt Learning

Un nuovo paradigma di apprendimento per l'AI:

• Pretraining: per la conoscenza
• Finetuning: per comportamenti abituali
• System Prompt Learning: per «prendere appunti» espliciti su come risolvere problemi

4. Mental Model degli LLM

Necessità di costruire un modello mentale profondo per sistemi che sono:

• Stocastici — non deterministici
• Fallibili — possono sbagliare
• Opachi — difficili da debuggare
• In evoluzione — cambiano costantemente

Scelta degli Strumenti

La Grande Domanda: Quale IDE?

Altri Tool Essenziali

Setup Pratico su Mac

1. Fondamentali

Homebrew (se non installato)

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Node.js — versione aggiornata

# Verifica versione corrente
node --version

# Se < 20, aggiorna
brew install node@24  # LTS attuale (Dic 2025)

# Minimum: Node.js >= 20
# Raccomandato: Node.js 24 LTS

2. VSCode + Continue

Installa estensioni

# Continue (AI assistant)
code --install-extension continue.continue

# Opzionale: GitHub Copilot (se hai abbonamento)
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat

# ESLint e Prettier (per validation)
code --install-extension dbaeumer.vscode-eslint
code --install-extension esbenp.prettier-vscode

Configura Continue

# Crea directory config
mkdir -p ~/.continue
touch ~/.continue/config.json

Contenuto di ~/.continue/config.json:

{
  "models": [
    {
      "title": "Claude Sonnet 4",
      "provider": "anthropic",
      "model": "claude-sonnet-4-20250514",
      "apiKey": "${ANTHROPIC_API_KEY}"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Claude Sonnet 4",
    "provider": "anthropic",
    "model": "claude-sonnet-4-20250514"
  },
  "contextProviders": [
    { "name": "code", "params": {} },
    { "name": "diff", "params": {} },
    { "name": "terminal", "params": {} },
    { "name": "problems", "params": {} }
  ],
  "allowAnonymousTelemetry": false
}

3. Aider — AI Git Agent

# Installa con pipx (metodo pulito, raccomandato)
brew install pipx
pipx ensurepath
pipx install aider-chat

# Verifica installazione
aider --version

Configura Aider — contenuto di ~/.aider.conf.yml:

model: claude-sonnet-4-20250514
dark-mode: true
pretty: true
stream: true
auto-commits: true
dirty-commits: false
attribute-commits: true
edit-format: diff
# Lint prima di commit (opzionale ma raccomandato)
lint-cmd: "npm run lint"
# Test prima di commit
test-cmd: "npm test"

4. Claude Desktop + MCP

1. Scarica Claude Desktop da claude.ai/download
2. Installa l'app
3. Configura gli MCP servers

# Crea directory config
mkdir -p ~/Library/Application\ Support/Claude/

# Crea config file
touch ~/Library/Application\ Support/Claude/claude_desktop_config.json

Contenuto di claude_desktop_config.json (esempio sicuro):

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/TUOUSERNAME/Projects"
      ],
      "env": {}
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  },
  "globalShortcut": "CommandOrControl+Shift+Space"
}

5. Configurazione Progetto

File .cursorrules (o .continuerules) — crea questo file nella root del progetto per dare «istruzioni permanenti» all'AI:

# .cursorrules (o .continuerules)

You are an expert Node.js developer working with MongoDB.

Tech stack:
- Node.js 24 LTS
- MongoDB with Mongoose
- Express.js for APIs
- Modern ES6+ syntax
- TypeScript (if applicable)

Code style:
- Use async/await over callbacks
- Prefer arrow functions
- Use descriptive variable names
- Add JSDoc comments for complex functions
- Follow ESLint and Prettier configs

When writing code:
- ALWAYS handle errors properly with try/catch
- NEVER expose sensitive data or credentials
- Validate all MongoDB queries and user input
- Consider performance for database operations
- Write modular, reusable code
- Add logging for critical paths
- Consider edge cases and error scenarios

Security:
- Never commit API keys, passwords, or secrets
- Validate and sanitize all inputs
- Use parameterized queries (prevent injection)
- Follow OWASP best practices

Testing:
- Suggest Jest for unit tests when relevant
- Write tests for critical business logic
- Consider edge cases and error paths
- Test security validations

Before committing:
- Run linter (npm run lint)
- Run tests (npm test)
- Verify no secrets in code
- Check diff size (max 300 lines without explicit approval)

6. Variabili d'Ambiente Sicure

# Setup .env file
touch .env
echo ".env" >> .gitignore
echo "node_modules/" >> .gitignore

# Setup API keys in .env
echo "ANTHROPIC_API_KEY=your_key_here" >> .env
echo "GITHUB_TOKEN=your_token_here" >> .env

# Setup environment loader
npm install dotenv

In package.json aggiungi gli script:

{
  "scripts": {
    "dev": "node -r dotenv/config server.js",
    "lint": "eslint .",
    "lint:fix": "eslint . --fix",
    "test": "jest",
    "test:watch": "jest --watch"
  }
}

7. Verifica Setup

# VSCode installato?
which code

# Estensione Continue attiva?
code --list-extensions | grep continue

# Aider funziona?
aider --version

# Node.js versione corretta?
node --version  # deve essere >= 20

# Git configurato?
git --version
git config --global user.name
git config --global user.email

# ESLint presente?
npm list eslint

Security & Compliance

1. Gestione Secrets

Setup .gitignore completo

# .gitignore

# Secrets
.env
.env.local
.env.*.local
*.key
*.pem
*.p12
config/secrets.json

# AI tools temp files
.aider*
.cursor/
.continue/
*.ai-temp

# Dependencies
node_modules/
npm-debug.log*

# OS
.DS_Store
Thumbs.db

Environment variables template

# .env.example (committa questo, non .env)
ANTHROPIC_API_KEY=your_key_here
MONGODB_URI=mongodb://localhost:27017/yourdb
JWT_SECRET=generate_random_secret
NODE_ENV=development

2. Privacy Mode per AI Tools

Continue — privacy settings (~/.continue/config.json):

{
  "allowAnonymousTelemetry": false,
  "disableIndexing": false,
  "disableSessionStorage": false
}

(true sui secondi due per privacy massima e nessuna persistenza.)

Cursor: Settings → Privacy → Enable Privacy Mode (impedisce l'upload di codice).

Claude Desktop: Settings → Privacy → Limit data retention. Non condividere conversazioni con dati sensibili.

3. Code Review Checklist per AI-Generated Code

• Nessun hardcoded secret o credential
• Input validation presente su tutti gli endpoint
• Parameterized queries (no string interpolation per SQL/MongoDB)
• Error messages che non espongono dettagli interni
• Logging che non include dati sensibili
• CORS configurato correttamente
• Rate limiting implementato
• Authentication/Authorization verificate

4. Audit Trail

Setup di un git hook per tracciare i commit AI-assisted:

# .git/hooks/prepare-commit-msg
#!/bin/bash

# Aggiungi tag per AI commits
if [ -f .aider.commit ]; then
  echo "[AI-ASSISTED]" >> "$1"
fi

5. Compliance Considerations

Testing & Validation

1. Setup Testing Framework

# Installa Jest (Node.js testing)
npm install --save-dev jest @types/jest

# Se usi TypeScript
npm install --save-dev ts-jest @types/node

# Setup supertest per API testing
npm install --save-dev supertest @types/supertest

jest.config.js

module.exports = {
  testEnvironment: 'node',
  coverageDirectory: 'coverage',
  collectCoverageFrom: [
    'src/**/*.{js,ts}',
    '!src/**/*.test.{js,ts}',
    '!src/types/**'
  ],
  coverageThreshold: {
    global: {
      branches: 70,
      functions: 70,
      lines: 70,
      statements: 70
    }
  }
};

2. Test Strategy per AI-Generated Code

3. Golden Tests per AI Output

Tecnica per catturare regressioni negli output dell'AI:

// tests/golden/user-service.golden.test.js

const { createUser } = require('../../src/services/user');

describe('User Service Golden Tests', () => {
  test('createUser should maintain expected structure', async () => {
    const input = {
      email: 'test@example.com',
      name: 'Test User'
    };

    const result = await createUser(input);

    // Snapshot test - rileva cambi strutturali
    expect(result).toMatchSnapshot();

    // Explicit assertions sui campi critici
    expect(result).toHaveProperty('id');
    expect(result).toHaveProperty('email', input.email);
    expect(result).toHaveProperty('createdAt');
    expect(result.password).toBeUndefined(); // no password in response
  });
});

4. CI/CD Integration

.github/workflows/ai-code-quality.yml

name: AI Code Quality Check

on: [push, pull_request]

jobs:
  quality-gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Node
        uses: actions/setup-node@v3
        with:
          node-version: '24'

      - name: Install dependencies
        run: npm ci

      - name: Lint
        run: npm run lint

      - name: Type Check
        run: npm run type-check  # se usi TypeScript

      - name: Unit Tests
        run: npm test -- --coverage

      - name: Check Coverage Threshold
        run: npm run test:coverage:check

      - name: Security Audit
        run: npm audit --audit-level=moderate

5. Pre-commit Hooks

# Installa husky per git hooks
npm install --save-dev husky lint-staged

# Setup
npx husky install

# Crea pre-commit hook
npx husky add .husky/pre-commit "npx lint-staged"

package.json — lint-staged config

{
  "lint-staged": {
    "*.{js,ts}": [
      "eslint --fix",
      "jest --bail --findRelatedTests",
      "git add"
    ]
  }
}

6. Validation Rules

7. Testing Prompt per AI

Quando chiedi all'AI di scrivere codice, includi sempre la richiesta di test:

Create a user authentication endpoint with the following requirements:
- POST /api/auth/login
- Validate email and password
- Return JWT token on success
- Handle errors appropriately

IMPORTANT: Also write Jest tests that cover:
- Successful login
- Invalid credentials
- Missing fields
- SQL injection attempts
- Rate limiting

Workflow Quotidiano

Scenario 1: Coding Normale

Apri il progetto in VSCode

cd /tuo/progetto
code .

Usa Continue per:

• Tab — autocomplete inline
• Cmd+L — chat sidebar con l'AI
• Cmd+I — edit su selezione
• Highlight del codice → Cmd+I → chiedi modifiche

Scenario 2: Refactoring / Feature Complesse

Usa Aider per task automatizzati

cd /tuo/progetto
aider

# Esempi di comandi in Aider:
# "Refactor this module to use async/await"
# "Add comprehensive error handling to all database operations"
# "Create a new API endpoint for user authentication with tests"
# "Write unit tests for the payment service"

Vantaggi:

• Fa commit automatici con messaggi descrittivi
• Gestisce i branch Git
• Modifica più file coordinati
• Mantiene il context del codebase
• Può eseguire lint e test prima del commit

Scenario 3: Task End-to-End

Usa Claude Code (se disponibile)

claude-code "Build a complete user management system with:
- CRUD operations
- Authentication with JWT
- Role-based access control
- MongoDB persistence
- Comprehensive tests
- API documentation"

Nota: autonomia massima, review critica necessaria.

Scenario 4: Ricerca / Documentazione

Usa Claude Desktop con MCP — apri Claude Desktop e sfrutta gli MCP server configurati:

• «Cerca nel codebase tutte le funzioni che interagiscono con MongoDB»
• «Trova i file modificati nell'ultima settimana su GitHub»
• «Genera documentazione API per il modulo auth»
• «Analizza le performance delle query database più usate»

L'Autonomy Slider in Pratica

Best Practices Giornaliere

1. Mattina: review del codice generato il giorno prima
   • Rileggi con mente fresca
   • Esegui la test suite completa
   • Verifica gli edge case
   • Check delle implicazioni di security
2. Durante il giorno: usa lo slider appropriato
   • Task ripetitivi/boilerplate → autonomia alta
   • Logica business critica → autonomia bassa, supervisione stretta
   • Operazioni su dati sensibili → sempre review manuale
3. Prima di ogni commit:
   • Lint passing
   • Tests green
   • Nessun secret nel diff
   • Commit message descrittivo
4. Sera: commit consapevoli
   • Review dei diff completi
   • Squash dei commit se necessario
   • Non committare codice non compreso
   • Update della documentazione se necessario

AI Change Policy & Decision Matrix

1. Dimensione Diff Limits

2. Test Requirements

• Unit tests per ogni nuova funzione pubblica
• Integration tests per i nuovi endpoint
• Coverage minimo 70% per il nuovo codice
• Security tests per codice che tocca auth/input validation
• Golden/snapshot tests per gli output critici

3. Security Checklist

• No secrets nel codice (verificato con grep/tools)
• Input validation presente
• Parameterized queries (no string concat)
• Error handling che non espone dettagli interni
• Logging senza PII/secrets
• CORS/auth verificati per i nuovi endpoint

4. Decision Matrix: Quale Tool Usare

5. PR Template per AI-Generated Code

## AI-Assisted Change

### Tool Used
- [ ] Continue
- [ ] Aider
- [ ] Cursor Composer
- [ ] Claude Code
- [ ] Other: ___________

### Autonomy Level
- [ ] Low (tab complete / small edits)
- [ ] Medium (single file refactor)
- [ ] High (multi-file feature)
- [ ] Very High (complete service/module)

### Verification Checklist
- [ ] All tests passing (link to CI run)
- [ ] Lint clean
- [ ] No secrets in code (verified)
- [ ] Security review done (if applicable)
- [ ] Manual testing performed
- [ ] Edge cases considered
- [ ] Error handling verified
- [ ] Performance acceptable

### Changes Summary
<!-- Describe what was changed and why -->

### AI Prompt Used
<!-- Optional: include the prompt given to AI for transparency -->

### Manual Changes
<!-- List any manual modifications made after AI generation -->

### Risk Assessment
- [ ] Low risk (minor changes, well tested)
- [ ] Medium risk (significant changes, good coverage)
- [ ] High risk (critical path, needs extra scrutiny)

6. Changelog Trimestrale

Documenta e rivedi ogni trimestre:

• Quali tool AI sono stati usati e con che frequenza
• Incidents/bug causati da codice AI-generated
• Time saved vs time spent in review
• Update sui nuovi tool disponibili
• Policy adjustments necessari

Risorse per Approfondire

Video e Talk di Karpathy (2024–2025)

• YC AI Startup School 2024 — il talk «Software 3.0» (YouTube)
• YouTube Channel — @AndrejKarpathy
• State of GPT (Microsoft Build 2023) — fundamentals ancora validi
• Dwarkesh Podcast 2024 — Eureka Labs vision e futuro dell'educazione

Documentazione Tool

• Continue: docs.continue.dev
• Aider: aider.chat
• MCP: modelcontextprotocol.io + MCP Servers
• Cursor: cursor.sh/docs
• Claude Code: claude.ai/code

Security & Best Practices

• OWASP Top 10: owasp.org/www-project-top-ten
• Node.js Security Best Practices: nodejs.org security guide
• npm audit: security scanning built-in
• Snyk: automated security scanning per le dependencies

Testing Resources

• Jest Documentation: jestjs.io
• Testing Best Practices: JavaScript Testing Best Practices
• Supertest: API testing library

Blog e Articoli

• Software 2.0 — l'essay originale di Karpathy (2017), ancora rilevante
• Latent Space — latent.space (AI Engineer community)
• The AI Engineer — newsletter di swyx
• Simon Willison's Blog — simonwillison.net (AI tools, LLMs)

Community

• Discord Continue — community di utenti Continue
• Reddit r/aiprogramming — discussioni AI-assisted dev
• Twitter/X: @karpathy, @swyx, @simonw

Corsi e Learning

• CS231n — il corso Stanford di Karpathy (free online)
• LLM University — corso gratuito di Cohere
• Prompt Engineering Guide — promptingguide.ai
• Anthropic Prompt Library — esempi real-world

Conclusioni