<?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 Geraldo Bastos on Medium]]></title>
        <description><![CDATA[Stories by Geraldo Bastos on Medium]]></description>
        <link>https://medium.com/@GeraldoBastos?source=rss-4a2a7df91230------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*qcXzGKi6KaGxX5EM.jpg</url>
            <title>Stories by Geraldo Bastos on Medium</title>
            <link>https://medium.com/@GeraldoBastos?source=rss-4a2a7df91230------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 20:15:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@GeraldoBastos/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[Entendendo e trabalhando com Atlas no Godot]]></title>
            <link>https://medium.com/@GeraldoBastos/entendendo-e-trabalhando-com-atlas-no-godot-6803e6ceb92d?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/6803e6ceb92d</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[indie-game-development]]></category>
            <category><![CDATA[mobile-game-development]]></category>
            <category><![CDATA[game-programming]]></category>
            <category><![CDATA[godot-engine]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 11:04:36 GMT</pubDate>
            <atom:updated>2026-08-21T11:04:36.538Z</atom:updated>
            <content:encoded><![CDATA[<p>Continuando meus estudos com o <strong>Godot</strong>, chegou o momento de começar a trabalhar com os elementos que vão formar o cenário do jogo.</p><p>E foi aí que apareceu um conceito que eu ainda não tinha trabalhado dessa forma: <strong>Atlas</strong>.</p><p>No começo pode parecer apenas uma imagem com várias imagens menores dentro — e, de certa forma, é exatamente isso, kkkk.</p><p>Mas entender como ele funciona começou a fazer bastante diferença na forma como estou organizando os assets do jogo.</p><h3>Afinal, o que é um Atlas?</h3><p>Imagine que eu tenha vários elementos que serão utilizados para construir o chão do jogo:</p><ul><li>grama;</li><li>terra;</li><li>asfalto;</li><li>transições entre grama e terra;</li><li>cantos;</li><li>bordas.</li></ul><p>Eu poderia ter um arquivo de imagem para cada um desses elementos.</p><p>Mas também posso organizar vários deles dentro de <strong>uma única imagem maior</strong>.</p><p>Essa imagem é o <strong>Atlas</strong>. No meu caso, comecei trabalhando com tiles de <strong>128 × 128 px</strong>.</p><p>Se eu colocar 4 tiles na horizontal e 4 na vertical, terei: <strong>4 × 128 = 512 px. </strong>Portanto, uma imagem de <strong>512 × 512 px</strong> pode armazenar uma grade de: <strong>4 × 4 = 16 tiles.</strong></p><p>É simples depois que você entende. Antes disso, fiquei olhando aquela imagem cheia de quadradinhos tentando entender o que estava acontecendo. 😅</p><h3>Mas como o Godot sabe qual imagem usar?</h3><p>Essa foi uma das partes importantes para eu entender.</p><p>Apesar de eu entregar ao Godot uma imagem de 512 × 512 px, eu também informo que cada região do Atlas possui <strong>128 × 128 px</strong>.</p><p>Com isso, o Godot consegue dividir aquela textura em células. Então, em vez de eu trabalhar com vários arquivos:</p><p>grama.png<br>terra.png<br>canto.png<br>borda.png</p><p>posso ter algo como:</p><p>terrain_atlas.png</p><p>E dentro dele estão vários tiles.</p><p>Na prática, continuo trabalhando com os pequenos blocos do cenário. A diferença é que eles estão organizados dentro de uma textura maior.</p><h3>Onde a coisa começou a ficar mais interessante: transições</h3><p>Ter um tile de grama e outro de terra é fácil. O problema aparece quando queremos colocar <strong>grama ao lado da terra</strong>.</p><p>Se simplesmente colocarmos um quadrado de grama ao lado de um quadrado de terra, a divisão fica muito evidente.</p><p>Você literalmente começa a enxergar os quadrados que formam o cenário. E não era isso que eu queria.</p><p>Foi aí que comecei a trabalhar com <strong>tiles de transição</strong>. Em vez de ter somente:</p><p><strong>GRAMA | TERRA</strong></p><p>eu posso criar peças intermediárias com bordas, cantos e diferentes combinações dos dois terrenos.</p><p>No projeto comecei trabalhando com transições como:</p><p><strong>Grama ↔ Terra seca</strong></p><p><strong>Grama ↔ Terra úmida</strong></p><p><strong>Grama ↔ Asfalto</strong></p><p>Assim consigo montar o cenário sem deixar aquelas divisões quadradas tão aparentes.</p><h3>As combinações</h3><p>Aqui surgiu outro aprendizado interessante. Uma transição não precisa acontecer apenas da esquerda para a direita.</p><p>Ela pode aparecer em cima, embaixo, nos cantos ou em várias combinações ao mesmo tempo.</p><p>Por isso o Atlas começa a possuir diferentes versões daquela mesma transição.</p><p>No meu caso, trabalhei com uma organização de <strong>16 combinações possíveis de cantos</strong>, dentro de uma matriz 4 × 4.</p><p>Visualmente fica muito mais fácil entender:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oYGYe2T09RQrw0S2FbbXnA.png" /></figure><p>Cada quadrado continua tendo 128 × 128 px.</p><p>O que muda é o desenho dentro dele.</p><p>Quando esses tiles são colocados lado a lado corretamente, as peças se conectam e o jogador deixa de perceber claramente onde termina um tile e começa o próximo.</p><p>E esse foi um dos pontos em que comecei a perceber que criar o cenário não era simplesmente “desenhar um chão”.</p><p>Existe toda uma lógica por trás de como essas peças precisam se conectar.</p><h3>Atlas não precisa ter apenas o chão</h3><p>Outra coisa que aprendi foi a não tentar colocar toda a informação visual dentro do mesmo tile.</p><p>Por exemplo, eu queria que a grama tivesse alguns detalhes para não parecer completamente vazia.</p><p>O problema é que, se uma pedra, folha ou outro detalhe estiver dentro do tile de grama, sempre que aquele tile for utilizado o detalhe aparecerá naquele mesmo lugar.</p><p>Depois de algumas repetições, nosso cérebro começa a perceber o padrão. A solução que estou utilizando é separar as responsabilidades.</p><p>Tenho uma camada responsável pelo <strong>terreno</strong> e posso ter outra responsável pelos <strong>detalhes</strong>.</p><p>Esses detalhes podem utilizar imagens com transparência e serem posicionados separadamente.</p><p>Dessa forma consigo ter um chão mais contínuo e adicionar variedade por cima dele.</p><h3>E então apareceu o TileSet</h3><p>Dentro do Godot, o Atlas começa a fazer sentido junto com o <strong>TileSet</strong>. De forma simplificada, o fluxo que entendi até agora é:</p><p><strong>Imagem do Atlas → TileSet → TileMapLayer → Mundo</strong></p><p>Eu importo a imagem que contém meu Atlas.</p><p>No TileSet, configuro o tamanho das células para que o Godot saiba como dividir aquela imagem.</p><p>No meu caso: <strong>128 × 128 px</strong></p><p>Depois disso, aqueles pequenos pedaços da imagem passam a funcionar como tiles que posso utilizar para construir o mapa.</p><p>É aqui que aquela imagem 512 × 512 deixa de ser apenas uma imagem e começa a virar realmente um conjunto de peças para montar o cenário.</p><h3>E o Autotiling?</h3><p>Durante os estudos sobre Atlas e TileSet, também conheci o conceito de <strong>Autotiling</strong>.</p><p>De forma simplificada, com ele podemos definir regras para que o Godot escolha automaticamente qual tile utilizar de acordo com os tiles ao redor. Isso evita ter que selecionar manualmente cada borda, canto ou transição durante a construção do terreno.</p><p>Mas, pelo menos por enquanto, <strong>preferi não utilizar o Autotiling</strong> efoi uma escolha proposital.</p><p>Como meu objetivo neste projeto também é aprender, decidi montar o terreno do jogo <strong>manualmente utilizando o Atlas</strong>.</p><p>Fui escolhendo as peças, encaixando os cantos, criando as transições e observando como cada tile se comportava quando colocado ao lado dos outros.</p><p>Pode não ser a maneira mais rápida de construir um mapa, mas, para mim, foi uma maneira muito melhor de entender na prática <strong>por que cada uma daquelas variações existe</strong>.</p><p>Depois de passar um tempo montando o terreno dessa forma, aquele Atlas cheio de quadradinhos deixou de parecer apenas uma imagem com várias combinações. Comecei realmente a entender a função de cada peça.</p><p>Pretendo utilizar o <strong>Autotiling</strong> futuramente. Quando chegar esse momento, quero estudar sua configuração, aplicar no projeto e comparar a experiência com a construção manual.</p><p>Provavelmente isso vai virar assunto para outro post. 😄</p><p>Por enquanto, montar o terreno manualmente fez parte do aprendizado — e era exatamente isso que eu estava procurando.</p><h3>Uma coisa é olhar o Atlas. Outra é olhar o jogo.</h3><p>Talvez esse tenha sido um dos aprendizados mais importantes dessa etapa.</p><p>Um tile pode parecer perfeito quando estou olhando a imagem isoladamente, mas isso não significa que ele funciona dentro do jogo.</p><p>Quando comecei a montar o cenário, passei a observar coisas como:</p><ul><li>repetição dos tiles;</li><li>costuras entre as peças;</li><li>escala do personagem em relação ao cenário;</li><li>quantidade de tiles visíveis;</li><li>zoom da câmera;</li><li>leitura do cenário durante o gameplay.</li></ul><p>E principalmente comecei a testar isso no celular.</p><p>No final, não importa tanto se o Atlas está bonito quando aberto no editor de imagens.</p><p><strong>Ele precisa funcionar quando o jogo está rodando.</strong></p><h3>O que entendi até aqui</h3><p>Hoje minha visão de Atlas é bem mais simples:</p><p>Um Atlas é uma forma de organizar várias pequenas peças gráficas dentro de uma imagem maior.</p><p>O Godot divide essa imagem novamente em regiões e permite que eu utilize cada uma delas como uma peça independente.</p><p>O mais interessante, porém, não foi aprender apenas o que é um Atlas.</p><p>Foi começar a entender como <strong>pensar os assets para que eles funcionem juntos</strong>.</p><p>O chão, as transições, os detalhes e os demais elementos começam a deixar de ser imagens isoladas e passam a fazer parte de um sistema.</p><p>E acho que esse foi o verdadeiro aprendizado dessa etapa.</p><h3>Importante</h3><p>Continuo utilizando o <strong>ChatGPT</strong> como ferramenta de apoio durante o desenvolvimento e os estudos.</p><p>Inclusive, boa parte das dúvidas sobre Atlas, organização dos tiles e possibilidades de implementação surgiu dessas conversas.</p><p>Poderia simplesmente pedir para a IA criar toda a solução e me entregar pronta.</p><p>Mas continuo tentando evitar isso. Meu objetivo não é apenas terminar um jogo.</p><p><strong>Quero entender como ele foi construído.</strong></p><p>E cá estamos nós… aprendendo mais um pouco. 😄</p><p>E para finalizar, estou compartilhando onde eu conheci o conceito:</p><p><a href="https://www.youtube.com/watch?v=TxyBoDqE6Zo?si=utWhGjozRuipQOFa">- YouTube</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6803e6ceb92d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O dia em que descobri por que um export Web do Godot não funciona com file://]]></title>
            <link>https://medium.com/@GeraldoBastos/o-dia-em-que-descobri-por-que-um-export-web-do-godot-n%C3%A3o-funciona-com-file-54093a199a00?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/54093a199a00</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[godot]]></category>
            <category><![CDATA[indie-game]]></category>
            <category><![CDATA[indiedev]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 22:45:09 GMT</pubDate>
            <atom:updated>2026-07-10T22:45:09.291Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TkNITJxvW54r3lKBN3A1LA.png" /></figure><p>Uma das coisas que mais me chamou atenção ao começar a trabalhar com exportação Web no Godot foi descobrir que gerar um index.html não significa que você pode simplesmente dar dois cliques no arquivo e esperar que tudo funcione.</p><p>Minha primeira reação foi pensar:</p><blockquote><em>“Se existe um </em><em>index.html, por que não posso abri-lo diretamente pelo navegador?&quot;</em></blockquote><p>A resposta está em como o Godot prepara uma aplicação para a Web.</p><h3>O export Web não é apenas um HTML</h3><p>Quando exportamos um projeto para Web, normalmente são gerados arquivos como:</p><pre>index.html<br>index.js<br>index.wasm<br>index.pck</pre><p>Cada um possui uma responsabilidade diferente.</p><ul><li><strong>index.html</strong> cria a página.</li><li><strong>index.js</strong> inicializa o runtime do Godot.</li><li><strong>index.wasm</strong> contém o código compilado da engine em WebAssembly.</li><li><strong>index.pck</strong> contém os recursos do projeto (cenas, imagens, sons, scripts compilados etc.).</li></ul><p>O HTML é apenas o ponto de entrada.</p><h3>O que realmente acontece</h3><p>Ao abrir a página, o JavaScript do Godot começa a carregar os demais arquivos.</p><p>Em vez de tudo estar embutido no HTML, ele faz requisições para buscar o .wasm e o .pck.</p><p>De forma simplificada, o navegador faz algo parecido com:</p><pre>fetch(&quot;index.wasm&quot;);<br>fetch(&quot;index.pck&quot;);</pre><p>Ou seja, o jogo precisa carregar arquivos adicionais antes de iniciar.</p><h3>Então por que file:// não funciona?</h3><p>Quando abrimos um arquivo local, o navegador utiliza o protocolo:</p><pre>file://</pre><p>Nessa situação não existe um servidor web.</p><p>Embora o HTML seja aberto normalmente, diversos navegadores aplicam restrições de segurança para impedir que aplicações carreguem outros arquivos locais da mesma forma que fariam em um servidor HTTP.</p><p>O resultado costuma ser erros como:</p><ul><li>Failed to fetch</li><li>Erros relacionados ao carregamento do WebAssembly</li><li>Falha ao localizar o arquivo .pck</li><li>Origem null</li></ul><p>O problema não é o HTML. O problema é que a aplicação inteira depende de recursos que precisam ser servidos corretamente.</p><h3>A solução é simples</h3><p>Em vez de abrir o arquivo diretamente, basta executar um pequeno servidor HTTP na pasta do export.</p><p>Com Python:</p><pre>python3 -m http.server 8000</pre><p>Depois basta acessar:</p><pre>http://localhost:8000</pre><p>Também é possível usar outras ferramentas como:</p><pre>npx serve .</pre><p>ou qualquer servidor web de sua preferência.</p><h3>Em produção isso deixa de ser um problema</h3><p>Quando a aplicação é publicada em serviços como Cloudflare Pages, GitHub Pages, Netlify ou qualquer hospedagem tradicional, os arquivos passam a ser entregues via HTTP ou HTTPS.</p><p>Nesse cenário, o navegador consegue carregar corretamente todos os recursos necessários e a aplicação funciona como esperado.</p><h3>O aprendizado</h3><p>Esse foi um daqueles detalhes que parecem pequenos, mas ajudam bastante a entender como aplicações Web realmente funcionam.</p><p>Antes eu enxergava um export Web como “um arquivo HTML”.</p><p>Hoje vejo que ele é, na verdade, um conjunto de arquivos que trabalham juntos:</p><ul><li>uma página HTML;</li><li>um runtime JavaScript;</li><li>um módulo WebAssembly;</li><li>um pacote de recursos.</li></ul><p>O navegador precisa receber tudo isso através de um servidor HTTP.</p><p>É um conceito simples depois que entendemos, mas pode economizar horas de investigação para quem está começando a publicar aplicações Web com o Godot.</p><p>Às vezes, o erro não está no projeto. Está apenas na forma como ele está sendo executado.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=54093a199a00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como transformei a memória de um projeto Godot em um grafo navegável para IA]]></title>
            <link>https://medium.com/@GeraldoBastos/como-transformei-a-mem%C3%B3ria-de-um-projeto-godot-em-um-grafo-naveg%C3%A1vel-para-ia-1aaff144757e?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/1aaff144757e</guid>
            <category><![CDATA[obsidian]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Fri, 19 Jun 2026 16:04:24 GMT</pubDate>
            <atom:updated>2026-06-19T16:04:24.070Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yQqo1IpqSSa85CM51faNXA.png" /></figure><p>Em projetos que usam IA de forma recorrente, uma coisa começa a ficar evidente com o tempo: não basta o agente saber programar. Ele também precisa entender o contexto do projeto.</p><p>E contexto, quando fica espalhado ou concentrado demais em poucos arquivos, vira um problema.</p><p>Foi isso que me levou a repensar a forma como eu organizava a memória de um projeto em Godot. O objetivo não era alterar gameplay, cenas, scripts ou assets. A mudança foi em uma camada que normalmente fica invisível: a memória operacional usada por agentes de IA, como o Codex, para entender o projeto antes de modificar qualquer coisa.</p><p>Antes, a memória era baseada em poucos arquivos Markdown grandes e lineares. Depois, ela passou a ser organizada como um grafo documental versionado, com frontmatter (bloco de metadados colocado no início de um arquivo Markdown), tags, relações explícitas e uma visualização Mermaid gerada automaticamente.</p><p>O resultado prático foi uma memória mais fácil de navegar, validar e reaproveitar em novas sessões de IA.</p><h3>Visualizando o resultado pelo Obsidian</h3><p>No vídeo abaixo mostro a ideia de visualizar a memória como grafo documental, tem várias pessoas ensinando a fazer no youtube é só pesquisar por Obsidian + IA:</p><p><a href="https://www.youtube.com/watch?v=0JAD2uKAcSc">https://www.youtube.com/watch?v=0JAD2uKAcSc</a></p><blockquote><strong><em>Atenção:</em></strong><em> este artigo está escrito de forma que você consiga reaplicar a estratégia em qualquer projeto semelhante. A ideia não é copiar exatamente a minha estrutura, mas entender o padrão e adaptar ao seu projeto.</em></blockquote><h3>O problema da estratégia anterior</h3><p>A estratégia anterior funcionava, mas tinha um limite claro: ela concentrava contexto demais em poucos arquivos.</p><p>É comum um projeto começar com documentos como:</p><ul><li>memory.md</li><li>memory/current-state.md</li><li>memory/architecture.md</li><li>memory/decisions.md</li><li>memory/next-tasks.md</li><li>arquivos históricos em memory/sessions/</li></ul><p>Esse modelo é simples e funciona muito bem no início. O problema aparece quando o projeto cresce.</p><p>Com o tempo, esses arquivos começam a misturar coisas diferentes:</p><ul><li>estado atual;</li><li>decisões antigas;</li><li>decisões ainda válidas;</li><li>ideias abandonadas;</li><li>histórico de sessões;</li><li>próximos passos;</li><li>detalhes de arquitetura;</li><li>referências de assets;</li><li>regras de gameplay;</li><li>dúvidas em aberto.</li></ul><p>O arquivo continua existindo, mas deixa de ser uma memória navegável. Ele vira um bloco grande de contexto.</p><p>Para uma pessoa, isso já atrapalha. Para uma IA, atrapalha ainda mais, porque o agente precisa gastar tokens lendo muito conteúdo para encontrar poucas informações realmente relevantes.</p><p>O problema principal não era falta de memória. Era falta de estrutura.</p><h3>A ideia: transformar memória em grafo documental</h3><p>A solução foi tratar cada arquivo Markdown como um nó de conhecimento.</p><p>Em vez de um único arquivo enorme tentando explicar tudo, a memória passa a ser dividida por assunto. Cada documento tem uma responsabilidade clara e se conecta com outros documentos por meio de tags, links e relações explícitas.</p><p>A estrutura fica mais ou menos assim:</p><pre>memory/<br>├── index.md<br>├── graph.md<br>├── tags.md<br>├── README.md<br>├── _legacy/<br>│   └── memory-original.md<br>├── gameplay/<br>│   ├── index.md<br>│   ├── mechanics.md<br>│   ├── controls.md<br>│   ├── enemies.md<br>│   └── spawn-system.md<br>├── assets/<br>│   ├── index.md<br>│   ├── sprites.md<br>│   └── import-pipeline.md<br>├── architecture/<br>│   ├── index.md<br>│   ├── godot-structure.md<br>│   ├── scenes.md<br>│   ├── scripts.md<br>│   └── mobile-export.md<br>├── decisions/<br>│   ├── index.md<br>│   └── 2026-06-16-memory-graph-strategy.md<br>├── open-questions/<br>│   └── index.md<br>└── prompts/<br>    └── codex-memory-navigation.md</pre><p>Essa estrutura não precisa ser copiada exatamente. Ela deve refletir o seu projeto. Em um jogo, pode fazer sentido ter gameplay/, assets/, architecture/ e lore/.</p><p>Em um aplicativo mobile, talvez faça mais sentido:</p><pre>memory/<br>├── product/<br>├── architecture/<br>├── screens/<br>├── api/<br>├── observability/<br>├── decisions/<br>└── open-questions/</pre><p>Em uma API backend, poderia ser:</p><pre>memory/<br>├── domain/<br>├── endpoints/<br>├── database/<br>├── architecture/<br>├── integrations/<br>├── decisions/<br>└── open-questions/</pre><p>O ponto não é a pasta em si. O ponto é transformar conhecimento solto em nós navegáveis.</p><h3>Frontmatter: a ficha técnica de cada nó</h3><p>Cada arquivo principal de memória passou a ter um frontmatter YAML.</p><p>Exemplo:</p><pre>---<br>id: memory-index<br>title: Índice Principal da Memória<br>type: index<br>status: active<br>scope: project<br>godot_version: &quot;4.4.1&quot;<br>tags:<br>  - memory<br>  - index<br>  - graph<br>related:<br>  - memory-graph<br>  - memory-tags<br>  - codex-memory-navigation<br>aliases:<br>  - memória principal<br>  - mapa da memória<br>created: &quot;2026-06-16&quot;<br>updated: &quot;2026-06-16&quot;<br>---</pre><p>Esse cabeçalho transforma um Markdown comum em um nó mais fácil de interpretar.</p><p>A IA consegue entender rapidamente:</p><ul><li>qual é o ID do documento;</li><li>qual é o tipo de informação;</li><li>se o conteúdo está ativo, em rascunho ou depreciado;</li><li>quais tags representam aquele assunto;</li><li>quais outros arquivos estão relacionados;</li><li>quais nomes alternativos podem aparecer em conversas anteriores.</li></ul><p>Em um projeto Godot 4.4.1, o campo godot_version ajuda a evitar respostas genéricas baseadas em versões diferentes da engine.</p><p>Para projetos que não usam Godot, basta trocar esse campo por algo mais adequado, como:</p><pre>platform: &quot;android&quot;<br>language: &quot;kotlin&quot;</pre><p>ou:</p><pre>runtime: &quot;node&quot;<br>framework: &quot;nestjs&quot;</pre><p>O importante é registrar o contexto técnico que não pode ser esquecido.</p><h3>Tags: menos criatividade, mais consistência</h3><p>Um erro fácil nesse tipo de estrutura é criar tags demais. Por exemplo:</p><pre>sprite<br>sprites<br>sprite-sheet<br>spritesheet<br>sheet<br>animation-sheet</pre><p>Isso parece inofensivo, mas começa a fragmentar a busca. Por isso, vale criar um arquivo central:</p><pre>memory/tags.md</pre><p>Esse arquivo funciona como catálogo oficial de tags. Exemplo:</p><pre># Cátalogo de Tags de Memória<br>## Tags técnicas<br>- `godot`: assuntos relacionados à engine Godot.<br>- `godot-4-4-1`: decisões específicas para Godot 4.4.1.<br>- `gdscript`: scripts em GDScript.<br>- `scene`: cenas da Godot.<br>- `node`: nós da Godot.<br>- `mobile`: decisões para Android/iOS.<br>- `export`: exportação do projeto.<br>## Tags de gameplay<br>- `gameplay`: regras e experiência do jogo.<br>- `enemy`: inimigos.<br>- `spawn`: criação de inimigos.<br>- `score`: pontuação.<br>- `controls`: controles.<br>## Tags de memória<br>- `memory`: sistema de memória.<br>- `graph`: grafo de conhecimento.<br>- `decision`: decisão tomada.<br>- `open-question`: questão em aberto.<br>- `architecture`: arquitetura do projeto.</pre><p>A regra é simples:</p><blockquote><em>Não crie uma tag nova sem antes verificar se já existe uma tag equivalente.</em></blockquote><p>Isso deixa a navegação melhor para humanos e para IA.</p><h3>Relações explícitas entre documentos</h3><p>O campo mais importante do frontmatter é o related. Ele permite declarar que um documento se conecta com outro.</p><p>Exemplo:</p><pre>related:<br>  - gameplay-enemies<br>  - assets-enemies<br>  - architecture-scenes</pre><p>Mas só listar IDs não é suficiente. Também vale explicar a relação em linguagem natural dentro do próprio arquivo:</p><pre>## Relações<br>- Relacionado a [Inimigos](../gameplay/enemies.md), porque o comportamento do inimigo depende das regras de gameplay.<br>- Relacionado a [Assets de Inimigos](../assets/enemies.md), porque cada inimigo precisa de sprite, colisão e comportamento visual.<br>- Relacionado a [Cenas](../architecture/scenes.md), porque a organização das cenas influencia como o inimigo é instanciado.</pre><p>Esse tipo de texto ajuda muito.</p><p>A IA não precisa inferir sozinha por que dois arquivos estão conectados. A relação já está documentada.</p><h3>Separando fonte ativa de legado</h3><p>Outro ponto importante foi preservar a memória antiga sem deixar que ela competisse com a memória nova.</p><p>A solução foi criar:</p><pre>memory/_legacy/memory-original.md</pre><p>Esse arquivo guarda o conteúdo antigo, com um aviso claro:</p><ul><li>Este arquivo preserva a memória original antes da reorganização em grafo.</li><li>Ele deve ser usado como histórico, não como fonte ativa principal.</li></ul><p>Isso evita dois problemas:</p><ol><li>perder conhecimento antigo;</li><li>fazer a IA usar informação antiga como se ainda fosse a verdade atual.</li></ol><p>A memória antiga continua disponível, mas agora ela tem o lugar certo.</p><h3>Protocolo de navegação para IA</h3><p>Uma parte essencial da estratégia foi criar um protocolo para o agente seguir antes de implementar mudanças.</p><p>Exemplo de arquivo:</p><pre>memory/prompts/codex-memory-navigation.md</pre><p>Ele pode conter algo assim:</p><pre># Protocolo de Navegação da Memória para IA<br>Antes de implementar qualquer alteração relevante no projeto, siga este processo:<br>## 1. Comece pelo índice<br>Leia:<br>- `memory/index.md`<br>Identifique qual área da memória está relacionada à tarefa.<br>## 2. Consulte tags e grafo<br>Leia:<br>- `memory/tags.md`<br>- `memory/graph.md`<br>Use tags para localizar assuntos relacionados.<br>## 3. Leia os nós relevantes<br>Antes de alterar código, leia todos os arquivos diretamente relacionados ao tema.<br>## 4. Siga os relacionamentos<br>Para cada arquivo lido, verifique o campo `related`.<br>Leia também os arquivos relacionados quando forem relevantes para a tarefa.<br>## 5. Não invente memória<br>Se uma informação não estiver documentada:<br>- não trate como decisão aprovada;<br>- registre em `memory/open-questions/index.md`;<br>- ou proponha como sugestão claramente marcada como sugestão.<br>## 6. Atualize a memória após decisões<br>Quando uma decisão nova for tomada:<br>- atualize o arquivo de memória correspondente;<br>- atualize o grafo se criar nova relação;<br>- atualize o catálogo de tags se criar nova tag;<br>- registre decisões importantes em `memory/decisions/`.</pre><p>Esse protocolo muda a relação com a IA.</p><p>Em vez de dizer apenas “faça a tarefa”, o projeto passa a ensinar o agente onde procurar contexto antes de agir.</p><h3>Gerando uma visualização Mermaid</h3><p>Depois que a memória foi organizada como grafo, o próximo passo foi gerar uma visualização automática.</p><p>A ideia é simples:</p><ol><li>percorrer os arquivos Markdown em memory/;</li><li>ler o frontmatter YAML;</li><li>extrair id, title, type, status, tags e related;</li><li>criar nós a partir dos arquivos;</li><li>criar arestas a partir do campo related;</li><li>gerar um arquivo Markdown com Mermaid.</li></ol><p>O arquivo gerado pode ser:</p><pre>memory/graph.visual.md</pre><p>E o Mermaid pode usar:</p><pre>flowchart LR<br>    memory_index[&quot;Índice Principal&quot;] --&gt; memory_graph[&quot;Grafo de Relações&quot;]<br>    memory_index --&gt; memory_tags[&quot;Catálogo de Tags&quot;]<br>    memory_index --&gt; codex_navigation[&quot;Protocolo de Navegação&quot;]<br>    gameplay_enemies[&quot;Inimigos&quot;] --&gt; spawn_system[&quot;Sistema de Spawn&quot;]<br>    assets_sprites[&quot;Sprites&quot;] --&gt; import_pipeline[&quot;Pipeline de Importação&quot;]</pre><p>Isso permite visualizar a memória dentro do próprio GitHub, Obsidian ou qualquer ferramenta que renderize Mermaid.</p><h3>Por que usar git ls-files</h3><p>Um detalhe importante: se o script simplesmente percorrer a pasta memory/, ele pode capturar arquivos locais que não deveriam fazer parte do grafo.</p><p>Por exemplo:</p><ul><li>rascunhos temporários;</li><li>arquivos criados por ferramentas locais;</li><li>notas pessoais não versionadas;</li><li>arquivos de teste.</li></ul><p>Por isso, uma abordagem melhor é usar git ls-files quando disponível.</p><p>Assim, o grafo é gerado a partir dos arquivos versionados no repositório, não de qualquer arquivo solto na máquina.</p><p>Isso melhora a reprodutibilidade:</p><ul><li>o grafo representa o que está realmente no Git;</li><li>outra pessoa consegue gerar o mesmo resultado;</li><li>o PR mostra exatamente o que foi alterado;</li><li>arquivos locais não vazam para a documentação.</li></ul><h3>Consumo de tokens</h3><p>Não dá para afirmar uma economia exata de tokens sem medição oficial da ferramenta usada.</p><p>Mas dá para analisar o padrão de consumo.</p><p>Na estratégia anterior, o agente precisava ler arquivos grandes e lineares para recuperar contexto. Como esses arquivos misturavam estado atual, histórico e decisões, a tendência era carregar mais informação do que o necessário.</p><p>Na nova estratégia, a leitura pode ser guiada:</p><ol><li>começar por memory/index.md;</li><li>consultar memory/graph.md e memory/tags.md;</li><li>seguir apenas os nós relacionados ao tema da tarefa;</li><li>consultar decisões quando necessário;</li><li>consultar histórico somente quando fizer sentido.</li></ol><p>Isso muda o consumo de contexto de leitura ampla para leitura seletiva.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*na6g5QwJbQKUx0lYSsCzgA.png" /><figcaption>print da tabela markdown, o medium não tem suporte a tabela :(</figcaption></figure><p>O ganho principal não é apenas gastar menos tokens. O ganho é tornar previsível onde os tokens devem ser gastos.</p><h3>Pontos positivos da estratégia</h3><h4>1. Navegação explícita</h4><p>A memória passa a ter uma porta de entrada clara: memory/index.md. Isso reduz ambiguidade para qualquer pessoa ou agente que comece uma nova sessão.</p><h4>2. Relações auditáveis</h4><p>O campo related torna as conexões entre arquivos explícitas. Antes, a relação entre decisões, arquitetura, gameplay e assets dependia de leitura humana. Agora ela pode ser inspecionada, validada e visualizada.</p><h4>3. Separação entre ativo e legado</h4><p>Arquivos antigos podem ser preservados em _legacy/, mas deixam de competir com os documentos ativos.</p><p>Isso evita que uma decisão antiga seja usada como se ainda fosse atual.</p><h4>4. Melhor custo de contexto</h4><p>Ao invés de carregar tudo, o agente pode seguir o grafo. Para uma tarefa de gameplay, ele pode ler documentos de gameplay, assets e arquitetura relacionados.</p><p>Para uma tarefa de exportação mobile, ele pode seguir outro caminho. O contexto fica mais específico.</p><h4>5. Visualização versionada</h4><p>O arquivo memory/graph.visual.md permite revisar o grafo no próprio repositório. A visualização vira parte da documentação, não algo separado dela.</p><h4>6. Validação estrutural</h4><p>O gerador pode informar:</p><ul><li>IDs ausentes;</li><li>IDs duplicados;</li><li>relações quebradas;</li><li>nós órfãos;</li><li>arquivos sem frontmatter.</li></ul><p>Isso transforma problemas silenciosos de documentação em avisos explícitos.</p><h4>7. Melhor colaboração com IA</h4><p>Para agentes de IA, a memória em grafo reduz incerteza.</p><p>Ela responde rapidamente:</p><ul><li>onde começar;</li><li>quais arquivos são fonte principal;</li><li>quais documentos estão relacionados;</li><li>quais decisões precisam ser respeitadas;</li><li>quais pontos ainda estão em aberto.</li></ul><p>Isso diminui a chance de o agente inventar contexto ou repetir investigações já feitas.</p><h3>Comparação direta</h3><p>Antes, a memória era um conjunto de documentos. Agora, ela vira um sistema navegável. A diferença parece sutil, mas muda o uso diário:</p><ul><li>antes: ler arquivos grandes e inferir relações;</li><li>agora: seguir nós, tags e relações explícitas;</li><li>antes: histórico misturado com estado atual;</li><li>agora: histórico preservado, mas separado;</li><li>antes: validação manual;</li><li>agora: visualização e checagem automatizadas;</li><li>antes: maior chance de gastar tokens lendo contexto irrelevante;</li><li>agora: maior chance de gastar tokens na parte certa do problema.</li></ul><h3>Um prompt genérico para aplicar em outro projeto</h3><p>Abaixo está uma versão genérica do comando que pode ser adaptada para outro repositório:</p><pre>Reorganize a memória deste projeto em uma estrutura modular baseada em grafo de conhecimento, usando arquivos Markdown.<br>Objetivo:<br>Transformar a memória do projeto em uma estrutura navegável por IA, com arquivos menores, frontmatter YAML, tags, links internos, relações explícitas e um protocolo de navegação.<br>Regras importantes:<br>- Não apagar informações existentes.<br>- Não inventar decisões novas.<br>- Não alterar código-fonte, cenas, assets ou configurações do projeto, a menos que seja necessário apenas para atualizar referências de documentação.<br>- Preservar o conteúdo original em uma área de legado.<br>- Separar fonte ativa de histórico.<br>Antes de começar:<br>1. Execute `git status`.<br>2. Identifique se existem arquivos ou pastas de memória/documentação, como:<br>   - `memory.md`<br>   - `memory/`<br>   - `docs/`<br>   - `AGENTS.md`<br>   - `.agent/`<br>   - `.agents/`<br>   - `README.md`<br>3. Leia o conteúdo atual relacionado à memória do projeto.<br>4. Preserve o conteúdo original antes de reorganizar.<br>Crie ou reorganize uma estrutura semelhante a esta:<br>memory/<br>├── index.md<br>├── graph.md<br>├── tags.md<br>├── README.md<br>├── _legacy/<br>│   └── memory-original.md<br>├── architecture/<br>│   └── index.md<br>├── decisions/<br>│   └── index.md<br>├── domain/<br>│   └── index.md<br>├── assets/<br>│   └── index.md<br>├── open-questions/<br>│   └── index.md<br>└── prompts/<br>    └── ai-memory-navigation.md<br>Adapte as pastas ao tipo de projeto.<br>Crie frontmatter YAML nos arquivos principais:<br>---<br>id: exemplo-id-em-kebab-case<br>title: Título humano do documento<br>type: index | architecture | decision | domain | asset | prompt | open-question | note<br>status: active | draft | deprecated | superseded | open<br>scope: project<br>tags:<br>  - tag-principal<br>  - tag-secundaria<br>related:<br>  - outro-id-relacionado<br>aliases:<br>  - nome alternativo<br>created: &quot;YYYY-MM-DD&quot;<br>updated: &quot;YYYY-MM-DD&quot;<br>---<br>Regras:<br>- `id` deve ser único.<br>- `id` deve usar kebab-case.<br>- `tags` devem ser consistentes.<br>- `related` deve apontar para outros IDs existentes.<br>- Use links Markdown relativos.<br>- Crie uma seção `## Relações` nos arquivos principais explicando as conexões.<br>Crie também um protocolo de navegação para IA em:<br>memory/prompts/ai-memory-navigation.md<br>Esse protocolo deve orientar o agente a:<br>1. começar por `memory/index.md`;<br>2. consultar `memory/tags.md`;<br>3. consultar `memory/graph.md`;<br>4. ler apenas os nós relacionados à tarefa;<br>5. seguir o campo `related`;<br>6. não inventar decisões não documentadas;<br>7. registrar novas decisões em `memory/decisions/`;<br>8. registrar dúvidas em `memory/open-questions/`.<br>Ao final:<br>- confirme que o conteúdo original foi preservado;<br>- liste os arquivos criados;<br>- liste os arquivos alterados;<br>- explique como o conteúdo antigo foi distribuído;<br>- informe pendências de classificação;<br>- execute `git diff --stat`;<br>- execute `git status`.</pre><h3>Um segundo prompt para gerar o grafo visual</h3><p>Depois de organizar os arquivos, dá para pedir a criação de um gerador de grafo.</p><pre>Crie uma visualização automática do grafo de memória do projeto.<br>Contexto:<br>- A memória do projeto está organizada dentro da pasta `memory/`.<br>- Cada arquivo Markdown representa um nó de conhecimento.<br>- Os relacionamentos entre nós estão definidos principalmente no frontmatter YAML, usando o campo `related`.<br>Objetivo:<br>Criar um script que gere um grafo visual em Mermaid, salvo no próprio repositório.<br>Não alterar código de produto, assets ou configurações funcionais do projeto.<br>Esta tarefa é apenas documental/ferramental.<br>Crie o arquivo:<br>tools/generate_memory_graph.py<br>O script deve:<br>1. Percorrer recursivamente arquivos `.md` dentro de `memory/`.<br>2. Ignorar `memory/_legacy/`.<br>3. Usar `git ls-files` quando disponível para considerar apenas arquivos versionados.<br>4. Ler o frontmatter YAML de cada arquivo.<br>5. Extrair `id`, `title`, `type`, `status`, `tags` e `related`.<br>6. Criar nós a partir do campo `id`.<br>7. Criar arestas a partir do campo `related`.<br>8. Validar se cada item em `related` aponta para algum `id` existente.<br>9. Identificar nós órfãos.<br>10. Gerar o arquivo:<br>memory/graph.visual.md<br>Esse arquivo deve conter:<br>- título;<br>- data de geração;<br>- explicação breve;<br>- bloco Mermaid com `flowchart LR`;<br>- subgraphs por área quando possível;<br>- seção de avisos;<br>- seção de nós órfãos;<br>- seção de relacionamentos quebrados.<br>Ao final:<br>- execute o script;<br>- mostre o resumo da geração;<br>- execute `git diff --stat`;<br>- execute `git status`.</pre><h3>O que eu aprendi</h3><p>A principal lição é que memória persistente para IA não deve ser apenas um arquivo de notas.</p><p>Ela precisa ter estrutura. Um bom sistema de memória para agentes deve:</p><ul><li>ter uma entrada óbvia;</li><li>separar estado atual, decisões, histórico e perguntas em aberto;</li><li>tornar relações explícitas;</li><li>permitir validação automática;</li><li>preservar legado sem confundir com fonte ativa;</li><li>ser versionado junto com o código.</li></ul><p>Outra lição é que documentação também precisa de tooling.</p><p>Um gerador de grafo não muda o produto final, mas muda a confiabilidade do processo de desenvolvimento.</p><p>Isso é especialmente útil em projetos longos, onde diferentes sessões de IA precisam entender rapidamente o que já foi decidido.</p><h3>Conclusão</h3><p>Transformar memória em grafo não é apenas uma forma bonita de organizar Markdown.</p><p>É uma forma de ensinar o projeto a explicar a si mesmo.</p><p>Para projetos que usam IA de forma recorrente, isso pode ser tão importante quanto registrar decisões arquiteturais, manter um README atualizado ou criar bons testes automatizados.</p><p>No fim, a pergunta deixa de ser apenas:</p><blockquote><em>O que o agente precisa saber?</em></blockquote><p>A pergunta passa a ser:</p><blockquote><em>Como o projeto ensina o agente a encontrar o que precisa saber?</em></blockquote><p>Volto para falar se ficou boa a estratégia ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1aaff144757e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendendo o arquivo .import no Godot: o que eu aprendi abrindo ele na mão]]></title>
            <link>https://medium.com/@GeraldoBastos/entendendo-o-arquivo-import-no-godot-o-que-eu-aprendi-abrindo-ele-na-m%C3%A3o-a60b2ec25d30?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/a60b2ec25d30</guid>
            <category><![CDATA[godoto-import]]></category>
            <category><![CDATA[godot-engine]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 11:27:05 GMT</pubDate>
            <atom:updated>2026-06-15T11:27:05.236Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zZaxJwMEfcnU1LDmjMBOwQ.png" /></figure><p>Quando comecei a estudar o Godot, uma das coisas que me chamou atenção foi que, ao colocar um asset dentro do projeto, o engine criava automaticamente um arquivo com o mesmo nome, mas terminando com .import :</p><pre>ant.png<br>ant.png.import</pre><p>No começo, isso pode parecer estranho. Afinal, eu já tenho o arquivo png. Por que o Godot precisa criar outro arquivo ao lado dele? Foi aí que resolvi fazer um teste simples: abrir o arquivo .import diretamente e olhar o que tinha dentro. E esse teste ajudou bastante a entender como o Godot trabalha com assets por baixo dos panos.</p><h3>O que é o .import no Godot?</h3><p>No Godot 4.4.1, o arquivo .import é um arquivo de configuração gerado automaticamente pelo editor quando um asset é importado para o projeto.</p><p>Ele não é o asset em si, ou seja, se eu tenho:</p><pre>assets/enemies/ant.png<br>assets/enemies/ant.png.import</pre><p>O arquivo ant.png continua sendo a imagem original. Já o arquivo ant.png.import guarda informações sobre <strong>como o Godot deve importar aquela imagem</strong>.</p><p>Ele funciona como uma espécie de “registro de importação” daquele asset.</p><h3>O teste que eu fiz</h3><p>No passado, para entender melhor isso, eu abri um arquivo .import manualmente. Dá para fazer isso por uma ide, editor de texto ou até pelo terminal. Para esse teste eu fiz pelo vs code:</p><pre>cat assets/enemies/ant.png.import</pre><p>Quando abri o arquivo, vi algo parecido com isso:</p><pre>[remap]<br><br>importer=&quot;texture&quot;<br>type=&quot;CompressedTexture2D&quot;<br>uid=&quot;uid://...&quot;<br>path=&quot;res://.godot/imported/ant.png-xxxxx.ctex&quot;<br><br>[deps]<br><br>source_file=&quot;res://assets/enemies/ant.png&quot;<br>dest_files=[&quot;res://.godot/imported/ant.png-xxxxx.ctex&quot;]<br><br>[params]<br><br>compress/mode=0<br>mipmaps/generate=false<br>process/fix_alpha_border=true</pre><p>Na prática, esse arquivo estava dizendo:</p><p>“O arquivo original é este aqui, ele deve ser importado como textura, usando esses parâmetros, e o resultado processado fica neste outro caminho.”</p><p>Foi nesse momento que caiu a ficha: o Godot não usa simplesmente o png puro do jeito que eu coloquei na pasta. Ele importa, processa e gera uma versão interna otimizada para usar no jogo.</p><p>O asset original continua sendo o <em>ant.png</em>. O arquivo <strong>ant.png.import</strong> guarda a<strong> configuração de importação</strong> daquele asset.</p><p>E dentro da pasta .<em>godot/imported/</em>, o Godot mantém os arquivos gerados internamente a partir dessa importação. Esses arquivos não precisam ir para o Git, porque podem ser recriados automaticamente pelo editor.</p><h3>O .import não é a imagem</h3><p>Esse foi um ponto importante do aprendizado. O arquivo .import não contém a imagem. Ele não é um substituto do .png, ele é um arquivo de texto com metadados de importação.</p><p>Então, se eu apagar o ant.png e deixar só o ant.png.import, eu não tenho mais a imagem original. O correto é entender assim:</p><pre>ant.png          → asset original<br>ant.png.import   → configuração de importação<br>.godot/imported  → cache gerado pelo Godot</pre><h3>Devo commitar o .import no Git?</h3><p>Sim. No Godot 4.4.1, normalmente o ideal é versionar os arquivos .import. Por quê? Porque eles guardam as configurações de importação dos assets.</p><p>Se eu tenho um sprite configurado corretamente no meu computador, com filtro, mipmap e compressão ajustados, essas informações ficam no .import.</p><p>Se outra pessoa clonar o projeto sem esse arquivo, o Godot pode reimportar o asset usando configurações padrão.</p><p>E isso pode gerar diferença visual ou comportamento inesperado. Então, em um projeto Godot, normalmente eu versionaria:</p><pre>assets/enemies/ant.png<br>assets/enemies/ant.png.import</pre><p>mas não versionaria:</p><pre>.godot/</pre><p>ele é cache local. Então como forma de resumir tudo:</p><p>O .import funciona como a receita de importação. O Godot preserva o asset original, usa os metadados para gerar uma versão interna otimizada e, na exportação, empacota os recursos importados necessários para o jogo funcionar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a60b2ec25d30" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como usei IA para construir uma Sprite Sheet para um jogo]]></title>
            <link>https://medium.com/@GeraldoBastos/como-usei-ia-para-construir-uma-sprite-sheet-para-um-jogo-0aaf02eb18c3?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/0aaf02eb18c3</guid>
            <category><![CDATA[godot]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[openai-codex]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[spritesheet]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Thu, 11 Jun 2026 00:31:54 GMT</pubDate>
            <atom:updated>2026-06-11T00:31:54.345Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G81XVEyossfki2X4nmcBLw.png" /></figure><p>Antes de começar, eu tinha uma expectativa bastante comum quando falamos de IA para criação de assets: gerar uma spritesheet completa em uma única solicitação. Na prática, percebi que essa abordagem funciona bem para concept art, mas costuma falhar quando o objetivo é produzir assets realmente utilizáveis dentro de uma engine de jogos. O principal problema não era a qualidade visual das imagens, mas sim a consistência entre os frames. Pequenas variações de escala, posição, proporção e enquadramento acabavam tornando a animação difícil de usar dentro do jogo.</p><p>Gastei muito tempo com o ChatGpt buscando diversas variações de inputs e nenhum foi bom o suficiente.</p><h3>Virada do Jogo</h3><p>O ponto de virada aconteceu quando abandonei a ideia de gerar uma spritesheet inteira de uma vez e passei a tratar cada frame como um asset independente. Em vez de pedir uma animação completa, comecei criando uma imagem base do inimigo e depois fui produzindo variações controladas, frame a frame. Dessa forma, consegui orientar a IA para realizar apenas uma alteração específica em cada etapa da animação, preservando o restante da composição.</p><p>O resultado foi muito mais previsível e próximo do que normalmente encontramos em pipelines profissionais de desenvolvimento de jogos.</p><p>Gerei essas 4 imagens separadas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z4t2wjS1ARIFmdDioO_BSQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uWxnIz2HAkBI-zDS4iGmVg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uWxnIz2HAkBI-zDS4iGmVg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iozRCGX5KVaDGsJijv8jgg.png" /></figure><p>Durante esse processo, utilizei o Codex como parte fundamental da montagem dos assets. Uma vantagem interessante foi que o projeto já possuía em sua memória a informação de que os inimigos utilizavam spritesheets no formato 4x4. Esse detalhe aparentemente simples facilitou bastante o entendimento do contexto e permitiu que o Codex organizasse corretamente os arquivos gerados. Em vez de tentar interpretar livremente a estrutura da animação, ele já sabia exatamente quantos frames existiam e como eles deveriam ser distribuídos dentro da matriz.</p><p>A estratégia adotada foi bastante direta. Primeiro, gerei cada estado visual individualmente utilizando a IA de imagens. Em seguida, pedi ao Codex para reunir todos os arquivos em uma única spritesheet respeitando a ordem correta dos frames. Como cada imagem já representava uma etapa específica da animação, o trabalho de composição se tornou praticamente mecânico.</p><p>Importante: cada arquivo possuía no nome a posição que representava em uma matriz 4x4 isso ajudou muito a IA compreender.</p><p>Isso eliminou diversos problemas comuns, como mudanças inesperadas de enquadramento, personagens desalinhados ou objetos aparecendo em posições diferentes entre os frames.</p><p>Depois da montagem da spritesheet, o Codex executou algumas tarefas que normalmente consumiriam um tempo considerável caso fossem feitas manualmente. Pedi para redimensionar a imagem final de forma que cada frame tivesse exatamente 64x64 pixels, mantendo a estrutura da matriz. Também solicitei a remoção automática da cor de fundo #FF00FF, convertendo-a para canal alpha. Essa etapa foi especialmente importante porque permitiu utilizar os sprites diretamente no Godot sem a necessidade de tratamento adicional em softwares de edição de imagem.</p><h3>Cada ferramenta com seu propósito</h3><p>Outro aprendizado importante foi entender quais responsabilidades pertencem à IA e quais pertencem à engine. Em vários momentos percebi que estava tentando gerar via imagem efeitos que funcionariam melhor dentro do Godot. Partículas, fragmentos, poeira, fumaça e explosões costumam ficar mais naturais, mais leves e mais fáceis de ajustar quando implementados diretamente na engine. A partir desse momento passei a utilizar a IA apenas para criar os estados principais da animação, deixando para o Godot toda a parte dinâmica dos efeitos visuais.</p><p>Com a spritesheet pronta e importada para o projeto, os ajustes finais foram surpreendentemente simples. Bastou configurar corretamente o AnimatedSprite2D, ajustar a velocidade dos frames por segundo e fazer pequenos refinamentos na duração das animações. Como a base visual já estava consistente, a etapa de integração no Godot acabou sendo muito mais rápida do que eu imaginava inicialmente.</p><h3>TL;DR no fim</h3><p>O principal aprendizado dessa experiência foi perceber que a combinação entre IA generativa e automação produz resultados muito melhores do que tentar resolver tudo em uma única ferramenta. A ChatGpt foi excelente para criar os frames individuais, enquanto o Codex assumiu o papel de montar, organizar, redimensionar e preparar os assets para uso dentro do jogo. No final, o processo ficou mais próximo de um pipeline de produção do que de uma simples geração de imagens, e isso aumentou significativamente a qualidade dos resultados obtidos.</p><p>As imagens apresentadas fazem parte do jogo que estou produzindo, a reprodução delas precisa de autorização.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0aaf02eb18c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O que aprendi construindo memória e regras para agentes de IA]]></title>
            <link>https://medium.com/@GeraldoBastos/o-que-aprendi-construindo-mem%C3%B3ria-e-regras-para-agentes-de-ia-274f8b150ecd?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/274f8b150ecd</guid>
            <category><![CDATA[generative-ai-solution]]></category>
            <category><![CDATA[knowledge-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Thu, 04 Jun 2026 17:41:00 GMT</pubDate>
            <atom:updated>2026-06-04T17:41:00.669Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vXYfnNnIYO35h1QtYHPqvw.png" /></figure><p>Recentemente escrevi sobre a estratégia de criar uma memória persistente dentro do próprio repositório para auxiliar agentes de IA durante o desenvolvimento de software.</p><p>A ideia era simples:</p><p>Em vez de depender exclusivamente da janela de contexto da LLM, o projeto passaria a possuir uma base de conhecimento versionada junto com o código.</p><p>Após algumas semanas utilizando essa abordagem, surgiu um aprendizado interessante. O desafio não era apenas criar uma pasta memory/.</p><p>O desafio era entender a diferença entre memória, conhecimento, histórico e regras de comportamento.</p><h3>A primeira versão parecia boa</h3><p>A estrutura inicial era algo parecido com:</p><pre>memory/<br>├── current-state.md<br>├── architecture.md<br>├── decisions.md<br>├── next-tasks.md<br>└── sessions/</pre><p>A proposta funcionava muito bem, oagente conseguia:</p><ul><li>entender o estado atual do projeto;</li><li>conhecer a arquitetura;</li><li>consultar decisões passadas;</li><li>identificar próximos passos;</li><li>analisar sessões anteriores.</li></ul><p>Na prática, a produtividade aumentou bastante. Mas com o passar do tempo alguns problemas começaram a surgir.</p><h3>O erro que continuava voltando</h3><p>Em determinado momento percebi algo curioso. Alguns problemas já haviam sido resolvidos anteriormente. Eles apareciam documentados em sessões passadas.</p><p>Mesmo assim, ocasionalmente o agente voltava a investigar os mesmos caminhos. A informação existia, mas não estava fácil de encontrar.</p><p>Foi quando percebi um erro conceitual importante, estávamos registrando os aprendizados.</p><p>Mas não estávamos transformando esses aprendizados em conhecimento permanente.</p><h3>Sessions estava virando um arquivo morto</h3><p>A pasta:</p><pre>memory/sessions/</pre><p>foi criada para registrar o histórico do projeto. O problema é que ela começou a acumular informações importantes demais.</p><p>Exemplos:</p><ul><li>problemas recorrentes;</li><li>decisões técnicas;</li><li>procedimentos operacionais;</li><li>limitações de ferramentas;</li><li>soluções já validadas.</li></ul><p>Tudo isso acabava ficando enterrado dentro de sessões antigas.</p><p>Quando o agente precisava descobrir algo, muitas vezes precisava percorrer vários documentos históricos.</p><p>Isso é parecido com uma equipe que registra tudo em atas de reunião, mas nunca atualiza a documentação oficial.</p><p>A informação existe, mas ela não está acessível.</p><h3>A descoberta mais importante</h3><p>Foi nesse momento que surgiu uma distinção fundamental. Nem toda informação pertence à memória histórica.</p><p>Algumas informações precisam ser promovidas para uma camada mais permanente. Passamos então a separar três conceitos:</p><h3>Histórico</h3><p>Responde:</p><blockquote><em>O que aconteceu?</em></blockquote><p>Exemplo:</p><pre>memory/sessions/</pre><h3>Conhecimento</h3><p>Responde:</p><blockquote><em>O que sabemos hoje?</em></blockquote><p>Exemplo:</p><pre>current-state.md<br>architecture.md<br>known-issues.md<br>decisions.md</pre><h3>Regras</h3><p>Responde:</p><blockquote><em>Como devemos agir?</em></blockquote><p>Exemplo:</p><pre>.agent/rules/</pre><p>Essa separação mudou completamente a forma como passamos a estruturar o projeto.</p><h3>Surgimento do known-issues</h3><p>Uma das melhorias mais úteis foi a criação de um arquivo dedicado para problemas conhecidos.</p><pre>memory/known-issues.md</pre><p>Antes disso, um problema recorrente podia aparecer em três ou quatro sessões diferentes.</p><p>Agora existe uma fonte única de consulta. Quando um problema volta a ocorrer, o agente não precisa redescobrir a solução.</p><p>Ele consulta o conhecimento já consolidado.</p><h3>A criação do index</h3><p>Outra melhoria foi a criação de:</p><pre>memory/index.md</pre><p>Pode parecer algo simples. Mas foi uma das mudanças mais importantes.</p><p>Antes, o agente precisava descobrir sozinho onde procurar determinadas informações.</p><p>Agora existe um ponto de entrada único para toda a memória do projeto. Algo parecido com o índice de um livro.</p><h3>O nascimento da camada .agent</h3><p>Outra conclusão interessante surgiu durante o processo.</p><p>Inicialmente eu imaginava que qualquer informação relevante poderia ficar distribuída entre a memória e os arquivos de instrução do agente.</p><p>Com o tempo percebi que isso criava um problema novo: duplicação.</p><p>Em alguns casos, a mesma informação aparecia tanto na memória quanto nas regras do agente.</p><p>Isso significava que duas fontes diferentes precisavam ser mantidas sincronizadas.</p><p>Foi então que passamos a adotar uma regra simples:</p><p><strong>A memória é a fonte oficial de conhecimento do projeto.</strong></p><p><strong>O agente apenas aprende como utilizar esse conhecimento.</strong></p><p>A estrutura passou a seguir uma separação mais clara:</p><pre>memory/<br>├── index.md<br>├── current-state.md<br>├── architecture.md<br>├── decisions.md<br>├── known-issues.md<br>├── next-tasks.md<br>└── sessions/</pre><pre>.agent/<br>└── rules/<br>    ├── memory.md<br>    ├── testing.md<br>    ├── workflow.md<br>    ├── git.md<br>    ├── tooling.md<br>    └── project.md</pre><p>Por exemplo:</p><p>A arquitetura oficial do projeto existe em apenas um lugar:</p><pre>memory/architecture.md</pre><p>Já os arquivos do agente contêm apenas instruções como:</p><ul><li>quando consultar a arquitetura;</li><li>quando atualizá-la;</li><li>quais cuidados tomar antes de alterá-la.</li></ul><p>Essa mudança eliminou duplicidades e reduziu a chance de informações ficarem inconsistentes ao longo do tempo.</p><h3>A estratégia continuou evoluindo</h3><p>Talvez o aprendizado mais interessante tenha sido perceber que a própria estratégia de memória precisava ser tratada como um sistema vivo.</p><p>Em determinado momento identifiquei que alguns problemas voltavam a aparecer mesmo já tendo sido resolvidos anteriormente.</p><p>A solução estava registrada, mas estava escondida dentro do histórico de sessões.</p><p>Foi então que surgiu uma nova regra:</p><p>Quando uma informação aparece repetidamente em sessões diferentes, ela deve ser promovida para uma fonte mais estável.</p><p>Por exemplo:</p><ul><li>problemas recorrentes vão para known-issues.md;</li><li>decisões importantes vão para decisions.md;</li><li>estado do projeto vai para current-state.md;</li><li>comportamento operacional vai para .agent/rules/.</li></ul><p>As sessões continuam existindo, mas deixaram de ser a principal fonte de conhecimento.</p><p>Hoje elas funcionam como histórico. O conhecimento consolidado vive em arquivos permanentes.</p><p>E as regras do agente determinam como esse conhecimento deve ser utilizado.</p><h3>A diferença entre memória e regras</h3><p>Essa talvez tenha sido a principal descoberta de todo o processo.</p><h3>Memória</h3><pre>Foi identificado um problema recorrente.<br>A solução validada foi X.</pre><h3>Regra</h3><pre>Quando esse problema aparecer novamente,<br>seguir o procedimento X.</pre><p>A primeira registra um fato. A segunda altera comportamento. São responsabilidades completamente diferentes.</p><h3>O fluxo atual</h3><p>Hoje o processo segue aproximadamente esta ordem:</p><pre>1. Ler memory/index.md<br>2. Ler current-state.md<br>3. Ler next-tasks.md<br>4. Ler known-issues.md<br>5. Ler decisions.md<br>6. Consultar sessões recentes se necessário<br>7. Executar o trabalho</pre><p>Durante a execução:</p><pre>Problema recorrente?<br>↓<br>Consultar known-issues.md</pre><pre>Mudança arquitetural?<br>↓<br>Consultar decisions.md</pre><pre>Dúvida operacional?<br>↓<br>Consultar .agent/rules/</pre><p>Esse fluxo reduziu significativamente a necessidade de procurar informações espalhadas pelo histórico.</p><h3>O papel das sessões mudou</h3><p>Talvez a maior mudança tenha sido esta.</p><p>Antes:</p><pre>sessions = memória principal</pre><p>Agora:</p><pre>sessions = histórico</pre><p>As sessões continuam importantes. Mas deixaram de ser a fonte principal de conhecimento.</p><p>Quando uma informação se mostra relevante e reutilizável, ela deve ser promovida para:</p><pre>known-issues.md<br>decisions.md<br>current-state.md<br>ou<br>.agent/rules/</pre><h3>O que aprendi</h3><p>A principal lição foi perceber que agentes de IA precisam de algo muito parecido com o que equipes humanas precisam.</p><p>Não basta ter histórico se não conseguir transformá-lo em conhecimento e não basta ter conhecimento se não conseguir transformá-lo em comportamento reproduzível.</p><p>Hoje enxergo a estratégia de memória menos como uma solução para limites de contexto e mais como uma forma de construir uma base de conhecimento viva, versionada e compartilhada.</p><p>Curiosamente, essa base acaba ajudando não apenas a IA. Ela também me ajuda quando quero olhar no projeto.</p><p>E talvez esse seja o melhor sinal de que a estratégia está funcionando, pelo menos até agora :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=274f8b150ecd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A memória que mudou minha forma de trabalhar com agentes de IA]]></title>
            <link>https://medium.com/@GeraldoBastos/a-mem%C3%B3ria-que-mudou-minha-forma-de-trabalhar-com-agentes-de-ia-5741013b1d37?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/5741013b1d37</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Sun, 31 May 2026 08:01:01 GMT</pubDate>
            <atom:updated>2026-05-31T08:01:01.996Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FFqTM76cdz6vumg6mM3p1A.png" /></figure><p>Durante muito tempo eu enxerguei agentes de IA como colaboradores extremamente capazes, mas com um problema fundamental: a memória. Não importa se estamos falando de Codex, Claude Code, Gemini CLI ou qualquer outra solução. Todos eles possuem algum limite de contexto.</p><p>Em projetos pequenos isso raramente se torna um problema. Mas quando o projeto começa a crescer, surgem desafios como:</p><ul><li>decisões técnicas tomadas semanas atrás;</li><li>requisitos discutidos em sessões anteriores;</li><li>convenções específicas do projeto;</li><li>histórico de problemas encontrados;</li><li>planejamento das próximas etapas.</li></ul><p>Foi nesse momento que percebi que talvez estivesse tentando resolver o problema errado. A questão não era fazer a IA lembrar de tudo. A questão era criar um sistema onde ela pudesse consultar o que precisa saber.</p><h3>A diferença entre contexto e memória</h3><p>É comum confundir contexto com memória, são coisas diferentes.</p><p>O <strong>contexto</strong> é aquilo que está disponível para a IA durante a execução atual.</p><p>A <strong>memória</strong> é o conhecimento acumulado ao longo do tempo.</p><p>Quando uma sessão termina, boa parte do contexto desaparece, já uma memória persistente continua existindo.</p><p>Por isso comecei a tratar o repositório como uma base de conhecimento compartilhada entre humanos (só eu, kkkk…) e agentes de IA.</p><h3>A estrutura da memória</h3><p>A estrutura que venho utilizando é simples.</p><pre>memory/<br>├── README.md<br>├── current-state.md<br>├── architecture.md<br>├── decisions.md<br>├── next-tasks.md<br>└── sessions/<br>    ├── 2026-05-01.md<br>    ├── 2026-05-02.md<br>    ├── 2026-05-03.md<br>    └── ...</pre><p>Cada arquivo possui uma responsabilidade específica.</p><h3>current-state.md</h3><p>Este é provavelmente o arquivo mais importante. Ele responde uma única pergunta:</p><blockquote><em>Onde o projeto está agora?</em></blockquote><p>Exemplo de conteúdo:</p><pre># Estado Atual<br>## Funcionalidades concluídas<br>- Funcionalidade A<br>- Funcionalidade B<br>## Em andamento<br>- Funcionalidade C<br>## Pendências conhecidas<br>- Problema X<br>- Problema Y<br>## Próximos objetivos<br>- Objetivo 1<br>- Objetivo 2</pre><p>Quando uma nova sessão começa, esse costuma ser o primeiro arquivo lido. Ele evita que a IA precise reconstruir o estado do projeto analisando centenas de arquivos.</p><h3>architecture.md</h3><p>Este documento explica como o projeto está organizado. Ele não descreve apenas diretórios. Ele explica decisões estruturais.</p><p>Exemplo:</p><pre># Arquitetura<br>## Organização do projeto<br>- Camada de interface<br>- Camada de domínio<br>- Camada de infraestrutura<br>## Fluxos principais<br>Descrição dos fluxos mais importantes.<br>## Dependências<br>Descrição das principais dependências e integrações.</pre><p>Esse arquivo ajuda a IA a entender o “porquê” da organização e não apenas o “onde”.</p><h3>decisions.md</h3><p>Ao longo do tempo, projetos acumulam decisões. O problema é que raramente alguém lembra por que elas foram tomadas e por isso gosto de registrar decisões em formato semelhante a ADRs (Architecture Decision Records).</p><pre># Deccisão 001<br>## Contexto<br>Problema que precisava ser resolvido.<br>## Decisão<br>Solução escolhida.<br>## Motivo<br>Por que essa abordagem foi adotada.<br>## Consequências<br>Impactos positivos e negativos.</pre><p>Isso reduz significativamente a chance de uma IA tentar desfazer uma decisão importante simplesmente porque ela não conhece o histórico.</p><h3>next-tasks.md</h3><p>Este arquivo funciona como uma fila de trabalho.</p><pre># Alta prioridade<br>- Item A<br>- Item B<br># Média prioridade<br>- Item C<br># Baixa prioridade<br>- Item D</pre><p>Além de orientar futuras sessões, ele ajuda a evitar que a IA comece a trabalhar em tarefas aleatórias.</p><h3>sessions/</h3><p>A pasta de sessões é o diário do projeto. Cada dia gera um novo registro.</p><p>Exemplo:</p><pre># Sessão 2026-05-03<br>## Objetivo<br>Implementar funcionalidade específica.<br>## Arquivos analisados<br>- arquivo-a<br>- arquivo-b<br>## Alterações realizadas<br>Descrição das mudanças.<br>## Problemas encontrados<br>Descrição dos problemas.<br>## Decisões tomadas<br>Lista de decisões.<br>## Próximos passos<br>Lista de ações futuras.</pre><p>Com o passar do tempo, essa pasta se torna uma linha do tempo do projeto.</p><h3>O papel dos arquivos de regras</h3><p>A memória sozinha resolve apenas parte do problema. Também é importante ensinar ao agente como trabalhar e é aí que entram arquivos de regras.</p><p>Dependendo da ferramenta, podem existir estruturas como:</p><pre>.agents/<br>├── rules/<br>│   ├── coding.md<br>│   ├── testing.md<br>│   ├── git.md<br>│   └── architecture.md<br>│<br>├── prompts/<br>│   └── ...<br>│<br>└── workflows/<br>    └── ...</pre><p>Ou ainda:</p><pre>.agent/<br>.rules/<br>.instructions/<br>.ai/</pre><p>A nomenclatura muda. O conceito permanece. Esses arquivos normalmente não armazenam memória. Eles armazenam comportamento.</p><h3>A diferença entre memória e regras</h3><p>Muitas equipes misturam os dois conceitos. Eu prefiro separá-los.</p><p>Memória responde:</p><blockquote><em>O que aconteceu?</em></blockquote><p>Regras respondem:</p><blockquote><em>Como devemos trabalhar?</em></blockquote><p>Por exemplo:</p><h3>Memória</h3><pre>Foi decidido utilizar abordagem X<br>porque resolveu o problema Y.</pre><h3>Regra</h3><pre>Sempre criar testes automatizados<br>antes de abrir um pull request.</pre><p>A primeira fala sobre histórico e asegunda fala sobre comportamento.</p><h3>Como tudo se conecta</h3><p>Quando uma nova sessão começa, o fluxo costuma ser:</p><pre>1. Ler regras<br>2. Ler estado atual<br>3. Ler arquitetura<br>4. Ler decisões<br>5. Ler próximos passos<br>6. Ler últimas sessões<br>7. Iniciar trabalho</pre><p>Visualmente:</p><pre>                 ┌──────────────┐<br>                 │ Regras       │<br>                 └──────┬───────┘<br>                        │<br>                        ▼<br>┌─────────────────────────────────────┐<br>│          Estado Atual               │<br>└─────────────────────────────────────┘<br>                        │<br>                        ▼<br>┌─────────────────────────────────────┐<br>│          Arquitetura                │<br>└─────────────────────────────────────┘<br>                        │<br>                        ▼<br>┌─────────────────────────────────────┐<br>│          Decisões                   │<br>└─────────────────────────────────────┘<br>                        │<br>                        ▼<br>┌─────────────────────────────────────┐<br>│          Próximas Tarefas           │<br>└─────────────────────────────────────┘<br>                        │<br>                        ▼<br>┌─────────────────────────────────────┐<br>│          Histórico de Sessões       │<br>└─────────────────────────────────────┘</pre><p>Nesse modelo, a IA não precisa lembrar. Ela precisa saber onde consultar.</p><h3>A principal mudança de mentalidade</h3><p>A maior transformação para mim foi perceber que agentes de IA não devem ser tratados como pessoas tentando recordar informações.</p><p>Eles funcionam melhor quando existe uma base de conhecimento organizada.</p><p>Hoje penso menos em “quantos tokens cabem no contexto” e mais em “quão fácil é para um agente encontrar a informação correta”.</p><p>Essa mudança fez com que minhas sessões se tornassem mais previsíveis, mais reproduzíveis e menos dependentes de uma única conversa.</p><p>Talvez o futuro dos agentes não esteja em contextos infinitos. Talvez esteja em memórias simples, bem organizadas e versionadas junto com o próprio projeto.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5741013b1d37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Por que estou migrando do Antigravity para o Codex]]></title>
            <link>https://medium.com/@GeraldoBastos/por-que-estou-migrando-do-antigravity-para-o-codex-b63deed1de78?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/b63deed1de78</guid>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[godot-engine]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[codex-cli]]></category>
            <category><![CDATA[google-antigravity]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Sat, 30 May 2026 02:33:27 GMT</pubDate>
            <atom:updated>2026-05-30T02:33:27.780Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0islD07kG5qLO4Z2Ll5JgQ.png" /></figure><p>Nos últimos meses tenho dedicado parte do meu tempo a experimentar diferentes ferramentas de desenvolvimento assistido por IA.</p><p>Nesse processo utilizei bastante o Antigravity, principalmente integrado ao Claude Code. A experiência foi positiva em diversos aspectos, mas algumas observações começaram a me chamar atenção com o passar do tempo. Essas observações me levaram a testar alternativas e, mais recentemente, a migrar meu fluxo principal para o Codex.</p><p>Este artigo não tem o objetivo de apontar vencedores ou perdedores. Cada ferramenta possui seu espaço. O objetivo é compartilhar percepções práticas de uso diário.</p><h3>A sensação de uma interface pesada</h3><p>A primeira percepção surgiu no uso cotidiano.</p><p>Embora o Antigravity ofereça uma experiência bastante interessante, comecei a sentir que a interface adicionava uma carga cognitiva maior do que eu precisava para o meu fluxo de trabalho.</p><p>Em muitos momentos eu queria apenas:</p><ul><li>abrir um projeto;</li><li>descrever uma tarefa;</li><li>acompanhar a execução;</li><li>revisar o resultado.</li></ul><p>Porém a experiência frequentemente me fazia navegar por múltiplos painéis, estados da aplicação, configurações e componentes visuais.</p><p>Não se trata necessariamente de um problema de performance. A sensação era mais próxima de uma “carga cognitiva” adicional.</p><p>Quanto mais tempo passei utilizando agentes de IA, mais percebi que meu interesse estava migrando da interface para o resultado.</p><p>Eu queria gastar menos energia operando a ferramenta e mais energia pensando sobre o problema.</p><h3>O que me chamou atenção no Codex</h3><p>O que me chamou atenção ao codex foi simplesmente o fato do meu plano no chatgpt plus possuir suporte ao codex cli.</p><p>Quando comecei a utilizar o Codex de forma mais intensa, uma característica me agradou imediatamente: simplicidade.</p><p>O fluxo é bastante direto. A interação parece mais próxima da ideia de um engenheiro trabalhando ao lado de outro engenheiro. Você descreve o problema e o agente analisa.</p><p>Existe menos sensação de estar operando uma plataforma e mais sensação de estar colaborando com um parceiro técnico.</p><p>Para contexto do que estou usando no momento: codex CLI no linux e llm chatgpt 5.5.</p><h3>O consumo de tokens começou a me preocupar</h3><p>Outro aspecto que chamou minha atenção foi o consumo de contexto. Durante alguns testes utilizando Claude Code através do Antigravity, observei um comportamento que me pareceu consumir mais tokens do que eu esperava.</p><p>Naturalmente, parte desse consumo pode ser consequência da própria estratégia utilizada pelo agente. Algo que me incomodava era o contexto expandido.</p><p>Ao comparar sessões semelhantes utilizando outras LLMs disponíveis, tive a impressão de que algumas delas conseguiam chegar a resultados equivalentes consumindo menos tokens.</p><p><strong>Importante</strong> destacar que essa percepção é empírica.</p><p>Ainda assim, quando você passa horas por semana trabalhando com agentes de IA, pequenas diferenças de consumo começam a ficar perceptíveis. Principalmente em projetos de longa duração.</p><h3>A descoberta da memória externa</h3><p>Uma das ideias mais interessantes que encontrei recentemente não veio de uma ferramenta específica. Veio de uma prática.</p><p>A estratégia consiste em criar uma memória persistente dentro do próprio repositório.</p><p>Ao final de cada sessão, a IA gera arquivos contendo:</p><ul><li>estado atual do projeto;</li><li>decisões tomadas;</li><li>problemas encontrados;</li><li>próximos passos;</li><li>resumo da sessão.</li></ul><p>No início da próxima sessão, o agente lê esses arquivos antes de começar a trabalhar. Essa abordagem reduz dependência da janela de contexto da LLM, mais importante ainda: cria uma documentação viva do projeto.</p><p>Foi uma mudança de mentalidade importante para mim. Passei a enxergar a IA não como uma entidade que precisa lembrar de tudo, mas como uma colaboradora que consulta uma base de conhecimento organizada.</p><h3>A lição mais importante</h3><p>Depois de testar diferentes ferramentas, cheguei a uma conclusão simples. A qualidade do fluxo de trabalho não depende apenas do modelo utilizado.</p><p>Ela depende da combinação entre:</p><ul><li>modelo;</li><li>interface;</li><li>estratégia de memória;</li><li>documentação;</li><li>processo de desenvolvimento.</li></ul><p>Muitas vezes gastamos energia discutindo qual LLM é melhor, quando o verdadeiro ganho está em criar um ambiente onde qualquer boa LLM consiga trabalhar de forma eficiente.</p><p>Hoje o Codex atende melhor ao que procuro nesse momento: simplicidade, foco e um fluxo de trabalho mais direto.</p><p>Isso não significa que será minha escolha definitiva para sempre.</p><p>O mercado muda rápido e novos modelos surgem constantemente.</p><p>Mas, neste momento, minha impressão é que reduzir a complexidade da ferramenta me permitiu aumentar a atenção sobre aquilo que realmente importa: construir software.</p><p>Vale ressaltar que estas conclusões representam apenas minha experiência atual. Elas podem estar sendo influenciadas pelo meu fluxo de trabalho, pelos projetos que desenvolvo ou até por limitações no meu conhecimento das ferramentas. Não teria qualquer problema em rever essa opinião no futuro caso novas experiências apontem em outra direção.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b63deed1de78" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do Zero ao jogo: minha stack de estudos em game com IA- Parte 1]]></title>
            <link>https://medium.com/@GeraldoBastos/do-zero-ao-jogo-minha-stack-de-estudos-em-game-com-ia-parte-1-ac6b13ac3007?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac6b13ac3007</guid>
            <category><![CDATA[godot-engine]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[indie-game-dev]]></category>
            <category><![CDATA[godot]]></category>
            <category><![CDATA[indie-game]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Sat, 04 Apr 2026 12:09:44 GMT</pubDate>
            <atom:updated>2026-04-04T12:09:44.771Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*esyXhdwzkmrozGVQjOAC0Q.png" /></figure><p>Para os que me conhecem, sabem que no passado eu trabalhei com jogos e posso dizer que desde então descobri a área de desenvolvimento pela qual tenho paixão. Depois, passei muitos anos como desenvolvedor iOS, atuei em alguns projetos interessantes e fui para a carreira de gestão.</p><p>Venho, sem compromisso rígido, escrever a minha aventura em voltar a criar jogos, com uma engine (Godot) que nunca usei e com o apoio da IA. Vou colocar abaixo como foi o início e como está agora.</p><h4>Início</h4><p>Eu uso um notebook Dell com Ubuntu 26.04 LTS. Após muitos anos usando Mac, decidi que, já que vou voltar a estudar forte programação, escolheria um sistema operacional que sempre me chamou a atenção.</p><p>Nos meus primeiros estudos com o Godot, eu usei o ChatGPT 5.3. Ele foi minha fonte de tutoriais, pois não queria um agente programando para mim — queria ler e eu mesmo escrever (isso facilita aprender algo novo).</p><p>Foi um pouco cansativo, pois ele insistia em usar uma versão da engine diferente da que eu tinha, mesmo pedindo para atualizar sua memória.</p><p>Dessa forma, hoje eu tenho um jogo completo com: menu, tela jogável, sistema de pause, configurações, game over e restart. Consigo salvar localmente a maior pontuação e compará-la com a atual. Basicamente, o que eu queria no início: um jogo simples, para ser jogado em uma fila ou quando você tem alguns minutos e quer apenas relaxar, sem o compromisso de voltar — pois não há punição caso não o faça.</p><p>Acho que essa etapa foi fundamental para conhecer melhor a engine e decidir continuar com ela. Fiquei feliz com o resultado.</p><h4>Agora</h4><p>Para essa próxima etapa, eu vou fazer diferente. Primeiro, precisei instalar o Firejail, porque não quero agentes com livre acesso ao sistema operacional. Ele basicamente cria uma <em>home</em> privada para a solução que pretendo usar — o Antigravity.</p><p>Eu normalmente uso o Flatpak, que possui o mesmo objetivo de isolar aplicações, limitando seus acessos, mas para o Antigravity só foi possível utilizar o Firejail.</p><p><strong>Firejail config</strong></p><p>Ao usar, precisei fazer alguns ajustes:</p><p><strong>Rede</strong><br>Precisei liberar o acesso. Poderia configurar para funcionar apenas na minha residência, mas, ao trabalhar em outra rede, precisaria ajustar novamente. Por isso, preferi inicialmente apenas comentar a linha que bloqueia o uso de rede, permitindo acesso livre.</p><p><strong>Google Chrome como navegador</strong><br> Eu uso o Firefox como navegador padrão. Estou testando o Chrome, pois acredito que, com mais experiência, consigo melhorar meu julgamento. Ao abrir o Antigravity, ele solicita login com Google (<em>Google Sign-In</em>), o que abre um navegador. Nesse caso, precisei alterar o navegador padrão para o Google Chrome — e funcionou.</p><p>Depois, quero avaliar como configurar o Chrome apenas para o Antigravity e voltar a usar o Firefox como padrão no Ubuntu.</p><p><strong>Criação de profile</strong><br> O Firejail trabalha com perfis (<em>profiles</em>). Como alterei algumas configurações, o ideal foi criar um perfil específico para a aplicação que irei usar. Nesse arquivo, defino o diretório da <em>home</em> privada, permissões de acesso (como uso do <em>desktop portal</em> para abrir navegador), remoção de privilégios e outras configurações que dependem do projeto.</p><p>Aproveitei também para criar um alias, pois não queria digitar toda vez o comando completo de abertura do Antigravity com o perfil específico.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac6b13ac3007" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Curiosidades do Godot]]></title>
            <link>https://medium.com/@GeraldoBastos/curiosidades-do-godot-7a76e560f5c5?source=rss-4a2a7df91230------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a76e560f5c5</guid>
            <category><![CDATA[godot-engine]]></category>
            <category><![CDATA[variables]]></category>
            <category><![CDATA[bloco-de-notas]]></category>
            <category><![CDATA[gamedev]]></category>
            <category><![CDATA[gdscript]]></category>
            <dc:creator><![CDATA[Geraldo Bastos]]></dc:creator>
            <pubDate>Sat, 07 Feb 2026 13:55:03 GMT</pubDate>
            <atom:updated>2026-02-07T13:55:03.419Z</atom:updated>
            <content:encoded><![CDATA[<p>Bloco de notas Godot #1</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_h5GcSDrGOcgU6hCeyy8Rw.png" /></figure><h3>Linguagem</h3><p>É uma linguagem própria e que lembra o python em sua identação. Ela é uma linguagem de script executada pelo runtime do Godot.</p><h3>Variáveis</h3><p>Por uma questão de evolução da linguagem, ao declararmos uma variável temos duas formas:</p><h4>declaração + inferência de tipo</h4><pre>var player := Camera2D.new()</pre><p>Nesse caso usamos o : para que o interpretador saiba que naquele momento irá ocorrer uma inferência de tipo.</p><h4>declaração explícita</h4><pre>var player: Camera2D = Camera2D.new()</pre><h4>E se eu misturar, o que vai acontecer?</h4><pre>var player: Camera2D := Camera2D.new()</pre><p>A IDE irá apresentar a mensagem:</p><p><em>Expected end of statement after variable declaration, found “ :” instead.</em></p><h4>Variável sem tipo definido</h4><p>Tem momentos em que criamos uma variável mas inda não definimos o tipo dela — quem nunca fez isso atire a primeira pedra.</p><pre>var temp = null</pre><p>Para o interpretador temp na verdade possui um tipo, chama-se <em>Variant</em> (aceita tudo).</p><p>mas a linguagem permite tipagem dinâmica? Sim e não. A linguagem usada no Godot é de tipagem opcionalmente estática, ou seja, uma vez declarada de forma implícita ou explícita, não muda. A única exceção é quando usamos o tipo Variant, que dessa forma podemos fazer algo como:</p><pre>var cam = null<br> print(typeof(cam))<br> cam = &quot; bobonica&quot;<br> print(typeof(cam))<br> cam = Camera2D.new()<br> print(typeof(cam))<br><br>//output<br>0<br>4<br>24</pre><p>os valores númericos retornados é porque o typeof retorna um Variant.Type e em sua doc temos:</p><pre>enum Variant.Type:<br><br>● TYPE_NIL = 0<br>Variable is null.<br>● TYPE_BOOL = 1<br>Variable is of type bool.<br>● TYPE_INT = 2<br>Variable is of type int.<br>● TYPE_FLOAT = 3<br>Variable is of type float.<br>● TYPE_STRING = 4<br>Variable is of type String.<br>● TYPE_VECTOR2 = 5<br>Variable is of type Vector2.<br>● TYPE_VECTOR2I = 6<br>Variable is of type Vector2i.<br>● TYPE_RECT2 = 7<br>Variable is of type Rect2.<br>● TYPE_RECT2I = 8<br>Variable is of type Rect2i.<br>● TYPE_VECTOR3 = 9<br>Variable is of type Vector3.<br>● TYPE_VECTOR3I = 10<br>Variable is of type Vector3i.<br>● TYPE_TRANSFORM2D = 11<br>Variable is of type Transform2D.<br>● TYPE_VECTOR4 = 12<br>Variable is of type Vector4.<br>● TYPE_VECTOR4I = 13<br>Variable is of type Vector4i.<br>● TYPE_PLANE = 14<br>Variable is of type Plane.<br>● TYPE_QUATERNION = 15<br>Variable is of type Quaternion.<br>● TYPE_AABB = 16<br>Variable is of type AABB.<br>● TYPE_BASIS = 17<br>Variable is of type Basis.<br>● TYPE_TRANSFORM3D = 18<br>Variable is of type Transform3D.<br>● TYPE_PROJECTION = 19<br>Variable is of type Projection.<br>● TYPE_COLOR = 20<br>Variable is of type Color.<br>● TYPE_STRING_NAME = 21<br>Variable is of type StringName.<br>● TYPE_NODE_PATH = 22<br>Variable is of type NodePath.<br>● TYPE_RID = 23<br>Variable is of type RID.<br>● TYPE_OBJECT = 24<br>Variable is of type Object.<br>● TYPE_CALLABLE = 25<br>Variable is of type Callable.<br>● TYPE_SIGNAL = 26<br>Variable is of type Signal.<br>● TYPE_DICTIONARY = 27<br>Variable is of type Dictionary.<br>● TYPE_ARRAY = 28<br>Variable is of type Array.<br>● TYPE_PACKED_BYTE_ARRAY = 29<br>Variable is of type PackedByteArray.<br>● TYPE_PACKED_INT32_ARRAY = 30<br>Variable is of type PackedInt32Array.<br>● TYPE_PACKED_INT64_ARRAY = 31<br>Variable is of type PackedInt64Array.<br>● TYPE_PACKED_FLOAT32_ARRAY = 32<br>Variable is of type PackedFloat32Array.<br>● TYPE_PACKED_FLOAT64_ARRAY = 33<br>Variable is of type PackedFloat64Array.<br>● TYPE_PACKED_STRING_ARRAY = 34<br>Variable is of type PackedStringArray.<br>● TYPE_PACKED_VECTOR2_ARRAY = 35<br>Variable is of type PackedVector2Array.<br>● TYPE_PACKED_VECTOR3_ARRAY = 36<br>Variable is of type PackedVector3Array.<br>● TYPE_PACKED_COLOR_ARRAY = 37<br>Variable is of type PackedColorArray.<br>● TYPE_PACKED_VECTOR4_ARRAY = 38<br>Variable is of type PackedVector4Array.<br>● TYPE_MAX = 39<br>Represents the size of the Variant.Type enum</pre><p>A boa prática é evitar o uso de tipagem dinâmica, como forma de ajudar a compreender o código.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a76e560f5c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>