{"id":1153,"date":"2026-08-28T04:01:39","date_gmt":"2026-08-28T07:01:39","guid":{"rendered":"https:\/\/adrianosantostreina.com.br\/blog\/investigar-erros-com-ia-de-forma-estruturada\/"},"modified":"2026-08-28T04:01:46","modified_gmt":"2026-08-28T07:01:46","slug":"investigar-erros-com-ia-de-forma-estruturada","status":"publish","type":"post","link":"https:\/\/adrianosantostreina.com.br\/blog\/investigar-erros-com-ia-de-forma-estruturada\/","title":{"rendered":"O Print da Exce\u00e7\u00e3o N\u00e3o \u00e9 o Bug: Como Investigar Erros com IA de Forma Estruturada"},"content":{"rendered":"<p>S\u00e3o 16h37. Uma funcionalidade que funcionava desde a \u00faltima sexta-feira parou de funcionar hoje de manh\u00e3. N\u00e3o houve deploy novo, ningu\u00e9m mexeu naquele m\u00f3dulo, e o log mostra apenas uma linha gen\u00e9rica: <code>NullReferenceException<\/code> em um arquivo com quatrocentas linhas. Voc\u00ea abre o arquivo, olha para o ponto indicado pela pilha de chamadas, n\u00e3o encontra nada \u00f3bvio, e come\u00e7a a colocar <code>print<\/code> (ou <code>console.log<\/code>, ou <code>ShowMessage<\/code>, dependendo da linguagem) em cada linha suspeita. Quarenta minutos depois, voc\u00ea ainda n\u00e3o sabe a causa, s\u00f3 sabe que &#8220;o problema est\u00e1 em algum lugar ali&#8221;.<\/p>\n<p>Essa cena se repete todos os dias em equipes de desenvolvimento, em qualquer linguagem \u2014 Python, Java, C#, JavaScript, Delphi, n\u00e3o importa. Depurar c\u00f3digo (ou seja, investigar por que um programa n\u00e3o se comporta como esperado) \u00e9 uma das tarefas que mais consome tempo no dia a dia de quem programa, e \u00e9 tamb\u00e9m uma das que mais gera frustra\u00e7\u00e3o, porque o tempo investido nem sempre \u00e9 proporcional ao tamanho do problema: \u00e0s vezes um bug gigante se resolve em cinco minutos, e um erro aparentemente bobo consome a tarde inteira.<\/p>\n<p>Neste artigo voc\u00ea vai aprender, de forma simples e sem pressupor nenhuma ferramenta avan\u00e7ada instalada, como usar intelig\u00eancia artificial (IA) para investigar erros de c\u00f3digo de maneira estruturada \u2014 n\u00e3o como uma m\u00e1gica que &#8220;conserta sozinho&#8221;, mas como um m\u00e9todo que reduz o tempo gasto tateando no escuro. Vamos do conceito b\u00e1sico at\u00e9 exemplos pr\u00e1ticos em c\u00f3digo, para que voc\u00ea possa aplicar isso ainda hoje.<\/p>\n<h2>O problema real: por que depurar sozinho \u00e9 lento<\/h2>\n<p>Antes de falar de IA, vale entender por que a depura\u00e7\u00e3o tradicional consome tanto tempo. Normalmente, o processo segue mais ou menos este roteiro:<\/p>\n<ul>\n<li>Voc\u00ea l\u00ea a mensagem de erro, mas ela raramente explica <em>por que<\/em> o erro aconteceu \u2014 s\u00f3 descreve <em>o que<\/em> aconteceu.<\/li>\n<li>Voc\u00ea tenta reproduzir o erro, o que j\u00e1 \u00e9 dif\u00edcil quando ele depende de uma condi\u00e7\u00e3o espec\u00edfica de dados ou de ambiente.<\/li>\n<li>Voc\u00ea adiciona instru\u00e7\u00f5es de log ou usa um depurador (debugger \u2014 ferramenta que permite pausar a execu\u00e7\u00e3o do programa e inspecionar valores de vari\u00e1veis) para ir descobrindo o estado do programa passo a passo.<\/li>\n<li>Voc\u00ea formula hip\u00f3teses (&#8220;talvez seja isso&#8221;) e as testa uma a uma, muitas vezes sem um racioc\u00ednio expl\u00edcito, s\u00f3 por instinto.<\/li>\n<\/ul>\n<p>O problema n\u00e3o \u00e9 que esse processo esteja errado \u2014 ele funciona. O problema \u00e9 que ele \u00e9 <strong>lento e artesanal<\/strong>: voc\u00ea guarda toda a hip\u00f3tese e todo o hist\u00f3rico do problema na pr\u00f3pria cabe\u00e7a, e a cada nova pista precisa reconstruir o racioc\u00ednio. \u00c9 exatamente a\u00ed que a IA pode ajudar, n\u00e3o substituindo seu racioc\u00ednio, mas servindo como um investigador auxiliar que l\u00ea r\u00e1pido, lembra do que foi dito e ajuda a organizar hip\u00f3teses.<\/p>\n<blockquote><p><strong>\ud83d\udca1 Dica do Mestre:<\/strong> segundo a IBM, &#8220;a depura\u00e7\u00e3o com IA geralmente ocorre por meio de assistentes de programa\u00e7\u00e3o incorporados ou constru\u00eddos ao redor do ambiente de desenvolvimento, analisando c\u00f3digo, mensagens de erro e contexto de execu\u00e7\u00e3o para sugerir causas prov\u00e1veis e corre\u00e7\u00f5es&#8221;. Veja a explica\u00e7\u00e3o completa em <a href=\"https:\/\/www.ibm.com\/br-pt\/think\/topics\/ai-debugging\" target=\"_blank\" rel=\"noopener\">Depura\u00e7\u00e3o com IA \u2014 IBM<\/a>.<\/p><\/blockquote>\n<h2>O que \u00e9, de fato, &#8220;debugging com IA&#8221;<\/h2>\n<p>Debugging com IA n\u00e3o \u00e9 apenas colar a mensagem de erro em um chat e esperar a resposta. Isso at\u00e9 funciona para erros simples, mas para problemas reais \u2014 os que consomem sua tarde \u2014 funciona melhor quando voc\u00ea trata a IA como um assistente que precisa de <strong>contexto<\/strong> (as informa\u00e7\u00f5es relevantes sobre o problema) para gerar hip\u00f3teses \u00fateis.<\/p>\n<p>Pense na analogia de um m\u00e9dico. Um bom diagn\u00f3stico n\u00e3o nasce de &#8220;estou com dor&#8221;, mas de sintomas descritos com precis\u00e3o, exames e hist\u00f3rico. Da mesma forma, um bom diagn\u00f3stico de bug n\u00e3o nasce de &#8220;est\u00e1 dando erro&#8221;, mas de: mensagem de erro completa, trecho de c\u00f3digo relevante, o que era esperado, o que de fato aconteceu, e o que j\u00e1 foi tentado.<\/p>\n<h3>Os quatro elementos de um bom pedido de investiga\u00e7\u00e3o<\/h3>\n<p>Sempre que for pedir ajuda de uma IA para investigar um bug, tente reunir estas quatro informa\u00e7\u00f5es antes de perguntar:<\/p>\n<ul>\n<li><strong>Comportamento esperado:<\/strong> o que o c\u00f3digo deveria fazer.<\/li>\n<li><strong>Comportamento observado:<\/strong> o que ele est\u00e1 fazendo de fato, incluindo a mensagem de erro completa (n\u00e3o resumida).<\/li>\n<li><strong>C\u00f3digo relevante:<\/strong> a fun\u00e7\u00e3o ou trecho onde o problema aparece, com contexto suficiente (n\u00e3o a linha isolada).<\/li>\n<li><strong>O que j\u00e1 foi tentado:<\/strong> hip\u00f3teses descartadas, para a IA n\u00e3o repetir o mesmo caminho.<\/li>\n<\/ul>\n<p>Vamos ver isso na pr\u00e1tica.<\/p>\n<h2>Exemplo pr\u00e1tico 1: um erro cl\u00e1ssico em Python<\/h2>\n<p>Imagine a seguinte fun\u00e7\u00e3o, que deveria calcular a m\u00e9dia de notas de uma lista de alunos:<\/p>\n<pre><code class=\"language-python\">def calcular_media(notas):\n    total = 0\n    for nota in notas:\n        total += nota\n    return total \/ len(notas)\n\nalunos = {\n    \"Ana\": [8, 7, 9],\n    \"Bruno\": [],\n    \"Carla\": [6, 7, 5]\n}\n\nfor nome, notas in alunos.items():\n    media = calcular_media(notas)\n    print(f\"{nome}: {media:.2f}\")\n<\/code><\/pre>\n<p>Ao rodar, o programa quebra com:<\/p>\n<pre><code>ZeroDivisionError: division by zero\n<\/code><\/pre>\n<p>Um pedido malfeito para a IA seria: &#8220;meu c\u00f3digo d\u00e1 erro de divis\u00e3o por zero, conserta&#8221;. Um pedido bem estruturado, seguindo os quatro elementos acima, seria assim:<\/p>\n<pre><code>Comportamento esperado: calcular a m\u00e9dia de notas de cada aluno e imprimir o resultado.\n\nComportamento observado: o programa quebra com \"ZeroDivisionError: division by zero\"\nao processar o aluno \"Bruno\", que tem uma lista de notas vazia.\n\nC\u00f3digo relevante:\ndef calcular_media(notas):\n    total = 0\n    for nota in notas:\n        total += nota\n    return total \/ len(notas)\n\nO que j\u00e1 tentei: nada ainda, \u00e9 a primeira vez que vejo esse erro.\n\nPergunta: por que esse erro acontece e qual seria uma forma segura\nde tratar o caso de lista vazia sem quebrar o programa?\n<\/code><\/pre>\n<p>Com esse contexto, a resposta da IA tende a ser precisa: o erro ocorre porque <code>len(notas)<\/code> \u00e9 zero quando a lista est\u00e1 vazia, e a divis\u00e3o por zero n\u00e3o \u00e9 permitida. A corre\u00e7\u00e3o sugerida costuma ser algo como:<\/p>\n<pre><code class=\"language-python\">def calcular_media(notas):\n    if not notas:\n        return 0.0  # ou None, dependendo da regra de neg\u00f3cio\n    total = sum(notas)\n    return total \/ len(notas)\n<\/code><\/pre>\n<p>Note que o ganho de tempo n\u00e3o veio da IA &#8220;adivinhar&#8221; o problema \u2014 veio de voc\u00ea ter fornecido contexto suficiente para que a causa fosse \u00f3bvia na primeira tentativa, em vez de um ciclo de perguntas e respostas incompletas.<\/p>\n<h2>Exemplo pr\u00e1tico 2: erro ass\u00edncrono em JavaScript<\/h2>\n<p>Erros que envolvem c\u00f3digo ass\u00edncrono (c\u00f3digo que n\u00e3o executa de forma imediata e sequencial, como chamadas de rede) costumam ser mais dif\u00edceis de depurar porque a pilha de erros muitas vezes n\u00e3o aponta diretamente para a causa. Veja este exemplo:<\/p>\n<pre><code class=\"language-javascript\">async function buscarUsuario(id) {\n  const resposta = await fetch(`https:\/\/api.exemplo.com\/usuarios\/${id}`);\n  const dados = await resposta.json();\n  return dados;\n}\n\nasync function exibirNomeUsuario(id) {\n  const usuario = await buscarUsuario(id);\n  console.log(usuario.nome.toUpperCase());\n}\n\nexibirNomeUsuario(999);\n<\/code><\/pre>\n<p>Se o usu\u00e1rio com id 999 n\u00e3o existir, a API pode responder com um corpo de erro (por exemplo, <code>{ \"erro\": \"n\u00e3o encontrado\" }<\/code>), sem o campo <code>nome<\/code>. O programa ent\u00e3o quebra com:<\/p>\n<pre><code>TypeError: Cannot read properties of undefined (reading 'toUpperCase')\n<\/code><\/pre>\n<p>Um pedido estruturado para a IA, neste caso, incluiria tamb\u00e9m a resposta real da API, n\u00e3o s\u00f3 o c\u00f3digo:<\/p>\n<pre><code>Comportamento esperado: buscar um usu\u00e1rio pelo id e exibir o nome em mai\u00fasculas.\n\nComportamento observado: erro \"Cannot read properties of undefined (reading 'toUpperCase')\"\nquando o id n\u00e3o existe na base. A resposta da API nesse caso \u00e9:\n{ \"erro\": \"n\u00e3o encontrado\" }\n\nC\u00f3digo relevante: [colar as duas fun\u00e7\u00f5es acima]\n\nO que j\u00e1 tentei: confirmei que o fetch est\u00e1 retornando status 404,\nmas n\u00e3o estou tratando esse caso.\n\nPergunta: como devo validar a resposta antes de tentar acessar \"nome\",\nde forma que o erro fique claro em vez de quebrar o programa?\n<\/code><\/pre>\n<p>A resposta tende a sugerir uma verifica\u00e7\u00e3o expl\u00edcita do formato de resposta antes de usar os dados:<\/p>\n<pre><code class=\"language-javascript\">async function buscarUsuario(id) {\n  const resposta = await fetch(`https:\/\/api.exemplo.com\/usuarios\/${id}`);\n  if (!resposta.ok) {\n    throw new Error(`Usu\u00e1rio ${id} n\u00e3o encontrado (status ${resposta.status})`);\n  }\n  return resposta.json();\n}\n\nasync function exibirNomeUsuario(id) {\n  try {\n    const usuario = await buscarUsuario(id);\n    console.log(usuario.nome.toUpperCase());\n  } catch (erro) {\n    console.error(\"Falha ao exibir usu\u00e1rio:\", erro.message);\n  }\n}\n\nexibirNomeUsuario(999);\n<\/code><\/pre>\n<p>Esse tipo de corre\u00e7\u00e3o \u2014 validar antes de assumir que os dados existem \u2014 \u00e9 um padr\u00e3o comum, e a IA costuma reconhec\u00ea-lo rapidamente quando tem a resposta real da API \u00e0 disposi\u00e7\u00e3o, n\u00e3o apenas o c\u00f3digo.<\/p>\n<h2>Uma t\u00e9cnica avan\u00e7ada, mas simples: pe\u00e7a hip\u00f3teses, n\u00e3o solu\u00e7\u00f5es<\/h2>\n<p>Uma armadilha comum \u00e9 pedir diretamente &#8220;conserta esse c\u00f3digo&#8221; antes de entender a causa. Isso funciona para bugs triviais, mas em problemas mais complexos pode levar a uma corre\u00e7\u00e3o que trata o sintoma, sem resolver a causa raiz. Uma t\u00e9cnica mais segura \u00e9 pedir <strong>hip\u00f3teses<\/strong> antes de pedir a corre\u00e7\u00e3o:<\/p>\n<pre><code>Antes de sugerir uma corre\u00e7\u00e3o, liste de 3 a 5 hip\u00f3teses poss\u00edveis\npara esse comportamento, ordenadas da mais prov\u00e1vel para a menos prov\u00e1vel,\nexplicando brevemente como eu poderia confirmar cada uma.\n<\/code><\/pre>\n<p>Esse tipo de pedido transforma a IA em uma ferramenta de racioc\u00ednio, n\u00e3o apenas de gera\u00e7\u00e3o de c\u00f3digo. Voc\u00ea recebe uma lista de possibilidades, testa a mais prov\u00e1vel primeiro (adicionando um log, checando um valor, revisando uma condi\u00e7\u00e3o) e s\u00f3 ent\u00e3o pede a corre\u00e7\u00e3o depois de confirmar a causa real. Esse passo extra, que parece burocr\u00e1tico, \u00e9 o que evita o ciclo de &#8220;tenta de novo, tenta de novo&#8221; sem entender o que est\u00e1 sendo mudado.<\/p>\n<h3>Usando IA integrada ao editor para ver mais contexto de uma vez<\/h3>\n<p>Ferramentas como o GitHub Copilot ou assistentes integrados a editores de c\u00f3digo conseguem enxergar mais do que apenas o trecho colado em um chat \u2014 elas leem arquivos vizinhos, defini\u00e7\u00f5es de tipos e at\u00e9 o hist\u00f3rico do projeto. Isso reduz a necessidade de voc\u00ea copiar manualmente cada peda\u00e7o de contexto. Ainda assim, mesmo usando esse tipo de ferramenta, os quatro elementos citados anteriormente (esperado, observado, c\u00f3digo, tentativas) continuam sendo o que garante uma resposta precisa, porque a IA n\u00e3o sabe, sozinha, qual comportamento voc\u00ea considera &#8220;correto&#8221; para o seu sistema.<\/p>\n<blockquote><p><strong>\ud83d\udca1 Dica do Mestre:<\/strong> a Google descreve bem esse papel da IA no ciclo de desenvolvimento: &#8220;a IA para desenvolvedores pode automatizar tarefas, gerar c\u00f3digos de qualidade, personalizar modelos e acelerar o desenvolvimento de softwares e aplicativos&#8221;. Vale conferir a vis\u00e3o geral em <a href=\"https:\/\/cloud.google.com\/use-cases\/ai-for-developers?hl=pt-BR\" target=\"_blank\" rel=\"noopener\">IA para desenvolvedores \u2014 Google Cloud<\/a>.<\/p><\/blockquote>\n<h2>Exemplo pr\u00e1tico 3: um bug de l\u00f3gica sem mensagem de erro<\/h2>\n<p>Nem todo bug gera uma exce\u00e7\u00e3o. \u00c0s vezes o programa roda sem travar, mas produz um resultado errado \u2014 o tipo mais dif\u00edcil de investigar sozinho, porque n\u00e3o h\u00e1 uma pilha de erro apontando para o culpado. Veja este exemplo em Java:<\/p>\n<pre><code class=\"language-java\">public class Estoque {\n    public static double calcularDesconto(double preco, int quantidade) {\n        double desconto = 0;\n        if (quantidade &gt; 10) {\n            desconto = 0.1;\n        }\n        if (quantidade &gt; 20) {\n            desconto = 0.2;\n        }\n        return preco - (preco * desconto);\n    }\n\n    public static void main(String[] args) {\n        System.out.println(calcularDesconto(100.0, 25)); \/\/ esperado: 80.0, mas retorna 90.0\n    }\n}\n<\/code><\/pre>\n<p>Aqui n\u00e3o h\u00e1 erro nenhum na tela, apenas um valor incorreto. Um pedido bem feito para a IA precisa deixar claro o valor esperado versus o obtido:<\/p>\n<pre><code>Comportamento esperado: para quantidade 25, o desconto deveria ser 20% (resultado 80.0).\n\nComportamento observado: o m\u00e9todo retorna 90.0, como se o desconto aplicado\nfosse de apenas 10%.\n\nC\u00f3digo relevante: [colar o m\u00e9todo calcularDesconto]\n\nO que j\u00e1 tentei: revisei a l\u00f3gica dos \"if\" e n\u00e3o vejo o erro,\nos dois parecem cobrir os casos certos.\n\nPergunta: existe algum problema na ordem ou nas condi\u00e7\u00f5es desses \"if\"\nque explique esse comportamento?\n<\/code><\/pre>\n<p>Nesse caso, a causa \u00e9 simples de identificar quando bem explicada: como os dois blocos <code>if<\/code> s\u00e3o independentes (n\u00e3o s\u00e3o <code>if \/ else if<\/code>), e a condi\u00e7\u00e3o <code>quantidade &gt; 10<\/code> \u00e9 verdadeira ao mesmo tempo que <code>quantidade &gt; 20<\/code>, o valor de <code>desconto<\/code> \u00e9 sobrescrito corretamente para 0.2 \u2014 ent\u00e3o o bug de fato n\u00e3o est\u00e1 aqui. Esse \u00e9 exatamente o tipo de situa\u00e7\u00e3o em que pedir hip\u00f3teses antes da corre\u00e7\u00e3o evita que voc\u00ea (ou a IA) &#8220;conserte&#8221; algo que j\u00e1 estava certo, e direcione a investiga\u00e7\u00e3o para o lugar certo \u2014 por exemplo, verificar se o valor de <code>quantidade<\/code> realmente chega como 25 at\u00e9 esse m\u00e9todo, ou se h\u00e1 alguma convers\u00e3o de tipo acontecendo antes.<\/p>\n<p>Esse exemplo refor\u00e7a um ponto importante: a IA \u00e9 t\u00e3o boa quanto o contexto que voc\u00ea fornece, e \u00e0s vezes o maior ganho de produtividade \u00e9 simplesmente ser for\u00e7ado a descrever o problema com precis\u00e3o \u2014 processo que, por si s\u00f3, j\u00e1 revela parte da causa (esse efeito \u00e9 conhecido informalmente como &#8220;explicar o problema para o pato de borracha&#8221;, uma t\u00e9cnica antiga de depura\u00e7\u00e3o).<\/p>\n<h2>Checklist r\u00e1pido para aplicar hoje mesmo<\/h2>\n<ul>\n<li>Antes de pedir ajuda, escreva a mensagem de erro completa, sem resumir.<\/li>\n<li>Descreva o comportamento esperado em uma frase clara.<\/li>\n<li>Cole o trecho de c\u00f3digo com contexto suficiente (a fun\u00e7\u00e3o inteira, n\u00e3o s\u00f3 a linha).<\/li>\n<li>Liste o que voc\u00ea j\u00e1 tentou, para n\u00e3o receber a mesma sugest\u00e3o de novo.<\/li>\n<li>Pe\u00e7a hip\u00f3teses antes de pedir a corre\u00e7\u00e3o, principalmente em bugs sem erro expl\u00edcito.<\/li>\n<li>Depois de aplicar a corre\u00e7\u00e3o, teste o caso que falhava e tamb\u00e9m os casos que j\u00e1 funcionavam, para garantir que nada quebrou.<\/li>\n<\/ul>\n<blockquote><p><strong>\ud83d\udca1 Dica do Mestre:<\/strong> a Softdesign resume bem o cuidado necess\u00e1rio ao adotar IA no fluxo de desenvolvimento: a tecnologia agrega recursos e agilidade, mas o resultado depende de como ela \u00e9 aplicada dentro do processo da equipe. Leia mais em <a href=\"https:\/\/www.softdesign.com.br\/blog\/ia-para-desenvolvimento-de-software\/\" target=\"_blank\" rel=\"noopener\">IA para desenvolvimento de software \u2014 Softdesign<\/a>.<\/p><\/blockquote>\n<h2>Quer ir al\u00e9m do b\u00e1sico?<\/h2>\n<p>As t\u00e9cnicas apresentadas aqui s\u00e3o o ponto de partida para transformar a IA em uma parceira real de investiga\u00e7\u00e3o de bugs, n\u00e3o apenas em um gerador de c\u00f3digo. Se voc\u00ea quer trocar experi\u00eancias com outros desenvolvedores que j\u00e1 aplicam esses m\u00e9todos no dia a dia, discutir casos reais e aprender t\u00e9cnicas mais avan\u00e7adas de depura\u00e7\u00e3o, automa\u00e7\u00e3o e uso de agentes de IA no desenvolvimento, entre para a <a href=\"https:\/\/adrianosantos.link\/ComunidadeDevAI\" target=\"_blank\" rel=\"noopener\">Comunidade Dev&#8217;s AI<\/a>. \u00c9 um espa\u00e7o para quem quer aprender e evoluir junto, com gente que enfrenta os mesmos desafios que voc\u00ea enfrenta na sua rotina de c\u00f3digo.<\/p>\n<h2>Conclus\u00e3o<\/h2>\n<p>Debugging com IA n\u00e3o \u00e9 sobre colar um erro em um chat e torcer para a resposta certa aparecer. \u00c9 sobre transformar um processo que antes vivia s\u00f3 na sua cabe\u00e7a \u2014 hip\u00f3teses, tentativas, descartes \u2014 em um processo estruturado e comunic\u00e1vel, onde a IA participa como um investigador auxiliar r\u00e1pido e paciente. Quando voc\u00ea fornece o comportamento esperado, o comportamento observado, o c\u00f3digo relevante e o que j\u00e1 tentou, a chance de resolver o problema na primeira ou na segunda tentativa aumenta consideravelmente, e as horas que antes se perdiam em tentativa e erro passam a ser horas de trabalho de fato produtivo. A ferramenta muda, a linguagem muda, mas o m\u00e9todo \u2014 descrever o problema com precis\u00e3o antes de buscar a solu\u00e7\u00e3o \u2014 continua sendo a base de qualquer boa investiga\u00e7\u00e3o, com ou sem intelig\u00eancia artificial.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>S\u00e3o 16h37. Uma funcionalidade que funcionava desde a \u00faltima sexta-feira parou de funcionar hoje de manh\u00e3. N\u00e3o houve deploy novo, ningu\u00e9m mexeu naquele m\u00f3dulo, e o log mostra apenas uma linha gen\u00e9rica: NullReferenceException em um arquivo com quatrocentas linhas. Voc\u00ea abre o arquivo, olha para o ponto indicado pela pilha de chamadas, n\u00e3o encontra nada [&hellip;]<\/p>\n","protected":false},"author":127,"featured_media":1154,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1153","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog"],"_links":{"self":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/1153","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/users\/127"}],"replies":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/comments?post=1153"}],"version-history":[{"count":1,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/1153\/revisions"}],"predecessor-version":[{"id":1155,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/1153\/revisions\/1155"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/media\/1154"}],"wp:attachment":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/media?parent=1153"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/categories?post=1153"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/tags?post=1153"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}