Assistant de programmation IA — créer des outils similaires à Cursor avec Claude et GPT

Le paysage de l’IA pour le code, en bref

Cursor, Aider, Cline, Continue.dev, Claude Code lui-même — tous reposent sur les trois ou quatre mêmes LLM de pointe. Le facteur différenciant n’est pas le modèle, mais la boucle agentique qui l’entoure, l’indexation des fichiers, l’application des diffs et l’expérience utilisateur. Si vous développez l’un de ces produits (ou un copilote de programmation intégré à votre propre produit pour développeurs), cette page présente le menu des modèles, la réalité des coûts et le budget de latence.

Menu des modèles pour les flux de travail de programmation

• Claude Haiku 4.5 (claude-haiku-4-5) — autocomplétion (environ $0.0001-0.0005 par complétion). Le gagnant en latence ; un temps avant le premier token en streaming comparable à un appel direct au fournisseur
• Claude Sonnet 5 (claude-sonnet-5) — conversation avec la base de code, modifications multi-fichiers, boucles agentiques. Le modèle polyvalent de niveau Cursor à $1.40 / $7.00 par 1M
• Claude Opus 5 (claude-opus-5) — revue approfondie, critique d’architecture, audit de sécurité. Plus lent (P50 d’environ 3 s), mais le meilleur raisonneur, à $3.50 / $17.50 par 1M
• GPT-5.6 Sol (gpt-5-6-sol) — modèle d’OpenAI optimisé pour le code : qualité comparable, préférences stylistiques différentes

Les deux flux principaux

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 de latence par fonctionnalité

• Autocomplétion inline : le TTFT doit être <200ms. Claude Haiku 4.5. Diffusez la sortie en flux et interrompez-la lors du déplacement du curseur
• Conversation avec la base de code : TTFT <500ms acceptable. Sonnet + streaming. Affichez la réponse au fur et à mesure de sa génération
• Modification / refactorisation multi-fichiers : 5-30s est normal. Affichez la progression, exécutez en arrière-plan et présentez le diff pour révision
• Revue de pull request : 10-60s acceptable. Opus effectue l’analyse approfondie ; formatez le résultat en commentaires exploitables

Économie des coûts pour un produit de programmation

Consommation réaliste par développeur et par mois (utilisateur intensif) :

• ~500 complétions/jour × Haiku ~ $0.0003 = $0.15/jour = $4-5/mois
• ~30 sessions de chat/jour × Sonnet ~ $0.05 = $1.50/jour = $30-45/mois
• ~3 revues de PR/semaine × Opus ~ $0.30 = $1/semaine = $4/mois
• Utilisateur intensif : ~ $40-55/mois de coûts API
• Utilisateur moyen : ~ $10-15/mois

La plupart des produits d’IA pour le code facturent $20/utilisateur/mois — la marge existe, mais elle est étroite pour les utilisateurs intensifs. La mise en cache des prompts est essentielle : le contexte de l’espace de travail (structure des fichiers, conventions, fichiers récents) va dans le cache ; seul le contexte immédiat de la modification est nouveau à chaque appel. Économies de 50 à 70 % sur les entrées. Comment configurer la mise en cache.

Schémas architecturaux à reprendre

• Prompting FIM (Fill-in-Middle) : au lieu de « compléter à partir d’ici », transmettez before<CURSOR>after afin que le modèle utilise les deux côtés
• Séquences d’arrêt : stop=["<CURSOR>", "</file>", "```\n"] empêche le modèle d’inventer au-delà de la complétion demandée
• Utilisation d’outils pour les modifications multi-fichiers : ne demandez pas au modèle de produire 5 fichiers dans une seule réponse. Utilisez tools=[{name: 'edit_file', ...}] afin qu’il produise des modifications structurées que vous appliquez atomiquement
• Décodage spéculatif via le streaming : affichez les ~50 premiers tokens dès leur disponibilité ; les utilisateurs choisiront le bon résultat avant même que la réponse complète soit terminée

Changer de fournisseur en quelques secondes

Kunavo est compatible avec le protocole OpenAI. Si vous avez développé votre assistant avec le SDK OpenAI, remplacez base_url et vous accédez à Claude et GPT avec le même code. Consultez Appeler Claude avec le SDK OpenAI pour la migration.

Commencez : /app/signup — paiement à l’usage à partir d’un rechargement de 10 $ (~30 000 appels d’autocomplétion), le solde n’expire jamais. Référence de l’endpoint sur /docs/chat et API Messages native d’Anthropic sur /docs/messages.

FAQ