Pillar page
Sviluppo software con IA
Un processo collaudato per automatizzare lo sviluppo software con un team di agenti IA — dall'analisi dei requisiti, attraverso la codifica e i test multi-livello (unit, integration, E2E, security, performance), fino al deployment in produzione con un audit trail completo.
Disponiamo di un team di agenti IA specializzati che partecipa a ogni fase del ciclo di sviluppo software — dall'analisi dei requisiti, attraverso la progettazione dell'architettura, la codifica e i test multi-livello, fino al code review, alla documentazione e al deployment con un audit trail completo.
È così che sviluppiamo i nostri prodotti ESKOM AI — la piattaforma multi-agente HybridCrew, il sistema di audit Compliance, il microservizio KRS+CRBR e un portafoglio di integrazioni. Applichiamo lo stesso processo nei progetti per i clienti: sia per nuovi microservizi greenfield, sia per la modernizzazione di sistemi legacy.
Questo articolo descrive come funziona in pratica: quali compiti gli agenti prendono in carico, quali restano agli umani, quali test eseguiamo e perché questo processo è ripetibile tra diversi tipi di progetti.
Perché automatizzare lo sviluppo software?
Un classico ciclo di sviluppo software (analisi → codice → test → review → deploy) richiede tipicamente 2-4 settimane per una feature di medie dimensioni in un team maturo. La maggior parte di quel tempo è dedicata a compiti ripetitivi: scrivere boilerplate, generare unit test, fare review delle modifiche, aggiornare la documentazione, generare migrazioni del database. Tutte attività adatte all'automazione.
L'obiettivo del nostro processo è semplice: due o tre persone che lavorano con agenti IA forniscono il valore di un team di 8-10 persone — senza burnout, con maggiore qualità (più test, miglior code review, documentazione completa) e time-to-market più breve.
Non si tratta di „l'IA sostituirà gli sviluppatori". Si tratta di „gli sviluppatori con IA sostituiranno gli sviluppatori senza IA". Gli ingegneri esperti restano essenziali — progettano l'architettura, prendono decisioni strategiche, fanno review delle modifiche complesse. Gli agenti IA si occupano della routine.
Il processo in sei fasi
La pipeline dai requisiti alla produzione. Ogni fase è eseguita da agenti IA specializzati, mentre gli umani supervisionano e approvano le decisioni chiave.
Analisi dei requisiti e architettura
Gli agenti IA analizzano la documentazione di business, le conversazioni con i clienti (dalle trascrizioni) e il codice esistente. Propongono un'architettura a microservizi, lo schema del database, l'elenco degli endpoint e il modello di permessi. Un umano (CTO/architetto) revisiona e approva la proposta prima dell'inizio della codifica.
Scrittura del codice (TDD)
Prima i test, poi l'implementazione. Un agente backend scrive API in FastAPI/Express, un agente frontend scrive componenti React. Ogni modifica è una pull request separata con un commit chiaro. Gli standard di codifica (Black, ESLint, Prettier) vengono applicati automaticamente.
Test multi-livello
Unit (pytest, Jest), integration (testcontainers con PostgreSQL reale), E2E (Playwright), UI snapshot, security (OWASP, gitleaks, bandit), performance (k6/locust), accessibility (axe). Ogni PR esegue la pipeline completa — un test fallito blocca il merge.
Code review tramite IA
Un agente SecurityReviewer scansiona per problemi OWASP Top 10, un agente QualityReviewer verifica leggibilità e pattern, un agente ArchitectureReviewer controlla la coerenza con il resto del sistema. I casi limite vengono escalati agli umani.
Documentazione e CHANGELOG
Ogni modifica logica = bump di versione + voce in CHANGELOG.md nel formato Keep a Changelog. La documentazione API (OpenAPI/Swagger) è generata automaticamente. CLAUDE.md viene aggiornato dopo ogni sessione con le nuove lezioni apprese.
Deployment con Change Request
Il deployment passa sempre per Git (MAI scp diretto). Prima l'ambiente di test con verifica Playwright, poi la produzione solo dopo l'approvazione della CR. Lo script di deploy include un piano di rollback (<5 min) e gli health check.
Cosa guadagna l'azienda?
Migliaia di test automatizzati
Ogni progetto di produzione ha da alcune migliaia a decine di migliaia di test — unit, integration, E2E, security, performance. Le regressioni vengono intercettate nel CI prima di raggiungere gli utenti.
Audit trail completo
Ogni modifica nel codice, nel database o nella configurazione viene registrata: Git, audit log nel database, CHANGELOG, Change Request. Soddisfa i requisiti ISO 27001, EU AI Act e GDPR.
Scalabilità del team
Due o tre persone con agenti IA forniscono il valore di un team di 8-10 persone. Senza burnout, con maggiore qualità e tempistiche più brevi.
Escalation a modelli più potenti
Il routing LLM sceglie il modello giusto per ogni compito: piccole modifiche — Ollama locale (costo zero), architettura complessa — Claude Opus. Ottimizzazione di costo e qualità in un'unica soluzione.
Ripetibilità e standard
Ogni progetto segue gli stessi standard: feature branch workflow, squash merge, Conventional Commits, CHANGELOG, EU AI Act, GDPR. Un nuovo sviluppatore comprende la struttura in un giorno.
Sicurezza by default
Gitleaks su pre-commit + CI, segreti in HashiCorp Vault, repository privati, SSO Keycloak, VPN Tailscale per i servizi interni. Nessun compromesso sulla velocità.
Test multi-livello — il fondamento della qualità
Ogni modifica al codice di produzione passa per una pipeline di test completa. Senza eccezioni — anche correggere un refuso in un commento attiva il CI, perché la pipeline di test è imposta da un Git hook, non da una decisione politica dello sviluppatore.
- Test unit: pytest, Jest, vitest. Coprono singole funzioni e classi. Copertura >80% sul codice critico.
- Test di integrazione: testcontainers con istanze reali di PostgreSQL, Redis, Vault. Mock solo per API esterne di terze parti.
- Test end-to-end (E2E): Playwright in Firefox (predefinito), Chrome (opzionale). Simulano percorsi utente completi: login → azione → verifica.
- Test UI (snapshot, accessibility): Playwright + axe-core. WCAG 2.0 AA come baseline, Lighthouse 100/100/100/100 come obiettivo.
- Test di sicurezza: OWASP Top 10 (semgrep, bandit, eslint-plugin-security), gitleaks (scansione di segreti su pre-commit e CI), trivy (scansione di immagini Docker).
- Test di performance: k6 o locust per i load test, verifica dei tempi di risposta p95/p99 sotto stress.
- Test di regressione: la suite completa viene eseguita prima di ogni deploy in produzione. Ogni bug segnalato diventa un test di regressione.
- Test smoke: un set minimo di 5-10 test eseguiti dopo il deploy in produzione (per verificare se l'applicazione è effettivamente partita).
- Test di accettazione: test di business (Cucumber/Gherkin) che confermano il soddisfacimento del requisito.
Test fallito = merge bloccato. Senza eccezioni. Se un test è „flaky" (instabile), un agente diagnostico analizza la causa principale e corregge il test o il codice, ma non rimuove mai il test senza una decisione umana.
Casi d'uso tipici
I pattern che applichiamo più spesso. Ognuno ha il proprio set di agenti, strumenti e template. Time-to-value misurato in settimane, non in mesi.
Modernizzazione sistemi legacy
- •Vecchia applicazione monolitica (PHP/.NET, senza test, difficile da mantenere)
- •Gli agenti scompongono il monolite in microservizi (incrementale, senza downtime)
- •Generano test di caratterizzazione (catturano il comportamento attuale) prima del refactoring
- •Migrazione dati con audit trail completo e piano di rollback
Nuovo microservizio enterprise
- •Specifica in ingresso (ticket Jira, PRD, trascrizione di meeting)
- •Architettura → codice → test → review → deploy in 2-3 settimane
- •Integrazione con SSO esistente (Keycloak), audit log, monitoring
- •Piena conformità EU AI Act e GDPR fin dal primo giorno
Integrazione di sistemi
- •Collegamento di ERP, CRM, registri aziendali, Microsoft Graph, IBM, Cisco, partner esterni
- •Gli agenti scrivono adattatori, mapping, retry/backoff, idempotenza
- •Test di integrazione su endpoint reali (sandbox API)
- •Monitoring (Prometheus + Grafana) e alert (Sentry) collegati automaticamente
Piattaforme multi-tenant
- •SaaS multi-cliente con isolamento completo dei dati (schema per-tenant o row-level security)
- •Onboarding cliente automatizzato (provisioning Keycloak, database, ruoli)
- •Billing basato su SSO Billing SDK (tracking utilizzo token, fail-open)
- •Compliance: GDPR, ISO 27001, EU AI Act pronti per audit
Confronto: team classico vs. processo guidato da IA
| Aspetto | Team classico (8-10 persone) | Team con agenti IA (2-3 persone) |
|---|---|---|
| Time-to-market (feature media) | 2-4 settimane | 3-7 giorni |
| Copertura dei test | 40-60% (quando il team ha tempo) | >80% by default (test generati insieme al codice) |
| Code review | 1 persona, media 30-60 min | 3 agenti (security, quality, architecture) + umano per modifiche complesse |
| Documentazione | Spesso incompleta, „aggiunta dopo" | Generata insieme al codice (OpenAPI, README, CHANGELOG) |
| Audit trail | Storia Git | Git + audit log nel database + CHANGELOG + Change Request |
| Scalabilità | Lineare (più persone = costo di comunicazione maggiore) | Non lineare (più agenti = stesso numero di persone che supervisionano) |
| Compliance (EU AI Act, GDPR, ISO 27001) | Spesso audit esterno a posteriori | Integrata nel processo dal primo giorno |
Domande frequenti
Cos'è lo sviluppo software automatizzato con IA?
In cosa differisce questo processo dalla programmazione classica con Copilot?
Quali tipi di test esegue questo processo?
L'IA effettua il deploy del codice in produzione autonomamente?
Questo processo funziona per progetti enterprise?
Quanto tempo serve per introdurre questo processo nella nostra azienda?
E la sicurezza del codice sorgente?
Sostituirete il nostro team di sviluppo?
Quanto costa lo sviluppo software con IA?
Quali sono i segnali tipici che un'azienda è pronta per questo processo?
Pronti per un pilota?
Iniziamo con un audit del processo esistente e un pilota su un microservizio selezionato. Primi risultati visibili entro 2-4 settimane. Nessun contratto a lungo termine richiesto.