AI Prompt Engineering · Aula

Definindo o cenário com eficácia

Técnicas de enquadramento: “Você é...”, “Dado que...” e “O objetivo é...”.

Aula 3 de 413 etapas

Definindo o cenário com eficácia é 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.

Frases iniciais que funcionam

A primeira frase da sua instrução é a mais importante. Ela define o contexto operacional do modelo — a perspectiva pela qual ele interpretará tudo o que vem a seguir.

Estruturas iniciais eficazes incluem: Você é..., O contexto é..., Dado que... e O objetivo é.... Cada uma ativa uma dimensão diferente do contexto antes que a tarefa propriamente dita comece.

A estrutura 'Você é...'

A estrutura Você é... atribui uma persona ao modelo. Ela ativa o vocabulário, o estilo de raciocínio e as prioridades associados a essa função.

O ponto principal é ser específico. 'Você é um especialista' é fraco. 'Você é um engenheiro sênior de Python com 10 anos de experiência que prioriza a legibilidade em vez da engenhosidade' é eficaz.

As estruturas de persona funcionam melhor quando a persona implica uma forma específica de pensar e se comunicar de que você precisa.

import anthropic

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

persona_prompts = [
    'You are a Socratic philosophy professor. Ask 3 probing questions about this claim: AI will replace programmers.',
    'You are a skeptical venture capitalist who has seen 500 pitches. Give brutal feedback on this pitch: We are building an AI writing assistant.',
    'You are a patient kindergarten teacher. Explain what a computer does in 3 sentences for 5-year-olds.'
]

for prompt in persona_prompts:
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=150,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'--- Persona ---')
    print(prompt[:80] + '...')
    print(response.content[0].text.strip())
    print()

A estrutura «Você é...» nas mensagens do sistema

O lugar mais eficaz para uma estrutura de persona é a mensagem do sistema, não a interação do usuário. As personas da mensagem do sistema permanecem ativas durante toda a conversa — não é necessário repeti-las.

Uma persona do sistema bem elaborada pode transformar completamente a forma como um assistente de IA responde a dezenas de perguntas subsequentes.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Persona set once in system; stays active for all turns
system_persona = (
    'You are Marcus, a senior software architect at a Fortune 500 company. '
    'You have 20 years of experience with distributed systems. '
    'Your communication style: direct, pragmatic, no buzzwords. '
    'You always ask about scale and failure modes before giving architecture advice. '
    'If a question lacks context, ask one clarifying question before answering.'
)

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[
        {'role': 'system', 'content': system_persona},
        {'role': 'user', 'content': 'Should we use microservices for our new product?'}
    ]
)
print(response.choices[0].message.content)

A estrutura «O contexto é...»

A estrutura O contexto é... define o contexto situacional sem atribuir uma persona. Use-a quando precisar que o modelo raciocine sobre a sua situação específica, em vez de adotar um personagem.

Ela é particularmente eficaz em tarefas técnicas e analíticas nas quais você quer que o modelo raciocine como ele mesmo, mas tenha plena consciência das suas restrições.

import anthropic

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

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=300,
    messages=[{
        'role': 'user',
        'content': (
            'The context is: we are a 5-person startup with $2M in seed funding. '
            'Our Python monolith handles 10,000 users and is starting to show performance issues. '
            'We have one backend engineer and cannot hire more for 6 months. '
            'We need to choose between refactoring the monolith vs migrating to microservices.\n\n'
            'Give a recommendation with 3 supporting reasons. Be direct.'
        )
    }]
)
print(response.content[0].text)

A estrutura «Dado que...»

A estrutura Dado que... estabelece uma premissa ou suposição que orienta toda a resposta. Use-a para estabelecer fatos que o modelo deve considerar verdadeiros para os fins da tarefa.

Ela é poderosa para análises hipotéticas, planejamento condicional e redação baseada em cenários, quando você precisa que o modelo raciocine a partir de um ponto de partida específico.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

scenarios = [
    'Given that our user base will grow 10x in 6 months, what architecture changes should we make today?',
    'Given that we must launch in 2 weeks with the current team, which features should we cut from the MVP?',
    'Given that our API key was exposed publicly for 3 hours, what steps should we take in the next 24 hours?'
]

for scenario in scenarios:
    response = client.chat.completions.create(
        model='gpt-4o',
        max_tokens=120,
        messages=[{
            'role': 'user',
            'content': scenario + ' (Answer in 3 bullet points.)'
        }]
    )
    print(f'Scenario: {scenario[:60]}...')
    print(response.choices[0].message.content.strip())
    print()

A estrutura «O objetivo é...»

A estrutura O objetivo é... declara a finalidade posterior da saída. Ela é diferente da instrução da tarefa — explica por que você precisa dessa saída e o que ela deve realizar.

Essa estrutura ajuda o modelo a tomar decisões menores melhores: qual nível de persuasão usar, quais objeções antecipar e quais detalhes incluir ou omitir.

import anthropic

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

goal_frames = [
    (
        'The goal is to get the reader to schedule a 30-minute demo call. '
        'Write a 100-word cold outreach email for our AI data pipeline tool '
        'targeting data engineers at e-commerce companies.'
    ),
    (
        'The goal is to help the reader pass a senior Python interview at a FAANG company. '
        'Explain Python decorators with one conceptual explanation and one practical code example.'
    )
]

for prompt in goal_frames:
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=200,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print('--- Goal Frame ---')
    print(prompt[:80] + '...')
    print(response.content[0].text.strip())
    print()

Combinando estruturas iniciais

As instruções mais poderosas combinam várias estruturas iniciais antes da instrução da tarefa. Uma estrutura típica de alto desempenho:

  1. Você é... [persona]
  2. O contexto é... [situação]
  3. O objetivo é... [finalidade posterior]
  4. Dado que... [suposição ou restrição essencial]
  5. [Instrução da tarefa]

Cada estrutura acrescenta uma camada de orientação. Juntas, elas deixam muito pouco espaço para o modelo ter de adivinhar.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

combined_frame_prompt = (
    'You are a senior product manager with 10 years of B2B SaaS experience.\n'
    'The context is: our team is debating whether to build a native mobile app '
    'or keep investing in our responsive web app.\n'
    'The goal is: to help our leadership team make a clear go/no-go decision at '
    'next week\'s board meeting.\n'
    'Given that: we have 3 engineers, $300k runway, and 85% of current users are on desktop.\n\n'
    'Write a 250-word recommendation memo with a clear position (build or wait) '
    'and 3 supporting arguments. End with one risk to monitor.'
)

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': combined_frame_prompt}]
)
print(response.choices[0].message.content)

Estruturas para definir tom e voz

As estruturas iniciais também podem definir o tom e a voz sem usar a palavra «tom». Descrever a persona e a situação define implicitamente o registro:

  • «Você é um mentor acolhedor e paciente que fala com um estudante com dificuldades» → automaticamente acolhedor e encorajador
  • «Você é um oficial de logística militar direto e objetivo» → automaticamente direto e preciso
  • «Você é um jornalista de tecnologia espirituoso que escreve para a Wired» → automaticamente inteligente e acessível
import anthropic

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

frames = [
    'You are a warm, patient mentor. Explain why learning to code is hard but worth it.',
    'You are a no-nonsense military logistics officer. Explain why learning to code is hard but worth it.',
    'You are a witty tech journalist writing for Wired. Explain why learning to code is hard but worth it.'
]

for frame in frames:
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=80,
        messages=[{'role': 'user', 'content': frame + ' (2 sentences only)'}]
    )
    print(f'Frame: {frame[:55]}...')
    print(response.content[0].text.strip())
    print()

Estruturas para obter rigor analítico

Quando você precisa de uma análise rigorosa e crítica, em vez de concordância entusiasmada, comece com uma estrutura que ative explicitamente uma mentalidade cética ou analítica:

  • «Você é um revisor crítico cujo trabalho é encontrar falhas...»
  • «Atue como advogado do diabo e questione o seguinte...»
  • «Suponha o oposto do senso comum e argumente...»
  • «Apresente a versão mais forte do argumento mais fraco contra...»
import openai

client = openai.OpenAI(api_key='sk-your-key-here')

analytical_frames = [
    'You are a critical reviewer whose job is to find fatal flaws. Review this startup idea: a subscription box for AI prompt templates.',
    'Play devil\'s advocate. Challenge this claim: AI will make every knowledge worker 10x more productive.',
    'Steelman the weakest argument against remote work, then give the strongest counter-argument.'
]

for frame in analytical_frames:
    response = client.chat.completions.create(
        model='gpt-4o',
        max_tokens=120,
        messages=[{'role': 'user', 'content': frame + ' (3 sentences max)'}]
    )
    print(f'Frame type: analytical/critical')
    print(f'Prompt: {frame[:60]}...')
    print(response.choices[0].message.content.strip())
    print()

Quando não usar uma estrutura de persona

As estruturas de persona nem sempre são a ferramenta certa. Evite-as quando:

  • Você precisa extrair dados objetivos — uma persona acrescenta viés
  • Você está processando dados estruturados — as personas distraem
  • A tarefa é puramente mecânica — não envolve raciocínio
  • Você quer a avaliação genuína do modelo — uma persona molda a opinião

Para tarefas como «converta este CSV para JSON» ou «conte o número de frases neste parágrafo», não é necessária nenhuma estrutura — basta a instrução.

import anthropic

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

# Persona frame is unhelpful here — just adds tokens
prompt_with_unnecessary_frame = (
    'You are an expert data processing specialist with years of experience. '
    'Convert the following to JSON: Name: Alice, Age: 30, City: London'
)

# Clean, direct instruction
prompt_direct = (
    'Convert to a JSON object with keys name, age, city:\n'
    'Name: Alice, Age: 30, City: London'
)

for label, prompt in [('WITH UNNECESSARY FRAME', prompt_with_unnecessary_frame), ('DIRECT', prompt_direct)]:
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=50,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'[{label}]')
    print(response.content[0].text.strip())
    print()

Testando suas estruturas

A melhor maneira de descobrir quais estruturas funcionam para o seu caso de uso é realizar testes A/B: mesma tarefa, estruturas iniciais diferentes e comparação das saídas.

Teste estas dimensões:

  • Sem estrutura versus com estrutura de persona
  • Persona vaga versus persona específica
  • Apenas estrutura de contexto versus estrutura de contexto + estrutura de objetivo
  • Uma estrutura versus estruturas combinadas

Mantenha um registro de quais estruturas produzem as melhores saídas para cada categoria de tarefa no seu trabalho.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

task = 'Explain the pros and cons of using TypeScript over JavaScript.'

frames = {
    'No frame':       task,
    'Persona frame':  f'You are a TypeScript advocate who also knows JavaScript deeply. {task}',
    'Goal frame':     f'The goal is to help a JavaScript developer decide if switching to TypeScript is worth it. {task}',
    'Combined frame': f'You are a pragmatic senior engineer. The goal is to help a JavaScript developer decide. {task} Give a balanced view in 3 bullet points.'
}

for label, prompt in frames.items():
    response = client.chat.completions.create(
        model='gpt-4o', max_tokens=80,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'[{label}]: {response.choices[0].message.content.strip()[:120]}...')
    print()

Verificação de conhecimento

Um desenvolvedor quer que a IA dê um feedback crítico e severo sobre a apresentação da sua startup — nada de incentivo ou equilíbrio, apenas uma crítica de oposição. Qual estrutura inicial consegue isso da melhor forma?

Definindo o cenário — recapitulação

As estruturas iniciais orientam o modelo antes que ele leia a instrução da tarefa. As quatro estruturas mais eficazes:

  • «Você é...»: atribui uma persona com conhecimentos específicos, estilo de comunicação e prioridades
  • «O contexto é...»: define o contexto situacional sem uma persona
  • «Dado que...»: estabelece premissas ou restrições que o modelo deve considerar verdadeiras
  • «O objetivo é...»: define a finalidade posterior da saída

Combine estruturas para tarefas complexas. Não use nenhuma estrutura em tarefas puramente mecânicas. Teste variações das estruturas para descobrir o que funciona melhor no seu caso de uso.

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

Perguntas Frequentes

A aula “Definindo o cenário com eficácia” é grátis?

Sim — o texto completo de “Definindo o cenário com eficácia” é 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 “Definindo o cenário com eficácia”?

Técnicas de enquadramento: “Você é...”, “Dado que...” e “O objetivo é...”. 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 “Definindo o cenário com eficácia”?

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

  1. O que significa contexto ao criar prompts para IA
  2. Fornecendo informações de base
  3. Definindo o cenário com eficácia
  4. Extensão e relevância do contexto
← Voltar para AI Prompt Engineering