Texto simples versus resultado formatado
Quando solicitar texto simples e limpo em vez de um resultado em markdown avançado.
Texto simples versus resultado formatado é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 4 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.
O caso do texto simples
A formatação em marcação é poderosa — mas nem sempre é a escolha certa. Muitos aplicativos do mundo real precisam de texto limpo e sem formatação, no qual os símbolos de marcação apareceriam como caracteres literais em vez de serem exibidos como formatação.
Saber quando solicitar texto simples é tão importante quanto saber como solicitar uma formatação avançada.
Quando o texto simples é necessário
Use saída em texto simples quando o ambiente não renderizar marcação:
- Texto para e-mail: a maioria dos clientes de e-mail exibe os asteriscos brutos
- SMS e notificações push: não há suporte a formatação
- Saída de voz: a síntese de fala lê '** negrito **' literalmente
- Campos de CRM e suporte técnico: muitos não renderizam marcação
- Processamento de dados por API: quando o texto será armazenado ou processado posteriormente
- Campos de entrada de sistemas antigos: somente texto simples
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=200,
messages=[{
'role': 'user',
'content': (
'Write a 120-character push notification for a flash sale ending in 2 hours. '
'Plain text only — no emojis, no markdown, no asterisks, no special characters. '
'Must include: urgency, discount percentage (30%), and category (electronics). '
'Output the notification text only — nothing else.'
)
}]
)
print(response.content[0].text)Solicitando texto simples explicitamente
Em muitos contextos, os modelos de IA geram por padrão uma saída com muita marcação. Para obter texto realmente simples, é necessário dizer isso explicitamente e, muitas vezes, indicar os símbolos específicos que devem ser evitados:
- 'Somente texto simples — sem formatação em marcação'
- 'Sem asteriscos, sem sinais de cerquilha e sem símbolos de marcadores'
- 'Sem cabeçalhos, sem negrito e sem listas — somente parágrafos de prosa contínua'
- 'Remova toda a formatação — produza a saída como se estivesse escrevendo no Bloco de Notas'
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# Without plain text instruction — likely gets markdown
default_prompt = 'Explain what a webhook is in 100 words.'
# With explicit plain text instruction
plain_prompt = (
'Explain what a webhook is in 100 words. '
'Output format: plain text only. No markdown. No asterisks. No headers. '
'No bullet points. Just continuous prose paragraphs.'
)
for label, prompt in [('DEFAULT (likely markdown)', default_prompt), ('EXPLICIT PLAIN TEXT', plain_prompt)]:
response = client.chat.completions.create(
model='gpt-4o', max_tokens=150,
messages=[{'role': 'user', 'content': prompt}]
)
print(f'--- {label} ---')
print(response.choices[0].message.content)
print()Texto simples para textos de e-mail
A redação de e-mails é um dos casos de uso mais comuns para texto simples. Embora alguns clientes de e-mail ofereçam suporte à formatação HTML, o texto gerado por IA deve chegar como uma prosa limpa que um editor possa colar diretamente em um cliente de e-mail ou CRM, sem precisar limpá-la.
Especifique: 'Escreva o corpo do e-mail em texto simples. Sem marcação. Sem asteriscos para negrito. Sem traços para listas. Use frases numeradas ou quebras de linha em vez de listas.'
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': (
'Write a 3-paragraph re-engagement email for inactive newsletter subscribers. '
'Context: SaaS analytics tool, subscriber inactive for 60 days.\n'
'Format requirements:\n'
'- Plain text only — no asterisks, no pound signs, no bullet symbols\n'
'- Paragraph 1: acknowledge absence, create curiosity\n'
'- Paragraph 2: one new feature they missed\n'
'- Paragraph 3: CTA with a direct link placeholder [LINK]\n'
'- No subject line — body only'
)
}]
)
print(response.content[0].text)Parágrafos de prosa clara
Além de evitar símbolos de marcação, escrever uma 'prosa clara' significa estruturar as ideias como frases contínuas, em vez de pontos fragmentados.
Uma boa prosa:
- Usa palavras de transição para conectar ideias (porém, além disso, como resultado)
- Varia o comprimento das frases para criar ritmo
- Agrupa ideias relacionadas em parágrafos coerentes
- Evita começar todas as frases com um substantivo
Solicitação: 'Escreva em parágrafos de prosa clara — sem listas, sem cabeçalhos, com frases contínuas e palavras de transição.'
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
prose_prompt = (
'Explain the advantages of using Docker for development environments. '
'Write in 3 clean prose paragraphs. '
'Requirements:\n'
'- No bullet points or numbered lists\n'
'- No markdown headers\n'
'- Use transition words between sentences and paragraphs\n'
'- Vary sentence length — mix short and long\n'
'- 150 words total maximum'
)
response = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prose_prompt}]
)
print(response.choices[0].message.content)Texto simples para saída de voz
Os sistemas de síntese de fala leem tudo literalmente. Se a saída da IA for falada em voz alta:
- Evite todos os símbolos de marcação
- Evite abreviações (TTS talvez não as desenvolva)
- Escreva os números por extenso quando apropriado
- Use vírgulas para indicar pausas naturais
- Evite parênteses — a síntese de fala costuma lê-los de maneira estranha
- Escreva os caracteres especiais por extenso ('@' → 'arroba')
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=200,
messages=[{
'role': 'user',
'content': (
'Write a 45-second spoken weather briefing for London today. '
'Conditions: 12 degrees Celsius, light rain, wind 15 km/h from the southwest.\n'
'Format for voice output:\n'
'- No markdown symbols of any kind\n'
'- No parentheses\n'
'- No abbreviations (write "kilometres per hour" not "km/h")\n'
'- Natural spoken rhythm — use commas for pause points\n'
'- Write numbers as words when under ten'
)
}]
)
print(response.content[0].text)Removendo a marcação de uma saída existente
Às vezes, você recebe uma saída em marcação de uma chamada de IA e precisa limpá-la para outro contexto. Pode usar uma segunda chamada de IA especificamente para fazer essa remoção:
'Remova toda a formatação em marcação do texto a seguir. Substitua **negrito** por texto simples, remova os cabeçalhos com #, converta os marcadores em frases numeradas, remova todos os asteriscos e sinais de cerquilha. Produza somente texto simples e limpo.'
import openai
import re
client = openai.OpenAI(api_key='sk-your-key-here')
markdown_text = (
'## Key Benefits\n'
'- **Faster deployment** with Docker containers\n'
'- **Consistent environments** across dev and prod\n'
'- Reduced *configuration drift* between machines\n'
'### Getting Started\n'
'Run docker-compose up to start all services.'
)
# Option 1: Ask AI to strip
response = client.chat.completions.create(
model='gpt-4o',
max_tokens=150,
messages=[{
'role': 'user',
'content': (
'Remove all markdown formatting from the text below. '
'Keep all the information but strip: **, ##, ###, -, *, backticks. '
'Convert bullet lists to flowing sentences. Output plain text only.\n\n'
+ markdown_text
)
}]
)
print('AI-stripped:', response.choices[0].message.content.strip())
# Option 2: Simple regex strip (for code-based pipelines)
import re
clean = re.sub(r'[#*]', '', markdown_text).strip()
print('Regex-stripped:', clean)Texto simples nas mensagens do sistema
Para assistentes de IA que produzem continuamente saídas para ambientes de texto simples, defina a regra de formatação uma vez na mensagem do sistema, em vez de repeti-la a cada interação do usuário.
Essa é a abordagem mais simples para aplicativos de produção quando o ambiente de renderização é conhecido antecipadamente.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
# System message enforces plain text for all responses
plain_text_system = (
'You are a helpful assistant embedded in a mobile push notification system. '
'All your responses are displayed as plain text in mobile notifications. '
'ALWAYS follow these formatting rules:\n'
'- Never use markdown (no **, no #, no -, no backtick, no *, no _)\n'
'- Never use bullet points or numbered lists\n'
'- Write in 1-2 complete sentences only\n'
'- Maximum 120 characters per response\n'
'- No emojis'
)
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=64,
system=plain_text_system,
messages=[
{'role': 'user', 'content': 'Notify user their order has shipped and will arrive in 2 days.'}
]
)
print(response.content[0].text)Estrutura de decisão de formatação
Use esta estrutura rápida de decisão antes de solicitar qualquer formato de saída:
- Para onde vai a saída? Interface web, e-mail, terminal, voz ou banco de dados
- Esse ambiente renderiza marcação? Sim → use marcação. Não → texto simples.
- Uma pessoa lerá o conteúdo? Sim → estruture para facilitar a leitura rápida. Não → otimize para análise automática.
- O código processará o conteúdo? Sim → JSON ou CSV, sem prosa.
- O conteúdo será falado? Sim → texto simples adequado para voz, sem abreviações.
def choose_format(environment, human_reads, code_processes, voice_output):
'''Simple formatting decision tree.'''
if voice_output:
return 'PLAIN TEXT — voice safe, spell out numbers and units'
if code_processes:
return 'JSON or CSV — machine-parseable, no prose'
renders_markdown = environment in ['web', 'notion', 'github', 'vscode', 'obsidian']
if renders_markdown and human_reads:
return 'MARKDOWN — headers, bold, code blocks, lists'
return 'PLAIN TEXT — clean prose paragraphs, no markdown symbols'
scenarios = [
('web', True, False, False),
('email', True, False, False),
('api_pipeline',False, True, False),
('voice_app', False, False, True),
('terminal', True, False, False),
]
for env, human, code, voice in scenarios:
result = choose_format(env, human, code, voice)
print(f'{env:<15} -> {result}')Texto simples estruturado
O texto simples não precisa ser desestruturado. É possível criar uma estrutura sem marcação usando:
- ALL CAPS SECTION LABELS (exibidos da mesma forma em qualquer lugar)
- Quebras de linha entre as seções
- Frases numeradas: '1. Primeiro ponto. 2. Segundo ponto.'
- Travessões para separação: 'Insight principal — verifique sempre antes de agir.'
- Indentação consistente com espaços (para saída de terminal)
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
response = client.chat.completions.create(
model='gpt-4o',
messages=[{
'role': 'user',
'content': (
'Write a daily briefing for a developer — 3 sections: TASKS, BLOCKERS, NOTES. '
'Format: plain text only. '
'Use ALL CAPS section labels followed by a colon. '
'Use a line break between sections. '
'Number each item within a section. '
'No markdown symbols of any kind. '
'Use realistic placeholder content.'
)
}]
)
print(response.choices[0].message.content)Detecção do formato de saída
Em aplicativos de produção, é possível detectar programaticamente o ambiente de saída e inserir automaticamente a instrução de formato adequada — assim, nunca será necessário especificá-la manualmente em cada instrução.
Esse é um padrão comum em sistemas de IA multicanal que fornecem o mesmo conteúdo para consumidores web, móveis e de API.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
def get_format_instruction(channel):
formats = {
'web': 'Use markdown formatting: headers, bold, bullet points, code blocks.',
'email': 'Plain text only. No markdown symbols. Use line breaks between sections.',
'sms': 'Plain text. Single paragraph. Max 160 characters.',
'voice': 'Plain text. No symbols. Natural spoken sentences only. Spell out numbers.',
'api': 'JSON output only. No prose.',
}
return formats.get(channel, 'Plain text only.')
def ask_with_channel(question, channel):
fmt = get_format_instruction(channel)
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=100,
system=f'Format instruction: {fmt}',
messages=[{'role': 'user', 'content': question}]
)
return response.content[0].text
q = 'What are 3 benefits of regular code reviews?'
for ch in ['web', 'sms', 'voice']:
print(f'[{ch.upper()}]:')
print(ask_with_channel(q, ch)[:150])
print()Verificação de conhecimento
Um desenvolvedor cria um chatbot de IA para atendimento ao cliente que envia as respostas para um CRM antigo que armazena texto simples. A IA continua produzindo respostas com ** para negrito e - para marcadores, que são exibidos como caracteres brutos no CRM. Qual é a correção mais confiável?
Texto simples versus saída formatada — recapitulação
A escolha do formato adequado depende do ambiente de saída. Regras principais:
- Use marcação quando o ambiente a renderizar: interfaces web, aplicativos de notas, GitHub e documentação
- Use texto simples para textos de e-mail, SMS, voz, CRMs e fluxos de processamento de API
- Use JSON/CSV quando o código processar a saída
- Solicite texto simples listando explicitamente o que deve ser evitado: sem asteriscos, sem sinais de cerquilha e sem marcadores
- Defina as regras de formatação uma vez na mensagem do sistema para garantir um comportamento consistente do aplicativo
- O texto simples ainda pode ter estrutura por meio de CAPS LABELS, quebras de linha e frases numeradas
Perguntas Frequentes
A aula “Texto simples versus resultado formatado” é grátis?
Sim — o texto completo de “Texto simples versus resultado formatado” é 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 “Texto simples versus resultado formatado”?
Quando solicitar texto simples e limpo em vez de um resultado em markdown avançado. 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 4 de 4.
Quanto tempo leva a aula “Texto simples versus resultado formatado”?
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
- Solicitando listas e tópicos
- Solicitando tabelas e dados estruturados
- Formatação markdown nas solicitações
- Texto simples versus resultado formatado