Assistente di programmazione IA — costruire strumenti simili a Cursor con Claude e GPT

Il panorama dell'AI per il codice, in breve

Cursor, Aider, Cline, Continue.dev, Claude Code stesso: tutti si basano sugli stessi tre o quattro LLM di frontiera. Il fattore distintivo non è il modello, ma il ciclo agentico che lo circonda, l'indicizzazione dei file, l'applicazione dei diff e l'esperienza utente. Se stai costruendo uno di questi prodotti (o un copilota di codice nel tuo prodotto per sviluppatori), questa pagina è il menu dei modelli, la realtà dei costi e il budget di latenza.

Menu dei modelli per i flussi di lavoro del codice

• Claude Haiku 4.5 (claude-haiku-4-5) — completamento automatico (circa 0,0001-0,0005 $ per completamento). Il vincitore in latenza, con time-to-first-token in streaming paragonabile alla chiamata diretta al provider
• Claude Sonnet 5 (claude-sonnet-5) — chat con il codebase, modifiche multi-file e cicli agentici. Il modello di riferimento al livello di Cursor, a $1,40 / $7,00 per 1M
• Claude Opus 5 (claude-opus-5) — revisione approfondita, critica dell'architettura e audit di sicurezza. Più lento (P50 circa 3 s), ma il miglior ragionatore, a $3,50 / $17,50 per 1M
• GPT-5.6 Sol (gpt-5-6-sol) — modello di OpenAI ottimizzato per il codice: qualità comparabile, preferenze stilistiche diverse

I due flussi principali

import json
from openai import OpenAI
client = OpenAI(api_key="sk-kn-...", base_url="https://api.kunavo.com/v1")

# Code completion (autocomplete-as-you-type)
def complete(file_content: str, cursor_offset: int, file_path: str) -> str:
    before = file_content[:cursor_offset]
    after = file_content[cursor_offset:]
    resp = client.chat.completions.create(
        model="claude-haiku-4-5",   # FAST for IDE latency
        messages=[
            {"role": "system", "content": (
                "Complete the code at the cursor. Output ONLY the inserted "
                "text — no markdown, no explanation."
            )},
            {"role": "user", "content": (
                f"<file path=\"{file_path}\">\n{before}<CURSOR>{after}\n</file>"
            )},
        ],
        max_tokens=200,
        stop=["<CURSOR>", "</file>"],
    )
    return resp.choices[0].message.content

# Code review (heavier model). Claude enforces a json_schema
# response_format; json_object it does not.
REVIEW = {
    "type": "object",
    "properties": {
        "comments": {"type": "array", "items": {
            "type": "object",
            "properties": {"file": {"type": "string"},
                           "line": {"type": "integer"},
                           "comment": {"type": "string"}},
            "required": ["file", "line", "comment"],
            "additionalProperties": False,
        }},
        "verdict": {"type": "string", "enum": ["approve", "request_changes"]},
    },
    "required": ["comments", "verdict"],
    "additionalProperties": False,
}

def review(diff: str, conventions: str) -> dict:
    resp = client.chat.completions.create(
        model="claude-opus-5",
        messages=[
            {"role": "system", "content": [{
                "type": "text",
                "text": conventions,  # team style guide, security policy
                "cache_control": {"type": "ephemeral"},
            }]},
            {"role": "user", "content": f"Review this diff.\n\n{diff}"},
        ],
        response_format={"type": "json_schema",
                         "json_schema": {"name": "review", "schema": REVIEW}},
        max_tokens=2000,
    )
    return json.loads(resp.choices[0].message.content)

Budget di latenza per funzionalità

• Completamento inline: TTFT deve essere <200ms. Claude Haiku 4.5. Trasmetti l'output in streaming, interrompilo quando il cursore si sposta
• Chat con il codebase: TTFT <500ms è accettabile. Sonnet + streaming. Mostra la risposta mentre viene generata
• Modifica / refactoring multi-file: 5-30 s è normale. Mostra l'avanzamento, esegui in background e presenta il diff per la revisione
• Revisione di una PR: 10-60 s è accettabile. Opus esegue l'analisi approfondita; formatta il risultato come commenti operativi

Economia dei costi per un prodotto di codice

Consumo realistico per sviluppatore al mese (utente intensivo):

• ~500 completamenti/giorno × Haiku ~0,0003 $ = 0,15 $/giorno = 4-5 $/mese
• ~30 sessioni di chat/giorno × Sonnet ~0,05 $ = 1,50 $/giorno = 30-45 $/mese
• ~3 revisioni PR/settimana × Opus ~0,30 $ = 1 $/settimana = 4 $/mese
• Utente intensivo: ~40-55 $/mese di costi API
• Utente medio: ~10-15 $/mese

La maggior parte dei prodotti di AI per il codice applica 20 $ per utente al mese: c'è margine, ma è ridotto per gli utenti intensivi. Il caching dei prompt è essenziale: il contesto del workspace (struttura dei file, convenzioni, file recenti) viene inserito nella cache; a ogni chiamata viene inviato fresco solo il contesto della modifica immediata. Risparmia il 50-70% sugli input. Come configurare il caching.

Pattern architetturali da copiare

• Prompting FIM (Fill-in-Middle): invece di "completa da qui", passa before<CURSOR>after così il modello usa entrambi i lati
• Sequenze di arresto: stop=["<CURSOR>", "</file>", "```\n"] impedisce al modello di inventare contenuti oltre il completamento richiesto
• Uso degli strumenti per modifiche multi-file: non chiedere al modello di produrre 5 file in una risposta. Usa tools=[{name: 'edit_file', ...}] per ottenere modifiche strutturate da applicare atomicamente
• Decodifica speculativa tramite streaming: mostra i primi ~50 token appena arrivano; gli utenti sceglieranno quello giusto anche prima che la risposta completa sia terminata

Cambiare provider in pochi secondi

Kunavo è compatibile con il protocollo OpenAI. Se hai creato il tuo assistant con l'SDK OpenAI, sostituisci base_url e avrai accesso a Claude e GPT con lo stesso codice. Consulta Chiamare Claude con l'SDK OpenAI per la migrazione.

Inizia da: /app/signup — pagamento a consumo con una ricarica da 10 $ (circa 30.000 chiamate di completamento automatico), il saldo non scade mai. Riferimento dell'endpoint in /docs/chat e API Messages nativa Anthropic in /docs/messages.

FAQ