AI Prompt Engineering · Lezione

Quando usare modelli di reasoning o standard

Tipi di problemi in cui il ragionamento esteso è vantaggioso: matematica, codice e logica a più passaggi

Lezione 3 di 413 passaggi

Quando usare modelli di reasoning o standard è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.

Non tutte le attività richiedono modelli di ragionamento

I modelli di ragionamento sono potenti, ma costosi e lenti. Scegliere il tipo di modello giusto per ogni attività è una delle decisioni più importanti nella progettazione di sistemi LLM.

La domanda fondamentale è: questa attività trae effettivamente vantaggio da una deliberazione estesa? Molte attività non ne traggono vantaggio, e usare un modello di ragionamento in questi casi spreca denaro senza migliorare la qualità.

Dove eccellono i modelli di ragionamento: matematica a più passaggi

I modelli di ragionamento superano nettamente i modelli standard nei problemi matematici che richiedono più passaggi, soprattutto quando gli errori si accumulano da un passaggio all'altro.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Multi-step math: use reasoning model
hard_math_prompt = (
    'A company has 3 factories. Factory A produces 240 units/day, '
    'Factory B produces 180 units/day, and Factory C produces 300 units/day. '
    'They operate 5 days/week. A unit sells for $47.50. Operating costs are '
    '$18,000/week for A, $14,500/week for B, and $22,000/week for C. '
    'What is the total weekly profit across all factories?'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=8000,
    thinking={'type': 'enabled', 'budget_tokens': 5000},
    messages=[{'role': 'user', 'content': hard_math_prompt}]
)
print(next(b.text for b in response.content if b.type == 'text'))

Dove eccellono i modelli di ragionamento: codice complesso

Per i problemi algoritmici, come implementare strutture dati, correggere sottili errori logici o progettare soluzioni efficienti, i modelli di ragionamento superano quelli standard perché possono esplorare internamente diversi approcci prima di sceglierne uno.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Complex coding: use reasoning model
code_prompt = (
    'Implement a thread-safe LRU cache in Python with these requirements:\n'
    '- O(1) get and put operations\n'
    '- Thread-safe using minimal locking\n'
    '- Support a max_size parameter\n'
    '- Include full docstrings and type hints\n'
    '- Handle edge cases: empty cache, size=1, duplicate keys'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=10000,
    thinking={'type': 'enabled', 'budget_tokens': 8000},
    messages=[{'role': 'user', 'content': code_prompt}]
)
code = next(b.text for b in response.content if b.type == 'text')
print(code[:400])

Dove eccellono i modelli di ragionamento: pianificazione strategica

Le attività che richiedono di valutare più opzioni in competizione, compromessi su molteplici dimensioni e conseguenze a lungo termine traggono vantaggio dal ragionamento esteso. Esempi: decisioni sulla progettazione dell'architettura, valutazione della roadmap di un prodotto e analisi degli investimenti.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Strategic decision: reasoning model adds real value
strategy_prompt = (
    'We are a B2B SaaS startup with $2M ARR, 15% monthly churn, '
    '3 engineers, and $800K runway. We have two options:\n'
    'A) Raise a Series A now at a $10M valuation\n'
    'B) Cut costs, extend runway 18 months, raise at higher valuation\n\n'
    'Analyze the trade-offs and recommend a course of action with reasoning.'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=10000,
    thinking={'type': 'enabled', 'budget_tokens': 8000},
    messages=[{'role': 'user', 'content': strategy_prompt}]
)
print(next(b.text for b in response.content if b.type == 'text')[:400])

Dove eccellono i modelli standard: domande e risposte semplici

Le domande fattuali con risposte dirette non traggono vantaggio dal ragionamento esteso. Usare o3 o il ragionamento esteso di Claude per «Qual è la capitale della Francia?» significa spendere da 20 a 50 volte di più per ottenere risultati identici.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Simple Q&A: standard model is just as good, much cheaper
simple_questions = [
    'What is the capital of France?',
    'Who wrote Hamlet?',
    'What year did the Berlin Wall fall?',
]

for q in simple_questions:
    # Use claude-haiku-4-5 — fast, cheap, equally accurate for factual recall
    r = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=50,
        messages=[{'role': 'user', 'content': q}]
    )
    print(f'Q: {q}\nA: {r.content[0].text}\n')

# Reasoning model would give the same answers at 50-100x the cost

Dove eccellono i modelli standard: formattazione del testo

Riformattare, riepilogare, tradurre e trasformare il testo non richiede un ragionamento approfondito, ma padronanza della lingua. I modelli standard eccellono in questi compiti, con costi e latenza molto inferiori.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Text formatting tasks: standard model wins
formatting_tasks = [
    ('Summarize in 2 sentences: The Eiffel Tower was built in 1889...', 100),
    ('Translate to Spanish: Good morning, how are you?', 50),
    ('Convert to bullet points: We need to buy milk, eggs, and bread.', 50),
]

for prompt, max_tok in formatting_tasks:
    r = client.messages.create(
        model='claude-haiku-4-5',  # Fastest, cheapest
        max_tokens=max_tok,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(r.content[0].text, '\n')

# Reasoning model: same quality, 50-100x more expensive, 10-30x slower

Dove eccellono i modelli standard: applicazioni a bassa latenza

Le applicazioni in tempo reale, come chatbot, completamento automatico e assistenza dal vivo, non possono tollerare tempi di risposta di 30-60 secondi. I modelli standard rispondono in 1-5 secondi. Li utilizzi per le interazioni in tempo reale rivolte agli utenti.

import anthropic
import time

client = anthropic.Anthropic(api_key='sk-ant-...')

def latency_comparison(question):
    # Standard model: fast for real-time use
    start = time.time()
    r1 = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=200,
        messages=[{'role': 'user', 'content': question}]
    )
    t_standard = time.time() - start

    # Reasoning model: accurate but slow
    start = time.time()
    r2 = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=5000,
        thinking={'type': 'enabled', 'budget_tokens': 3000},
        messages=[{'role': 'user', 'content': question}]
    )
    t_reasoning = time.time() - start

    print(f'Standard: {t_standard:.1f}s | Reasoning: {t_reasoning:.1f}s')

latency_comparison('What does API stand for?')

Problemi di ragionamento ambigui

Alcuni problemi sono ambigui: la risposta corretta dipende da presupposti non dichiarati. I modelli di ragionamento li gestiscono meglio dei modelli standard perché esplorano internamente più interpretazioni e scelgono quella più difendibile.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Ambiguous reasoning: reasoning model handles this much better
ambiguous_prompt = (
    'Alice, Bob, and Carol are in a room. Alice says Bob is lying. '
    'Bob says Carol is lying. Carol says both Alice and Bob are lying. '
    'Who, if anyone, is telling the truth? '
    'Explain all possible consistent interpretations.'
)

# Reasoning model explores the logical space
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=8000,
    thinking={'type': 'enabled', 'budget_tokens': 6000},
    messages=[{'role': 'user', 'content': ambiguous_prompt}]
)
print(next(b.text for b in response.content if b.type == 'text')[:400])

Quadro decisionale: quale modello usare

Un albero decisionale pratico per scegliere tra modelli standard e modelli di ragionamento:

Il problema è matematicamente complesso o richiede una logica a più passaggi? → Ragionamento
Richiede di valutare compromessi con molte variabili? → Ragionamento
Si tratta di recuperare informazioni fattuali, riepilogare o tradurre? → Standard
Richiede un tempo di risposta inferiore a 2 secondi? → Standard
Il costo per richiesta è fondamentale su larga scala? → Standard (a meno che il divario di qualità non sia ampio)
È fondamentale la correttezza nei casi limite difficili (medico, legale, finanziario)? → Ragionamento

Instradamento ibrido: il meglio di entrambi i mondi

In produzione, utilizzi un livello di instradamento che classifichi le richieste e le indirizzi al livello di modello appropriato. Le richieste semplici vengono indirizzate a modelli veloci ed economici; quelle complesse vengono inoltrate ai modelli di ragionamento.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def classify_complexity(query):
    prompt = (
        f'Classify this query as SIMPLE or COMPLEX:\n'
        f'SIMPLE: factual, formatting, translation, short Q&A\n'
        f'COMPLEX: multi-step reasoning, analysis, code design, math\n\n'
        f'Query: {query}\n\n'
        f'Reply with only SIMPLE or COMPLEX.'
    )
    r = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=10,
        messages=[{'role': 'user', 'content': prompt}]
    )
    return r.content[0].text.strip()

def smart_query(query):
    complexity = classify_complexity(query)
    if complexity == 'SIMPLE':
        model, thinking = 'claude-haiku-4-5', None
    else:
        model = 'claude-opus-4-5'
        thinking = {'type': 'enabled', 'budget_tokens': 8000}

    kwargs = {'model': model, 'max_tokens': 2048, 'messages': [{'role': 'user', 'content': query}]}
    if thinking:
        kwargs['thinking'] = thinking
        kwargs['max_tokens'] = 10000

    r = client.messages.create(**kwargs)
    print(f'Used: {model} ({complexity})')
    return r.content[-1].text

Valutare quando il ragionamento è utile

Non dia per scontato che il ragionamento sia sempre utile. Lo misuri. Confronti l'accuratezza dei modelli standard e di ragionamento sul tipo specifico di attività, utilizzando un dataset di valutazione etichettato.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def compare_models_on_task(task_examples, metric_fn):
    results = {'standard': [], 'reasoning': []}

    for ex in task_examples:
        # Standard model
        r_std = client.messages.create(
            model='claude-haiku-4-5',
            max_tokens=200,
            messages=[{'role': 'user', 'content': ex.question}]
        )
        results['standard'].append(
            metric_fn(ex.answer, r_std.content[0].text)
        )

        # Reasoning model
        r_rsn = client.messages.create(
            model='claude-opus-4-5',
            max_tokens=8000,
            thinking={'type': 'enabled', 'budget_tokens': 5000},
            messages=[{'role': 'user', 'content': ex.question}]
        )
        ans = next(b.text for b in r_rsn.content if b.type == 'text')
        results['reasoning'].append(metric_fn(ex.answer, ans))

    for model, scores in results.items():
        avg = sum(scores) / len(scores)
        print(f'{model}: {avg:.1%}')
    return results

Verifica delle conoscenze: instradamento delle attività

Quale tipo di attività ha MENO probabilità di trarre vantaggio da un modello di ragionamento rispetto a un modello standard?

Rispondi nella lezione interattiva

Riepilogo: quando usare modelli di ragionamento o modelli standard

Utilizzi i modelli di ragionamento per: matematica a più passaggi, programmazione algoritmica complessa, pianificazione strategica, problemi di logica ambigui e decisioni critiche in cui l'accuratezza è più importante del costo. Utilizzi i modelli standard per: domande e risposte semplici, formattazione del testo, traduzione, riepiloghi e tutte le applicazioni in tempo reale sensibili alla latenza. In produzione, crei un livello di instradamento che classifichi la complessità delle richieste e indirizzi ogni richiesta al livello di modello appropriato. Misuri sempre se il ragionamento migliora effettivamente l'accuratezza per la sua attività specifica prima di sostenere un sovrapprezzo da 20 a 100 volte.

Gratis per iniziare

Impara AI Prompt Engineering con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 53
Lezioni: 199

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Quando usare modelli di reasoning o standard» è gratuita?

Sì — il testo completo di «Quando usare modelli di reasoning o standard» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.

Cosa imparerò in «Quando usare modelli di reasoning o standard»?

Tipi di problemi in cui il ragionamento esteso è vantaggioso: matematica, codice e logica a più passaggi Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Prompt Engineering?

Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Quando usare modelli di reasoning o standard»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?

Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Differenze tra i modelli di reasoning
Prompt efficaci per il ragionamento esteso
Quando usare modelli di reasoning o standard
Compromessi tra costi e latenza

← Torna a AI Prompt Engineering