<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Massimo Yang</title>
    <description>The latest articles on DEV Community by Massimo Yang (@yenpodev).</description>
    <link>https://dev.to/yenpodev</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4216370%2F1f6135a7-684f-4c6e-ac6a-f3d3d22d6cc6.png</url>
      <title>DEV Community: Massimo Yang</title>
      <link>https://dev.to/yenpodev</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/yenpodev"/>
    <language>en</language>
    <item>
      <title>How to review diffs from AI coding agents before you commit</title>
      <dc:creator>Massimo Yang</dc:creator>
      <pubDate>Sun, 15 Nov 2026 07:00:54 +0000</pubDate>
      <link>https://dev.to/yenpodev/how-to-review-diffs-from-ai-coding-agents-before-you-commit-4p31</link>
      <guid>https://dev.to/yenpodev/how-to-review-diffs-from-ai-coding-agents-before-you-commit-4p31</guid>
      <description>&lt;p&gt;A useful review ends with a clear decision about the exact change you will commit. That requires more than reading the agent's summary or seeing a passing test command. You need to establish what changed, whether it meets the request, and whether the staged snapshot contains everything it needs.&lt;/p&gt;

&lt;p&gt;This workflow applies to code written with Claude Code, Codex, Cursor, or another agent. On a Mac, you can perform it with Git, your editor, and the project's existing checks. Start with scope, then inspect behavior, then verify the commit contents.&lt;/p&gt;

&lt;h2&gt;
  
  
  Stop edits and establish the review boundary
&lt;/h2&gt;

&lt;p&gt;Ask the agent to pause before you review. Record the intended outcome and the work that is outside scope. If you cannot describe the change in a sentence, divide the review into coherent pieces before reading lines.&lt;/p&gt;

&lt;p&gt;Run &lt;code&gt;git status --short&lt;/code&gt; and separate pre-existing work from the current task. Note staged, unstaged, and untracked files. A file can have both staged and unstaged changes, so seeing its name once does not mean you have seen everything that might matter.&lt;/p&gt;

&lt;p&gt;Ask for a concise handoff: changed behavior, design decisions, checks actually run, and known limitations. Verify those statements against the repository rather than treating the handoff as approval evidence by itself.&lt;/p&gt;

&lt;h2&gt;
  
  
  Inventory the whole change before opening hunks
&lt;/h2&gt;

&lt;p&gt;Read the changed-file list first. Compare it with the requested behavior and identify the likely entry points, implementation, configuration, dependencies, and tests. A small feature that also rewrites unrelated code needs an explanation before detailed review begins.&lt;/p&gt;

&lt;p&gt;Use &lt;code&gt;git diff --name-status&lt;/code&gt; for unstaged tracked changes and &lt;code&gt;git diff --cached --name-status&lt;/code&gt; for staged changes. Check untracked files through status and open them separately. Ordinary diffs omit them, even when they contain the entire implementation of a new feature.&lt;/p&gt;

&lt;p&gt;Review additions, deletions, and renames deliberately. New files can be required dependencies; deleted files can remove behavior; renamed files can include substantive edits. Look for unintended generated output, local settings, credentials, or unrelated work before selecting anything for the commit.&lt;/p&gt;

&lt;h2&gt;
  
  
  Choose the comparison that answers your question
&lt;/h2&gt;

&lt;p&gt;Different comparisons reveal different parts of the work. Keep the distinction visible while reviewing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;git diff&lt;/code&gt; compares unstaged tracked changes with the index.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git diff --cached&lt;/code&gt; compares the staged snapshot with the current commit.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git show HEAD&lt;/code&gt; shows the latest commit, useful when the agent has already committed a step.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git diff main...HEAD&lt;/code&gt; compares the current commit with its common ancestor with main, showing committed changes since that shared point.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git diff main HEAD&lt;/code&gt; compares the two committed endpoints directly, so changes on main can also affect the result.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Use the actual target branch in place of main when appropriate, and make sure the reference is current enough for your review. Branch comparisons omit uncommitted work. If the task spans committed and local changes, inspect both before deciding that the review is complete.&lt;/p&gt;

&lt;h2&gt;
  
  
  Inspect contracts and callers, then the details
&lt;/h2&gt;

&lt;p&gt;Start with changes that alter behavior across a boundary: input validation, return values, errors, saved data, or shared state. For each one, describe the previous behavior and the intended new behavior. Check whether the requirement supports that difference.&lt;/p&gt;

&lt;h3&gt;
  
  
  Trace outside the changed lines
&lt;/h3&gt;

&lt;p&gt;Jump to definitions for unfamiliar calls and find references to changed functions or types. A diff can be internally consistent while an unchanged caller still expects an older contract. Follow data through the caller, the changed code, and the resulting side effect.&lt;/p&gt;

&lt;p&gt;Try concrete edge cases that fit the task: missing input, repeated actions, cancellation, or failure after a partial update. Inspect ordering as well as values. A guard added after a write cannot prevent that write.&lt;/p&gt;

&lt;p&gt;For each concern, record the trigger, the observed code behavior, and the consequence. This makes a repair request specific enough to verify. Review the repair as a new change, including any callers or tests it affects.&lt;/p&gt;

&lt;h2&gt;
  
  
  Check what the tests actually prove
&lt;/h2&gt;

&lt;p&gt;Read modified tests before accepting their results. Ask whether the assertions cover the requirement and would detect its absence. Inspect removed assertions and changed expectations carefully, particularly when they make an existing failure disappear.&lt;/p&gt;

&lt;p&gt;Run the narrowest relevant checks using the project's documented commands. Expand to a build, static analysis, or broader tests when shared behavior or configuration changed. Record the command and result, including checks that could not run. Separate environment failures from evidence of a code defect.&lt;/p&gt;

&lt;p&gt;Remember that tests normally run against the working tree. If you later stage only part of that tree, the tested files may differ from the proposed commit. Either keep the reviewed, tested change together or verify the proposed subset separately before committing. An essential new file left untracked can cause the same mismatch.&lt;/p&gt;

&lt;h2&gt;
  
  
  An optional Mac workspace for diff review
&lt;/h2&gt;

&lt;p&gt;Disclosure: I make Yenpo.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://yenpo.app/?utm_source=devto&amp;amp;utm_medium=article&amp;amp;utm_campaign=launch" rel="noopener noreferrer"&gt;Yenpo&lt;/a&gt; is a native Mac app that opens local Git repositories for reading and reviewing changes. It provides line diffs by commit, branch comparisons against main from the common ancestor or directly, and local uncommitted changes, including untracked files. Definition jumps and reference searches use local language servers, which are not bundled with the app. It also provides full-text search.&lt;/p&gt;

&lt;p&gt;It has no integration with Claude Code, Codex, Cursor, or GitHub. AI Reader is optional and uses your own AI provider. You can see the files it reads and the searches it performs, and follow clickable file-and-line references. AI Reader is read-only by default. Allow Edits applies only to the next message you send to AI Reader; it then returns to read-only mode. If you permit a repair, inspect the resulting changes before accepting them.&lt;/p&gt;

&lt;p&gt;No Yenpo account and no telemetry. It only connects to your own AI provider, an optional daily update check, and downloads you start yourself.&lt;/p&gt;

&lt;p&gt;It is Freeware and supports macOS 14+, Apple silicon, and Intel.&lt;/p&gt;

&lt;h2&gt;
  
  
  Verify the exact snapshot you will commit
&lt;/h2&gt;

&lt;p&gt;Stage the reviewed changes deliberately, then read &lt;code&gt;git diff --cached&lt;/code&gt; in full. Run &lt;code&gt;git diff --cached --check&lt;/code&gt; to catch whitespace errors and conflict markers; it does not establish behavioral correctness. Check status again for required files still untracked or unstaged.&lt;/p&gt;

&lt;p&gt;Confirm that the staged snapshot includes its dependencies and tests, excludes unrelated changes, and matches what you verified. If the agent edited anything after that verification, review the new material and rerun affected checks. Commit when you can explain what the snapshot changes, why it is correct, and what remains unverified.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>codereview</category>
      <category>git</category>
      <category>productivity</category>
    </item>
    <item>
      <title>How to keep up with code your AI coding agent writes</title>
      <dc:creator>Massimo Yang</dc:creator>
      <pubDate>Sat, 14 Nov 2026 12:43:40 +0000</pubDate>
      <link>https://dev.to/yenpodev/how-to-keep-up-with-code-your-ai-coding-agent-writes-k9</link>
      <guid>https://dev.to/yenpodev/how-to-keep-up-with-code-your-ai-coding-agent-writes-k9</guid>
      <description>&lt;p&gt;AI coding agents can move a project forward while leaving you unsure how the result works. A feature runs, the tests pass, and the explanation sounds plausible. Yet you cannot say where the new behavior starts or what else it affects. That gap makes the next request harder to judge.&lt;/p&gt;

&lt;p&gt;To keep up with code your AI coding agent writes, make understanding part of each change. Whether you use Claude Code, Codex, or Cursor on a Mac, work in small increments, inspect the actual diff, and trace the behavior before moving on. You need a repeatable reading routine that fits between tasks.&lt;/p&gt;

&lt;h2&gt;
  
  
  Give each task a boundary you can explain
&lt;/h2&gt;

&lt;p&gt;Before asking for implementation, describe the observable behavior you want. State what should change, what should stay the same, and how you will recognize success. A request to reject an empty form submission gives you something specific to verify. A request to improve the form leaves many decisions open.&lt;/p&gt;

&lt;p&gt;Ask the agent to identify the likely areas of change before editing. Treat that list as a hypothesis: if the implementation spreads elsewhere, ask what made the extra work necessary. An unexpected dependency or configuration change deserves attention while the task is still small.&lt;/p&gt;

&lt;h3&gt;
  
  
  Ask for intent and evidence
&lt;/h3&gt;

&lt;p&gt;A useful instruction is: Explain the intended behavior, the main design choice, and the checks you will run. After editing, summarize what changed and identify anything you could not verify.&lt;/p&gt;

&lt;p&gt;Keep that explanation beside the diff. It gives you questions to investigate; the code and checks determine whether the answers hold.&lt;/p&gt;

&lt;h2&gt;
  
  
  Read one stable increment at a time
&lt;/h2&gt;

&lt;p&gt;Ask the agent to finish a coherent piece of behavior and pause. Reviewing a moving working tree makes it difficult to know whether the code you just read still matches what will be kept. If another task is already running, agree on a stopping point before beginning the review.&lt;/p&gt;

&lt;p&gt;Start with &lt;code&gt;git status --short&lt;/code&gt; to see the current state. Distinguish changes that existed before the task from those made during it. Shared working trees can contain your own unfinished edits, so avoid assuming every modified file belongs to the agent's request.&lt;/p&gt;

&lt;p&gt;Use small commits as checkpoints after review and relevant checks. A useful checkpoint contains one explainable change and a message describing its purpose. If the project uses branches, keep the branch focused on the same objective. Unrelated cleanup can be a separate task, with its own explanation and review.&lt;/p&gt;

&lt;h2&gt;
  
  
  Build a map from the changed files
&lt;/h2&gt;

&lt;p&gt;Before reading individual lines, inspect the file list and change summary. &lt;code&gt;git diff --name-status&lt;/code&gt; shows which tracked files changed in the unstaged diff. &lt;code&gt;git diff --stat&lt;/code&gt; gives a rough sense of where the work is concentrated. Neither command lists untracked files, so keep the status output in view.&lt;/p&gt;

&lt;p&gt;Group the files by responsibility: entry points, behavior, stored data, configuration, and tests. You are building a reading order. If a task changes a validation rule, find the rule, its caller, and the tests that describe the expected result.&lt;/p&gt;

&lt;p&gt;Investigate files that do not fit that map. A dependency update might be necessary, but it should have a reason. A deleted test might signal changed requirements, or it might remove the only check for an existing behavior. Ask which explanation the diff supports.&lt;/p&gt;

&lt;h2&gt;
  
  
  Follow one behavior through the code
&lt;/h2&gt;

&lt;p&gt;Pick a concrete input and follow it from the entry point to the result. Open definitions when a changed line calls unfamiliar code. Find references when a function's contract changes, because callers outside the diff may rely on its previous behavior. Search for the same concept elsewhere to see how the project already handles it.&lt;/p&gt;

&lt;p&gt;Do this for a normal case and a relevant failure case. For a form change, consider both a valid submission and missing input. Check where validation occurs, how failure reaches the interface, and whether anything is saved before rejection.&lt;/p&gt;

&lt;h3&gt;
  
  
  Turn uncertainty into a precise question
&lt;/h3&gt;

&lt;p&gt;Instead of asking the agent to explain everything, ask what a particular caller assumes, where an error is handled, or why state changes before a check. Request the definition or reference that supports its answer, then inspect it yourself.&lt;/p&gt;

&lt;p&gt;Write a short behavior note in your own words. If you cannot describe the input, the decision, and the effect, you have found the next part to read.&lt;/p&gt;

&lt;h2&gt;
  
  
  Close the loop with checks and a checkpoint
&lt;/h2&gt;

&lt;p&gt;Choose checks from the behavior you traced. Run the relevant existing tests, then use the project's normal build or static checks where the change calls for them. For interface work, exercise the interaction yourself. A successful command answers a bounded question; record what it covered and what it did not.&lt;/p&gt;

&lt;p&gt;Read changed tests too. Confirm that their assertions would fail if the intended behavior were absent. A test that repeats a result calculated by the implementation can agree with the same mistake. Pay particular attention when the agent changes expected values or removes assertions.&lt;/p&gt;

&lt;p&gt;Before the next task, inspect the final diff again. Fixes made after review create new material to understand. Check untracked files explicitly: a new helper or test may be essential even though it never appeared in the ordinary diff. Keep the checkpoint only when you can explain its purpose and its evidence.&lt;/p&gt;

&lt;h2&gt;
  
  
  An optional Mac workflow for reading changes
&lt;/h2&gt;

&lt;p&gt;Disclosure: I make Yenpo.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://yenpo.app/?utm_source=devto&amp;amp;utm_medium=article&amp;amp;utm_campaign=launch" rel="noopener noreferrer"&gt;Yenpo&lt;/a&gt; is a native Mac app for reading and reviewing code changes in local Git repositories. It shows line diffs by commit, branch comparisons against main from the common ancestor or directly, and uncommitted local changes, including untracked files. Local language servers support jumping to definitions and finding references; full-text search is also available. Language servers are not bundled with the app.&lt;/p&gt;

&lt;p&gt;There is no integration with Claude Code, Codex, Cursor, or GitHub. You open the local repository to read its changes. AI Reader is optional and uses your own AI provider. It shows which files it reads and what it searches for, with clickable file-and-line references. It is read-only by default. Allow Edits applies only to the next message you send to AI Reader, after which it returns to read-only mode.&lt;/p&gt;

&lt;p&gt;No Yenpo account and no telemetry. It only connects to your own AI provider, an optional daily update check, and downloads you start yourself.&lt;/p&gt;

&lt;p&gt;It is Freeware for macOS 14+, on Apple silicon and Intel. These reading tools can support the routine above; understanding and accepting the change remain your responsibility.&lt;/p&gt;

&lt;h2&gt;
  
  
  Know when you are ready for the next task
&lt;/h2&gt;

&lt;p&gt;Before continuing, explain the change without copying the agent's summary. Name the behavior, the affected callers, the checks you ran, and any open question. If an important answer is missing, pause and resolve it or reduce the scope. Keeping up becomes manageable when each task ends with a small piece of code you can confidently explain.&lt;/p&gt;

</description>
      <category>productivity</category>
      <category>ai</category>
      <category>programming</category>
      <category>codereview</category>
    </item>
    <item>
      <title>Como ler de verdade o código que seu agente de IA escreveu</title>
      <dc:creator>Massimo Yang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 09:16:11 +0000</pubDate>
      <link>https://dev.to/yenpodev/como-ler-de-verdade-o-codigo-que-seu-agente-de-ia-escreveu-5876</link>
      <guid>https://dev.to/yenpodev/como-ler-de-verdade-o-codigo-que-seu-agente-de-ia-escreveu-5876</guid>
      <description>&lt;p&gt;&lt;em&gt;Este artigo também existe em inglês: &lt;a href="https://dev.to/yenpodev/how-to-actually-read-the-code-your-ai-agent-wrote-1fj9"&gt;How to actually read the code your AI agent wrote&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Uma sessão com um agente termina com um resumo animado e um diff que mexe em um monte de arquivos. O caminho fácil é rolar a tela, achar que está tudo razoável e fazer o merge.&lt;/p&gt;

&lt;p&gt;Isso é passar o olho, não revisar. O resumo diz o que o agente pretendia fazer; o diff mostra o que ele fez de fato, e as duas coisas nem sempre batem. Aqui vai o fluxo que eu sugiro para fechar essa diferença, venha a mudança do Claude Code, do Codex, do Cursor ou de qualquer outro.&lt;/p&gt;

&lt;h2&gt;
  
  
  Primeiro, saiba o que você está lendo
&lt;/h2&gt;

&lt;p&gt;O trabalho de um agente costuma chegar em um de três formatos, e cada um pede uma abordagem um pouco diferente.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Um único commit.&lt;/strong&gt; Bom quando o agente vai commitando conforme trabalha. &lt;code&gt;git show &amp;lt;sha&amp;gt;&lt;/code&gt; mostra a mensagem e o diff juntos. Leia a mensagem primeiro e trate ela como uma afirmação que você vai conferir.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Uma branch comparada com a main.&lt;/strong&gt; É o formato comum para tarefas mais longas. Aqui existem duas perguntas diferentes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;git diff main...feature&lt;/code&gt; (três pontos) mostra só o que mudou na branch desde que ela saiu da main. Quase sempre é isso que você quer para revisar.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git diff main feature&lt;/code&gt; (dois pontos ou espaço) compara as duas versões diretamente, então tudo o que entrou na main nesse meio-tempo aparece também. Útil para saber o que o merge vai fazer de verdade; confuso se você achar que são as mudanças da própria branch.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Mudanças locais não commitadas.&lt;/strong&gt; Comum com agentes que editam sua working tree e deixam o commit para você. &lt;code&gt;git diff&lt;/code&gt; cobre os arquivos rastreados, mas não mostra arquivos novos que o agente criou. Rode &lt;code&gt;git status&lt;/code&gt; e olhe a lista de untracked, ou use &lt;code&gt;git add -N .&lt;/code&gt; para os arquivos novos aparecerem no &lt;code&gt;git diff&lt;/code&gt; (desfaça com &lt;code&gt;git reset&lt;/code&gt;). Agentes criam scripts, helpers e fixtures com mais frequência do que os resumos deles contam.&lt;/p&gt;

&lt;h2&gt;
  
  
  Veja o formato antes das linhas
&lt;/h2&gt;

&lt;p&gt;Antes de ler qualquer hunk, tenha uma visão geral:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git diff &lt;span class="nt"&gt;--stat&lt;/span&gt; main...feature
git diff &lt;span class="nt"&gt;--name-status&lt;/span&gt; main...feature
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Depois faça algumas perguntas:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Todo arquivo era esperado?&lt;/strong&gt; Se a tarefa era "corrigir o bug de parsing de data" e mudaram o lockfile, a config de CI e um componente sem relação, descubra o porquê antes de qualquer outra coisa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Onde está o peso?&lt;/strong&gt; Um arquivo com 300 linhas alteradas numa "correção pequena" merece atenção.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Testes foram adicionados, alterados ou apagados?&lt;/strong&gt; Asserções editadas merecem mais atenção que testes novos. Um agente que não consegue fazer um teste passar às vezes muda o que o teste espera.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Leia na ordem das dependências, não em ordem alfabética
&lt;/h2&gt;

&lt;p&gt;Ferramentas de diff listam os arquivos em ordem alfabética, que raramente é a ordem em que a mudança faz sentido. Uma ordem melhor:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Tipos, interfaces, schemas e config: o que mudou no contrato.&lt;/li&gt;
&lt;li&gt;A lógica principal que implementa a mudança.&lt;/li&gt;
&lt;li&gt;Os pontos de chamada que foram ajustados.&lt;/li&gt;
&lt;li&gt;Os testes por último, para lê-los já sabendo o que eles deveriam provar.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Em cada hunk, não pare nas linhas alteradas. Abra a função onde elas estão. Uma mudança de duas linhas numa condição só pode ser julgada com o código ao redor à vista, e é exatamente esse contexto que o diff deixa de fora.&lt;/p&gt;

&lt;h2&gt;
  
  
  Confira o raciocínio, não só o código
&lt;/h2&gt;

&lt;p&gt;Agentes produzem código que lê bem, então "isso parece código razoável?" é o teste errado. Perguntas melhores:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Você consegue dizer a causa do bug em uma frase, e a mudança ataca essa causa?&lt;/strong&gt; Muita correção de agente trata o sintoma: um null check, um retry, um try/except que engole o erro.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Siga uma função renomeada ou com assinatura nova até quem a chama.&lt;/strong&gt; Procure no repositório o nome antigo e o novo. Chamadas esquecidas, ou "corrigidas" mudando o comportamento, são comuns.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Procure aumento de escopo silencioso.&lt;/strong&gt; Refatorações que ninguém pediu, arquivos reformatados, defaults alterados, dependências novas. Cada uma precisa da sua própria justificativa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Confira as afirmações do resumo.&lt;/strong&gt; Se diz "adicionei validação de entrada", ache a validação. Se diz "todos os testes passam", rode você mesmo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Desconfie de invenções confiantes.&lt;/strong&gt; Chamadas a funções de biblioteca ou opções de config que não existem, ou que existem em outra versão. Vá até a definição e confirme.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Se algo não fecha, pergunte ao agente por que ele fez aquela escolha. Depois confira a resposta no código em vez de aceitá-la. Uma explicação que cita linhas específicas é fácil de checar; uma que não cita é só mais texto para confiar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Mantenha os checkpoints pequenos
&lt;/h2&gt;

&lt;p&gt;Revisar é muito mais fácil quando as unidades são pequenas. Alguns hábitos ajudam:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Peça ao agente para commitar a cada passo lógico, com uma mensagem dizendo o quê e por quê.&lt;/li&gt;
&lt;li&gt;Revise entre os passos, não no fim de uma sessão de duas horas.&lt;/li&gt;
&lt;li&gt;Quando um diff for grande demais para ler direito, diga isso: peça para dividir, ou volte e refaça em partes menores. Uma mudança que você não consegue revisar é uma mudança que você ainda não entende.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Onde o Yenpo entra
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcd1jlzsn1676eqcv8ju6.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcd1jlzsn1676eqcv8ju6.gif" alt="Revisando o que o seu agente de IA mudou no Yenpo"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Demo de 20 segundos: revisando o que o seu agente de IA mudou — mudanças locais antes do commit, incluindo arquivos novos.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Eu fiz o Yenpo, um app para Mac, justamente para essa etapa de leitura. A ideia é acompanhar o que a IA fez enquanto você constrói um projeto com ela. Para deixar claro o que ele é e o que não é:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ele abre os três formatos deste post: um único commit, uma branch comparada com a main (só as mudanças desde o ponto em que ela saiu da main, ou a comparação direta das duas versões) e mudanças locais não commitadas, incluindo arquivos novos ainda não rastreados. Os diffs são inline.&lt;/li&gt;
&lt;li&gt;Ir para a definição e encontrar referências vêm de language servers locais (Swift, Rust, C/C++/Objective-C, Python, JS/TS, Go). Eles não vêm embutidos: Swift e a família C usam os do Xcode, os outros usam o que estiver no seu PATH, e o rust-analyzer tem instalação com um clique. Ir para a definição funciona direto no diff para mudanças não commitadas; para commits e branches, você abre o arquivo no editor. Também tem busca de texto completo.&lt;/li&gt;
&lt;li&gt;Tem um AI Reader opcional que usa o seu próprio provedor. Ele mostra quais arquivos leu e o que pesquisou, e as referências arquivo:linha nas respostas são clicáveis, então dá para conferir no código. O AI Reader é somente leitura por padrão. O Allow Edits vale só para a próxima mensagem que você enviar ao AI Reader, e depois volta para somente leitura.&lt;/li&gt;
&lt;li&gt;Ele foi feito para ler mudanças, não para escrever código nem comandar o seu agente, e não se integra com Claude Code, Codex, Cursor ou GitHub. Ele lê o seu repositório git local. Não tem conta Yenpo nem telemetria; ele só acessa a internet para o seu próprio provedor de IA, uma verificação diária de atualização opcional e downloads que você mesmo inicia.&lt;/li&gt;
&lt;li&gt;Precisa do macOS 14 ou mais recente.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Você não precisa dele para seguir esse fluxo. &lt;code&gt;git diff&lt;/code&gt;, seu editor e um pouco de disciplina resolvem a maior parte. Se quiser testar: &lt;a href="https://yenpo.app/?utm_source=devto_pt&amp;amp;utm_medium=community&amp;amp;utm_campaign=showcase_1030" rel="noopener noreferrer"&gt;yenpo.app&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Resumindo
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Saiba qual formato você está lendo: um commit, uma branch desde o ponto em que saiu da main, ou mudanças locais incluindo arquivos não rastreados.&lt;/li&gt;
&lt;li&gt;Olhe a lista de arquivos e as estatísticas antes das linhas.&lt;/li&gt;
&lt;li&gt;Leia na ordem das dependências, com o código ao redor aberto.&lt;/li&gt;
&lt;li&gt;Trate o resumo e as explicações do agente como afirmações, e confira no código.&lt;/li&gt;
&lt;li&gt;Mantenha os passos pequenos o bastante para você conseguir ler de verdade.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Queria muito ouvir como vocês fazem isso, principalmente com diffs grandes de agente. O que vocês olham primeiro? E se testarem o Yenpo, o que faltou ou atrapalhou? Pode ser sincero.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Rascunho feito com ajuda de IA e revisado por mim.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>braziliandevs</category>
      <category>portugues</category>
      <category>ai</category>
      <category>codereview</category>
    </item>
    <item>
      <title>How to actually read the code your AI agent wrote</title>
      <dc:creator>Massimo Yang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 04:02:34 +0000</pubDate>
      <link>https://dev.to/yenpodev/how-to-actually-read-the-code-your-ai-agent-wrote-1fj9</link>
      <guid>https://dev.to/yenpodev/how-to-actually-read-the-code-your-ai-agent-wrote-1fj9</guid>
      <description>&lt;p&gt;An agent session ends with a cheerful summary and a diff that touches a lot of files. The easy move is to scroll through it, see that it looks reasonable, and merge.&lt;/p&gt;

&lt;p&gt;That's skimming, not review. The summary tells you what the agent meant to do; the diff tells you what it actually did, and the two don't always match. This post is the workflow I'd suggest for closing that gap, whether the change came from Claude Code, Codex, Cursor or anything else.&lt;/p&gt;

&lt;h2&gt;
  
  
  First, decide what you're reading
&lt;/h2&gt;

&lt;p&gt;Agent work usually reaches you in one of three shapes, and each needs a slightly different approach.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A single commit.&lt;/strong&gt; Good when the agent commits as it goes. &lt;code&gt;git show &amp;lt;sha&amp;gt;&lt;/code&gt; gives you the message and the diff together. Read the message first and treat it as a claim you're going to check.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A branch compared against main.&lt;/strong&gt; This is the usual shape for a longer task. There are two different questions here:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;git diff main...feature&lt;/code&gt; (three dots) shows only what changed on the branch since it forked from main. This is almost always what you want for review.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git diff main feature&lt;/code&gt; (two dots or a space) compares the two versions directly, so anything that landed on main in the meantime shows up as well. Useful when you want to know what merging will actually do, confusing if you mistake it for the branch's own changes.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Uncommitted local changes.&lt;/strong&gt; Common with agents that edit your working tree and leave committing to you. &lt;code&gt;git diff&lt;/code&gt; covers tracked files, but it doesn't show new files the agent created. Run &lt;code&gt;git status&lt;/code&gt; and look at the untracked list, or &lt;code&gt;git add -N .&lt;/code&gt; so new files show up in &lt;code&gt;git diff&lt;/code&gt; (undo with &lt;code&gt;git reset&lt;/code&gt;). Agents create helper files, scripts and fixtures more often than their summaries mention.&lt;/p&gt;

&lt;h2&gt;
  
  
  Get the shape before the lines
&lt;/h2&gt;

&lt;p&gt;Before reading any hunk, get an overview:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git diff &lt;span class="nt"&gt;--stat&lt;/span&gt; main...feature
git diff &lt;span class="nt"&gt;--name-status&lt;/span&gt; main...feature
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then ask a few questions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Is every file expected?&lt;/strong&gt; If the task was "fix the date parsing bug" and the lockfile, the CI config and an unrelated component changed, find out why before anything else.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Where is the weight?&lt;/strong&gt; One file with 300 changed lines in a "small fix" is worth a look.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Were tests added, changed, or deleted?&lt;/strong&gt; Edited assertions deserve more attention than new tests. An agent that can't make a test pass will sometimes change what the test expects.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Read in dependency order, not alphabetical order
&lt;/h2&gt;

&lt;p&gt;Diff tools list files alphabetically, which is rarely the order the change makes sense in. A better order:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Types, interfaces, schemas and config: what changed in the contract.&lt;/li&gt;
&lt;li&gt;The core logic that implements the change.&lt;/li&gt;
&lt;li&gt;Call sites that were updated to match.&lt;/li&gt;
&lt;li&gt;Tests last, so you read them knowing what they're supposed to prove.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;For each hunk, don't stop at the changed lines. Open the function they live in. A two-line change to a condition can only be judged with the surrounding code in view, and that's exactly the context a diff leaves out.&lt;/p&gt;

&lt;h2&gt;
  
  
  Check the reasoning, not just the code
&lt;/h2&gt;

&lt;p&gt;Agents produce code that reads fluently, so "does this look like reasonable code?" is the wrong test. Better questions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Can you state the cause of the bug in one sentence, and does the change address that cause?&lt;/strong&gt; A lot of agent fixes treat the symptom: a null check, a retry, a try/except that swallows the error.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Follow one renamed or re-signed function to its callers.&lt;/strong&gt; Search the repo for the old name and the new one. Missed call sites, and call sites "fixed" by changing their behavior, are common.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Look for silent scope creep.&lt;/strong&gt; Refactors nobody asked for, reformatted files, changed defaults, new dependencies. Each one needs its own justification.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Check the claims in the summary.&lt;/strong&gt; If it says "added input validation," find the validation. If it says "all tests pass," run them yourself.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Watch for confident inventions.&lt;/strong&gt; Calls to library functions or config options that don't exist, or that exist in a different version. Go to the definition and confirm it's real.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If something doesn't add up, ask the agent why it made that choice. Then verify the answer against the code instead of accepting it. An explanation that cites specific lines is easy to check; one that doesn't is just more text to trust.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep the checkpoints small
&lt;/h2&gt;

&lt;p&gt;Review is much easier when the units are small. A few habits help:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ask the agent to commit after each logical step, with a message that says what and why.&lt;/li&gt;
&lt;li&gt;Review between steps rather than at the end of a two-hour session.&lt;/li&gt;
&lt;li&gt;When a diff is too big to read properly, say so: ask for it to be split, or reset and redo it in smaller pieces. A change you can't review is a change you don't understand yet.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where Yenpo fits
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcd1jlzsn1676eqcv8ju6.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcd1jlzsn1676eqcv8ju6.gif" alt="Yenpo: reviewing what your AI agent changed before a commit, new files included" width="560" height="380"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Yenpo is the Mac app I made for the reading step above. To be clear about what it is and isn't:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;It opens the three shapes from this post: a single commit, a branch compared against main (only the changes since the fork point, or a direct compare of the two versions), and uncommitted local changes, including untracked new files. Diffs are inline.&lt;/li&gt;
&lt;li&gt;Go to definition and find references come from local language servers (Swift, Rust, C/C++/Objective-C, Python, JS/TS, Go). They aren't bundled: Swift and the C family use Xcode's, the others use what's on your PATH, and rust-analyzer has a one-click install. Go to definition works right in the diff for uncommitted changes; for commits and branches, you open the file in the editor. There's also full-text search.&lt;/li&gt;
&lt;li&gt;There's an optional AI Reader that uses your own provider. It shows which files it read and what it searched, and the file:line references in its answers are clickable, so you can check them against the code. The AI Reader is read-only by default. Allow Edits applies only to the next message you send to the AI Reader, then switches back to read-only.&lt;/li&gt;
&lt;li&gt;It's built for reading changes, not for writing code or driving your agent, and it doesn't integrate with Claude Code, Codex, Cursor or GitHub. It reads your local git repo. No Yenpo account or telemetry; it only goes online for your own AI provider, an optional daily update check, and downloads you start yourself.&lt;/li&gt;
&lt;li&gt;It needs macOS 14 or later.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You don't need it to follow this workflow. &lt;code&gt;git diff&lt;/code&gt;, your editor and some discipline get you most of the way. If you want to try it: &lt;a href="https://yenpo.app/?utm_source=devto&amp;amp;utm_medium=community&amp;amp;utm_campaign=devto_article" rel="noopener noreferrer"&gt;yenpo.app&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The short version
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Know which shape you're reading: a commit, a branch since its fork point, or local changes including untracked files.&lt;/li&gt;
&lt;li&gt;Look at the file list and stats before the lines.&lt;/li&gt;
&lt;li&gt;Read in dependency order, with the surrounding code open.&lt;/li&gt;
&lt;li&gt;Treat the agent's summary and explanations as claims, and check them against the code.&lt;/li&gt;
&lt;li&gt;Keep the steps small enough that you can actually read them.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I'd like to hear how others handle this, especially on large agent diffs. What do you check first?&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Drafted with AI assistance and reviewed by me.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>codereview</category>
      <category>git</category>
      <category>productivity</category>
    </item>
  </channel>
</rss>
