Software Engineer
Stai imparando il mestiere in un mondo in cui l'agente scrive il codice e l'umano scrive le specifiche. Il lavoro non è quello di tre anni fa, e tu non stai imparando a essere l'ingegnere che esisteva tre anni fa.
Il lavoro
Contribuisci alle funzionalità di un team. L'agente gestisce una grossa porzione della produzione di codice a livello di riga; tu gestisci il lavoro che l'agente fa male, il lavoro che richiede un giudizio che stai ancora costruendo, e il lavoro che il processo del team si aspetta da te a questo livello. Stai imparando due artigianati contemporaneamente: l'ingegneria stessa e il modello operativo IA-nativo che fa funzionare l'ingegneria.
Nel quotidiano:
- Implementi funzionalità che sono state specificate. Un Senior FSE o un Tech Lead scrive la specifica; tu collabori con l'agente sull'implementazione, validi l'output rispetto alla specifica e porti il lavoro a un PR pronto per il merge.
- Scrivi le tue specifiche per ambiti più piccoli. Correzioni di bug, piccoli miglioramenti, strumentazione interna: prima specifichi, l'agente implementa, tu validi. La pratica di specifica inizia presto.
- Leggi l'output dell'agente con spirito critico. Anche quando l'agente produce codice funzionante, ti chiedi: è così che questo codebase vuole che sia scritto? Corrisponde ai pattern del team? La lettura è l'apprendistato.
- Fai coppia con l'agente attraverso dialoghi di chiarimento. Prima che l'agente esegua, fa emergere domande; tu rispondi a quelle che puoi, fai escalation per quelle che non puoi.
- Accetti feedback sulle tue specifiche e sui tuoi PR. Da Senior FSE, Tech Lead, dal revisore agente. Ogni feedback è una lezione; il team sta investendo nel tuo mestiere.
- Validi a porte calibrate sul rischio. Il lavoro di routine passa attraverso il revisore agente con te come seconda coppia d'occhi. Tutto ciò che è irreversibile, rivolto al cliente o oltre il tuo livello attuale fa escalation a un Senior FSE o Tech Lead.
- Mantieni il contesto. Documentazione, runbook, i prompt condivisi del team e le librerie di scenari. Contribuirvi fa parte del costruire il tuo giudizio.
- Ti presenti alle sessioni di ricalibrazione. Quando l'agente si blocca, il team si riunisce. Tu partecipi; osservi come gli ingegneri senior diagnosticano; osservare insegna.
Come si misura il successo
Risultati concreti a questo livello:
- Throughput in crescita. Le storie che prendi end-to-end vengono rilasciate a un ritmo prevedibile. Il tuo throughput cresce di trimestre in trimestre man mano che le tue specifiche si affinano.
- Qualità dei PR. Il revisore agente segnala sempre meno tuoi PR nel tempo. Il feedback degli ingegneri senior si compone in indipendenza.
- Scrittura di specifiche emergente. Stai iniziando a scrivere specifiche che un agente può eseguire end-to-end. Alcune hanno ancora bisogno del passaggio senior; la proporzione si sposta verso l'autosufficienza nei mesi.
- Consapevolezza della ricalibrazione. Quando una storia si blocca, sai articolare se il problema è di specifica, contesto o implementazione. Anche se fai escalation, porti un'ipotesi.
- Intuito del codebase. Stai iniziando a sapere quale astrazione vuole questo codebase, quali pattern seguire, cosa significa lo stile della casa. Il gusto si sta formando.
Cosa non conta come successo: righe di codice scritte, conteggio dei PR da solo, ore registrate, attenersi a metriche legacy da ingegnere junior che non si traducono in questo modello operativo.
Cosa rende questo lavoro interessante
Stai imparando il mestiere dell'ingegneria mentre viene reinventato. È raro e prezioso.
Non hai abitudini legacy da disimparare. Gli ingegneri senior che passano al lavoro IA-nativo devono rinunciare a memoria muscolare costruita in anni. Tu no. Il modo di lavorare basato su specifica e collaborazione con l'agente è il tuo normale: è un vantaggio, non una carenza.
Il tuo impatto cresce più rapidamente. Un ingegnere junior nel mondo legacy passava i primi 6-12 mesi a produrre per lo più codice semplice. Al T2 in un team IA-nativo, puoi specificare e rilasciare funzionalità significative entro mesi. Il ciclo di feedback dal tuo contributo al valore rilasciato è molto più breve.
Il team ti sta insegnando, intenzionalmente. Le specifiche che ricevi sono anche materiale didattico. Il feedback sui PR è strutturato. Le sessioni di ricalibrazione sono apprendimento pubblico. L'apprendistato è reale e più visibile dell'esperienza junior per prova-ed-errore dell'era legacy.
Costruisci cross-stack presto. Con l'agente che assorbe ciò che prima era lavoro specialistico profondo (layout frontend, cablatura backend, configurazione infrastrutturale), puoi contribuire su tutto lo stack fin dall'inizio della carriera. L'ampiezza arriva più rapidamente.
Stai imparando a pensare prima di battere. È la competenza di carriera più duratura in qualsiasi era, e il tuo ruolo la concentra. Le persone che imparano presto a specificare bene superano quelle che costruiscono la competenza solo dopo.
Vedi il giudizio senior da vicino. Dialoghi di specifica, code review, sessioni di ricalibrazione: sono i momenti in cui gli ingegneri senior rivelano come pensano. La vicinanza è apprendistato reale.
Cosa potrebbe non piacerti. Se volevi il ruolo per l'esperienza di lunghe sessioni di coding focalizzato, producendo codice funzionale da zero riga per riga, quel lavoro è in gran parte assorbito. Gli ingegneri junior che si sono messi in questo campo perché amano l'atto di programmare a volte trovano il lavoro IA-nativo meno hands-on di quanto si aspettassero. Alcuni sviluppano il nuovo mestiere e lo trovano più soddisfacente del vecchio; altri no. L'esperienza legacy del junior developer che costruisce lentamente il mestiere attraverso il volume di codice scritto è per lo più scomparsa. Lo costruisci attraverso il volume di specifiche lette, specifiche scritte e ricalibrazioni assistite.
Chi prospera in questo ruolo
Le attitudini che contano di più sono quelle di apprendimento, sviluppo del giudizio e scrittura, e si applicano prima nella tua carriera rispetto a un tempo.
Poni buone domande. La competenza che più predice la tua crescita a questo livello è la qualità delle domande che poni: sulle specifiche, sui codebase, sull'output dell'agente, sul tuo lavoro bozza. Le persone che fanno pattern matching e restano in silenzio imparano più lentamente di chi chiede.
Leggi voracemente. Specifiche, PR, codebase, output dell'agente, gli standard del framework. L'ingegneria al T2+ è per lo più un lavoro di lettura; la scrittura segue dalla lettura.
Gestisci l'essere novizio con grazia. Non sai tutto; non dovresti. Le persone che sanno reggere quella condizione senza recitare certezza imparano più rapidamente di chi finge.
Scrivi con chiarezza. Specifiche, descrizioni di PR, note di design. Gli ingegneri che sanno scrivere chiaramente a questo livello salgono più rapidamente di quelli che non sanno, indipendentemente dall'intelligenza nel codice.
Accetti bene il feedback. Ingegneri senior e revisore agente ti danno feedback costantemente. Le persone che sanno assorbirlo senza difensiva si compongono molto più rapidamente di chi diventa difensivo.
Sei curioso sulle modalità di fallimento dell'agente. Perché l'agente ha sbagliato questo? Perché la specifica ha mancato questo caso limite? Perché la sessione di ricalibrazione ha cambiato il risultato? La curiosità sul sistema è ciò che ti rende bravo.
Costruisci pazienza con la diagnosi disordinata. Ricalibrazione vs debugging vs gap di specifica è difficile da distinguere anche per i senior. Non lo farai bene presto; costruisci il giudizio nel tempo.
Meno essenziale di prima: velocità di battitura grezza, profondità in un singolo linguaggio di programmazione, curiosità sugli algoritmi, la capacità di macinare lavoro CRUD per ore. Era l'apprendistato dell'ingegnere junior. Non sono più i fattori differenzianti.
Competenze da sviluppare per arrivarci
Le attitudini descrivono la disposizione. Le competenze qui sotto sono ciò che costruisci attivamente.
Lettura delle specifiche. Capire cosa una specifica sta chiedendo, cosa non chiede e cosa è ambiguo. Come esercitarsi: prima di implementare qualsiasi specifica, scrivi un paragrafo che riassuma cosa costruirai e cosa è ancora poco chiaro. Confronta con l'intento dell'autore.
Scrittura di specifiche (iniziando in piccolo). Correzioni di bug, piccoli miglioramenti, strumentazione interna: scrivi prima la specifica. Come esercitarsi: per ogni compito che prendi, abbozza una specifica anche se nessuno l'ha chiesto. Rivedila con un Senior FSE; affina. Costruisci il muscolo.
Lettura dei diff. Leggere il codice prodotto dall'agente con spirito critico. Come esercitarsi: prima di approvare qualsiasi PR dell'agente che hai preso, articola perché ogni blocco significativo è corretto o scorretto. Traccia quando ti è sfuggito qualcosa; il pattern è il tuo apprendimento.
Navigazione del dialogo di chiarimento. Rispondere produttivamente alle domande pre-esecuzione dell'agente. Come esercitarsi: nota le domande che salti o approvi senza pensare. Le domande saltate sono di solito dove l'implementazione va male.
Assistere alla ricalibrazione. Imparare come gli ingegneri senior diagnosticano i blocchi. Come esercitarsi: partecipa a ogni sessione di ricalibrazione che puoi. Prendi appunti su cosa ha scatenato la diagnosi. I pattern si accumulano nella tua capacità diagnostica.
Costruire intuito del codebase. Capire cosa vuole questo codebase. Come esercitarsi: prima di qualsiasi modifica non banale, leggi 3 pattern simili nel codebase. Nota le convenzioni. Adattati.
Porre domande migliori. La singola competenza che più accelera la crescita ingegneristica. Come esercitarsi: prima di porre qualsiasi domanda, scrivila. Rileggi. È chiara? Ha risposta? Mostra cosa hai già provato? Riscrivi prima di chiedere.
Contributo al contesto. Aggiungere ai prompt condivisi, alle librerie di scenari, ai runbook. Come esercitarsi: un piccolo contributo per sprint. Anche un singolo caso limite aggiunto alla libreria di scenari del team si compone.
Scegli la competenza che corrisponde al tuo più recente momento di blocco. Esercitati per due settimane su lavoro reale.
Come differisce dal ruolo legacy di Junior/Mid Software Engineer
| Junior engineer legacy (pre-IA) | Software Engineer (IA-nativo) |
|---|---|
| Passa la maggior parte della giornata a scrivere codice a mano | Passa la maggior parte della giornata a leggere specifiche, rivedere l'output dell'agente e imparare a specificare |
| Impara scrivendo molte righe di codice semplice nei mesi | Impara leggendo specifiche, osservando le revisioni e partecipando alle ricalibrazioni |
| I primi 12 mesi sono per lo più CRUD e correzioni di bug per problemi banali | I primi 12 mesi includono contributi significativi alle funzionalità perché l'agente gestisce il livello banale |
| Gli ingegneri senior hanno tempo scarso; il pairing è raro | Il pairing avviene tramite specifiche, revisioni di PR e sessioni di ricalibrazione; il giudizio senior è più accessibile |
| Percorso di carriera: Junior → Mid → Senior, rampa lenta | Percorso di carriera: progressione simile ma con una rampa più veloce sul contributo significativo; T2.5/T3 raggiungibili prima |
| I migliori ingegneri junior sono i più prolifici | I migliori ingegneri junior sono i lettori e scrittori più chiari |
Il ruolo non è "un junior dev legacy con strumenti IA". È un apprendistato diverso, e il mestiere che stai costruendo è diverso.
Quali pattern di evoluzione dei ruoli sono in gioco
- Elevation (primario, ma da un punto di partenza diverso). Come il Senior FSE, il tuo lavoro si sposta dall'esecuzione alla specifica e validazione, ma stai imparando entrambi gli artigianati simultaneamente, anziché passare dall'uno all'altro.
- Convergence (secondario). Come gli ingegneri senior, operi su tutto lo stack prima dei junior legacy, perché l'agente gestisce qualsiasi livello.
- Emergence (parziale). Alcuni rituali di apprendistato (pratica del dialogo di chiarimento, osservazione della ricalibrazione, cicli di feedback del revisore agente) sono modi genuinamente nuovi di imparare il mestiere.
Specialization e Absorption non si applicano in modo significativo al tuo ruolo, anche se Absorption si applica al pattern di lavoro del junior developer legacy (volume di scrittura di codice banale) che non definisce più l'apprendistato.
Ruoli correlati nel catalogo
dove sei diretto; molte delle tue specifiche vengono da qui
la persona che spesso imposta gli standard che stai imparando a soddisfare
il tuo manager; coaching, performance e conversazioni di carriera avvengono qui
Fonti e letture di approfondimento
- Stack Overflow (2025). Developer Survey: AI Tools section. Include dati sull'uso di strumenti IA da parte di ingegneri junior/mid.
- GitHub & Accenture (2024). Quantifying GitHub Copilot's Impact.
- GitClear (2025). AI Assistant Code Quality Research. I dati sul degrado della qualità quando la progressione delle competenze non tiene il passo.
- Di questo framework: Guida alle specifiche, Ingegneria dell'affidabilità e Mappa di progressione delle competenze.
← Torna ai ruoli · Pattern di evoluzione dei ruoli · Quadro di riferimento · Trasformare il tuo ruolo · Guida alle specifiche