Quer trabalhar com IA? Comece por aqui

Tem uma hora exata em que a IA deixa de parecer mágica e vira uma ferramenta de trabalho: é quando você entende como ela funciona. Não nos detalhes de engenheiro, mas o suficiente pra usar bem, saber quanto ela está te custando e continuar no controle.

Como uma IA realmente pensa

Os tokens: a unidade de medida escondida

Quando você escreve pra uma IA, ela não lê palavras. Ela lê tokens: pedacinhos de texto. Um token pode ser uma palavra inteira ("casa"), um pedaço de palavra ("inteligên" + "cia") ou só um sinal de pontuação.

Mas por que picar o texto assim, em vez de trabalhar com palavras inteiras?

Se o modelo só conhecesse palavras completas, qualquer palavra que ele nunca viu o travaria na hora: um erro de digitação, um nome próprio, um termo técnico, uma palavra estrangeira. Tudo o que estivesse fora do vocabulário dele virava um buraco negro. Com os pedacinhos, é o contrário: ele reconstrói até o que nunca encontrou, juntando partes que já conhece — e é por isso que ele te entende mesmo quando você digita com pressa e escreve umas palavras que mal fazem sentido! 😉

Então é melhor descer até as letras soltas?

Também não, porque quanto menor a unidade, mais tokens você precisa pra dizer a mesma coisa — e o trabalho do modelo cresce bem mais rápido que o número de tokens: dobrar os tokens não dobra o esforço, ele explode. O token é o ponto certo: grande o bastante pra continuar eficiente, pequeno o bastante pra nunca engasgar numa palavra nova.

Na IA, tudo é contado em tokens — o quanto você escreve, o quanto o modelo responde — e é em cima deles que se calcula quanto você paga, na entrada e na saída. Não é curiosidade técnica: é a unidade com que se mede trabalho e custo.

O custo dos modelos: por que duas respostas parecidas têm custos diferentes

Todo modelo tem a sua tabela de preço, em geral cotada em custo por milhão de tokens. E aqui vem a primeira surpresa: a mesma pergunta, feita pra dois modelos diferentes, pode custar vinte vezes mais.

Os modelos mais potentes são mais caros de rodar, então custam mais por token: um modelo leve te sai por alguns centavos onde um de ponta pede alguns euros. Daí uma regra prática: nem sempre você precisa do modelo mais potente. Pra resumir um e-mail ou triar pedidos, o leve dá conta lindamente por uma fração do preço; o caro você guarda pra quando precisa mesmo que ele pense — uma análise complicada, código sensível, um texto que tem de ficar redondo. Casar o modelo com a tarefa já é metade do controle de custo.

Tem uma segunda coisa que pesa na conta: entrada e saída não têm o mesmo preço. Os tokens que você manda — prompt, documentos, histórico da conversa — são a entrada. Os que o modelo escreve de volta são a saída, e quase sempre custam mais, muitas vezes o triplo ou o quádruplo por token.

Tudo se resume a onde vai o esforço. Ler o seu prompt é a parte fácil: o modelo absorve tudo de uma vez. Escrever a resposta é o trabalho de verdade — ele solta um token de cada vez e, a cada passo, decide qual vem depois levando em conta tudo o que já escreveu. A energia vai pra escrita, não pra leitura. É por isso que você paga mais pela saída e menos pela entrada.

O contexto: a memória de trabalho do modelo

O contexto é tudo o que o modelo tem na frente enquanto te responde: a sua pergunta, as instruções, os documentos que você passou, a conversa até agora.

Duas coisas pra saber. A primeira: o contexto tem um teto, a janela de contexto, também medido em tokens. Quando é grande, você joga ali contratos ou relatórios inteiros; quando é pequena, tem de escolher bem o que entra. A segunda, menos óbvia: você paga pelo contexto inteiro, a cada mensagem. Numa conversa longa, cada nova linha faz o modelo reler tudo o que veio antes. É por isso que os chats intermináveis ficam lentos e caros: vão arrastando uma carga cada vez mais pesada.

Pensa numa escrivaninha. O contexto é o espaço sobre a mesa: você mantém ali os documentos de que precisa agora. Enche de papel inútil e você trabalha pior. Manter a mesa limpa — dar ao modelo só o que de fato serve — é uma habilidade de verdade.

E qual o tamanho da janela?

Cada vez maior. Ao lado do nome de um modelo você vê com frequência um número tipo 1M: a janela comporta um milhão de tokens, hoje quase o máximo que existe. São centenas de páginas: em tese, cabem documentos inteiros ou conversas longuíssimas.

Em tese. Porque ter o espaço não quer dizer que valha a pena encher: quanto mais você carrega o contexto, piores ficam as respostas. Soterrado por milhares de linhas, o modelo perde o fio do que importa — já lá pelos 300.000 tokens ele começa a perder precisão e a "esquecer" coisas importantes. É um limite de hoje, que vai amenizar conforme os modelos melhoram, mas por ora precisa entrar na conta. O objetivo não é encher a janela: é nunca chegar perto do fundo.

Na prática, dois hábitos cobrem quase tudo:

• Compacte com frequência. Vá por etapas: a cada marco, escreva um resumo curto de onde você chegou, recomece a partir dele e deixe o resto pra trás. Uma conversa enxuta roda muito melhor do que uma que arrasta cada linha desde o começo. Algumas ferramentas fazem isso sozinhas — ChatGPT e Claude cuidam do contexto nos bastidores, descartando as mensagens mais antigas conforme o chat se estica. Outras, feitas pra quem trabalha a fundo (Claude Code, por exemplo), deixam o controle com você: a compactação você dispara na mão, com um comando tipo /compact.
• Um assunto por sessão. Trabalhos diferentes, chats diferentes. Não use o mesmo fio pra escrever um e-mail pra um cliente, ajeitar uma planilha e depois buscar ideias pra um post: cada assunto deixa resíduo que embola o seguinte. Abrir um chat novo não custa nada, e quase sempre é a jogada certa.

Modelos simples e modelos complexos: a diferença que conta

A gente tende a achar que o modelo mais caro é o melhor. Na real, é mais útil imaginar os modelos como um time com papéis diferentes.

Um modelo leve é rápido e econômico, ótimo pra tarefas bem definidas e repetitivas: extrair dados, classificar, responder perguntas de rotina, soltar primeiros rascunhos. É o estagiário esperto: você dá uma tarefa clara e ele resolve num instante.

Um modelo de ponta é mais lento e mais caro, mas aguenta o pensamento mais elaborado, as nuances, os problemas de vários passos. É o consultor sênior: você paga mais, mas só chama quando a coisa é séria.

Saber alternar os dois — leve pro volume, potente pros nós difíceis — é o que separa quem usa a IA com critério de quem usa no improviso.

Linguagem ou multimodal: o que o modelo "vê"

Os primeiros modelos entendiam e produziam só texto: são os modelos de linguagem. Você escreve, eles escrevem.

Os modelos multimodais lidam com vários tipos de dado ao mesmo tempo: texto, imagens, às vezes áudio e vídeo. Você mostra a foto de uma nota fiscal e ele tira os valores, manda a captura de um gráfico e ele comenta, passa uma imagem e ele te diz o que tem ali.

Uma distinção útil: multimodal na entrada e na saída. Na entrada quer dizer que o modelo pode receber coisas além de texto — fotos, PDF, áudio, vídeo. Na saída, que ele pode produzir essas coisas — não só escrever, mas gerar uma imagem ou uma voz. Os modelos de ponta de hoje (GPT-5.5, Gemini 3, Claude Opus 4.7) engolem quase tudo na entrada; o que produzem na saída varia bastante de um pro outro, então vale conferir caso a caso.

Aqui pintam algumas siglas, que vale decifrar de uma vez por todas:

• STT (Speech-To-Text): de voz pra texto. A transcrição automática — você fala, e aparece escrito. Você também encontra como ASR (Automatic Speech Recognition).
• TTS (Text-To-Speech): de texto pra voz. O caminho inverso — você escreve, e o modelo lê em voz alta.
• Text-to-Image (às vezes TTI): de texto pra imagem. Você descreve o que quer e o modelo desenha — é o coração de ferramentas como Midjourney ou DALL·E.
• Image-to-Image (img2img): de imagem pra imagem. Você parte de uma imagem e transforma — muda o estilo, retoca, estende pra além das bordas.

A pergunta prática, pra você que decide o que automatizar, é uma só: o material de partida é só texto, ou tem também imagens e documentos visuais?

Digitalizações, fotos, PDF cheios de tabelas: você precisa de um multimodal. Só texto: um modelo de linguagem dá conta de sobra.

O prompt que faz a diferença

Na maioria das vezes, a diferença entre um resultado medíocre e um ótimo não está no modelo, mas em como você pede.

O prompt é a instrução que você dá pra IA, e a qualidade da resposta acompanha a do pedido. Um prompt vago ("escreve algo sobre marketing") dá um resultado vago. Um afiado — com papel, contexto, objetivo, formato e exemplos — dá algo que dá pra usar.

Vale saber, principalmente quando você começa a usar a IA dentro das suas ferramentas e não só no chat, que existem três tipos de prompt.

• System (sistema): as instruções de base — quem o modelo é e como ele se comporta. Papel, tom, regras pra respeitar sempre. É a moldura de toda a conversa e normalmente fica escondido: num app ou num assistente pronto, o system prompt foi escrito por quem construiu e você nem vê.
• User (usuário): aquilo que você pede, mensagem por mensagem.
• Assistant (assistente): as respostas do modelo, que também fazem parte do prompt — a cada nova mensagem ele relê também o que já disse.

No chat do dia a dia esses três tipos ficam nos bastidores: você simplesmente escreve. Mas assim que você trabalha via API ou monta um assistente seu, entender a diferença é o que te deixa dar a ele uma identidade estável (no system), separada de cada pedido (no user).

Três hábitos que mudam os resultados na hora:

• Seja específico sobre contexto e objetivo. Não "faz um e-mail", mas "escreve um follow-up pra um cliente PME que sumiu há duas semanas, tom cordial mas direto, no máximo 120 palavras".
• Mostre um exemplo. Uma amostra de como é um bom resultado vale mais que mil explicações.
• Itere. Trate o primeiro prompt como um rascunho: você refina, acrescenta uma restrição, melhora passo a passo. Cada ajustezinho se acumula.

Escrever bons prompts não é truque de quem fuça em computador: é a habilidade com o melhor retorno sobre o investimento.

As ferramentas de que você precisa

Entender os conceitos é metade do serviço; a outra metade é o ambiente em que você trabalha. Não são "coisa de programador": são a bancada de qualquer um que queira construir algo sério com a IA — scripts, integrações, projetinhos que ficam de pé com o tempo.

Git: a máquina do tempo para os seus arquivos

O Git acompanha cada mudança nos seus arquivos. Toda vez que você salva um estado (um commit), ele tira um instantâneo: você pode voltar pra qualquer versão, ver o que mudou e quando, e testar ideias diferentes em paralelo sem quebrar a que já funciona.

Imagina o histórico de versões de um documento compartilhado, só que muito mais potente e pra qualquer tipo de arquivo. O valor não é só técnico: é dormir tranquilo, sabendo que nada se perde e que todo erro dá pra desfazer.

Mas você precisa mesmo disso?

Pergunta justa — no começo o Git pode assustar — e a resposta depende de como você trabalha. Se você é freelancer e roda 90% na própria máquina, usando o Claude ou outro agente local pros seus arquivos (projetos, second brain, notas fiscais), provavelmente o Git não te serve: basta um drive sincronizado na nuvem (Google Drive, OneDrive, Dropbox) que mantém um backup sempre atualizado. Simples, automático, resolvido.

O Git ganha valor na hora em que mais de um par de mãos passa a mexer nos mesmos arquivos: você trabalha em equipe nos mesmos projetos — local ou na nuvem — e hoje, entre os "membros da equipe", estão também os agentes.

Um exemplo do meu setup. Tudo cai na minha inbox: links, ideias, fotos, anotações. Mas entra por portas diferentes — às vezes escrevo nas notas do iPhone, às vezes mando um áudio pra um agente que transcreve (STT) e faz commit do texto direto no GitHub. Aí a mesma pasta é tocada pelo meu PC e por um agente que escreve da nuvem, às vezes no mesmo minuto. Sem o Git pra conciliar essas sobreposições e juntar tudo sem perder nada, eu estaria perdido.

A regra de bolso, então:

• Você trabalha sozinho e está começando com os agentes locais?
  Um drive sincronizado como backup já basta de sobra.
• Você tem um second brain compartilhado com os seus sócios, ou várias fontes — você mais os seus agentes — escrevendo nos mesmos arquivos?
  Aí o Git deixa de ser brinquedo de dev e vira a única coisa que segura tudo junto.

Um ponto a favor que agrada: o Git é grátis. Pra começar você se apoia no GitHub ou no GitLab, com planos gratuitos mais que suficientes. E se você tem dados que prefere não confiar a um provedor externo, o Git é open source: você sobe um servidor self-hosted (Gitea ou GitLab CE) num VPS seu e mantém tudo em casa. Mesma ferramenta, controle total.

Arquivos .md (Markdown): documentar sem esforço

O Markdown (os arquivos .md) é um jeito de escrever texto formatado — títulos, listas, negrito, links — com sinais simples, sem Word e sem menus. Um # faz um título, um traço faz uma lista, dois asteriscos fazem o negrito.

É leve, dá pra ler assim como está, e funciona em qualquer lugar. É o padrão pra documentar projetos e tomar notas organizadas e — não por acaso — o formato em que a gente muitas vezes conversa com as IAs. As quatro regras básicas você aprende em dez minutos.

Tem mais um motivo, e diz respeito à IA: um Markdown desce muito mais fácil que um PDF. O PDF nasceu pra impressão e está entupido de dados de diagramação que não servem pro modelo e só entulham o contexto dele; o Markdown é texto limpo. Pro mesmo conteúdo, ocupa menos da janela e deixa o modelo com a cabeça mais clara.

E a melhor parte: deixe a IA gerar e arrumar os seus .md — pedindo pra ela manter tudo enxuto — e é ela quem vai colocar as ligações entre as notas (os wikilinks), os índices, as referências cruzadas. Na prática ela te monta de mansinho um pequeno second brain navegável, sem que você diagrame nada.

"Mas eu tenho uma montanha de PDF, e agora?"

Depende do uso:

• PDF de trabalho diário que a IA precisa reler toda vez (manuais, fichas, documentos de referência): converta uma vez pra Markdown e guarde essas versões como cópias de trabalho. Entram no contexto limpos e leves.
• PDF de arquivo dos quais só interessa o dado agregado (extratos bancários, notas fiscais, recibos): não dê pra IA um por um. No fim do mês, puxe os números de que você precisa pra um CSV ou uma planilha e trabalhe em cima disso. Uma tabela organizada vale cem PDF folheados um a um.

Uma última dica: pra ler e gerenciar os .md sem dor de cabeça existe o Obsidian, um app gratuito feito exatamente pra isso. Ele mostra tudo formatado, segue as ligações entre notas com um clique e transforma uma pasta de .md num arquivo navegável de verdade.

API e OAuth: conectar as suas ferramentas

Uma API é o jeito como dois softwares trocam informação: um programa manda uma requisição num formato combinado, o outro responde, de forma automática e sempre igual. As regras do diálogo — quais requisições são permitidas e que forma tem a resposta — são fixadas por quem disponibiliza a API. Você não faz o que quer: usa só as operações previstas, do jeito previsto.

Por que elas importam tanto?

Porque hoje as APIs são o conector principal entre todas as suas ferramentas, as suas e as de terceiros. Quase todo serviço sério — Gmail, Asana, Trello, o seu sistema de gestão, até o banco — tem uma API: é a porta por onde passam as automações e o jeito de uma ferramenta conversar com a outra. E é também como uma IA trabalha dentro das suas ferramentas, não só no chat dela.

Mas pra bater nessa porta você precisa se identificar, e tem dois jeitos pra separar:

• Chave API (API key): um código secreto que você gera no painel do serviço e que diz "sou eu". Você usa nas suas automações, onde controla as duas pontas. Precisa guardar com cuidado — mais adiante, nos arquivos .env, a gente vê como.
• OAuth: o "aperto de mão de permissão". Em vez de copiar uma chave, você clica em Conectar, faz login e autoriza o app a entrar — sem nunca entregar a senha. É o que acontece quando você conecta o Asana ou o Trello ao Claude: uma tela pede permissão, você concede, e a partir dali as duas ferramentas conversam. O acesso você revoga quando quiser, e a senha nunca passa de mão.

Uma distinção que custa dinheiro de verdade: assinatura ou API por consumo?

Usar o Claude ou o ChatGPT pelos apps deles, com a assinatura mensal fixa, é cômodo pro dia a dia: você paga um valor fixo e ganha a interface pronta.

Via API — pelo Console da Anthropic ou pela Platform da OpenAI — funciona de outro jeito: sem mensalidade, você paga por consumo, por token (lembra da entrada e da saída?). É o caminho pra embutir a IA nas suas ferramentas ou automações: mais flexível e potente, mas olho no medidor — com os modelos de ponta os valores sobem rápido, e quem acompanha a conta é você.

Pra se orientar:

• Você usa o Claude todo dia e quer conectar a ele Gmail, Asana, Drive, Calendar?
  Assinatura + OAuth. Você paga o valor fixo e liga as suas ferramentas com um clique, sem tocar numa chave.
• Você está construindo agentes — na nuvem ou localmente — em cima de modelos da OpenAI ou da Anthropic?
  Gere uma chave API e adicione ao projeto: você acessa todos os modelos do provedor, em geral uma lista mais ampla do que a do pacote mensal.

Por fim, uma ferramenta prática: o Postman te deixa testar uma API sem ainda escrever um programa. Você preenche a requisição numa interface visual, aperta enviar, vê a resposta. É a academia ideal pra entender como um serviço se comporta antes de integrar de verdade — sem medo de quebrar nada.

Python & Cia: quando você quer construir algo seu

Aviso honesto: aqui entramos no terreno "avançado", então vou ser breve.

Você quer ir além e criar uns softwares seus?

Não trave logo de cara no "qual linguagem eu uso? como eu desenvolvo?". Depende do que você quer fazer, mas com um punhado de ferramentas populares e bem documentadas você já vai longe.

Antes, dois termos que você vai ouvir em todo canto:

• Stack: o conjunto de ferramentas com que você constrói um software — a linguagem, o banco de dados, a interface. "Escolher um stack" é decidir com quais blocos você levanta a aplicação.
• Frontend e backend: o frontend é o que o usuário vê e mexe — telas, botões, formulários. O backend é o motor por trás da cortina — lógica e dados, que o usuário não vê. É como num restaurante: o salão é o frontend, a cozinha é o backend.

Um stack sólido e bem usado pra começar: Python ou Node.js (JavaScript) pra lógica, PostgreSQL como banco de dados, e um framework JavaScript como React ou Next.js pro frontend. Ferramentas super populares, cheias de guias e exemplos, e bem conhecidas pelas IAs que te ajudam a escrever o código.

Duas palavras sobre as linguagens que você vai encontrar mais.

O Python é a referência pra dados e IA: dá pra ler quase como inglês, tem uma biblioteca pra quase tudo, e é o ponto de encontro natural entre automação e inteligência artificial. No dia em que você quiser que uma IA processe dados de forma sistemática, quase certamente vai fazer isso aqui.

O Node.js é o JavaScript fora do navegador: a mesma linguagem das páginas web, mas rodando no seu computador ou num servidor. É a escolha natural pros apps web e tudo o que vive online. O bônus: aprendeu JavaScript, você usa tanto no frontend quanto no backend.

O Bash é a linguagem do terminal, a linha de comando: mover arquivos, encadear programas, automatizar operações. E está voltando à moda por um motivo bem claro: é assim que um agente no seu PC fala com o computador. Quando um agente local cria um arquivo, abre uma pasta ou roda um comando, é Bash por baixo. Entender o básico vale a pena, nem que seja só pra saber o que ele está fazendo no seu lugar.

Variáveis de ambiente e arquivos .env: os segredos a salvo

Quando um programa chama uma IA via API, ele precisa se identificar com uma chave secreta. Essa chave é como a senha do seu cartão: quem tem ela gasta no seu nome.

A regra de ouro: nunca escreva chaves e senhas no código. Guarde à parte, em variáveis de ambiente — valores que vivem fora do programa — em geral num arquivo .env. O programa lê de lá, e esse arquivo continua privado: nunca compartilhado, nunca publicado.

É o cofre: os valores importantes ficam dentro, não pintados na parede. É um dos primeiros hábitos de segurança pra adotar, e um dos mais ignorados por quem começa — uma chave roubada significa custo real na sua conta.

Um exemplo de quão concreto isso é: com a IA, muita gente se jogou a programar sem dominar o básico, e acaba publicando as próprias chaves API no GitHub, às vezes em repositórios públicos. O problema é que já tem gente que vasculha esses repositórios de propósito, à caça de chaves pra usar de graça — às custas do azarado.

Um pouco de documentação: o presente que você dá a si mesmo

Por fim, o hábito mais subestimado de todos: anotar duas linhas sobre o que uma coisa faz e por quê. Um arquivo de notas, uma linha sobre o motivo de uma escolha.

Você não precisa de um manual. Só do mínimo que deixa o seu-eu-daqui-a-seis-meses — que vai ter esquecido tudo — retomar aquilo em cinco minutos em vez de numa tarde inteira. A documentação é uma carta pro seu eu futuro, e o seu futuro vai te agradecer toda vez.

Dois jeitos práticos de não deixar isso ao acaso:

• Se você usa o Git, apoie-se nas issues: fichas embutidas no repositório onde você acompanha tarefas, bugs e ideias pra não perder. Ficam ligadas ao projeto e ao seu histórico, então a to-do list vive ao lado do trabalho em vez de espalhada em dez lugares.
• Se você não usa o Git, peça ao seu agente local pra manter a documentação em ordem: arquivos de index que funcionam como mapa, arquivos de sessão que registram o que você fez e quando. Você configura uma vez, e ele cuida do resto.

O quadro completo

De um lado você entendeu como uma IA pensa: os tokens com que ela mede — e cobra — tudo, entrada e saída inclusas; o custo que muda enormemente entre um modelo leve e um de ponta; o contexto pra manter limpo como uma escrivaninha, compactar com frequência e nunca encher até o fundo; a diferença entre linguagem e multimodal; e os prompts — com os papéis system, user e assistant — como alavanca principal pra resultados melhores.

Do outro você tem a bancada de trabalho: o Git pra não perder nada (quando você precisa mesmo), o Markdown pra documentar e conversar melhor com a IA, as API com chave ou OAuth pra conectar as suas ferramentas, a escolha entre assinatura e consumo, Python, Node e Bash pra construir algo seu, os arquivos .env pros segredos, e um pouco de documentação pro você de amanhã.

Nenhum desses conceitos exige um doutorado. Basta ver uma vez com clareza — e então eles viram a linguagem comum com que você pega a IA na mão e usa com critério.