AI Prompt Engineering · Aula

Quando usar modelos de raciocínio ou modelos padrão

Tipos de problemas em que o raciocínio prolongado compensa: matemática, código e lógica em várias etapas.

Aula 3 de 413 etapas

Quando usar modelos de raciocínio ou modelos padrão é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Nem toda tarefa precisa de modelos de raciocínio

Os modelos de raciocínio são poderosos, mas caros e lentos. Escolher o tipo de modelo adequado para cada tarefa é uma das decisões de maior impacto no projeto de sistemas com LLM.

A questão central é: essa tarefa realmente se beneficia de uma deliberação prolongada? Muitas tarefas não se beneficiam — e utilizar um modelo de raciocínio nelas desperdiça dinheiro sem melhorar a qualidade.

Onde os modelos de raciocínio se destacam: matemática em várias etapas

Os modelos de raciocínio superam amplamente os modelos padrão em problemas matemáticos que exigem várias etapas, especialmente quando os erros se acumulam ao longo delas.

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'))

Onde os modelos de raciocínio se destacam: código complexo

Em problemas algorítmicos — implementar estruturas de dados, depurar erros lógicos sutis ou projetar soluções eficientes — os modelos de raciocínio superam os modelos padrão porque podem explorar internamente várias abordagens antes de escolher uma.

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])

Onde os modelos de raciocínio se destacam: planejamento estratégico

Tarefas que exigem avaliar várias opções concorrentes, compromissos em muitas dimensões e consequências de longo prazo se beneficiam do raciocínio estendido. Exemplos: decisões de projeto de arquitetura, avaliação do roteiro de um produto e análise de investimentos.

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])

Onde os modelos padrão vencem: perguntas e respostas simples

Perguntas factuais com respostas diretas não se beneficiam de um raciocínio estendido. Usar o3 ou o raciocínio estendido do Claude para perguntar 'Qual é a capital da França?' desperdiça de 20 a 50 vezes mais dinheiro para obter resultados idênticos.

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

Onde os modelos padrão vencem: formatação de texto

Reformatar, resumir, traduzir e transformar textos não exige raciocínio profundo — exige domínio da linguagem. Os modelos padrão se destacam nessas tarefas com custo e latência muito menores.

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

Onde os modelos padrão vencem: aplicações de baixa latência

Aplicações em tempo real — robôs de conversa, preenchimento automático e assistência ao vivo — não podem tolerar tempos de resposta de 30 a 60 segundos. Os modelos padrão respondem em 1 a 5 segundos. Utilize-os em interações em tempo real voltadas ao usuário.

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?')

Problemas de raciocínio ambíguos

Alguns problemas são ambíguos — a resposta correta depende de suposições que não foram declaradas. Os modelos de raciocínio lidam melhor com esses problemas que os modelos padrão porque exploram internamente várias interpretações e escolhem a mais defensável.

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])

Estrutura de decisão: qual modelo utilizar

Uma árvore prática de decisão para escolher entre modelos padrão e de raciocínio:

O problema é matematicamente complexo ou exige lógica em várias etapas? → Raciocínio
É necessário avaliar compromissos com muitas variáveis? → Raciocínio
Trata-se de recuperação factual, resumo ou tradução? → Padrão
É necessário um tempo de resposta inferior a 2 segundos? → Padrão
O custo por consulta é crítico em grande escala? → Padrão (a menos que a diferença de qualidade seja grande)
A correção em casos extremos difíceis é crítica (médicos, jurídicos, financeiros)? → Raciocínio

Roteamento híbrido: o melhor dos dois mundos

Em produção, utilize uma camada de roteamento que classifique as consultas e as direcione para o nível adequado de modelo. Consultas simples vão para modelos rápidos e baratos; consultas complexas são encaminhadas para modelos de raciocínio.

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

Avaliando quando o raciocínio ajuda

Não presuma que o raciocínio sempre ajuda. Meça isso. Compare a precisão dos modelos padrão e de raciocínio no seu tipo específico de tarefa usando um conjunto de avaliação rotulado.

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ção de conhecimento: roteamento de tarefas

Qual tipo de tarefa tem a menor probabilidade (LEAST) de se beneficiar de um modelo de raciocínio em comparação com um modelo padrão?

Responda na aula interativa

Recapitulação: quando utilizar modelos de raciocínio em vez de modelos padrão

Utilize modelos de raciocínio para: matemática em várias etapas, programação algorítmica complexa, planejamento estratégico, problemas de lógica ambíguos e decisões críticas nas quais a precisão é mais importante que o custo. Utilize modelos padrão para: perguntas e respostas simples, formatação de texto, tradução, resumo e todas as aplicações em tempo real sensíveis à latência. Em produção, desenvolva uma camada de roteamento que classifique a complexidade das consultas e direcione cada solicitação para o nível adequado de modelo. Sempre meça se o raciocínio realmente melhora a precisão na sua tarefa específica antes de pagar um custo adicional de 20 a 100 vezes.

Grátis para começar

Aprenda AI Prompt Engineering com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 53
Aulas: 199

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Quando usar modelos de raciocínio ou modelos padrão” é grátis?

Sim — o texto completo de “Quando usar modelos de raciocínio ou modelos padrão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Quando usar modelos de raciocínio ou modelos padrão”?

Tipos de problemas em que o raciocínio prolongado compensa: matemática, código e lógica em várias etapas. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Quando usar modelos de raciocínio ou modelos padrão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Como os modelos de raciocínio são diferentes
Prompts eficazes para raciocínio prolongado
Quando usar modelos de raciocínio ou modelos padrão
Relações de compromisso entre custo e latência

← Voltar para AI Prompt Engineering