Intro: Copilot nel Terminale e in Agent Mode Autonomo

Quando GitHub lanciò la prima versione di Copilot nel 2021, era un'assistente IDE: scrivi commenti, ricevi completamenti. Nel 2024, arrivò gh copilot, un'estensione per GitHub CLI con gh copilot suggest e gh copilot explain-ma pur sempre conversazionale e single-shot, non autonomo.

Il 25 settembre 2025, GitHub annunziò Copilot CLI in public preview: un terminale agent vero, che poteva leggere la codebase, scrivere codice, eseguire comandi e iterare autonomamente su task multi-step. Cinque mesi di feedback utente più centinaia di miglioramenti, e il 25 febbraio 2026 arriva la disponibilità generale (GA).

Contemporaneamente, VS Code evolve Agent Mode (preview febbraio 2025) verso tre tier di autonomia: Default (manual approval), Bypass Approvals, e soprattutto Autopilot (marzo 2026), che lascia l'agente autoapprovare e retry senza interruzioni umane.

Il risultato: il terminale diventa il tuo IDE principale. Non più "apri VS Code per scrivere codice", ma "avvia `copilot plan` e guarda l'agente eseguire l'intero refactoring in 90 secondi".

Death of gh-copilot: La Vecchia Guardia (Deprecation 25 Ottobre 2025)

Per chi ha usato gh copilot dal 2024, brutta notizia: è deprecato.

La ragione è semplice: gh copilot era single-turn, conversazionale. @github/copilot-cli è multi-turn, agentico, e non ha bisogno della wrapper GitHub CLI. Installi via npm e hai tutto quello che serve.

Migration Guide

Se usi gh copilot oggi:

# Vecchio (deprecato)
gh copilot suggest "write a unit test for UserService"
gh copilot explain "what does this bash script do?"

# Nuovo (Copilot CLI GA)
npx @github/copilot-cli explore
# Poi: "find all auth logic in UserService"
# Poi: "write tests"
# Copilot autonomamente suggerisce, esegue, itera

La differenza non è cosmetica: con gh copilot chiedevi, aspettavi una risposta, poi copiavi-incollavi nel tuo editor. Con @github/copilot-cli, chiedi e Copilot esegue quello che serve (esplora il codebase, legge file, esegue test, committa).

GitHub Copilot CLI GA (25 Febbraio 2026)

Il 25 febbraio 2026, GitHub Copilot CLI raggiunge GA ufficiale. Disponibile per:

• GitHub Copilot Free: ✅ 2 mil token/mese gratis
• GitHub Copilot Pro: ✅ 8 mil token/mese (US$20/mese)
• GitHub Copilot Pro+: ✅ 16 mil token/mese (US$30/mese)
• GitHub Copilot Business/Enterprise: ✅ Pool org-wide con Agent Control Plane

Installazione

# Prerequisiti: Node.js 18+
npm install -g @github/copilot-cli

# Login
copilot auth login

# Verifica
copilot -v
# copilot version 1.0.0 GA (25 febbraio 2026)

Sessione Copilot Interactive

Avvia una sessione interattiva nel tuo repo:

cd ~/my-project
copilot
# Entra in interactive prompt

> /explore "find all JWT validation logic"
# Copilot scannerizza il codebase via semantic search (RediSearch-like)
# Ritorna 3-5 file rilevanti con preview

> /task "run unit tests for auth module"
# Copilot automaticamente:
# 1. Identifica come lanciare i test (npm test --testPathPattern=auth)
# 2. Esegue il comando
# 3. Mostra output
# 4. Se fail, suggerisce fix

> /plan "refactor UserService to use dependency injection"
# Switch a Plan mode (Shift+Tab): Copilot chiede dettagli,
# propone structured plan (5-7 step), aspetta approvazione, esegue

Multi-Model Support

A differenza di Copilot VS Code che usa Claude Sonnet by default, Copilot CLI ti consente scegliere il modello per sessione:

copilot --model claude-opus-4.6
# o
copilot --model gpt-5.3-codex
# o
copilot --model gemini-3-pro
# o (per task rapidi)
copilot --model claude-haiku-4.5

Scelta strategica: Opus per task complesse di refactoring (è il modello più ragionevole), Haiku per quick fixes (3x più economico), GPT-5.3-Codex se il tuo codebase è in Python/Go (tradizionalmente forte su quel linguaggio).

Subagents Specializzati: Explore e Task (Gennaio 2026)

Nel gennaio 2026, GitHub rilascia specialized subagents che Copilot chiama automaticamente in base al contesto della richiesta.

Explore Agent

Scopo: analisi rapida del codebase via semantic search, NON full-file-read.

Caso uso: "dove sta la logica di autenticazione?"

> /explore "where is JWT token validation?
# Explore agent in parallel scans:
# - file names (matching "jwt", "token", "auth")
# - import chains
# - function signatures (patterns come "validate", "verify")
# Ritorna in 2-3 secondi: AuthFilter.java, JwtService.ts, auth.middleware.py
# Senza leggere full file, solo struttura

> /explore "find all database queries that join users and posts"
# Semantic search su AST: trova 8 query su 340 file
# Output conciso

Vantaggio vs /ask "where is X": Explore è specializzato e veloce (2-3 secondi su codebase da 50K file). È il vostro grep semantico turbo.

Task Agent

Scopo: eseguire comandi terminali (build, test, linting) e interpretare l'output.

Caso uso: "esegui i test del modulo auth, e se falliscono, suggerisci fix"

> /task "run the test suite for UserService"
# Task agent:
# 1. Legge package.json / Maven POM → detect test runner (Jest / Maven / pytest)
# 2. Esegue `npm test -- --testNamePattern=UserService` (o equivalente)
# 3. Riceve output: 3 test pass, 2 fail
# 4. Legge i test falliti
# 5. Propone fix (tipicamente: mock non ok, asserts sbagliati, setup incompleto)
# 6. Se approvi, applyga il fix e re-esegue

> /task "build the Docker image and push to ECR"
# Task agent:
# 1. Trova Dockerfile
# 2. Esegue `docker build -t my-app:latest .`
# 3. Esegue `docker push 123456789.dkr.ecr.us-east-1.amazonaws.com/my-app:latest`
# 4. Monitora output per errori (auth missing, tag non valido)
# 5. Se fail, suggiere chiaramenti (account ID, IAM role)

Auto-compaction token: Quando la sessione si avvicina al token limit (es. 90% di 8M per Pro), Copilot compatta automaticamente la history: mantiene i comandi recenti e i risultati chiave, scarta chattare verbose più vecchia.

Web Fetch Tool e Allowlist Sicurezza

Copilot CLI può invocare fetch() per leggere documentazione online: "mi serve la signature di questo metodo dalla docs ufficiale?".

Per sicurezza, è possibile creare un allowlist di URL che Copilot può leggere, e una denylist di domini vietati.

Configurazione

Nel tuo repo, crea .copilot/settings.json:

{
  "web_fetch": {
    "allowed_urls": [
      "https://docs.spring.io/**",
      "https://angular.dev/**",
      "https://fastapi.tiangolo.com/**",
      "https://nodejs.org/docs/**",
      "https://docs.github.com/**"
    ],
    "denied_urls": [
      "https://internal-company-wiki.slack.com/**",
      "https://aws-account-info.internal/**"
    ]
  }
}

Da questo momento, se chiedi "qual è il signature di @PostMapping in Spring Boot?", Copilot fetch la doc ufficiale (allowed), ma NON può accedere a Slack interno o AWS account pages.

Caso uso reale: API Spec Integration

> /task "integrate our REST API with Stripe API for payment processing"
# Copilot:
# 1. Legge il tuo OpenAPI spec da /docs/api-spec.yaml (locale)
# 2. Fetch Stripe API docs da https://stripe.com/docs/api (allowed)
# 3. Scrive il client code che connette i due
# 4. Esegue test (mocka Stripe via testcontainers)
# 5. Genera GitHub issue "Stripe webhook verification needed"

# Ma: se provi a far fetch https://internal-slack-audit.company.internal,
# Copilot rifiuta (denied_urls match)

ACP Support: Agent Client Protocol (28 Gennaio 2026)

Agent Client Protocol (ACP) è il "MCP per agent": consente terze parti di integrarsi come endpoint agent custom per Copilot CLI.

Lanciato il 28 gennaio 2026 via GitHub Changelog, ACP abilita:

• Custom agent endpoints: scrivi un microservice che implementa ACP, Copilot CLI lo chiama
• Tool discovery: il tuo agente espone strumenti (es. "deploy to Kubernetes", "query analytics DB") come tool
• Multi-provider orchestration: un agente ACP può gestire task su Zed editor, custom CI pipeline, Vercel, ecc.

Esempio: Custom Deployment Agent

// deploy-agent.ts - ACP endpoint
import Fastify from 'fastify';

const app = Fastify();

// ACP Tool: deploy-to-staging
app.post('/tools/deploy-staging', async (req, res) => {
  const { repo, branch, version } = req.body;

  // Logica: trigger deployment via Vercel API
  const result = await vercelApi.deployPreview({
    repo,
    ref: branch,
    version
  });

  return {
    status: 'success',
    preview_url: result.url,
    logs: result.logs
  };
});

// ACP Discovery: quali tool offri?
app.get('/acp/tools', (req, res) => {
  return {
    tools: [
      { name: 'deploy-staging', description: 'Deploy to Vercel Preview' },
      { name: 'run-e2e-tests', description: 'Trigger E2E test suite' },
      { name: 'check-perf-regression', description: 'Run performance benchmark' }
    ]
  };
});

app.listen({ port: 3000 });

Poi, nel tuo repo, registri questo agente in .copilot/settings.json:

{
  "acp_agents": [
    {
      "name": "deployment",
      "endpoint": "http://localhost:3000",
      "auth": { "type": "bearer", "token": "${DEPLOY_AGENT_TOKEN}" }
    }
  ]
}

Ora, quando chiedi /task "deploy this change to staging", Copilot automaticamente delega al tuo agente custom, che executa il deploy via Vercel API.

Caso uso reale in azienda: sviluppatori chiedono "deploy questo feature branch a staging" da terminale, Copilot chiama l'agente interno che verifica permessi (Okta), traccia audit (Datadog), esegue deploy (Kubernetes), e notifica #deployments Slack. Todo orchestration, zero CLI manuale.

VS Code Agent Mode: dalla Preview all'Autopilot (Marzo 2026)

VS Code Copilot Agent Mode (preview febbraio 2025) si evolve verso tre tier di autonomia nel marzo 2026. La evoluzione riflette un incremento di fiducia: con esperienza, impari quando è safe approvare automaticamente.

Tre Tier di Autonomia

Abilitare Autopilot in VS Code

Settings → Copilot Agent Mode → Agent Approval Level → Autopilot

Oppure, via settings.json:

{
  "github.copilot.agentMode.enabled": true,
  "github.copilot.agentMode.approvalLevel": "autopilot",
  "github.copilot.agentMode.maxRetries": 3,
  "github.copilot.agentMode.timeoutSeconds": 120
}

Sicurezza e Limiti

Anche in Autopilot, Copilot NON può:

• Eseguire rm -rf / o qualsiasi comando che ha effetti distruttivi globali
• Pusciare a main senza protezione di branch
• Disabilitare GitHub Actions o security check
• Leggere secrets da .env (sandboxed)

In sostanza: Copilot è sandboxed alla tua working directory. Non ha accesso di root, non può modificare config di sistema, non può accedere ai tuoi AWS credentials (vengono validate a livello IDE, non passati a Copilot).

Esperienza Reale: Refactoring di Classe

Con Autopilot enabled:

Prompt: "Refactor UserService to use dependency injection instead of direct new() calls"

Copilot Agent:
1. [AUTO] Legge UserService.java (30 file nella classe)
2. [AUTO] Identifica 12 istanze di new NotificationService(), new CacheClient(), ecc.
3. [AUTO] Scrive modifiche: aggiunge @Autowired private NotificationService ns;
4. [AUTO] Esegue `mvn test` → 2 test fail (mock injection issue)
5. [AUTO] Legge test error
6. [AUTO] Modifica test: aggiunge @MockBean NotificationService mock;
7. [AUTO] Re-esegue `mvn test` → PASS ✓
8. [AUTO] Committa: "refactor(UserService): use DI instead of direct instantiation"
9. [AUTO] Apre PR su GitHub (se configured)

Total time: 45 secondi, zero interruzioni

Senza Autopilot (Default tier), stesso task prende 8-10 minuti (approvi ogni edit, clicchi "approve command", aspetti test, ecc).

Nested Subagents e Session Forking (Marzo 2026)

Nested subagents: un agente chiama un altro agente, che chiama un terzo agente. Pipeline multi-step orchestrate automaticamente.

Esempio: Code Review Pipeline

Initial task: "Review this PR and fix any critical issues"

1. Copilot Agent (main) chiama Subagent "code-review"
   ├─ Analizza cambio: 45 file modificati, 3200 righe added
   ├─ Esegue static analysis (SonarQube)
   ├─ Identifica 8 critical issue (SQL injection, memory leak, XSS)
   └─ Genera list: "[CRITICAL] SQL injection in UserRepository.java:234"

2. Copilot Agent (main) delega a Subagent "fix-critical"
   ├─ Legge SQL injection line
   ├─ Propone PreparedStatement fix
   ├─ Scrive test che verify fix
   └─ Ritorna: "fixed 8/8 critical issues, all test green"

3. Copilot Agent (main) chiama Subagent "performance-check"
   ├─ Esegue benchmark (Apache JMeter)
   ├─ Detecta +15% latency su UserController
   ├─ Propone caching strategy
   ├─ Scrive Redis integration test
   └─ Ritorna: "latency mitigated, cache hit rate 92%"

4. Copilot Agent (main) riassume:
   "PR reviewed, 8 critical fixes applied, 1 performance improvement. Ready to merge."

Total orchestration: 3 min 45 sec, zero human review

Session Forking

Durante una sessione Copilot, puoi "fork" in un punto critico per esplorare alternative senza toccare il ramo principale.

# Sessione principale
> /plan "refactor UserService to reactive (Project Reactor)"
# Copilot propone plan: 7 step

# Tu: "aspetta, mostrami due approcci: uno con Reactor, uno con Coroutine di Kotlin"
# Copilot: [FORK] Crea sessione alternativa

# Sessione A (fork 1): Reactor approach
> [A] /implement "use Project Reactor"
> [A] /task "run performance test"
# Result: 150ms latency, 98% memory stable

# Sessione B (fork 2): Kotlin Coroutine approach
> [B] /implement "use Kotlin suspend functions"
> [B] /task "run performance test"
# Result: 145ms latency, 92% memory stable

# Sessione main: tu compari i due fork
# Decidi: "merge fork B, Kotlin coroutine è leggermente migliore"
> /merge fork-B

# Fine: sei tornato al ramo principale con l'implementazione Kotlin

Vantaggio: esplori due strategie di implementazione in parallelo, senza fare il revert al Git. È una "branch temporanea" all'interno della sessione Copilot, con context retention completo.

Confronto con Claude Code Sub-Agents

Claude Code (Anthropic, da dicembre 2024) ha .claude/agents/ per definire sub-agent specializzati (planner, code-reviewer, tdd-guide, architect, ecc).

Copilot nested subagents vs Claude Code agents:

Verdict: Copilot nested subagents è più "magic" (meno config, più automatico), ma meno customizable. Claude Code agents è più "esplicito" (scrivi le regole), più flessibile. Usa Copilot CLI per task standard (refactoring, test, deploy), usa Claude Code agents per workflow custom aziendali (audit security, compliance check, domain-specific planning).

Inline Agent Mode JetBrains: Preview (24 Aprile 2026)

Il 24 aprile 2026 (GIORNO FA!), GitHub annunzia Copilot Inline Agent Mode per JetBrains (IntelliJ, PyCharm, WebStorm, RubyMine, GoLand, CLion) in preview.

Da ora, sviluppatori JetBrains hanno parità VS Code: inline agent con suggestion, approval, e (coming soon) auto-approve toggle.

Setup JetBrains

IntelliJ IDEA 2024.2 e successive:

1. File → Settings → Plugins → Marketplace → Cerca "GitHub Copilot"
2. Installa plugin ufficiale GitHub
3. Settings → GitHub Copilot → Enable Agent Mode ✓
4. Settings → GitHub Copilot → Global Auto Approve (toggle, default OFF)
5. Restart IDE

Ora, quando premi Cmd+I (macOS) / Ctrl+I (Linux/Windows) e scrivi "refactor this class to use builder pattern", Copilot ti suggerisce le modifiche inline nel file, proprio come VS Code.

Global Auto Approve Setting

A differenza di VS Code che ha session-level approvalLevel (Default / Bypass / Autopilot), JetBrains per ora ha solo Global Auto Approve toggle:

• OFF (default): Copilot propone change, tu clicchi "Accept" o "Reject"
• ON: Copilot auto-approva file edit (non comandi shell, che non sono in JetBrains)

Roadmap JetBrains (maggio-giugno 2026): aggiungere Autopilot-like tier, nested subagent delegation, session memory tracking.

Next Edit Suggestions (Enhancement)

Con il rilascio aprile 2026, JetBrains Copilot migliora "Next Edit Suggestions": after you accept una modifica, Copilot propone la successiva modifica logica (es. se aggiungi parametro a funzione, Copilot propone di aggiungere null check, test, ecc).

Stato iniziale: UserService.getUser(id)
Tu: Copilot inline "add email parameter"
Copilot propone:
  public User getUser(id, email) { ... }

Tu accetti ✓

Copilot suggerisce next edit:
  "Consider adding email validation before query"

Tu accetti ✓

Copilot suggerisce:
  "Add new test case for email validation"

Zero prompt, zero "per favore", zero "Cmd+I": suggeriment logici basati su AST e task context.

Confronto con Claude Code CLI

Anthropic ha lanciato Claude Code CLI (novembre 2024) come alternativa a GitHub Copilot CLI. Dicembre 2024 è stato il mese di "AI agent hype", e adesso sia GitHub che Anthropic hanno CLI agent terminal-first.

Head-to-Head Comparison

Quale Scegliere?

• Scegli Copilot CLI se:
  • Usi già GitHub Enterprise (integrazione nativa, Agent Control Plane org-wide)
  • Vuoi scegliere il modello (Opus per refactoring, Haiku per quick fix, GPT-5.3 per Python)
  • Ami il terminale (Copilot CLI è terminale-first, zero IDE)
  • Lavori in team e serve auditare cosa fa l'agente (GitHub Enterprise audit logs)
• Scegli Claude Code CLI se:
  • Preferisci Opus sopra tutto (extended thinking nativo, massima qualità)
  • Usi Zed editor (Anthropic supporta nativamente Zed)
  • Scrivi custom .claude/agents/ per workflow proprietari aziendali
  • Non usi GitHub Enterprise (sei indie/startup, nessuna integrazione org-wide needed)

Mio consiglio (febbraio 2026): se sei in azienda con GitHub Enterprise e team, Copilot CLI + Autopilot + Agent Control Plane. Se sei indie, Claude Code CLI è eccellente (Opus è superiore a Sonnet su reasoning complex). Se vuoi il meglio da entrambi, alterna: Copilot CLI per task routine (test, build, deploy), Claude Code per task strategic (architettura, refactoring major, design review).

Conclusione

Il 25 febbraio 2026, GitHub Copilot CLI raggiunge GA. Non è più una beta, non è più sperimentale: è il tuo terminale che diventa uno sviluppatore junior competente, che sa refactor codice, eseguire test, deploiare applicazioni, scrivere test, leggere documentazione, tutto autonomamente.

Con Autopilot tier (VS Code marzo 2026) e Autopilot-like approval model (JetBrains aprile 2026), il paradigma shift è completo: non più "apri IDE e scrivi", ma "dai comando e Copilot esegue".

In questa serie di 22 articoli su GitHub Copilot, abbiamo visto l'evoluzione da "autocomplete che suggerisce linea di codice" a "agente autonomo che esegue refactoring di classe".

Prossimo articolo (23): MCP Shared - come Anthropic e GitHub hanno standardizzato il protocollo di extensibility, e perché questo apre nuove possibilità per agenti custom.

Riferimenti

Documentazione Ufficiale

• GitHub Copilot CLI is now generally available (25 feb 2026)
• GitHub Copilot CLI: Enhanced agents, context management (14 gen 2026)
• VS Code: Introducing Copilot Agent Mode (24 feb 2025)
• VS Code: Agent Mode Update (7 apr 2025)
• GitHub Copilot in VS Code: March 2026 releases
• Deprecation: gh copilot extension (25 ott 2025)

Leggi Anche nella Serie

• Articolo 20: Agent Mode Preview - Primi passi con multi-step task
• Articolo 21: Planning Phase - Come Copilot struttura piani di implementazione
• Articolo 23 (prossimo): MCP Shared - Anthropic + GitHub Protocol Alignment
• Articolo 24 (coming): Pricing & Quota Management - Token limits, cost optimization

Risorse Correlate

• GitHub Copilot CLI GitHub repo: github/copilot-cli
• Claude Code CLI documentation: anthropic.com
• MCP (Model Context Protocol): modelcontextprotocol.io
• Zed editor (Agent Mode native): zed.dev