<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Felipe Silva on Medium]]></title>
        <description><![CDATA[Stories by Felipe Silva on Medium]]></description>
        <link>https://medium.com/@felipesilva_71272?source=rss-95894567914a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Dk1TWtjDAW3gq5BG</url>
            <title>Stories by Felipe Silva on Medium</title>
            <link>https://medium.com/@felipesilva_71272?source=rss-95894567914a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 16:32:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@felipesilva_71272/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Outbox Pattern em .NET: como garantir consistência entre banco de dados e eventos]]></title>
            <link>https://medium.com/@felipesilva_71272/outbox-pattern-em-net-como-garantir-consist%C3%AAncia-entre-banco-de-dados-e-eventos-716b68369a41?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/716b68369a41</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[mongodb]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 20:19:14 GMT</pubDate>
            <atom:updated>2026-07-20T20:19:14.897Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/739/0*zi3AECnkwCGhWGk_" /></figure><p>Em sistemas distribuídos, um dos principais desafios é manter consistência entre o estado do banco de dados e a publicação de eventos. Em cenários de integração com Kafka, mensageria ou serviços downstream, é comum acontecer um problema simples, mas muito crítico: a operação de negócio é persistida com sucesso, mas a mensagem que deveria notificar o restante do sistema falha ao ser enviada.</p><p>Esse tipo de falha pode gerar inconsistência de negócio. O dado existe, mas o evento que deveria informar sobre esse dado pode nunca ser publicado. Em outras palavras, o sistema local passou a ter um estado válido, enquanto os demais componentes ainda não sabem disso.</p><p>É exatamente para resolver esse tipo de cenário que o Outbox Pattern se torna tão relevante.</p><h4>O que é o Outbox Pattern?</h4><p>O Outbox Pattern é uma estratégia usada para garantir que eventos de integração sejam publicados de forma confiável, sem depender de uma publicação imediata e diretamente acoplada à operação principal.</p><p>A ideia central é simples: em vez de tentar publicar a mensagem no momento em que a operação é processada, a aplicação grava essa mensagem em um “outbox” no mesmo fluxo transacional do negócio. Assim, a persistência do domínio e a persistência do evento acontecem juntos.</p><p>Se a transação for confirmada, tanto o estado principal quanto o evento de saída estarão salvos. Se algo falhar, a operação inteira é revertida. Isso evita que o sistema persista um dado sem registrar a intenção de publicar o evento correspondente.</p><h4>Quem popularizou o pattern?</h4><p>O conceito é frequentemente associado a <strong>Greg Young</strong>, que ajudou a popularizar ideias relacionadas a eventos, consistência e arquitetura orientada a eventos. Embora o padrão tenha sido discutido e adotado por diversos times ao longo do tempo, ele passou a ser amplamente reconhecido como uma solução prática para problemas de integração confiável.</p><h4><strong>O problema que ele resolve</strong></h4><p>Imagine uma API que cadastra um ativo financeiro. O fluxo mais comum seria:</p><ol><li>gravar o ativo no banco;</li><li>publicar um evento no Kafka informando que o ativo foi criado;</li><li>permitir que outros serviços consumam essa informação.</li></ol><p>O problema aparece quando a primeira etapa funciona, mas a segunda falha. Talvez o Kafka esteja indisponível, a rede tenha caído, ou o broker tenha apresentado um erro temporário. O resultado é que o dado foi salvo, mas o evento não foi entregue.</p><p>Esse é exatamente o tipo de situação que o Outbox Pattern tenta evitar.</p><h4>Como a solução funciona na prática</h4><p>Com o Outbox Pattern, o fluxo muda:</p><ol><li>a aplicação grava o objeto de negócio no banco;</li><li>a aplicação grava também uma mensagem de outbox no mesmo contexto transacional;</li><li>um worker ou processo background lê as mensagens pendentes;</li><li>publica o evento no Kafka;</li><li>marca a mensagem como publicada.</li></ol><p>Ou seja, em vez de “publicar agora”, o sistema passa a “registrar o que precisa ser publicado” e, depois, processa isso de forma assíncrona.</p><h4>Exemplo prático no projeto</h4><p>No projeto criado para demonstrar esse padrão, o cenário foi simplificado para facilitar a compreensão. A API recebe um cadastro de ativo financeiro e, em seguida:</p><ul><li>salva o FinancialAsset no MongoDB;</li><li>cria um OutboxMessage com o evento FinancialAssetCreated;</li><li>grava tudo dentro de uma transação;</li><li>um worker lê as mensagens ainda pendentes;</li><li>publica a mensagem no Kafka;</li><li>atualiza o status da mensagem para Published.</li></ul><p>A ideia aqui não é mostrar uma arquitetura complexa, mas sim um exemplo claro e didático do padrão em ação.</p><p>Exemplo de código: persistindo o negócio e o evento juntos</p><pre>var asset = new FinancialAsset<br>{<br>    Name = command.Name,<br>    AssetType = command.AssetType,<br>    IsinCode = command.IsinCode,<br>    InitialValue = command.InitialValue,<br>    CreatedAt = DateTime.UtcNow<br>};<br><br>var outboxMessage = new OutboxMessage<br>{<br>    AggregateId = asset.Id,<br>    EventType = &quot;FinancialAssetCreated&quot;,<br>    Payload = JsonSerializer.Serialize(new<br>    {<br>        asset.Id,<br>        asset.Name,<br>        asset.IsinCode,<br>        asset.InitialValue<br>    }),<br>    Status = OutboxMessageStatus.Pending,<br>    CreatedAt = DateTime.UtcNow<br>};<br><br>using var session = await _mongoDbContext.Client.StartSessionAsync();<br>session.StartTransaction();<br><br>await _mongoDbContext.FinancialAssets.InsertOneAsync(session, asset);<br>await _mongoDbContext.OutboxMessages.InsertOneAsync(session, outboxMessage);<br><br>await session.CommitTransactionAsync();</pre><p>Esse trecho mostra a essência do padrão: a operação de negócio e o evento de saída são tratados como uma única unidade de consistência.</p><p>Exemplo de código: worker publicando mensagens pendentes</p><pre>var pendingMessages = await _mongoDbContext.OutboxMessages<br>    .Find(message =&gt; message.Status == OutboxMessageStatus.Pending)<br>    .ToListAsync();<br><br>foreach (var message in pendingMessages)<br>{<br>    await _publisher.PublishAsync(message);<br><br>    await _mongoDbContext.OutboxMessages.UpdateOneAsync(<br>        m =&gt; m.Id == message.Id,<br>        Builders&lt;OutboxMessage&gt;.Update<br>            .Set(x =&gt; x.Status, OutboxMessageStatus.Published));<br>}</pre><p>Aqui, o worker é responsável por transformar as mensagens de outbox em eventos reais no Kafka. Esse mecanismo é o que permite que o sistema continue funcionando mesmo quando a publicação original falha.</p><h4>Por que esse padrão faz sentido?</h4><p>O Outbox Pattern é especialmente útil em cenários onde:</p><ul><li>você precisa garantir que eventos sejam publicados mesmo quando a integração estiver temporariamente indisponível;</li><li>deseja reduzir o risco de perder mensagens;</li><li>quer desacoplar o processamento principal da publicação de eventos;</li><li>precisa construir fluxos mais resilientes e confiáveis.</li></ul><p>Ele não elimina todos os problemas de sistemas distribuídos, mas ajuda muito a reduzir uma das fontes mais comuns de inconsistência: a divergência entre o que foi persistido e o que foi comunicado.</p><h4>Conclusão</h4><p>O Outbox Pattern é uma solução prática e eficiente para um problema muito comum em arquiteturas orientadas a eventos: como garantir que um evento seja publicado sem comprometer a consistência do sistema.</p><p>Ao gravar a intenção de publicar o evento junto com a operação principal, a aplicação passa a ter um mecanismo mais confiável para lidar com falhas, retries e integrações assíncronas. O resultado é uma arquitetura mais resiliente, com menos chance de inconsistência entre banco e mensageria.</p><p>No projeto apresentado, esse conceito foi aplicado de forma simples e didática com .NET, MongoDB, Kafka e um worker de publicação. O objetivo foi mostrar que o padrão pode ser compreendido e implementado sem precisar de uma arquitetura excessivamente complexa.</p><p>O repositório completo está disponível aqui:<br><a href="https://github.com/felipeleitao-spec/OutBoxPattern">https://github.com/felipeleitao-spec/OutBoxPattern</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=716b68369a41" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Uma IA se recusou a me obedecer — e foi a melhor coisa que aconteceu com meu projeto essa semana]]></title>
            <link>https://medium.com/@felipesilva_71272/uma-ia-se-recusou-a-me-obedecer-e-foi-a-melhor-coisa-que-aconteceu-com-meu-projeto-essa-semana-0b6d7a374e77?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b6d7a374e77</guid>
            <category><![CDATA[inteligencia-artificial]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Fri, 17 Jul 2026 15:13:28 GMT</pubDate>
            <atom:updated>2026-07-17T15:13:28.790Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/360/0*IKBq1Q-J-DQguzBE" /></figure><p>Eu tinha uma ideia simples: escrever um artigo. Sentei, abri uma conversa com uma ferramenta de IA e digitei o que queria. Esperava o de sempre — aquele “ótima ideia! aqui está um rascunho completo pra você”. Foi aí que a coisa deu errado. No melhor sentido possível.</p><p>A resposta que recebi não foi um rascunho. Foi uma pergunta. E depois outra. E quando eu tentei escapar com uma resposta genérica, veio a frase que mudou o tom de tudo:</p><blockquote>Você não respondeu minha pergunta. Você me deu uma lista de ingredientes, não uma tese.</blockquote><p>Eu tinha acabado de ser pego.</p><h4>A ferramenta: grill-me</h4><p>grill-me é uma skill — uma extensão de comportamento para agentes de IA — com uma única função: te entrevistar de forma implacável para afiar um plano ou uma ideia. Você roda /grilling e, em vez de um assistente prestativo que concorda com tudo, aparece um interrogador que faz o oposto: uma pergunta de cada vez, sem elogios, sem aceitar resposta pela metade.</p><p>Se você já usou ChatGPT, conhece o padrão contrário: você diz qualquer coisa e ele valida, elogia, expande. É confortável. E é exatamente por isso que raramente melhora suas ideias — um espelho que só concorda não mostra os pontos cegos. A grill-me foi feita para ser o espelho que discorda.</p><h4>A virada: eu esperava um sócio, ganhei um chefe exigente</h4><p>Minha primeira resposta sobre o que eu queria do artigo foi algo como: “explicar as vantagens, comentar sobre a skill, colocar um caso de teste e publicar.”</p><p>Parece razoável, né? A ferramenta não achou. Ela apontou que aquilo era um catálogo de ingredientes, não uma direção — e me desafiou a completar, em uma única frase falseável: “Depois de ler meu artigo, o leitor vai acreditar que ___ e por isso vai fazer ___.”</p><p>Eu tentei. Errei. Ela apontou que minha tese sobrevivia se eu trocasse “grill-me” por “conversar com um amigo esperto” — ou seja, não vendia nada de específico. Pediu o diferencial. Eu respondi, de novo vago: “ajuda a deixar minha ideia menos vaga.”</p><p>E aqui está o momento que eu não esperava.</p><h4>Antes e depois: as três respostas que me denunciaram</h4><p>A ferramenta me devolveu isto:</p><blockquote>Repare no que acabou de acontecer: eu perguntei qual o diferencial e você respondeu “menos vaga” — que é a tese que já tínhamos, repetida, e de forma vaga. Isso não é crítica gratuita. É o seu melhor material de artigo. Você está, neste exato momento, sendo grelhado e escorregando pra respostas genéricas.</blockquote><p>Ela estava certa. Em três perguntas seguidas eu tinha respondido “comentar sobre a skill”, “refinar ideias” e “menos vaga” — três formas de não dizer nada. E o diferencial da ferramenta que eu não conseguia nomear estava bem ali, acontecendo comigo: ela recusa a resposta fácil e te obriga a ser específico até doer.</p><p>Comparado ao ponto de partida, o contraste é gritante:</p><p>Início: “quero explicar as vantagens e comentar sobre a skill.”<br>Fim: “a skill refina ideias porque recusa respostas vagas e força especificidade repetidamente — algo que um assistente bajulador não faz.”</p><p>A segunda frase não foi ideia dela. Foi minha — arrancada de mim a fórceps, uma pergunta de cada vez.</p><h4>Por que isso funciona</h4><p>O mecanismo é quase bobo de tão simples: a ferramenta não deixa o vago passar. Toda vez que eu me escondia atrás de uma abstração — “refinar”, “melhorar”, “ajudar” — ela parava, apontava e pedia de novo.</p><p>Nós fazemos isso o tempo todo sem perceber. Achamos que temos uma ideia clara porque conseguimos descrevê-la com palavras confortáveis e genéricas. A grill-me remove o conforto. E sem o conforto, ou você tem clareza de verdade, ou percebe que não tinha — que já é meio caminho andado.</p><p>Não substitui pensar. Faz o oposto: te impede de fingir que já pensou.</p><h4>O resultado</h4><p>No fim da sessão, eu não tinha só “uma ideia mais clara”. Eu tinha um plano completo do artigo que você está lendo: a tese, o formato, a estrutura seção por seção, o gancho, e até três pontos cegos que eu ainda precisava resolver. Este texto é o resultado do experimento — a prova rodando na sua frente.</p><h4><strong>Como testar você mesmo</strong></h4><p>1. Tenha um agente com suporte a skills.<br>2. Instale ou ative a skill grill-me.<br>3. Rode /grilling e traga uma ideia que você acha que já está clara.<br>4. Resista à vontade de responder por cima. Quando a resposta fácil vier, é aí que está o ouro.</p><p>Leva dez minutos. E, aviso: é desconfortável. É pra ser.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b6d7a374e77" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Economizando tokens com o CavemanCode]]></title>
            <link>https://medium.com/@felipesilva_71272/economizando-tokens-com-o-cavemancode-5b089fc4fc95?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b089fc4fc95</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[token]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Tue, 02 Jun 2026 19:08:16 GMT</pubDate>
            <atom:updated>2026-06-04T10:44:03.103Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R_783TQtypPomdLy.jpg" /><figcaption>Fazia parte da minha infância</figcaption></figure><p>Nos últimos meses, muita gente descobriu na prática o que as tabelas de preços de LLMs já avisavam:<br>ficar mandando tudo para o modelo — logs, contextos gigantes, históricos de conversa — <strong>custa caro</strong>.</p><p>Se você trabalha com produtos que usam modelos de linguagem, provavelmente já viu uma dessas situações:</p><ul><li>A fatura de IA crescendo mês a mês, sem ninguém saber exatamente o porquê.</li><li>Features “simples” (tipo autocomplete, sumarização, explicação de erro) consumindo milhares de tokens por requisição.</li><li>Time de engenharia tendo que “capar” contexto ou desativar logs ricos para tentar segurar custo.</li></ul><p>Foi nesse contexto que comecei a explorar ferramentas para reduzir o uso de tokens sem sacrificar a experiência. Uma das mais interessantes desse universo é o Caveman: um plugin que, em essência, ajuda você a falar com o modelo no “modo econômico”.</p><p>Neste artigo, vou explicar:</p><ul><li>O problema de gastos de tokens hoje.</li><li>Como o Caveman entra nessa história.</li><li>Como instalar e configurar.</li><li>Exemplos práticos de uso.</li><li>E como isso tudo ajuda a reduzir custo na vida real.</li></ul><h3>O problema: estamos desperdiçando tokens</h3><p>Modelos de linguagem cobram por tokens, não por “requisição”. E aí aparecem vários antipadrões bem comuns:</p><ol><li><strong>Prompts verbosos demais</strong><br>Você manda 2–3 páginas de texto de contexto, instruções redundantes, exemplos enormes… em toda chamada.</li><li><strong>Contexto histórico infinito</strong><br>Cada nova interação reenvia toda a conversa anterior, mesmo quando o modelo só precisa de uma parte.</li><li><strong>Estruturas de dados enormes</strong><br>JSONs com muitos campos, logs extensos, schemas gigantes, tudo indo em texto puro para o modelo.</li><li><strong>Uso ingênuo de ferramentas/“agents”</strong><br>Vários agentes conversando entre si, cada um gerando prompts enormes, sem nenhum controle fino de custo.</li></ol><p>O resultado é simples:<br>você paga por um monte de tokens que não agregam valor à resposta.</p><p>É aqui que entra a ideia de “falar como um caveman”: dizer o mínimo necessário, da forma mais compacta possível, sem perder o sentido.</p><h3>O que é o Caveman e por que ele ajuda</h3><p>O Caveman é, de forma geral, um plugin/ferramenta que:</p><ul><li>Reduz a quantidade de texto que você envia para o modelo (compressão/compactação de prompt).</li><li>Estrutura melhor o que vai ser enviado, removendo redundâncias e ruído.</li><li>Em alguns cenários, transforma o texto em uma representação mais densa (por exemplo, resumos, tags, códigos), para depois reconstruir ou complementar a resposta.</li></ul><p>A ideia não é “deixar o modelo burro”.<br>A ideia é dizer a mesma coisa em menos tokens.</p><p>Na prática, isso pode significar:</p><ul><li>Mandar resumos em vez de textos integrais quando não precisa de 100% dos detalhes.</li><li>Reduzir instruções repetidas e padronizá-las.</li><li>Compactar contextos muito grandes para caberem em menos tokens.</li></ul><p>O Caveman entra como uma camada entre a sua aplicação e o modelo, ajudando a:</p><ul><li>Diminuir o tamanho dos prompts.</li><li>Controlar melhor o custo por requisição.</li><li>Evitar estouro de limite de contexto em modelos menores (mais baratos).</li></ul><h3>Instalação</h3><p>A instalação pode ser feita através da propria npm através do comando abaixo</p><pre>npm install -g @juliusbrussee/caveman-code</pre><h4><strong>Inicio Rápido</strong></h4><pre>caveman                            # interactive TUI<br>caveman &quot;fix the failing tests&quot;     # start with a prompt<br>caveman -p &quot;summarize this file&quot;    # non-interactive: print and exit<br>cat err.log | caveman -p &quot;debug&quot;    # pipe stdin<br>caveman -c                          # continue last session<br>caveman -r                          # browse + resume sessions<br>caveman --plan &quot;ship payments v2&quot;   # plan mode — read-only<br>caveman --goal &quot;ship payments v2&quot;   # autonomous Ralph loop]</pre><p>Para abrir a ferramenta, basta digitar “caveman” no seu terminal predileto, aqui estou utilizando windows com WSL</p><p>Após abrir a ferramenta, você precisa autenticar o seu provider de tokens, no meu caso estou utilizando o copilot, faça isso utilizando o slash command /login</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*KgX-MfuTCERPAnArH0VktQ@2x.jpeg" /></figure><p>No meu caso, segui o passo abaixo</p><p>/login -&gt; Github Copilot -&gt; github.com -&gt; acessar a url e digitar os 8 digitos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/615/1*EcOSFBgRwxQ9zonkLYvF4Q.avif" /></figure><p>Agora finalmente, podemos configurar o nivel de caveman que queremos utilizar, para isso utilize o comando /cave &lt;nivel&gt;, no meu caso irei usar cave ultra</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/699/1*d0gPLueYUGBXG3gm03YKoQ.avif" /></figure><h3>Exemplo prático #01 — Criação de AGENTS.md</h3><h4>Modo Normal</h4><p>Aqui vamos rodar um exemplo simples de comparação, na criação de um arquivo agents.md, algo que deveria ser padrão para todo projeto, lembrando que ter um contexto por si só já diminui muito o uso de tokens por diminuir ambiguidade e deixar claro como aquele componente funciona.</p><p>Gerando AGENTS.MD sem o caveman, a geração foi feita através do prompt “me faça um resumo desse projeto”, aqui foram gastos 20mil tokens</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/323/1*MLzL2lbMQHrvkMC2OH4txA.avif" /></figure><h4>Caveman Code</h4><p>Agora vamos testar utilizar o caveman code para redução de tokens, mas antes de começar, precisamos entender como ele trabalha essa redução, basicamente podemos configurar “niveis” de redução, aqui irei utilizar o modo ultra, que é o segundo mais alto. Aqui o nosso gasto foi de apenas 12mil tokens (aproximadamente uma redução de 40%)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*UfhZI5DOVCS1UFeoOmYlGA.avif" /></figure><h3>Conclusão: IA é poderosa, mas não precisa ser cara</h3><p>O que o Caveman mostra na prática é que:</p><ul><li>Não é porque você <em>pode</em> mandar tudo para o modelo que você <em>deve</em> mandar.</li><li>Um pouco de inteligência na forma de representar contexto gera economia real de tokens.</li><li>Essa economia é especialmente importante quando você escala o uso de IA para muitos usuários, squads e produtos.</li></ul><p>Se você está sentindo a dor da fatura de IA crescendo, vale testar:</p><ul><li>Introduzir uma camada de compressão/otimização de prompts (como o Caveman).</li><li>Medir tokens antes e depois.</li><li>Ajustar o “modo econômico” até encontrar o equilíbrio entre custo e qualidade.</li></ul><p>No fim, a ideia é simples:</p><blockquote>Falar menos, com mais precisão — e deixar o modelo trabalhar com o que realmente importa.</blockquote><p>Se você já usa Caveman ou alguma solução similar, compartilha nos comentários do Medium quais foram os seus ganhos e aprendizados. Esse é um campo novo, e quanto mais a gente troca experiências, mais fácil fica construir soluções de IA sustentáveis e baratas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5b089fc4fc95" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Configurando ambiente  .NET no WSL]]></title>
            <link>https://medium.com/@felipesilva_71272/configurando-ambiente-de-desenvolvimento-net-no-wsl-47d88e3ef86d?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/47d88e3ef86d</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Wed, 06 May 2026 21:59:10 GMT</pubDate>
            <atom:updated>2026-05-11T13:46:01.537Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Configurando ambiente .NET no WSL</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/539/0*L-o-ponxyZsIg9MC.png" /><figcaption>WSL Rocks</figcaption></figure><p>Se você é desenvolvedor de aplicações .net e ainda está utilizando windows para escrever seu código, debugar ou trabalhar, você está sacrificando grande parte da sua performance.</p><p>Neste artigo, você vai aprender:</p><ul><li>Por que usar WSL desenvolvimento</li><li>Como instalar o .net via apt-get</li><li>Utilizando CLI’s para automatizar atividades</li><li>Configurar o VS Code para WSL</li><li>Consumindo um privacy nuget</li></ul><p>Vamos direto ao ponto.</p><h3>Por que usar o WSL?</h3><p>Se você está no Windows, recomendo fortemente usar o WSL (Windows Subsystem for Linux) para desenvolver a criação do seu projeto.</p><h3>Vantagens do WSL:</h3><p>✅ Compatibilidade total com ferramentas Unix/Linux<br>✅ Performance superior para operações de I/O e processos<br>✅ Ecosistema nativo para Node.js, Python e ferramentas de dev<br>✅ Integração com VS Code via extensão Remote-WSL<br>✅ Evita problemas de path, permissões e encoding do Windows</p><h3><strong>Como instalar o WSL (se ainda não tiver):</strong></h3><p>Abra o PowerShell como administrador e rode:</p><p>wsl --install</p><p>Isso instala o WSL 2 com Ubuntu por padrão. Reinicie o PC quando solicitado.</p><p>Após reiniciar, abra o terminal Ubuntu e configure seu usuário.</p><p>Pronto! Agora você tem um ambiente Linux completo rodando no Windows.</p><h3><strong>Como Instalar o .net no ambiente WSL</strong></h3><p>O SDK .NET permite que você desenvolva aplicativos com .NET. Se você instalar o SDK .NET, não precisa instalar o runtime correspondente. Para instalar o SDK .NET, execute os seguintes comandos:</p><pre>#configure dotnet backports<br>sudo add-apt-repository ppa:dotnet/backports<br><br>#10.0<br>sudo apt-get update &amp;&amp; \<br> sudo apt-get install -y dotnet-sdk-10.0<br><br>#8.0<br>sudo apt-get update &amp;&amp; \<br> sudo apt-get install -y dotnet-sdk-8.0</pre><p>Para aprender a usar a CLI .NET, veja <a href="https://learn.microsoft.com/en-us/dotnet/core/tools/">a visão geral da CLI .NET</a>.</p><h3><strong>Utilizando CLI’s para automatizar atividades</strong></h3><p>Hoje um grande desafio que enfrentamos é o tempo gasto com atividades que precisam de atuação humana, como por exemplo, criar boards no azure devops, consumir dados de atividades, iniciar pipelines, interagir com github via ferramentas e etc; abaixo vou trazer algumas CLI’s que podem</p><p><strong>Azure CLI</strong></p><p>A maneira mais fácil de instalar o CLI do Azure é por meio de um script mantido pela equipe de CLI do Azure. Esse script executa todos os comandos de instalação em uma única etapa. Esse script é baixado por meio de curl e encaminhado diretamente para bash a fim de instalar a CLI.</p><p>Se você quiser inspecionar o conteúdo do script por conta própria antes de executá-lo, basta baixar o script primeiro usando curl e inspecioná-lo no seu editor de texto favorito.</p><pre>curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash</pre><p>Para validar se o azure cli foi instalado corretamente:</p><pre>az --version</pre><p>Você deverá visualizar as informações referentes ao azure cli</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jl-udlIwAscaV7ba.jpg" /></figure><p>Com o azure CLI, você está apto para realizar o login nele e realizar operações contra o portal azure ou az devops</p><pre>#Instalação padrão (pode ocorrer erros caso não tenha subscriptions)<br>az login<br><br>#caso você não possua subscriptions no portal azure, utilize o comando abaixo<br>az login --allow-no-subscriptions</pre><p><strong>Github CLI</strong></p><p>A ferramenta github cli vai nos permitir realizar operações contra o github através de linhas de comando, também facilitando para uso de ferramentas agênticas, com o gh cli você pode realizar clones, pr’s, commits etc</p><p>Para instalar, o comando é o abaixo (ele é meio grande mesmo)</p><pre>(type -p wget &gt;/dev/null || (sudo apt update &amp;&amp; sudo apt install wget -y)) \<br>	&amp;&amp; sudo mkdir -p -m 755 /etc/apt/keyrings \<br>	&amp;&amp; out=$(mktemp) &amp;&amp; wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg \<br>	&amp;&amp; cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg &gt; /dev/null \<br>	&amp;&amp; sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \<br>	&amp;&amp; sudo mkdir -p -m 755 /etc/apt/sources.list.d \<br>	&amp;&amp; echo &quot;deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main&quot; | sudo tee /etc/apt/sources.list.d/github-cli.list &gt; /dev/null \<br>	&amp;&amp; sudo apt update \<br>	&amp;&amp; sudo apt install gh -y</pre><p>Após a instalação precisamos autenticar no github</p><pre>gh auth login</pre><p>Deve ser exibido algumas informações e você deve escolher a forma para autenticar, normalmente é pelo proprio github e de maneira publica, você precisará abrir a tela no browser e digitar os código</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6r-7XPSknNeF94aN.png" /><figcaption>Exemplo de autenticação no github cli</figcaption></figure><p>Para finalizar, você deve salvar seu setup</p><pre>gh auth setup-git</pre><h3><strong>Utilizando o vs code integrado ao WSL</strong></h3><p>A extensão Visual Studio Code WSL permite que você use o <a href="https://learn.microsoft.com/windows/wsl">Windows Subsystem for Linux (WSL)</a> como seu ambiente de desenvolvimento em tempo integral diretamente do VS Code. Você pode desenvolver em um ambiente baseado em Linux, usar cadeias de ferramentas e utilitários específicos do Linux, e executar e depurar seus aplicativos baseados em Linux, tudo no conforto do Windows.</p><p>A extensão executa comandos e outras extensões diretamente no WSL, então você pode editar arquivos localizados no WSL ou no sistema de arquivos montado do Windows (por exemplo) sem se preocupar com problemas de caminhos, compatibilidade binária ou outros desafios entre sistemas operacionais. A extensão instalará o VS Code Server dentro do WSL; o servidor é independente de qualquer instalação existente de VS Code no WSL./mnt/c</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/0*V-Z__25R2Ja2yXXq.png" /></figure><p>Isso permite que o VS Code ofereça uma experiência de desenvolvimento de qualidade local — incluindo IntelliSense completo (completações), navegação de código e depuração — independentemente de onde seu código esteja hospedado</p><h3>A partir do VS Code</h3><p>Para conectar seu vscode ao WSL, você pode clicar na opção Remoto Host e selecionar WSL e sua distribuição</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/0*XHcYq9qiFstJvrXm.png" /></figure><p>O botão de remote host fica no canto inferior esquerdo do vscode, clicando nele basta selecionar WSL</p><h3><strong>Configurando o uso de um privacy nuget via CLI</strong></h3><p>Para começar, você pode acessar a página do azure devops de sua companhia <a href="https://&lt;your.company&gt;.visualstudio.com/">https://&lt;your_company&gt;.visualstudio.com/</a> e clicar no botão ao lado do seu login, e selecionar a opção Personal Acess tokens</p><p>Ou simplesmente acessar a <a href="https://xpinvestimentos.visualstudio.com/_usersSettings/tokens">https://&lt;your.company&gt;.visualstudio.com/_usersSettings/tokens</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/437/0*rEdqoLs-s51tthLE" /><figcaption>PAT LOCATION</figcaption></figure><p>Dê um nome ao seu token, escolha a data de validade e se possivel, use a opção custom defined para liberar apenas acesso read em Packaging</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/0*dWJwDkKotQNYb9W6" /></figure><h3>Adicionando via linha de comando</h3><p>Basta executar o comando abaixo informando seu token, você também pode utilizar variáveis de ambiente caso deseje.</p><pre>dotnet nuget add source https://someServer/myTeam -n myTeam -u myUsername -p myPassword</pre><h3>Validação</h3><p>Para validar, você pode realizar o comando abaixo independente do ambiente</p><pre>dotnet nuget list source</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/0*lGdSr0Ic0ZXZwtKh.png" /></figure><p>Prontinho, se você chegou até aqui, você já tem um ambiente totalmente configurado para enfrentar grande parte dos desáfios de um desenvolvedor .NET com foco em auta produtividade</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47d88e3ef86d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[User stories ainda fazem sentido num mundo em que a IA escreve código?]]></title>
            <link>https://medium.com/@felipesilva_71272/user-stories-ainda-fazem-sentido-num-mundo-em-que-a-ia-escreve-c%C3%B3digo-00fde78a4573?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/00fde78a4573</guid>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Wed, 22 Apr 2026 12:53:16 GMT</pubDate>
            <atom:updated>2026-04-22T12:53:16.364Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*w50z1fICxmWGM6UX.jpeg" /></figure><p>Durante muito tempo, falar em user stories foi quase sinônimo de “fazer produto ágil direito”.<br>Só que hoje temos IA ajudando a desenhar arquitetura, gerar plano de execução e até escrever boa parte do código.</p><p>Isso muda a pergunta:</p><blockquote>Em um contexto onde a IA faz o plano e o desenvolvimento, ainda faz sentido investir tempo escrevendo user stories?</blockquote><p>Ou, de forma mais provocativa:</p><blockquote>O que ainda precisa ser definido por humanos para garantir que o software certo seja construído?</blockquote><p>Este artigo é uma reflexão prática sobre isso: o que muda, o que continua essencial e como podemos evoluir o formato das user stories para um mundo em que a IA faz parte do time.</p><h3>1. O verdadeiro papel de uma user story (sem romantizar o formato)</h3><p>Antes de falar de IA, vale voltar ao básico: user story nunca foi, de verdade, sobre o template clássico:</p><blockquote>“Como pessoa X, quero fazer Y para obter Z.”</blockquote><p>Isso é só forma. O valor real está em quatro coisas:</p><ol><li>Alinhamento de objetivo<br>Por que essa demanda existe?<br>Que problema estamos tentando resolver?<br>Qual dor, oportunidade ou risco ela ataca?</li><li>Contexto de negócio<br>Onde isso se encaixa na jornada do usuário?<br>O que veio antes e o que vem depois?<br>Que regras de negócio estão envolvidas?</li><li>Critérios de sucesso<br>O que significa “feito” do ponto de vista do usuário e do negócio, não só do código?<br>Quais comportamentos ou métricas queremos ver mudando?</li><li>Base para conversas<br>Um artefato que permita produto, tech, UX, negócios e stakeholders conversarem, perguntarem, refinarem e cortarem escopo.</li></ol><p>Quando a gente entende isso, fica mais fácil perceber que:</p><blockquote>Se outro formato cumprir bem esse papel, o nome (user story, spec, brief, RFC) vira detalhe.</blockquote><p>O problema não é a user story em si; é quando ela vira só um campo obrigatório no Jira.</p><h3>2. O que muda quando a IA gera o plano técnico e o código?</h3><p>Agora, imagine um cenário cada vez mais comum:</p><ul><li>Você fornece contexto, objetivo e algumas restrições;</li><li>A IA gera:</li><li>uma proposta de arquitetura</li><li>um plano de execução (épicos, tasks, dependências)</li><li>APIs, modelos de dados e contratos</li><li>e ainda escreve boa parte do código e dos testes.</li></ul><p>Nesse mundo, o gargalo muda de lugar.</p><h3>O que deixa de ser o principal problema?</h3><ul><li>Detalhar o como implementar (a IA é boa nisso).</li><li>Repetir em texto o que a arquitetura e o código já vão expressar melhor.</li></ul><h3>O que vira o principal problema?</h3><ul><li>Deixar claro o que deve ser feito e por quê.</li><li>Tornar explícitas as restrições de negócio, segurança, regulatório e risco.</li><li>Evitar que a IA implemente algo tecnicamente brilhante, mas estrategicamente errado.</li></ul><p>A IA é muito boa em:</p><ul><li>Decompor requisitos em tarefas técnicas;</li><li>Gerar código coerente com um contexto bem definido;</li><li>Sugerir cenários de teste a partir de regras claras.</li></ul><p>Mas ainda é fraca em:</p><ul><li>Captar nuances políticas, culturais e estratégicas da empresa;</li><li>Tomar decisões de trade-off de produto (time-to-market vs robustez, risco vs oportunidade);</li><li>Entender o que realmente importa para o usuário final em um contexto específico.</li></ul><p>Ou seja:</p><blockquote>Em um mundo com IA, não faz sentido gastar tanta energia descrevendo minúcias de implementação, mas continua crítico descrever muito bem o problema, o contexto, o objetivo e o que é aceitável ou não como solução.</blockquote><h3>3. Então… ainda vale a pena escrever user stories?</h3><p>Depende muito do que você chama de “escrever user stories”.</p><h3>3.1. O que tende a ser cada vez menos eficiente</h3><p>Coisas que fazem pouco sentido num cenário com IA forte no ciclo de desenvolvimento:</p><ul><li>Ficar preso ao template “Como pessoa X, quero Y para Z” apenas por ritual, sem ganhar clareza real.</li><li>Produzir textões funcionais descrevendo tela a tela, quando você poderia prototipar visualmente ou deixar a IA sugerir fluxos a partir de um contexto mais simples.</li><li>Criar uma infinidade de stories hipergranulares, quando a IA é muito boa em decompor um objetivo maior em partes menores.</li></ul><p>Em resumo, user story como burocracia tende a perder espaço.</p><h3>3.2. O que fica ainda mais importante com IA no jogo</h3><p>Por outro lado, algumas coisas que já eram importantes ganham ainda mais peso:</p><p>Definir o objetivo de negócio com clareza brutal</p><ul><li>Que métrica queremos afetar?</li><li>Que comportamento do usuário queremos mudar?</li><li>Que problema concreto, observável, estamos atacando?</li></ul><p>Explicitar restrições e riscos</p><ul><li>Regras regulatórias, legais, de compliance;</li><li>Limites de performance, segurança, privacidade;</li><li>Dependências com outros sistemas ou times;</li><li>Acordos de SLA, padrões internos etc.</li></ul><p>Descrever cenários de uso em linguagem humana</p><ul><li>Como o usuário chega até ali, o que tenta fazer, qual atrito existe hoje, como queremos que funcione;</li><li>Cenários extremos relevantes: baixa conexão, grandes volumes, perfis específicos de clientes ou riscos.</li></ul><p>Definir critérios de aceitação com exemplos concretos</p><ul><li>“Consideramos que deu certo se…”</li><li>“Deve bloquear/rejeitar se…”</li><li>Exemplos de entrada e saída, incluindo casos extremos que o negócio realmente se importa em tratar.</li></ul><p>Você pode chamar esse conjunto de user story, brief de produto ou spec leve. O ponto é:</p><blockquote>Esse pacote de contexto + objetivo + restrições + critérios é o insumo essencial que a IA precisa para gerar um bom plano técnico e um bom código.</blockquote><h3>4. Um fluxo mais eficiente com IA no ciclo de desenvolvimento</h3><p>Em vez de discutir se “user story morreu ou não”, faz mais sentido olhar para o fluxo de trabalho num mundo com IA.</p><p>Um fluxo saudável poderia ser algo assim:</p><h3>1. Humanos definem o problema e os outcomes (em linguagem de negócio)</h3><ul><li>Contexto: onde isso entra na estratégia do produto/empresa?</li><li>Problema atual: o que dói hoje? como sabemos que dói?</li><li>Objetivo: qual mudança queremos ver (em comportamento ou métrica)?</li><li>Restrições: tudo o que é inegociável (legal, risco, segurança etc.);</li><li>Cenários principais + edge cases críticos.</li></ul><h3>2. IA transforma isso em artefatos técnicos</h3><p>A partir desse insumo, a IA pode gerar:</p><ul><li>user stories mais técnicas (se o time ainda preferir esse formato);</li><li>plano de execução (épicos, tasks, dependências);</li><li>modelos de dados, APIs, diagramas;</li><li>casos de teste, incluindo testes automatizados.</li></ul><h3>3. Humanos revisam, podam e ajustam trade-offs</h3><ul><li>Conferem se as propostas da IA respeitam o objetivo de negócio;</li><li>Cortam complexidade e escopo que não trazem ganho real;</li><li>Discutem trade-offs: qual a versão mínima que gera valor?</li><li>Onde podemos simplificar sem comprometer resultado ou risco?</li></ul><h3>4. IA implementa; humanos supervisionam e decidem</h3><ul><li>IA gera código, testes, documentação técnica;</li><li>Humanos revisam criticamente:</li><li>qualidade, riscos, alinhamento com a estratégia, aderência a padrões internos, etc.</li></ul><p>Nesse fluxo, faz pouco sentido gastar horas escrevendo manualmente dezenas de user stories tradicionais.<br>Mas faz muito sentido garantir que o insumo de negócio esteja sólido, para que tudo o que vem depois — acelerado pela IA — esteja apontando para o lugar certo.</p><h3>5. Evoluindo o formato: de “user story ágil” para “brief orientado à IA”</h3><p>Em vez de “abandonar user stories”, a evolução natural é:</p><blockquote>Sair do apego ao template ágil e ir para um brief de produto pensado para humanos + IA.</blockquote><p>Abaixo, um exemplo de template que funciona bem nesse contexto.</p><h3>Template de brief orientado à IA</h3><p>1. Contexto</p><ul><li>Área/produto:</li><li>Situação atual em 2–3 frases:</li><li>Quem é impactado (tipo de usuário, segmento, canal etc.):</li></ul><p>2. Problema</p><ul><li>O que exatamente está ruim hoje?</li><li>Como isso aparece na jornada do usuário?</li><li>Existe algum dado ou evidência (mesmo que qualitativa)?</li></ul><p>3. Objetivo (outcome)</p><ul><li>O que queremos mudar?</li><li>Métrica(s) alvo, quando houver (ex.: conversão, NPS, tempo de operação, % de erros);</li><li>Comportamentos que queremos incentivar ou reduzir.</li></ul><p>4. Escopo</p><ul><li>Inclui:</li><li>Itens que precisam necessariamente ser contemplados.</li><li>Não inclui (explicitamente fora de escopo agora):</li><li>Coisas que poderiam gerar escopo infinito, mas não entram nesta entrega.</li></ul><p>5. Cenários principais</p><ul><li>Cenário 1 — fluxo principal<br>Descreva em linguagem natural: como o usuário entra, o que faz, o que espera ver em cada etapa.</li><li>Cenário 2 — variação importante<br>Outro caminho relevante (usuário com perfil diferente, outro canal, outra condição).</li><li>Cenários de erro / edge cases críticos</li><li>O que pode dar errado e é importante tratar?</li><li>Quais erros podem virar problema sério de negócio ou risco?</li></ul><p>6. Critérios de aceitação</p><ul><li>Considerar concluído com sucesso quando:</li><li>…</li><li>…</li><li>Não considerar concluído se:</li><li>…</li><li>…</li><li>Exemplos de entrada/saída (quando fizer sentido):</li><li>Exemplo 1: …</li><li>Exemplo 2: …</li></ul><p>7. Restrições e requisitos não funcionais</p><ul><li>Regras regulatórias e de compliance;</li><li>SLAs e performance;</li><li>Limitações de integração;</li><li>Padrões internos obrigatórios (design, segurança, dados).</li></ul><p>A partir desse brief, você pode pedir para uma IA:</p><ul><li>“Quebre esse conteúdo em user stories técnicas com tasks de implementação e QA.”</li><li>“Sugira cenários de testes (incluindo automatizados) para esses critérios de aceitação.”</li><li>“Gere uma arquitetura inicial e contratos de API alinhados a esse contexto.”</li></ul><p>Você desloca o esforço humano para o que exige entendimento de produto, negócio e contexto, e deixa a IA cuidar da forma técnica.</p><h3>6. Em resumo: o que muda e o que não muda</h3><p>Voltando à pergunta original:</p><blockquote>Em um mundo moderno de construção de software, com IA gerando plano de execução e código, quão importante é continuar escrevendo user stories? O que é mais eficiente?</blockquote><ul><li>User stories no formato tradicional, escritas manualmente e em grande volume, tendem a ser cada vez menos eficientes.<br>Especialmente quando são tratadas como burocracia de processo.</li><li>Entender e comunicar com clareza o problema, o contexto, o objetivo e os critérios de aceitação continua absolutamente essencial.<br>Na verdade, fica ainda mais importante, porque a IA amplifica qualquer ambiguidade presente no insumo.</li><li>A discussão não é “user story morreu?”, e sim:</li></ul><blockquote>Qual é o melhor formato de insumo para humanos + IA construírem o software certo, rápido e com segurança?</blockquote><p>Na prática, a resposta tende a ser:</p><ul><li>Menos apego ao template “Como pessoa X, quero Y para Z”;</li><li>Mais foco em contexto + objetivo + cenários + restrições;</li><li>E um fluxo em que a IA gera o detalhamento técnico, enquanto humanos tomam as decisões de negócio, trade-off e priorização.</li></ul><p>User stories não deixam de existir — <strong>mas evoluem</strong>.<br>De rituais textuais para algo mais próximo de briefs inteligentes, escritos para serem consumidos por pessoas e por modelos de IA ao mesmo tempo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=00fde78a4573" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Potencializando seu desenvolvimento com IA utilizando OPENCODE + OMO (Oh My OpenAgent)]]></title>
            <link>https://medium.com/@felipesilva_71272/potencializando-seu-desenvolvimento-com-ia-utilizando-opencode-omo-oh-my-openagent-a511dd4ea8c3?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/a511dd4ea8c3</guid>
            <category><![CDATA[open-code]]></category>
            <category><![CDATA[oh-my-opencode]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 15:03:02 GMT</pubDate>
            <atom:updated>2026-05-15T13:05:41.966Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/831/0*BFyPHnwW81gKKREQ.png" /></figure><p>Se você quer turbinar sua produtividade com IA diretamente no terminal, o OpenCode é uma ferramenta essencial. E quando você adiciona o Oh My OpenAgent (também conhecido como “oh-my-opencode”), você transforma sua experiência de desenvolvimento com IA em algo verdadeiramente poderoso e personalizado.</p><p>Neste artigo, você vai aprender:</p><ul><li>Por que usar WSL para rodar o OpenCode</li><li>Como instalar o OpenCode via npm</li><li>Como autenticar e configurar o OpenCode</li><li>O que é o Oh My OpenAgent e como ele potencializa o OpenCode</li><li>Passo a passo completo de instalação e configuração</li><li>Configuração de plugins e personalização</li></ul><p>Vamos direto ao ponto.</p><h3>Por que usar o WSL?</h3><p>Se você está no Windows, recomendo fortemente usar o WSL (Windows Subsystem for Linux) para rodar o OpenCode.</p><h3>Vantagens do WSL:</h3><p>✅ Compatibilidade total com ferramentas Unix/Linux<br>✅ Performance superior para operações de I/O e processos<br>✅ Ecosistema nativo para Node.js, Python e ferramentas de dev<br>✅ Integração com VS Code via extensão Remote-WSL<br>✅ Evita problemas de path, permissões e encoding do Windows</p><h3>Como instalar o WSL (se ainda não tiver):</h3><p>Abra o PowerShell como administrador e rode:</p><p>wsl --install</p><p>Isso instala o WSL 2 com Ubuntu por padrão. Reinicie o PC quando solicitado.</p><p>Após reiniciar, abra o terminal Ubuntu e configure seu usuário.</p><p>Pronto! Agora você tem um ambiente Linux completo rodando no Windows.</p><h3>O que é o OpenCode?</h3><p>O OpenCode (<a href="https://opencode.ai/">https://opencode.ai/</a>) é um assistente de código com IA que roda diretamente no terminal. Ele permite que você:</p><ul><li>Gere código a partir de descrições em linguagem natural</li><li>Refatore e otimize código existente</li><li>Depure problemas com sugestões inteligentes da IA</li><li>Automatize tarefas repetitivas de desenvolvimento</li><li>Converse sobre arquitetura, padrões e melhores práticas</li></ul><p>A grande força do OpenCode é trazer modelos de linguagem avançados (LLMs) para dentro do seu fluxo de trabalho, sem sair do terminal.</p><p>Exemplo prático:</p><p>opencode &quot;criar uma API REST em FastAPI com autenticação JWT&quot;</p><p>E você recebe o código completo, pode revisar, ajustar e usar imediatamente.</p><h3>O que é o Oh My OpenAgent?</h3><p>O Oh My OpenAgent (<a href="https://github.com/code-yeongyu/oh-my-openagent">https://github.com/code-yeongyu/oh-my-openagent</a>) é um framework de configuração e extensão para o OpenCode, também chamado de “oh-my-opencode”.</p><p>Ele funciona como um gerenciador de configurações e plugins que:</p><ul><li>Adiciona comandos customizados e atalhos</li><li>Integra ferramentas do seu ambiente de desenvolvimento</li><li>Automatiza workflows complexos</li><li>Gerencia contexto de projetos e sessões</li><li>Expande as capacidades do OpenCode com plugins da comunidade</li></ul><p>Pense nele como o “Oh My Zsh” do mundo OpenCode: transforma a experiência básica em algo poderoso e personalizado.</p><h3>Pré-requisitos</h3><p>Antes de começar, certifique-se de ter:</p><h3>No Windows:</h3><p>✅ WSL 2 instalado (veja seção anterior)<br>✅ Windows Terminal (recomendado para melhor experiência)</p><h3>No WSL/Linux/macOS:</h3><p>✅ Node.js 18+ e npm<br>✅ Git instalado<br>✅ Curl instalado</p><h3>Verificar instalações:</h3><p>Abra seu terminal WSL (ou terminal Linux/macOS) e rode:</p><p>node --version # deve ser v18 ou superiornpm --versiongit --versioncurl --version</p><h3>Instalar Node.js (se necessário):</h3><p>Método recomendado (via nvm):</p><p># Instalar nvmcurl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash # Recarregar shellsource ~/.bashrc # Instalar Node.js LTSnvm install --ltsnvm use --lts</p><p>Ou via apt (Ubuntu/Debian):</p><p>curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -sudo apt-get install -y nodejs</p><h3>1. Instalando o OpenCode</h3><h3>1.1. Instalação global via npm</h3><p>No terminal WSL (ou Linux/macOS), rode:</p><p>npm install -g opencode-ai</p><p>A flag -g instala o OpenCode globalmente, tornando o comando opencode disponível em qualquer diretório.</p><h3>1.2. Verificar instalação</h3><p>Confirme que o OpenCode foi instalado corretamente:</p><p>opencode --version</p><p>Você deve ver algo como:</p><p>opencode-ai v1.x.x</p><h3>1.3. Autenticar o OpenCode</h3><p>Este passo é essencial. O OpenCode precisa de autenticação para funcionar:</p><p>opencode auth login</p><p>Você verá algo como:</p><ol><li>Uma página será aberta automaticamente</li><li>Faça login com sua conta (GitHub, Google, etc.)</li><li>Autorize o OpenCode</li><li>Volte ao terminal</li></ol><p>Quando bem-sucedido, você verá:</p><p>✓ Authentication successful!✓ Your API key has been saved securely.</p><h3>1.4. Teste básico</h3><p>Rode um comando simples para validar:</p><p>opencode &quot;escrever um hello world em Python&quot;</p><p>Se tudo estiver correto, você verá o código gerado:</p><p>print(&quot;Hello, World!&quot;)</p><h3>2. Instalando o Oh My OpenAgent</h3><p>Agora vamos adicionar a camada de superpoderes ao OpenCode.</p><h3>2.1. O que fazer ANTES de instalar</h3><p>O Oh My OpenAgent é instalado dentro do próprio OpenCode, não como um pacote separado.</p><p>Certifique-se de que você:</p><p>✅ Instalou o OpenCode via npm (passo anterior)<br>✅ Autenticou com opencode auth login<br>✅ Está no terminal WSL/Linux/macOS</p><h3>2.2. Documentação do Oh My OpenAgent</h3><p>Para conhecer mais sobre o projeto, as documentações disponíveis estão no github no link:</p><p>📖 Documentação oficial de instalação:<br><a href="https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/installation.md">https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/installation.md</a></p><h3>2.3. Instalando o OMO</h3><p>Para instalar o opencode, basta apenas você abrir o opencode e pedir para que sua LLM faça isso, uma curiosidade é que a propria documentação recomenda fazer isso e cita que “humanos tem dedos gordos para configuração :D”</p><pre>Install and configure oh-my-opencode by following the instructions here:<br>https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/installation.md</pre><h3>2.4. Verificar instalação</h3><p>Para confirmar que está ativo:</p><p>opencode --help</p><p>Você deve ver comandos adicionais fornecidos pelo Oh My OpenAgent, como:</p><ul><li>Gerenciamento de plugins</li><li>Comandos customizados</li><li>Integrações com ferramentas</li></ul><h3>3. Estrutura de configuração</h3><p>Após a instalação completa, você terá uma estrutura similar a:</p><pre>~/.opencode/<br>├── config.json          # Configuração principal do OpenCode<br>├── auth.json           # Credenciais (não versionar!)<br>├── plugins/            # Plugins instalados<br>├── templates/          # Templates customizados<br>└── history/            # Histórico de comandos<br><br>~/.oh-my-openagent/     # (ou dentro de ~/.opencode)<br>├── plugins/            # Plugins do Oh My OpenAgent<br>├── themes/             # Temas visuais<br>├── config.yaml         # Configuração do Oh My OpenAgent<br>└── custom/             # Suas personalizações</pre><h3>3.1. Arquivo de configuração principal</h3><p>Edite a configuração:</p><pre># Usando vim<br>vim ~/.opencode/config.json<br><br># Ou VS Code<br>code ~/.opencode/config.json<br><br># Ou nano<br>nano ~/.opencode/config.json</pre><p>Estrutura típica:</p><pre>{<br>  &quot;llm&quot;: {<br>    &quot;provider&quot;: &quot;openai&quot;,<br>    &quot;model&quot;: &quot;gpt-4-turbo&quot;,<br>    &quot;temperature&quot;: 0.7,<br>    &quot;max_tokens&quot;: 4096<br>  },<br>  &quot;context&quot;: {<br>    &quot;auto_include&quot;: [<br>      &quot;README.md&quot;,<br>      &quot;package.json&quot;,<br>      &quot;requirements.txt&quot;<br>    ],<br>    &quot;max_files&quot;: 15<br>  },<br>  &quot;output&quot;: {<br>    &quot;format&quot;: &quot;markdown&quot;,<br>    &quot;syntax_highlight&quot;: true<br>  },<br>  &quot;plugins&quot;: {<br>    &quot;enabled&quot;: [<br>      &quot;git-helper&quot;,<br>      &quot;docker-tools&quot;,<br>      &quot;project-context&quot;<br>    ]<br>  }<br>}</pre><h3>4. Configurando plugins do Oh My OpenAgent</h3><p>Plugins são o coração do Oh My OpenAgent. Eles adicionam funcionalidades específicas.</p><h3>4.1. Listar plugins disponíveis</h3><p>opencode plugins list</p><p>Ou, se o Oh My OpenAgent tiver seu próprio comando:</p><p>omoa plugins list</p><p>Exemplos de plugins populares:</p><ul><li>git-smart → comandos Git melhorados com IA</li><li>docker-assistant → helpers para Docker</li><li>code-reviewer → revisão automática de código</li><li>test-generator → geração de testes unitários</li><li>doc-writer → documentação automática</li><li>refactor-tools → ferramentas de refatoração</li></ul><h3>4.2. Instalar um plugin</h3><p>opencode plugin install git-smart</p><p>Ou:</p><p>omoa plugin install git-smart</p><h3>4.3. Ativar plugins na configuração</h3><p>Edite ~/.opencode/config.json ou ~/.oh-my-openagent/config.yaml:</p><pre>plugins:<br>  enabled:<br>    - git-smart<br>    - docker-assistant<br>    - code-reviewer<br>    - test-generator</pre><p>Depois, recarregue a configuração:</p><p>opencode reload</p><h3>4.4. Exemplo de uso de plugins</h3><p>Plugin: git-smart</p><pre># Gerar mensagem de commit inteligenteopencode<br> git commit-msg <br><br># Explicar as mudanças no último commitopencode<br> git explain <br><br># Sugerir resolução de conflitoopencode <br>git resolve</pre><p>Plugin: test-generator</p><pre># Gerar testes para um arquivo<br>opencode test generate src/utils.py<br><br># Gerar testes unitários para uma função específica<br>opencode test generate --function calculate_total src/utils.py</pre><p>Plugin: code-reviewer</p><pre># Revisar código atual<br>opencode review src/<br><br># Revisar com foco em segurança<br>opencode review --focus security src/<br><br># Revisar e sugerir melhorias de performance<br>opencode review --optimize src/</pre><h3>5. Integração com VS Code no WSL</h3><p>Se você usa VS Code, pode integrar perfeitamente com o WSL:</p><h3>5.1. Instalar extensão Remote-WSL</h3><p>No VS Code (Windows):</p><ol><li>Instale a extensão Remote — WSL</li><li>Pressione F1 → digite &quot;WSL: Connect to WSL&quot;</li><li>Escolha sua distribuição Ubuntu</li></ol><p>Agora o VS Code roda nativamente no WSL, com acesso total ao OpenCode.</p><h3>5.2. Terminal integrado</h3><p>No VS Code (rodando no WSL):</p><ul><li>Abra o terminal integrado (Ctrl + &#39;)</li><li>O terminal já estará no contexto WSL</li><li>Todos os comandos opencode funcionam normalmente</li></ul><h3>5.3. Snippets e atalhos</h3><p>Crie atalhos de teclado no VS Code:</p><p>keybindings.json:</p><pre>[<br>  {<br>    &quot;key&quot;: &quot;ctrl+shift+g&quot;,<br>    &quot;command&quot;: &quot;workbench.action.terminal.sendSequence&quot;,<br>    &quot;args&quot;: {<br>      &quot;text&quot;: &quot;opencode generate &#39;${selectedText}&#39;\n&quot;<br>    },<br>    &quot;when&quot;: &quot;editorHasSelection&quot;<br>  }<br>]</pre><p>Agora, ao selecionar texto e pressionar Ctrl+Shift+G, o OpenCode gera código baseado na seleção.</p><h3>6. Dicas de produtividade</h3><h3>✅ Use contexto de projeto</h3><p>opencode --context . generate &quot;adicionar endpoint de autenticação&quot;</p><p>Isso faz o OpenCode analisar todo o projeto atual antes de gerar código.</p><h3>✅ Combine comandos</h3><p>opencode generate &quot;função de validação de CPF&quot; | opencode review --optimize</p><p>Isso:</p><ol><li>Gera a função</li><li>Revisa e otimiza</li></ol><h3>✅ Use modo interativo</h3><p>opencode chat</p><p>Isso abre uma sessão interativa onde você pode ter uma conversa contínua com a IA sobre seu código.</p><h3>7. Troubleshooting comum</h3><h3>❌ Problema: “command not found: opencode”</h3><p>Solução:</p><pre># Verificar instalação global<br>npm list -g opencode-ai<br><br># Verificar PATH<br>echo $PATH<br><br># Reinstalar<br>npm install -g opencode-ai<br><br># Verificar novamente<br>which opencode</pre><h3>❌ Problema: “Authentication required”</h3><p>Solução:</p><pre># Fazer logout e login novamente<br>opencode auth logout<br>opencode auth login<br><br># Verificar status<br>opencode auth status</pre><h3>❌ Problema: Oh My OpenAgent não carrega</h3><p>Solução:</p><pre># Verificar instalação<br>ls -la ~/.oh-my-openagent/<br><br># Reinstalar seguindo a documentação oficial<br># Acesse: https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/installation.md<br><br># Verificar configuração<br>opencode plugins list</pre><p>❌ Problema: Comandos lentos no WSL</p><p>Solução:</p><pre># Mover projeto para filesystem nativo do WSL<br># ❌ Evite: /mnt/c/Users/...<br># ✅ Use: ~/projects/...<br><br># Verificar performance de I/O<br>time ls -R<br><br># Se estiver lento, mova o projeto:<br>mv /mnt/c/Users/seu-usuario/projeto ~/projeto</pre><h3>❌ Problema: Erros de permissão</h3><p>Solução:</p><pre># Corrigir permissões npm global<br>sudo chown -R $(whoami) ~/.npm<br>sudo chown -R $(whoami) /usr/local/lib/node_modules<br><br># Reinstalar sem sudo<br>npm install -g opencode-ai</pre><h3>8. Melhores práticas</h3><h3>🎯 Organize seus prompts</h3><p>Crie um arquivo prompts.md no projeto:</p><pre># Prompts úteis<br><br>## Backend<br>- &quot;API REST com FastAPI, autenticação JWT, PostgreSQL&quot;<br>- &quot;CRUD completo para [recurso] com validações&quot;<br><br>## Frontend<br>- &quot;Componente React com TypeScript e styled-components&quot;<br>- &quot;Form com validação usando react-hook-form e zod&quot;<br><br>## Testes<br>- &quot;Testes unitários com pytest e mocks&quot;<br>- &quot;Testes E2E com Playwright&quot;</pre><h3>🎯 Versione suas configurações</h3><pre># Criar repositório de dotfiles<br>mkdir ~/dotfiles<br>cp ~/.opencode/config.json ~/dotfiles/opencode-config.json<br>cp ~/.bashrc ~/dotfiles/.bashrc<br><br>cd ~/dotfiles<br>git init<br>git add .<br>git commit -m &quot;Initial opencode config&quot;</pre><h3>Conclusão</h3><p>Configurar o OpenCode com Oh My OpenAgent no WSL transforma completamente a forma como você desenvolve com IA:</p><p>✅ Ambiente otimizado com WSL para melhor performance<br>✅ Instalação simples via npm<br>✅ Autenticação segura e configuração rápida<br>✅ Extensibilidade através de plugins do Oh My OpenAgent<br>✅ Integração perfeita com VS Code e seu workflow</p><h3>Próximos passos sugeridos:</h3><ol><li>Configure o WSL se estiver no Windows</li><li>Instale o OpenCode via npm e autentique</li><li>Adicione o Oh My OpenAgent seguindo a documentação oficial</li><li>Explore os plugins disponíveis e ative os que fazem sentido para você</li><li>Integre com VS Code para uma experiência ainda melhor</li></ol><h3>Recursos adicionais</h3><ul><li>📚 <a href="https://opencode.ai/docs">Documentação oficial do OpenCode</a></li><li>🐙 <a href="https://github.com/code-yeongyu/oh-my-openagent">Repositório Oh My OpenAgent</a></li><li>📖 <a href="https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/installation.md">Guia de instalação Oh My OpenAgent</a></li><li>💡 <a href="https://docs.microsoft.com/en-us/windows/wsl/">WSL Documentation</a></li></ul><p>E você, já usa OpenCode? Conta nos comentários sua experiência e quais plugins fazem mais diferença no seu dia a dia! 👇</p><p>Quer mais dicas de produtividade com IA? Me segue aqui no Medium para não perder os próximos artigos. 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a511dd4ea8c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Menos bugs, mais disciplina: os benefícios de usar Husky.Net no seu repositório .NET]]></title>
            <link>https://medium.com/@felipesilva_71272/menos-bugs-mais-disciplina-os-benef%C3%ADcios-de-usar-husky-net-no-seu-reposit%C3%B3rio-net-e7e2a236d5ad?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7e2a236d5ad</guid>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[hooks]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Mon, 13 Apr 2026 22:39:00 GMT</pubDate>
            <atom:updated>2026-04-13T22:50:02.696Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uStJ5Qw2c5dsGR1y2nmbCA.avif" /></figure><h3>1. Introdução: o caos silencioso dos commits sem disciplina</h3><p>Em times .NET, é comum vermos o mesmo padrão se repetir: alguém faz um commit rápido, esquece de rodar os testes, envia o código para a branch principal e, alguns minutos depois, A pipeline quebra e o tech lead chora. A correção até é simples, mas o custo de contexto, retrabalho e frustração é alto. Nesse cenário, depender apenas da disciplina individual não escala. É aqui que entra o Husky.Net.</p><h3>2. O que é Husky.Net e por que você deveria se importar?</h3><h3>2.1. Git hooks em poucas palavras</h3><ul><li>Git hooks são scripts que rodam em momentos específicos do fluxo Git (pre-commit, pre-push, commit-msg etc.).</li><li>Eles permitem automatizar verificações e tarefas antes que algo chegue no repositório remoto.</li></ul><h3>2.2. Onde entra o Husky.Net</h3><ul><li>Husky.Net = forma organizada, versionada e amigável de gerenciar Git hooks em projetos .NET.</li><li>Em vez de mexer direto em .git/hooks, você configura via projeto, com comportamento replicável para todo o time.</li></ul><p>Alguns destaques:</p><ul><li>Focado em .NET (rodar dotnet commands é natural).</li><li>Facilita manter a configuração junto do código.</li><li>Torna a automação parte da cultura do repositório, não algo manual.</li></ul><h3>3. Benefícios principais de usar Husky.Net</h3><h3>3.1. Automação de tarefas chatas (e fundamentais)</h3><ul><li>Rodar dotnet build, dotnet testautomaticamente antes do commit.</li><li>Rodar dotnet format para padronizar estilo.</li><li>Executar scripts de validação personalizados (verificação de pastas, geração de código, etc).</li></ul><p>Em vez de lembrar de rodar testes, você deixa o Husky.Net lembrar por você. Se algo quebra, o commit é bloqueado, e o problema é resolvido na origem, enquanto o contexto ainda está fresco na sua cabeça.</p><h3>3.2. Padronização de código e revisão mais produtiva</h3><ul><li>Garantir que todo commit passe por formatação e validações mínimas.</li><li>Menos discussões sobre estilo em PR, mais foco em lógica e arquitetura.</li><li>Ajudar a manter o repositório limpo, mesmo com muitos contribuidores.</li></ul><h3>3.3. Menos bugs triviais chegando na main</h3><ul><li>Evitar commits que não compilam ou com testes unitários quebrados.</li><li>Husky.Net como primeira linha de defesa; CI como segunda.</li><li>Menos frustração com pipeline quebrado por problemas óbvios.</li></ul><p>Abordagem:<br>Gostaria de trazer aqui alguns casos comuns que são basicamente, quando um desenvolvedor precisa alterar um trecho pequeno de código, no auto de sua confiança, é muito comum ele simplesmente alterar, commitar e realizar o push; acontece que, na grande maioria das vezes, ele vai abrir Pull Request, o time vai ler, aprovar. E depois o fluxo de CI/CD vai ser executado, e quando chegar na etapa de testes, descobrir que algum teste de unidade quebrou, com isso foram perdido DIVERSOS minutos, com um hook bem configurado, podemos realizar builds e testes de maneira totalmente automática e local.</p><h3>3.4. Onboarding e colaboração mais fluídos</h3><ul><li>Novo dev clona o repositório, instala dependências, e já está sob as mesmas regras que o restante da equipe.</li><li>Menos “ah, eu não sabia que precisava rodar esse script antes”.</li><li>Reforça a cultura de engenharia do time.</li><li>Ajuda times distribuídos (remoto) a manter comportamento consistente.</li></ul><h3>4. Husky.Net na prática: um exemplo de setup</h3><blockquote>o Exemplo mais comum de setup para o husky, é configurarmos um dotnet build e dotnet test para quando o engenheiro realizar um commit;</blockquote><h3>4.1. Instalando o Husky.Net</h3><ul><li>Para configurar de maneira global, você pode utilizar os comandos abaixo em sua linha de comando, seja windows ou linux</li></ul><pre>dotnet new tool-manifest<br>dotnet tool install Husky</pre><p>Dentro do seu projeto:</p><pre>dotnet husky install</pre><p>Depois de instalar o husky, você deve criar um arquivo chamado task-runner.json na sua pasta .husky pra você definir suas tasks</p><p>Exemplo do mundo real:</p><pre>{<br>   &quot;$schema&quot;: &quot;https://alirezanet.github.io/Husky.Net/schema.json&quot;,<br>   &quot;tasks&quot;: [<br><br>      {<br>         &quot;name&quot;: &quot;dotnet-build&quot;,<br>         &quot;group&quot;: &quot;pre-commit&quot;,<br>         &quot;command&quot;: &quot;dotnet&quot;,<br>         &quot;args&quot;: [&quot;build&quot;, &quot;./src/&quot;, &quot;--no-restore&quot;, &quot;--verbosity&quot;, &quot;normal&quot;, &quot;--include&quot;, &quot;${staged}&quot;]<br>      },<br>      {<br>         &quot;name&quot;: &quot;dotnet-test&quot;,<br>         &quot;group&quot;: &quot;pre-commit&quot;,<br>         &quot;command&quot;: &quot;dotnet&quot;,<br>         &quot;args&quot;: [&quot;test&quot;, &quot;./tests/UnitTests/&quot;, &quot;--no-build&quot;, &quot;--verbosity&quot;, &quot;normal&quot;]<br>      },<br>      {<br>         &quot;name&quot;: &quot;Welcome&quot;,<br>         &quot;output&quot;: &quot;always&quot;,<br>         &quot;command&quot;: &quot;bash&quot;,<br>         &quot;args&quot;: [&quot;-c&quot;, &quot;echo Vai Corinthians! 🥂&quot;],<br>         &quot;windows&quot;: {<br>            &quot;command&quot;: &quot;cmd&quot;,<br>            &quot;args&quot;: [&quot;/c&quot;, &quot;echo Vai Corinthians! 🥂&quot;]<br>         }<br>      }<br>   ]<br>}</pre><h3>4.2. Criando um hook de pre-commit para rodar testes</h3><ul><li>A ideia aqui é o seguinte: vamos criar um hook de<strong> pre-commit</strong> que ira disparar um grupo de ativididades ao ser exer executado um commit</li></ul><pre>dotnet husky add pre-commit -c &quot;dotnet husky run --group pre-commit&quot;s</pre><ul><li>Com isso criamos um hook de pre-commit que roda nossos comandos, em caso de erro o commit será interrompido, seja via CLI ou IDE</li></ul><h3>4.3. Outros hooks interessantes para considerar</h3><ul><li>pre-push: rodar testes mais pesados, checagens de integração, testes de API.</li><li>commit-msg: validar padrão da mensagem de commit (ex: Conventional Commits).</li><li>pre-commit: rodar dotnet format ou outras ferramentas de análise estática.</li></ul><h3>5. Husky.Net + CI/CD: aliados, não concorrentes</h3><ul><li>O husky.net não impede que uma boa pipeline de CI/CD seja necessária, lembrando que aqui estamos ajudando o desenvolvedor a ganhar tempo e garantir mais cultura em nossos projetos, o CI/CD vai muito além disso.</li></ul><h3>6. Limitações, cuidados e boas práticas</h3><h3>6.1. Não transforme hooks em inimigos do time</h3><ul><li>Hook muito pesado torna o fluxo de desenvolvimento lento → dev começa a procurar formas de desativar.</li><li>Evitar rodar testes demorados em pre-commit; preferir pre-push ou CI.</li></ul><h3>6.2. Transparência e documentação</h3><ul><li>Documentar no README:</li><li>Quais hooks existem.</li><li>O que eles fazem.</li><li>Como proceder se der erro (como investigar).</li><li>Explicar como desativar temporariamente em casos emergenciais (sem incentivar abuso).</li></ul><h3>6.3. Evolução gradual</h3><ul><li>Começar simples:</li><li>1 ou 2 hooks críticos (ex: format + testes unitários).</li><li>Depois expandir:</li><li>Outras validações mais específicas da sua realidade.</li></ul><h3>7. Conclusão: disciplina automatizada a favor do time</h3><ul><li>Menos bugs triviais.</li><li>Mais consistência.</li><li>Time focado em resolver problemas de negócio, não em apagar incêndios óbvios.</li><li>Defender a ideia de “disciplina automatizada”:</li><li>Você não depende só da boa vontade; o sistema ajuda a manter o padrão.</li></ul><p>Adotar o Husky.Net não é sobre complicar o fluxo de desenvolvimento, e sim sobre garantir que o básico seja sempre feito. Ao automatizar checagens essenciais, você diminui o número de bugs triviais, aumenta a confiança nos commits e libera o time para se preocupar com o que realmente importa: entregar valor. Se você ainda não usa Husky.Net no seu repositório .NET, vale testar em um projeto piloto e sentir na prática a diferença.</p><h3>8. Referências e próximos passos</h3><ul><li>Documentação oficial <a href="https://alirezanet.github.io/Husky.Net/">Welcome | Husky.Net</a></li></ul><blockquote>Já usa Husky.Net ou alguma outra abordagem de automação com Git hooks em projetos .NET? Conta aqui nos comentários como está sendo a experiência no seu time.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7e2a236d5ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Glossário Essencial de Termos Financeiros]]></title>
            <link>https://medium.com/@felipesilva_71272/gloss%C3%A1rio-essencial-de-termos-financeiros-3fe40412751c?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fe40412751c</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[financial]]></category>
            <category><![CDATA[investimento]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Wed, 18 Jun 2025 14:49:19 GMT</pubDate>
            <atom:updated>2025-10-23T19:18:04.058Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você é desenvolvedor, profissional de tecnologia ou simplesmente quer entender melhor o universo financeiro, este glossário é para você. Reuni aqui os principais termos usados no mercado financeiro, especialmente focados em fundos de investimento, carteiras administradas e cadastro de clientes, com definições claras para facilitar o entendimento e a aplicação em soluções tecnológicas.</p><h3>Termos para fundos de investimento</h3><ul><li><strong>Fundo de Investimento (Investment Fund):</strong> Veículo coletivo que reúne recursos de vários investidores para aplicar em ativos financeiros.</li><li><strong>Cotista (Shareholder):</strong> Pessoa física ou jurídica que investe em um fundo, adquirindo cotas.</li><li><strong>Cota (Unit/Share):</strong> Unidade de participação do investidor no fundo, equivalente à fração do patrimônio do fundo.</li><li><strong>Patrimônio Líquido (Net Asset Value — NAV):</strong> Valor total dos ativos do fundo menos suas obrigações.</li><li><strong>Taxa de Administração (Management Fee):</strong> Valor cobrado pelo gestor para administrar o fundo, geralmente um percentual sobre o patrimônio.</li><li><strong>Taxa de Performance (Performance Fee / PFEE):</strong> Taxa cobrada sobre o rendimento que exceder um índice de referência ou benchmark.</li><li><strong>Benchmark (Benchmark):</strong> Índice de referência usado para comparar o desempenho do fundo.</li><li><strong>Gestor (Fund Manager):</strong> Profissional ou empresa responsável pela administração e decisões de investimento do fundo.</li><li><strong>Administrador (Administrator):</strong> Entidade responsável pela parte operacional e legal do fundo, como registro e controle.</li><li><strong>Liquidez (Liquidity):</strong> Facilidade e rapidez com que o investidor pode resgatar suas cotas e transformar em dinheiro.</li><li><strong>Resgate (Redemption):</strong> Ato de solicitar a devolução do valor investido no fundo, vendendo as cotas.</li><li><strong>Risco (Risk):</strong> Probabilidade de perda ou variação negativa no valor do investimento.</li><li><strong>Diversificação (Diversification):</strong> Estratégia de investir em diferentes ativos para reduzir riscos.</li><li><strong>Fundo Aberto (Open-End Fund):</strong> Fundo que permite entrada e saída de investidores a qualquer momento.</li><li><strong>Fundo Fechado (Closed-End Fund):</strong> Fundo com prazo determinado e número fixo de cotas, sem resgate antes do vencimento.</li><li><strong>Fundo Multimercado (Multimarket Fund):</strong> Fundo que pode investir em diversos tipos de ativos e estratégias, com maior flexibilidade.</li><li><strong>Fundo de Renda Fixa (Fixed Income Fund):</strong> Fundo que investe majoritariamente em títulos de renda fixa, como títulos públicos e privados.</li><li><strong>Fundo de Ações (Equity Fund / Stock Fund):</strong> Fundo que investe principalmente em ações de empresas negociadas na bolsa.</li><li><strong>Dividendos (Dividends):</strong> Parte do lucro distribuída aos cotistas, quando aplicável.</li><li><strong>Valor da Cota (Unit Price / Share Price):</strong> Preço unitário da cota do fundo, calculado dividindo o patrimônio líquido pelo número de cotas.</li><li><strong>Oferta Pública (Public Offering):</strong> Processo de disponibilizar cotas do fundo para investidores no mercado.</li><li><strong>Prospecto (Prospectus):</strong> Documento que apresenta informações detalhadas sobre o fundo, riscos, políticas e objetivos.</li><li><strong>Regulamento (Regulation / Bylaws):</strong> Documento que estabelece as regras de funcionamento do fundo.</li></ul><h3>Termos Financeiros Básicos</h3><ul><li><strong>Saldo (Balance):</strong> Valor disponivel em conta.</li><li><strong>Aplicação Inicial (Initial Investment):</strong> Valor investido no início de um investimento.</li><li><strong>Aplicações Adicionais (Additional Investments):</strong> Valores aportados após a aplicação inicial.</li><li><strong>Rentabilidade (Profitability/Return):</strong> Ganho ou perda obtida em um investimento, geralmente em percentual.</li><li><strong>Juros Compostos (Compound Interest):</strong> Juros calculados sobre o valor principal mais os juros acumulados anteriormente.</li><li><strong>CDI (Interbank Deposit Certificate):</strong> Taxa de referência para investimentos de renda fixa no Brasil.</li><li><strong>IPCA (Consumer Price Index):</strong> Índice oficial de inflação utilizado para correção de investimentos.</li><li><strong>Volatilidade (Volatility):</strong> Medida da variação dos preços de um ativo em determinado período.</li></ul><h3>Termos de Carteiras Administradas</h3><ul><li><strong>Carteira Administrada (Managed Portfolio):</strong> Serviço onde o gestor administra os investimentos de um cliente de forma personalizada.</li><li><strong>Alocação de Ativos (Asset Allocation):</strong> Distribuição dos investimentos entre diferentes classes de ativos.</li><li><strong>Perfil de Investidor (Investor Profile):</strong> Características e tolerância ao risco do investidor.</li><li><strong>Mandato de Investimento (Investment Mandate):</strong> Conjunto de regras e objetivos que guiam a gestão da carteira.</li><li><strong>Rebalanceamento (Rebalancing):</strong> Ajuste periódico da carteira para manter a alocação desejada.</li><li><strong>Risco Ajustado (Risk Adjusted Return):</strong> Retorno do investimento considerando o risco assumido.</li><li><strong>Custódia (Custody):</strong> Serviço de guarda dos ativos financeiros.</li><li><strong>Alocação Tática (Tactical Allocation):</strong> Ajustes temporários na alocação de ativos para aproveitar oportunidades de mercado.</li><li><strong>Alocação Estratégica (Strategic Allocation):</strong> Distribuição de ativos baseada em objetivos de longo prazo e perfil do investidor.</li><li><strong>Drawdown (Drawdown):</strong> Redução máxima do valor de uma carteira ou investimento em determinado período.</li><li><strong>Hedge (Hedge):</strong> Estratégia para proteção contra riscos financeiros.</li><li><strong>Liquidação (Settlement):</strong> Processo de transferência de ativos e dinheiro após uma operação financeira.</li></ul><h3>Termos de Cadastro de Clientes</h3><ul><li><strong>Cadastro (Registration):</strong> Processo de coleta e registro das informações do cliente.</li><li><strong>CPF (Individual Taxpayer Registry):</strong> Número de identificação fiscal do contribuinte no Brasil.</li><li><strong>CNPJ (National Registry of Legal Entities):</strong> Número de identificação fiscal de empresas no Brasil.</li><li><strong>Documento de Identidade (Identity Document):</strong> Documento oficial que comprova a identidade do cliente.</li><li><strong>Comprovante de Residência (Proof of Address):</strong> Documento que comprova o endereço do cliente.</li><li><strong>Perfil do Cliente (Client Profile):</strong> Conjunto de informações que definem características e necessidades do cliente.</li><li><strong>KYC — Conheça Seu Cliente (Know Your Customer):</strong> Processo de verificação da identidade e análise de risco do cliente.</li><li><strong>Due Diligence (Due Diligence):</strong> Processo de investigação para avaliar riscos legais e financeiros do cliente.</li><li><strong>Autenticação (Authentication):</strong> Processo de confirmação da identidade do cliente.</li><li><strong>Consentimento (Consent):</strong> Permissão dada pelo cliente para uso de seus dados pessoais.</li><li><strong>Termo de Adesão (Subscription Agreement):</strong> Documento que formaliza a aceitação dos termos e condições pelo cliente.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*JIBKGXcxNVpUPIkiKGudBg.avif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fe40412751c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lidando com idempôtencia em sistemas distribuídos]]></title>
            <link>https://medium.com/@felipesilva_71272/lidando-com-idemp%C3%B4tencia-em-sistemas-distribu%C3%ADdos-dfae96bd1388?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/dfae96bd1388</guid>
            <category><![CDATA[web]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Thu, 01 May 2025 22:29:40 GMT</pubDate>
            <atom:updated>2025-05-05T18:00:39.094Z</atom:updated>
            <content:encoded><![CDATA[<p>Mas afinal, o que é idempôtencia? vamos a um breve resumo..</p><blockquote>Idempotência é um conceito fundamental em sistemas de informação e, especialmente, em serviços da WEB e API’s. Refere-se à uma operação que pode ser realizada múltiplas vezes sem alterar o seu resultado além da primeira aplicação. Em outras palavras, uma operação é idempotente se, ao ser executada várias vezes, o estado do sistema permanece o mesmo após a primeira execução.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*N5F7MLBW75iRF_wI" /></figure><p>Vamos a um exemplo prático (aqui irei descrever uma situação real que aconteceu comigo anos atrás, no site do Carrefour), Imagine você, um lindo gafanhoto que estava interessado em trocar o som do seu carro, entrei no em um site e adicionei meu tão sonhado SOM ao carrinho de compras, até ai, tudo estaria indo bem. Porém, ao finalizar a compra, por uma instabilidade em minha internet, acabaram chegando <strong>duas requisições</strong> as API’s desse site com alguns segundos de diferença.. qual foi o resultado? Chegaram 2 pedidos em minha casa, e foi um caos na terra conseguir realizar a devolução no produto, sendo que tudo isso poderia ser evitado com uma simples implementação de idempôtencia nessas API’s.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*wGjiUYawmpdlB8f03UmSKg.png" /></figure><p>Qual foi o problema aqui? Basicamente a api não estava preparada para lidar com idempotencia, e a qualquer sinal de instabilidade em meu navegador ou no funcionamento da propria API ela entendeu que era uma nova requisição e fez o processamento duplicado.</p><p>Para resolvermos esse problema, vamos utilizar uma <strong>chave de idempotencia</strong>.</p><p>Uma chave de idempotência é um identificador único utilizado para garantir que uma operação seja executada apenas uma vez, mesmo que várias requisições idênticas sejam enviadas. Ela é crucial para evitar a duplicação de processos, como a criação de pedidos ou a realização de pagamentos, em caso de falhas de rede ou outros problemas que possam causar o reenvio de requisições.</p><p>Nesse caso podemos utilizar um <strong>GUID (</strong>Globally Unique Identifier) para identificar essa transação, aqui em nosso caso, podemos solicitar em nossa api que sempre seja informada um GUID para processar aquela operação, e utilizando alguma base de dados para armazena-la e garantir que já não esteja sendo processada. Ficando com uma arquitetura parecida com a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FWsJLKXmVms10ACLS_8uYw.png" /></figure><p>Aqui percebam como nossa arquitetura funciona, o frontend envia um GUID, que será utilizado pela api para realizar uma <strong>CONSULTA </strong>a base de dados e verificar se esse pedido já existe, caso ele não exista ela seguirá adiante, mas caso já exista podemos retornar um erro impedindo que tenhamos requisições dobradas.</p><p>Mas agora, explorando um pouco mais essas situações de stress, imagine um cenário onde: 2 requisições acabam chegando no <strong>MESMO MILISEGUNDO</strong>. (Pode parecer loucura da minha parte, mais isso acontece com uma frequência maior do que vocês imaginam :D). Pois bem, nesse cenário como as duas requisições estariam sendo processadas simultaneamente pode acontecer de as duas consultas a base de dados serem válidas e o pedido seguir adiante em ambos as requisições, mas e agora, como podemos melhorar ainda mais nossa lógica?</p><p>Aqui podemos utilizar um artificio de banco de dados chamado “UNIQUE KEY”</p><blockquote>Em bancos de dados, uma “unique key” (chave única) é uma restrição que garante que os valores em uma ou mais colunas de uma tabela sejam únicos. Diferentemente da chave primária, uma tabela pode ter múltiplas restrições UNIQUE.</blockquote><p>Sendo assim, com uma configuração de unique key em nossa tabela de pedidos na base de dados podemos garantir que de fato, a transação não seja processada duas vezes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V_TJP4FMZfai6d0c-iSYYg.png" /></figure><p>Pronto, agora temos uma arquitetura preparada para lidar com falhas de rede e que não realizará pedidos em duplicidade.</p><p>Viram como uma vez entendendo o conceito de idempôtencia, a sua implementação se torna fácil e sem muitos artificios? Em situações reais, podemos se deparar com alguns outros tipos de base de dados e situações, mas seguindo esses exemplos, tenho certeza que conseguirão lidar com esse problema fácilmente :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dfae96bd1388" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boas práticas para escrita de logs]]></title>
            <link>https://medium.com/@felipesilva_71272/boas-pr%C3%A1ticas-para-escrita-de-logs-fede526eac2d?source=rss-95894567914a------2</link>
            <guid isPermaLink="false">https://medium.com/p/fede526eac2d</guid>
            <category><![CDATA[logs]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[logger]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[best-practices]]></category>
            <dc:creator><![CDATA[Felipe Silva]]></dc:creator>
            <pubDate>Thu, 08 Feb 2024 13:09:44 GMT</pubDate>
            <atom:updated>2024-02-08T13:19:46.166Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BwnW5yUhzBaPy5ma.jpeg" /></figure><p>Nesse artigo, minha intenção é passar rapidamente por algumas boas práticas para escrita de logs e ser um guia prático de como escrever logs que serão efetivos.</p><h3>Provedores</h3><p>O .NET Core oferece uma API de log que funciona com uma variedade de provedores de logs internos e terceirizados, através do namespace [Microsoft.Extensions.Logging](<a href="https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging">https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging</a>).</p><p>A lista de <strong>provedores internos</strong> inclui:</p><ul><li>Console</li><li>Event Sorce</li><li>EventLog</li><li><a href="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-5.0#built-in-logging-providers">Outros</a></li></ul><p>❌ Evite utilizar o provedor `Console` em ambientes Windows em produção pois <a href="https://weblog.west-wind.com/posts/2018/Dec/31/.Dont-let-ASPNET-Core-Default-Console-Logging-Slow-your-App-down">pode afetar a performance da sua aplicação</a>.</p><p>Também são suportados **provedores de terceiros** como:</p><ul><li>NLog</li><li>log4net</li><li>Serilog</li><li><a href="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-3.1#third-party-logging-providers">Outros</a></li></ul><p>❌ Não chame o log do provedor diretamente mas utilize os tipos nativos <em>ILogger</em> ou <em>ILogger&lt;T&gt;</em> do namespace <a href="https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging?view=dotnet-plat-ext-3.1">Microsoft.Extensions.Logging</a>.</p><h3>Níveis de log</h3><p>Quando começamos a usar ferramentas corretas podemos tirar vantagens dos níveis de logs, através dos níveis de logs podemos filtrar as mensagens que fazem sentido naquele momento. Os níveis também representam prioridades.</p><p><strong>Error</strong>: Alguma coisa muito ruim aconteceu e precisa ser analisada. Em geral os sistemas falham quando situações assim acontecem</p><p><strong>Warn</strong>: Aqui podemos informar que ocorreu uma falha mas o fluxo continua.</p><p><strong>Info</strong>: logs com informações de negócio ou de fluxo que sejam interessantes para monitoramento, podemos utilizar esse nível também para armazenar informações para montar dashboards e alarmes de negócio.</p><p><strong>Debug</strong>: Coisas de desenvolvedor; são usados para informações muito detalhadas de um processo ou fluxo; importante tomarmos cuidado com o uso dele pois geralmente são muito verbosos</p><p>❌ Evite utilizar os níveis de `Trace` e `Debug` em excesso.</p><p>✅ Configure o <a href="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-3.1#log-level">nível do log</a> conforme a necessidade da sua aplicação.</p><p>✅Use os níveis de `Trace` e `Debug` somente para depurar problemas.</p><p>✅ Use os níveis de `Warning` e `Information` no dia-a-dia.</p><h3>Templates</h3><p>❌ Nunca faça uso de `string.Format` ou interpolação de string `$”Meu log: {variavel}”`:</p><pre>// ATENÇÃO: Não faça isso<br>var user = new { Name = &quot;Felipe Leitão&quot;, Age = 666 };<br>logger.LogInformation($&quot;User Age: {user.Age}&quot;);</pre><p>✅ Utilize <a href="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-3.1#log-message-template">templates de log</a> para informar variáveis às mensagens de log.</p><pre>var user = new { Name = &quot;John Doe&quot;, Age = 30 };<br>logger.LogInformation(&quot;User Age: {Age}&quot;, user.Age);</pre><p>✅ Utilize a classe <a href="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/loggermessage?view=aspnetcore-3.1">LoggerMessage</a> em cenários de <strong>alta performance</strong>, pois ele criará mensagens de log passiveis de serem armazenadas em cache, evitando assim conversões de tipos desnecessárias.</p><pre>Action&lt;ILogger, byte, Exception&gt; Message = LoggerMessage.Define&lt;byte&gt;(<br> LogLevel.Information, new EventId(1, &quot;Age&quot;), &quot;User Age: {Age}&quot;);<br><br>var user = new { Name = &quot;Tati Siqueira&quot;, Age = 25};<br>Message(logger, user.Age, null);</pre><h3>Efeitos Colaterais</h3><p>Logs não devem lançar exceções nem devem deixar sua aplicação mais lenta. Quando estiver montando seu log não faça consulta em databases e/ou chamadas a APIs ou sistemas externos. Isso acarreta em poder de processamento desperdiçado na sua aplicação e pode tornar sua aplicação mais lenta.</p><p>❌</p><pre>logger.LogInformation(&quot;Customer {customerName} was purchased a asset&quot;, _customerRepository.GetCustomer(id).Name);</pre><h3>Logs descritivos</h3><p>Mensagens de logs devem agregar valor. Elas devem permitir a quem está lendo (seja um humano ou um sistema) detectar **o que gerou** determinado erro, **em qual momento e quais foram os parâmetros**</p><p>❌</p><pre>logger.LogError(&quot;Database error…&quot;);<br>logger.LogError(&quot;Deu ruim aqui…&quot;);</pre><p>✅</p><pre>logger.LogError(exception, &quot;[Customer Register] Create customer with code: {customerCode} failed&quot;, customerCode);</pre><h3>Exceções</h3><p>Quando você escolhe logar simplesmente a mensagem de uma exceção, provavelmente você terá informações de qual linha do código gerou essa exceção e de qual classe/método aquele erro se originou. No entanto será difícil saber quais dados geraram determinada exceção somente olhando a stacktrace.</p><p>❌</p><pre>logger.LogError(ex.Message());<br><br>```</pre><p>✅</p><pre>logger.LogError(exception, &quot;[User Auth] Auth failed for user: {user}. Problem: {exceptionMessage}&quot;, userId, e.Message);</pre><h3>Dica</h3><p>Caso você utilize Serilog, para garantir que seu time vai utilizar os templates você pode usar o pacote<a href="https://www.nuget.org/packages/SerilogAnalyzer"> SerilogAnalyzer</a> quem é um Roslyn Analyzer que monitora os usos de Log garantido a uso correto do mesmo.</p><pre>&lt;PackageReference Include=&quot;SerilogAnalyzer&quot; Version=&quot;0.15.0&quot;&gt;<br> &lt;PrivateAssets&gt;all&lt;/PrivateAssets&gt;<br> &lt;IncludeAssets&gt;runtime; build; native; contentfiles; analyzers; buildtransitive&lt;/IncludeAssets&gt;<br>&lt;/PackageReference&gt;<br><br><br>:::</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fede526eac2d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>