DEV Community: Lucas Resende

Mentoria IBM "Ctrl+Alt Dream": Lições de Carreira na Prática

Lucas Resende — Tue, 20 Oct 2026 11:00:00 +0000

Entrei na sala do Microsoft Teams às dez em ponto com o Obsidian aberto na tela, esperando aquela rotina cansativa de evento corporativo online: alguém da organização compartilhando slides institucionais sobre tendências de mercado enquanto dezenas de estudantes assistem em silêncio.

A dinâmica da mentoria <Ctrl+Alt> <Dream>, promovida pela IBM SkillsBuild em parceria com o Centro Paula Souza, foi o oposto disso. A organização dividiu os alunos em salas menores para uma hora de conversa direta com profissionais voluntários. Éramos sete pessoas no total da chamada: quatro estudantes (eu, a Júlia e a Élida, colegas de Segurança da Informação na Fatec Americana, além da Ana Clara, do ensino médio da Etec) e três profissionais com vivências sólidas no setor financeiro, tributário e de consultoria:

Mariana Ribeiro, sócia de M&A Transaction Services na Deloitte, com quase duas décadas de consultoria e mais de 300 transações de fusões e aquisições no currículo.
Vanessa Celuppi, que hoje cuida de governança e planejamento comercial no Bradesco, depois de ter começado aos 19 anos como estoquista de shopping e supervisora no telebanco.
Luiza Monticeli, analista de Business TAX e Transfer Pricing na Deloitte, que se formou em Direito e migrou para a consultoria tributária aos 25 anos.

A conversa durou 60 minutos sem nenhum slide. Falaram com abertura e sem rodeios sobre contratações, insegurança e tropeços reais de carreira. Alguns direcionamentos práticos da conversa se destacaram assim que a sessão terminou.

O currículo cheio de certificados e a dúvida da Júlia

Logo no começo, a Júlia abriu o microfone e colocou na mesa uma dúvida que consome quem está nos primeiros semestres: vale a pena passar semanas acumulando diplomas rápidos para tentar impressionar recrutadores, ou isso é perda de tempo?

A resposta da Vanessa foi direta ao ponto:

"A empresa sempre vai olhar os seus hard skills para elegibilidade da vaga. O que faz você ganhar a vaga e se destacar são os soft skills: demonstrar vontade, relacionamento e brilho nos olhos."

Vanessa Celuppi, Analista de Planejamento Comercial no Bradesco

Gastar 40 horas fazendo dezenas de cursos rápidos de 2 horas costuma gerar mais volume do que substância. As certificações funcionam apenas como um filtro mecânico inicial para colocar o currículo na pilha. O que decide a contratação é como você sustenta uma conversa técnica e reage a problemas reais.

A Luiza viveu isso na pele ao entrar no programa de novos talentos da Deloitte. Recém-formada em Direito, ela não sabia montar um Procv no Excel e nunca tinha calculado tributos complexos na vida. Ela não tentou fingir conhecimento que não tinha. Assumiu suas limitações com clareza, mostrou lógica para aprender rápido e firmeza para lidar com clientes sob pressão.

Para se preparar para a entrevista, ela usou uma abordagem pragmática: em vez de pedir resumos prontos ao ChatGPT, ela instruía a IA a agir como uma entrevistadora técnica exigente. Pedia para o modelo fazer perguntas difíceis sobre legislação e apontar qualquer inconsistência no raciocínio dela. Treinar a fala sob pressão ajudou muito mais do que empilhar diplomas de cursos rápidos.

A porta de entrada e as passagens de ônibus em BH

A trajetória que a Vanessa compartilhou quebrou qualquer tom corporativo distante. Ela começou aos 19 anos descarregando caixas como estoquista em loja de shopping, trabalhou nas Lojas Renner e depois entrou no atendimento telefônico de telebanco.

Naquela rotina pesada de telemarketing, ela não tinha como prever os próximos dez anos. Mas colocou energia no atendimento, foi promovida a supervisora de 30 pessoas em apenas um ano e encontrou uma vocação comercial nítida. Passou oito anos gerenciando contas corporativas e hoje responde pela governança de negócios no Bradesco.

"Às vezes a porta de entrada não é exatamente aquilo que a gente espera. Onde você entra não precisa ser seu destino final. Os cargos e os momentos mudam, mas aquilo que é a sua essência continua com você para sempre."

Vanessa Celuppi, Analista de Planejamento Comercial no Bradesco

A trajetória da Mariana Ribeiro reforçou essa mesma sensação de realidade. Vinda de São Gonçalo do Sapucaí, no sul de Minas Gerais, ela foi a primeira pessoa da família a pisar em uma faculdade. No primeiro estágio que arrumou na prefeitura de Belo Horizonte, o custo do transporte público superava o valor da bolsa. Ela literalmente pagava para trabalhar. Anos depois, entrou como trainee na Deloitte, passou três anos em Boston liderando projetos globais e virou sócia da consultoria em 2020.

"A vida e a carreira não são linhas retas, são feitas de vales, altos e baixos. Ter resiliência e persistência para passar pelos desafios é o que faz a gente ser perene."

Mariana Ribeiro, Sócia de M&A Transaction Services na Deloitte

Ouvir esses relatos desmontou parte da neurose com o primeiro emprego ideal. Na faculdade de tecnologia, a gente costuma criar a ilusão de que a estreia precisa ser como júnior brilhante em uma grande empresa de software. Na prática, começar em suporte técnico, atendimento ou rotinas operacionais não atrasa a vida. É no trabalho puxado do dia a dia que a gente aprende a lidar com prazos, clientes nervosos e sistemas fora do ar.

O medo de falar inglês e a vaidade da pronúncia

A Élida, que trabalhou como advogada por 25 anos e entrou na Fatec aos 47 para estudar Segurança da Informação, compartilhou um bloqueio comum: ler documentações em inglês e responder e-mails é tranquilo, mas a voz trava na hora de falar por receio de errar a gramática.

A Mariana tirou o peso do assunto contando o que sentiu na pele quando foi transferida para os Estados Unidos. Ela passou meses travada nas reuniões porque queria falar com a fluência e a pronúncia de uma americana nativa. Até perceber que os diretores em Nova York e Boston só queriam saber se o cronograma da auditoria estava correto e se os números batiam. Ninguém prestava atenção no sotaque dela.

Esperar atingir uma pronúncia irretocável antes de arriscar uma frase em público é uma forma sutil de autossabotagem. Em reuniões de trabalho, clareza e objetividade importam muito mais do que perfeição gramatical.

A paralisia por análise e a pergunta que levei para a reta final

Depois de ouvir com atenção as trajetórias da Vanessa, da Mariana e da Luiza, e acompanhar os pontos levantados pela Júlia e pela Élida, aproveitei a reta final da sessão para colocar na mesa um desafio estratégico que tenho sentido de perto.

Ao migrar do design e marketing para a computação, a quantidade enorme de caminhos possíveis gera uma sobrecarga real. Quando você tem interesse por desenvolvimento, cibersegurança e mercados globais, é fácil cair na armadilha de tentar prever cada passo, refinando planos e sistemas de estudo no detalhe em vez de testar hipóteses no mundo real. Perguntei como elas equilibravam essa busca por direcionamento sem travar no excesso de opções.

A Élida levantou a mão para responder de imediato:

"Lucas, eu estou no último semestre e você está no primeiro. A sua cabeça vai mudar muitas vezes ainda. Você não vai descobrir do que gosta apenas olhando para a grade curricular ou montando planos isolados. Procura um estágio logo, entra no dia a dia técnico. Quando você estiver trabalhando, os desafios da empresa e o contato com a equipe mostram com naturalidade o que você precisa aprofundar. O foco nasce da prática, não do excesso de planejamento."

A fala dela resumiu perfeitamente a dinâmica da sala: mais do que respostas teóricas prontas, a troca trouxe a perspectiva de quem já enfrentou a transição no campo prático. Logo em seguida, a organização encerrou as salas simultâneas e reuniu todos os participantes no saguão principal do Teams.

O que muda na minha rotina a partir de amanhã

Desliguei o Teams com a cabeça muito mais no lugar e com uma clareza renovada sobre prioridades. Percebi que o excesso de planejamento muitas vezes vira uma forma confortável de adiar o contato com o mercado real.

Criar cronogramas bonitos no Notion ou no Obsidian dá uma sensação boa de controle. Só que ninguém contrata quem tem o melhor sistema de anotações. O mercado valoriza quem resolve problemas concretos, tem honestidade para assumir o que ainda não sabe e mostra energia para aprender rápido onde houver demanda.

A partir de amanhã, guardo os planos teóricos na gaveta. Vou ajustar meu currículo, reconhecer que o meu conhecimento técnico está em constante construção e intensificar as candidaturas para estágios e projetos reais. O ponto de partida quase nunca é como a gente desenha no papel, e os exemplos daquela sala demonstraram que a consistência na prática é o que constrói uma carreira sólida.

IBM "Ctrl+Alt Dream" Mentorship: Practical Career Lessons

Lucas Resende — Tue, 20 Oct 2026 11:00:00 +0000

I joined the Microsoft Teams room at ten sharp with Obsidian open on my screen, bracing for the usual exhausting routine of online corporate events: an organizer sharing institutional slides about market trends while dozens of students sit in silence.

The format of the <Ctrl+Alt> <Dream> mentorship, hosted by IBM SkillsBuild in partnership with Centro Paula Souza, was the exact opposite. The organizers split students into smaller breakout rooms for an hour of direct, candid conversation with volunteer leaders. There were seven of us on the call: four students (myself, Júlia and Élida, fellow Information Security classmates from Fatec Americana, plus Ana Clara, a high school student from Etec) and three professionals with solid experience across finance, tax, and consulting:

Mariana Ribeiro, Partner in M&A Transaction Services at Deloitte, with nearly two decades in consulting and over 300 mergers and acquisitions under her belt.
Vanessa Celuppi, who currently oversees governance and commercial planning at Bradesco, after starting at age 19 as a shopping mall stocker and telephone banking supervisor.
Luiza Monticeli, Business Tax and Transfer Pricing Analyst at Deloitte, who graduated in Law and transitioned into tax consulting at age 25.

The conversation lasted 60 minutes without a single slide. They spoke candidly and directly about hiring, insecurities, and real career missteps. A few practical takeaways stood out immediately after the call ended.

Resumes Packed With Certificates and Júlia's Question

Right at the start, Júlia unmuted her mic and brought up a dilemma familiar to anyone in their early college semesters: is it worth spending weeks collecting quick certificates to impress recruiters, or is that a waste of time?

Vanessa's response cut straight to the point:

"Companies will always check your hard skills for initial role eligibility. What wins you the job and makes you stand out are your soft skills: showing eagerness, interpersonal connection, and a visible drive."

Vanessa Celuppi, Commercial Planning Analyst at Bradesco

Spending 40 hours blazing through dozens of two-hour courses usually produces more noise than substance. Certifications act merely as an initial mechanical filter to land your resume in the review pile. What actually clinches the hire is how you hold up in a technical conversation and handle real-world challenges.

Luiza experienced this firsthand when joining Deloitte's new talent program. With a fresh law degree, she did not even know how to build a VLOOKUP in Excel and had never calculated complex corporate taxes. She never pretended to possess knowledge she lacked. Instead, she acknowledged her gaps clearly, demonstrated sharp problem-solving aptitude, and conveyed composure when dealing with demanding clients under pressure.

To prepare for interviews, she used a pragmatic technique: rather than asking ChatGPT for canned summaries, she instructed the AI to act as a rigorous technical interviewer. She prompted the model to ask tough regulatory questions and call out any flaws in her logic. Rehearsing under pressure proved far more effective than stacking certificates from quick online courses.

Entry Points and Bus Fares in Belo Horizonte

The journey Vanessa shared shattered any distant corporate tone. She started at 19 unloading shipping boxes as a stockroom worker in a shopping mall, worked at retail chain Lojas Renner, and later joined the call center for telephone banking.

In that grueling call center routine, she could not foresee where she would be ten years later. But she poured genuine energy into customer service, earned a promotion to lead a team of 30 within a single year, and uncovered a clear aptitude for business development. She spent eight years managing corporate accounts and now oversees business governance at Bradesco.

"Sometimes the entryway is not what you initially envisioned. Where you start does not have to be your final destination. Job titles and circumstances change, but your core character stays with you forever."

Vanessa Celuppi, Commercial Planning Analyst at Bradesco

Mariana Ribeiro's story grounded the conversation even further. Born in São Gonçalo do Sapucaí, a small town in southern Minas Gerais, she was the first person in her family to attend college. At her first internship with the Belo Horizonte municipal government, public transit fares exceeded her monthly stipend. She literally paid out of pocket to work. Years later, she joined Deloitte as a trainee, spent three years in Boston leading global cross-border engagements, and made partner in 2020.

"Life and careers are never straight lines - they are shaped by valleys, highs, and lows. Having the resilience and persistence to navigate through adversity is what creates enduring longevity."

Mariana Ribeiro, Partner in M&A Transaction Services at Deloitte

Hearing these accounts stripped away much of the anxiety surrounding the 'perfect' first job. In tech education, students often build the illusion that their debut must be as a brilliant junior developer at a major software firm. In reality, starting in IT support, customer service, or operational workflows does not hold your life back. It is inside those demanding everyday routines that you learn how to handle hard deadlines, frustrated customers, and system outages.

The Fear of Speaking English and Pronunciation Anxiety

Élida, who practiced law for 25 years before enrolling at Fatec at age 47 to study Information Security, shared a widespread hurdle: reading documentation and drafting emails in English feels manageable, but speaking aloud triggers hesitation over grammatical slips.

Mariana lifted the tension by recounting what she experienced firsthand after relocating to the United States. She spent months feeling self-conscious in boardroom meetings, trying to speak with native-level accent and cadence. Eventually, she realized executives in New York and Boston only cared whether the audit timeline was solid and whether the numbers balanced. No one scrutinized her accent.

Waiting for flawless pronunciation before daring to speak in public is a subtle form of self-sabotage. In workplace meetings, clarity and directness carry far more weight than grammatical perfection.

Analysis Paralysis and the Question I Brought Up at the End

After listening closely to Vanessa, Mariana, and Luiza, and following the threads raised by Júlia and Élida, I used the final segment of the session to bring up a strategic challenge I have been feeling firsthand.

Coming from design and marketing into computer science, the sheer volume of paths can trigger real cognitive overload. When you are drawn to software engineering, cybersecurity, and global teams, it is easy to fall into the trap of over-optimizing every step - refining elaborate roadmaps and study systems in isolation rather than testing hypotheses against the real world. I asked how they balanced seeking clear direction without freezing up under an abundance of options.

Élida raised her hand to answer immediately:

"Lucas, I am in my final semester and you are in your first. Your perspective will shift many times along the way. You will never discover what you truly enjoy simply by reading course syllabi or drawing up theoretical roadmaps. Look for an internship now, dive into day-to-day technical workflows. Once you are working, everyday problems and collaboration with your team will naturally illuminate what you need to master. Focus emerges from hands-on practice, not from overplanning."

Her advice captured the essence of the breakout room: rather than prescriptive theory, the exchange brought the grounded perspective of people who navigated career pivots in the real world. Soon after, the hosts closed the breakout rooms and brought everyone back to the main Teams lobby.

What Changes in My Routine Tomorrow

I closed Microsoft Teams with a clearer head and a renewed sense of focus. I realized that endless planning often doubles as a comfortable excuse to delay testing yourself against reality.

Building elegant roadmaps in Notion or Obsidian delivers a satisfying illusion of control. But nobody hires you for having the cleanest note-taking system. The market values people who solve concrete problems, stay honest about what they do not know yet, and bring the stamina to learn quickly wherever demands arise.

Starting tomorrow, I am putting overthought plans away. I will refine my resume, embrace that my technical expertise is an ongoing work in progress, and ramp up applications for internships and real projects. Where you start rarely looks like what you mapped on paper, and the mentors in that room proved that consistency through hands-on practice is what builds a resilient career.

Working Above the Loop: What I Learned at Capacita+ About the Reality of AI Agents

Lucas Resende — Mon, 19 Oct 2026 11:08:00 +0000

This week I attended Capacita+: Build with Gemini, an official training event by Google Cloud focused on transitioning into the agentic era. The event connected technical colleges and universities across Brazil to the main stage in São Paulo.

The event format was remarkably dynamic. Dante Olivier kicked things off as host, while technical leadership came from Mikaeri Ohana, developer and Technical Relations Lead at Google Cloud. Bringing in Lorrane Silva (Pequena Lô) was a great move to ground the discussion in everyday reality. Instead of letting the conversation get bogged down in tech jargon, she asked the questions everyday users actually care about: how does this genuinely help me, and why should I care?

The central takeaway was unmistakable: chatting with a model inside a popup window is one thing, but deploying an agentic system to handle real-world processes is an entirely different game.

Foosball with Gemma and Gemini: edge AI and real-time commentary

Before the keynote, one of the on-site interactive installations demonstrated an ingenious architectural division: a foosball table equipped with computer vision to deliver live play-by-play commentary.

The clever design decision was avoiding the trap of constantly streaming high-resolution video directly to the cloud, which would introduce heavy latency and prohibitive costs:

At the edge (Edge with TPU): A camera captured game frames every fifteen seconds, sending them directly to a local Gemma model running on an on-device TPU. This lightweight model handled the heavy computer vision workload, tracking ball possession, shot attempts, and player movements.
In the cloud (Gemini): Gemini received only this pre-processed, structured telemetry. Armed with this clean context, it stepped in as the live commentator, narrating plays, calculating real-time win probabilities, and even playing the role of a humorous VAR referee to disallow contentious goals.

This separation - offloading high-frequency triage to a lightweight edge model while reserving the heavy cloud model for deep reasoning - is the pattern that makes the most sense for balancing latency and operational costs.

Bot, assistant, or agent: where conversation ends and action begins

Many people label any terminal or chat window with AI as an "agent." Mikaeri clarified the spectrum with a simple, practical definition:

"An agent is given a goal, considers the context, decides how to move forward, and takes action."

Mikaeri Ohana, Technical Relations Lead at Google Cloud

Traditional chatbot: The typical retail banking bot. The one prompting you to "press 1 for account balance or press 2 to speak with an agent." It operates on rigid if/else trees. The moment you step outside the pre-programmed script, it hits a dead end.
AI assistant: Here enters the generative model capable of parsing context and natural language, such as Gemini or NotebookLM for research and synthesis. It summarizes documents, generates code, and answers open-ended questions effortlessly. But you remain the pilot driving every single step. You send the prompt, read the output, request an adjustment, and pick the next move.
AI agent: This is where the operating dynamic shifts. Instead of dispatching piecemeal instructions, you assign an overarching objective. The agent evaluates the goal, surveys the available context, creates a multi-step plan, and triggers external tools to deliver completed work.

The evolution progressed through distinct milestones. First, AI learned to generate coherent text and images. Then came function calling, allowing it to invoke external APIs. Now we have systems capable of pursuing autonomous goals and self-correcting along the way:

System Type	Operating Model	Flow Driver	Human Role
Traditional Chatbot	Hardcoded if/else decision trees	Static rules defined during development	User constrained by menus
AI Assistant	Generation and synthesis over context windows	User supplies prompts and drives every iteration	Pilot active at the keyboard
AI Agent	Goal pursuit via function calling and loops	Agent decomposes tasks and executes tools	Supervisor above the loop

Brain, hands, and nervous system: how the pieces fit together

To illustrate how an agentic architecture stands up, the human body analogy was one of the most effective explanations of the day:

The Brain (Model): The large language model (such as Gemini). It reasons, interprets instructions, and decides what actions are needed. But a brain in a jar cannot interact with the physical world. It can only converse.
The Hands (Tools): The integrations that allow the system to act. These fall into three primary categories:
- Standard tools: Everyday web services, such as flight booking APIs, mapping services, or weather endpoints.
- Custom functions: Purpose-built integrations for internal systems, like logging work hours, querying warehouse inventory, or generating proprietary reports.
- Authorized data retrieval (RAG): Secure pathways allowing the agent to query private repositories, technical manuals, and access-controlled databases before formulating responses.
The Nervous System (Orchestration): The control loop coordinating the entire workflow. It ensures the brain invokes the right tools in the correct sequence and gracefully handles incomplete or unexpected responses.

Without tools, a model is merely a passive advisor. Without orchestration, tools are nothing more than isolated scripts colliding with each other.

The four-stage loop and the Toronto test

At the center of this orchestration lies an ongoing cycle driven by four verbs: perceive, think, act, and check.

To demonstrate this in practice, the speakers walked through the scenario of planning a six-month study abroad program in Toronto with a thirty-five thousand real budget cap:

Perceive: The agent ingests travel constraints (destination, dates, strict financial ceiling, and required visa paperwork).
Think: It breaks the high-level mission down into smaller milestones, separating flight itineraries, campus-adjacent housing, and consular application steps.
Act: The system queries airline APIs, filters apartment listings on rental platforms, and pulls official consulate document checklists.
Check: It totals projected expenses and evaluates whether the plan fits comfortably within the assigned budget.

The genuine utility of an agent emerges precisely when things fail during the check phase.

Imagine that the lowest available price combination for airfare and housing totals thirty-six thousand reais. A conventional script would simply throw an exception or exit with an error alerting you that the budget was exceeded.

In an agentic loop, that one-thousand-real budget overrun becomes fresh context for the subsequent iteration. The agent perceives the ceiling breach, thinks through alternative routes, acts by searching for mid-week departures or slightly further transit-connected accommodations, and re-runs the validation check until it converges on an itinerary that satisfies the constraints.

Resisting overengineering: practical criteria for when to deploy agents

One of the best takeaways from the training was the pragmatic restraint against forcing agents into every problem. When requirements are straightforward, building an agent is merely an expensive and brittle way to overcomplicate your stack.

The decision comes down to clear criteria:

Repetitive workflows with predictable paths: Use standard deterministic automation scripts. They execute faster, never hallucinate, and cost nothing in inference tokens.
Ad-hoc questions or document summaries: Use a standard conversational assistant. Paste the text, ask your questions, and wrap up the task in two minutes.
Unpredictable pathways requiring dynamic adaptation and multi-system integration: This is where an agent earns its keep.

The job application workflow highlights this distinction clearly.

If you have already identified your target role and simply need to tune your resume for the job description, pasting it into Gemini in a browser tab gets it done immediately. A standard assistant handles that with ease.

On the other hand, if you want a system to monitor open openings over the next three weeks, cross-reference technical requirements against your project portfolio, and stage tailored cover letters awaiting your final approval, you are dealing with a persistent, non-linear objective. That is a task tailored for an agent.

The human above the loop: judgment remains yours

Autonomy does not mean handing over the keys to the vault and walking away. The agent operates inside the loop, handling the tedious legwork of evaluating options, reconciling data tables, and simulating scenarios. But the person remains above the loop.

The agent can research optimal flight combinations to Toronto and prepare the itinerary, but it should never charge the credit card without your final click of approval. The same principle applies to submitting a job application or executing database deletions.

This resonates with an insightful observation shared during the event by Giulia Bordignon (@spacecoding). She noted that technical syntax and code snippets can be picked up from documentation or search engines in minutes. The lasting differentiator for engineers is human perspective: our ability to observe daily workflows, pinpoint where people are losing time or running into friction, and steer these tools to resolve concrete bottlenecks.

The Google Deep Research feature offers a prime example of this dynamic. It can scour the internet and compile a structured ten-page dossier with cited sources. But unless you know how to calibrate the initial investigation and critically evaluate whether the findings hold up, the output is just digital noise.

At the conclusion of the training, I completed the hands-on lab milestones and earned the official certificate of completion issued by Google Cloud:

Official certificate of completion for Capacita+: Build with Gemini (Google Cloud).

Ultimately, the tooling moves forward, but the judgment remains ours.

Trabalhar Acima do Loop: O Que Aprendi no Capacita+ Sobre a Realidade dos Agentes de IA

Lucas Resende — Mon, 19 Oct 2026 11:08:00 +0000

Nesta semana participei do Capacita+: Construa com o Gemini, treinamento oficial do Google Cloud focado na transição para a chamada era agêntica. O evento conectou polos de ensino técnico e faculdades de vários cantos do país ao palco principal em São Paulo.

A condução do evento teve um formato bem dinâmico. O Dante Olivier abriu os caminhos como host, enquanto a apresentação técnica ficou por conta da Mikaeri Ohana, desenvolvedora e líder de relacionamento técnico no Google Cloud. Para completar, a participação da Lorrane Silva (a Pequena Lô) funcionou muito bem para puxar a conversa pro chão da realidade. Em vez de deixar a conversa presa em jargões de TI, ela fez as perguntas que qualquer usuário comum faria: onde isso me ajuda de verdade e por que eu deveria me importar?

O evento deixou um recado nítido: conversar com um modelo em uma janelinha de chat é uma coisa, mas colocar um sistema agêntico para resolver processos no mundo real é outra história completamente diferente.

Pebolim com Gemma e Gemini: IA na ponta e narração em tempo real

Antes da apresentação principal, uma das ativações montadas no espaço físico mostrou uma divisão de arquitetura que achei muito engenhosa: uma mesa de pebolim (ou totó, dependendo de onde você mora) equipada com visão computacional para narrar a partida ao vivo.

A sacada ali foi não tentar jogar vídeo em alta resolução para a nuvem o tempo todo, o que custaria caro e traria latência:

Na ponta (Edge com TPU): Uma câmera capturava quadros do jogo a cada quinze segundos e mandava direto para um modelo Gemma rodando localmente em uma TPU. Esse modelo menor cuidava do trabalho pesado de visão, medindo posse de bola, tentativas de chute ao gol e movimentação dos bonecos.
Na nuvem (Gemini): O Gemini recebia apenas esses dados já mastigados e estruturados. Com esse contexto limpo em mãos, ele assumia o papel de narrador, comentava os lances, previa as probabilidades de vitória de cada time durante a partida e até simulava um VAR de brincadeira para anular gols.

Essa separação entre o modelo leve na ponta fazendo triagem rápida e o modelo pesado na nuvem cuidando do raciocínio complexo é o padrão que mais faz sentido quando a gente pensa em custo e velocidade.

Bot, assistente ou agente: onde termina a conversa e começa a ação

Muita gente chama qualquer tela preta com inteligência artificial de agente. Só que a Mikaeri organizou essa régua de um jeito simples e direto:

"Um agente recebe um objetivo, considera o contexto, decide como avançar e consegue agir."

Mikaeri Ohana, líder de relacionamento técnico no Google Cloud

Chatbot tradicional: É o bot clássico de aplicativo de banco. Aquele que manda "digite 1 para consultar saldo ou digite 2 para falar com atendente". Ele roda em cima de regras rígidas e árvores de decisão. Se você sair um milímetro do script que o desenvolvedor previu, ele trava.
Assistente de IA: Aqui entra o modelo generativo que entende contexto e linguagem natural, como o Gemini ou o NotebookLM para anotações e estudos. Ele resume textos, sugere códigos e responde perguntas abertas com facilidade. Mas você continua pilotando tudo no braço. Você manda o prompt, lê o resultado, pede um ajuste e decide o próximo passo.
Agente de IA: Aqui a dinâmica muda. Em vez de pedir tarefa por tarefa, você entrega uma meta final. O agente entende o objetivo, analisa o contexto, traça um plano com passos intermediários e aciona ferramentas externas para entregar o trabalho concluído.

A transição aconteceu em etapas bem claras. Primeiro a IA aprendeu a gerar texto e imagens. Depois ganhou a capacidade de chamar funções (function calling) em outros programas. E agora chegamos aos sistemas que perseguem objetivos e corrigem a rota sozinhos:

Tipo de Sistema	Dinâmica Operacional	Quem Conduz o Fluxo	Papel do Humano
Chatbot Tradicional	Árvores if/else e regras pré-programadas	Código estático previsto no desenvolvimento	Navegador preso ao menu
Assistente de IA	Geração e síntese sobre janelas de contexto	O usuário envia cada prompt e guia a iteração	Piloto ativo no teclado
Agente de IA	Perseguição de metas com function calling e loops	O agente decompõe tarefas e aciona ferramentas	Supervisor acima do loop

Cérebro, mãos e sistema nervoso: como as peças se encaixam

Para explicar como essa estrutura fica de pé, a metáfora do corpo humano foi uma das partes mais didáticas do dia:

O Cérebro (Modelo): É o modelo de linguagem (como o Gemini). Ele é quem raciocina, interpreta o pedido e decide o que fazer. Mas um cérebro isolado em uma cuba não mexe em nada no mundo físico. Ele só conversa.
As Mãos (Ferramentas): São as conexões que permitem ao sistema agir. Elas se dividem em três tipos:
- Ferramentas prontas: Serviços comuns do dia a dia, como APIs de busca de passagens, mapas ou previsão do tempo.
- Funções customizadas: Conexões feitas sob medida para sistemas próprios, como bater ponto, consultar estoque ou emitir relatórios internos.
- Recuperação de dados autorizados (RAG): O canal para o agente consultar manuais, bases privadas e pastas seguras antes de responder.
O Sistema Nervoso (Orquestração): É o circuito que coordena essa dança inteira. Ele garante que o cérebro chame as mãos certas, na ordem correta, e saiba lidar com respostas incompletas.

Sem ferramentas, o modelo não passa de um conselheiro passivo. Sem orquestração, as ferramentas viram apenas scripts isolados batendo cabeça.

O loop de quatro tempos e o teste de Toronto

O coração dessa orquestração roda em um ciclo contínuo de quatro verbos: perceber, pensar, agir e checar.

Para mostrar isso na prática, veio o exemplo do intercâmbio de seis meses em Toronto com um teto de trinta e cinco mil reais:

Perceber: O agente lê as restrições da viagem (destino, datas, o limite do bolso e documentos necessários).
Pensar: Ele divide essa missão grande em tarefas menores, separando voos, hospedagem próxima do campus e o visto de estudante.
Agir: O sistema aciona APIs de companhias aéreas, filtra moradias em sites imobiliários e puxa os formulários consulares.
Checar: Ele soma tudo e confere se a conta fecha dentro do orçamento combinado.

A mágica do agente aparece justamente quando as coisas dão errado na checagem.

Imagine que a melhor combinação encontrada de passagem e estadia somou trinta e seis mil reais. Um script tradicional de programação daria erro de condição ou simplesmente travaria avisando que o orçamento estourou.

No loop agêntico, esse estouro de mil reais vira dado novo para o ciclo seguinte. O agente percebe que passou do teto, pensa em outras alternativas, age buscando passagens em dias de semana ou opções de acomodação mais afastadas, e roda a checagem novamente até encontrar uma combinação que caiba no orçamento.

Quando não inventar moda: a régua prática para usar ou não agentes

Uma das coisas que mais gostei no treinamento foi o bom senso de não empurrar agente para tudo. Se a sua necessidade é simples, criar um agente é só um jeito caro e complicado de complicar a vida.

Dá para resumir a escolha em critérios bem práticos:

Passos repetitivos com caminho previsível: Use um script comum de automação. É mais rápido, não alucina e roda de graça.
Dúvida pontual ou análise de documento: Use um assistente comum de chat. Cole o texto, faça perguntas e resolva o assunto em dois minutos.
Caminhos imprevisíveis que exigem adaptação e contato com sistemas de fora: Aqui sim o agente se paga.

A comparação com busca de vagas ilustra isso perfeitamente.

Se você já achou a vaga ideal e quer só adaptar o seu currículo para aquela oportunidade específica, o Gemini no chat resolve na hora. Um assistente dá conta do recado com folga.

Agora, se você quer que o sistema monitore vagas abertas nas próximas três semanas, cruze os requisitos técnicos com as suas habilidades e deixe cartas de apresentação rascunhadas esperando a sua revisão, você tem uma missão continuada. Isso é trabalho sob medida para um agente.

O humano acima do loop: quem decide ainda é você

Autonomia não significa dar a chave do cofre para o modelo sair fazendo o que quiser. O agente trabalha dentro do loop, cuidando da parte chata de buscar opções, cruzar tabelas e simular cenários. Mas quem fica acima do loop é a pessoa.

O agente pode pesquisar as melhores passagens para Toronto e deixar tudo pronto, mas ele não passa o cartão sem você dar o clique final de aprovação. O mesmo vale para submeter uma candidatura de emprego ou apagar registros de um banco de dados.

Isso bate com uma reflexão muito lúcida que a Giulia Bordignon (@spacecoding) trouxe no evento. Ela comentou que a técnica e os comandos de código a gente aprende no Google ou na documentação oficial em pouco tempo. O diferencial que sobra para o profissional é o repertório humano: a nossa capacidade de olhar para a rotina, perceber onde as pessoas estão perdendo tempo ou enfrentando gargalos reais e direcionar essas ferramentas para resolver problemas concretos.

O Google Deep Research é um bom exemplo dessa convivência. Ele pode vasculhar a internet inteira e entregar um relatório estruturado de dez páginas com fontes auditadas. Mas se você não souber calibrar o objetivo inicial e avaliar com olhar crítico se as conclusões fazem sentido, o relatório não passa de papel digital.

Ao final do treinamento, concluí as etapas práticas propostas e recebi o certificado oficial de participação emitido pelo Google Cloud:

Certificado oficial de participação no treinamento Capacita+: Construa com o Gemini (Google Cloud).

No fim das contas, a tecnologia avança, mas o critério continua sendo nosso.

Producing Became Cheap, Knowing Became Expensive: What Proud Tech Summit 2026 Reveals About the Frontier Between Prototype and Production

Lucas Resende — Sun, 18 Oct 2026 11:08:00 +0000

I followed the online stream of Proud Tech Summit 2026, an event hosted by Starian and Softplan. It was roughly eight hours of presentations focused on software engineering, legacy systems, production AI agents, and data architecture.

The event bypassed the superficial AI chatter that dominates the internet. Instead of canned chat demos, the sessions addressed real problems: legacy relational databases, brittle integrations, fiscal constraints, and the work required to run models with actual customers.

The sessions I followed throughout the day:

Carla Souza, Guilherme Brasil, and Luis Fausto (Starian and Softplan): opening and enterprise AI maturity.
Lucas Leung (Oracle Brazil): Formula 1 simulations with Oracle RedBull Racing.
Jean Roloff (Checklist Fácil / Starian): building Orbit with Working Backwards and SDD.
Pedro Escobar (Softplan): agent governance and the Softflow framework.
Rafael Gomides and Amanda Aragão (1Doc / Softplan): public municipal service via WhatsApp.
Diogo Noschang (Starian): corporate data governance and security with MCP servers.
Alexandre Messina (Lovable / VibeLabs): fast prototyping and Vibe Coding.

The three-prompt test and the 77% stalled in pilots

In the opening remarks, Carla Souza pointed out a clear mismatch: the speed of tooling development has accelerated drastically, but the time it takes to grasp business logic and validate systems remains thoroughly human.

Guilherme Brasil demonstrated this with a test using the exact same LLM model. He asked for a 32-word opening statement containing the numbers 5, 10, 15, 25, and 50. Given the bare request, the model produced empty corporate buzzwords about milestones and future impact. When he supplied the actual context - the 5th edition of the summit, 10 years at the company, his daughter's 15th birthday, 25 years of marriage, and turning 50 -, the output became direct and humorous. The model was identical. The difference was solely the context provided in the input.

Luis Fausto presented market research from Gartner and McKinsey on adoption: roughly 77% of companies remain trapped in early pilots and proofs of concept, while only 23% have managed to deploy agentic systems into actual production.

The reason for this bottleneck is operational. For an agent to run in actual production, it requires an accountable owner, explicit Service Level Agreements (SLAs), and a dependable rollback mechanism to recover from errors.

Orbit: three weeks, PR/FAQ, and SDD

Jean Roloff detailed the development of Orbit, Starian's agent platform, built during an intensive three-week sprint.

Before writing code, the team applied Amazon's Working Backwards approach: they wrote the launch press release and internal FAQs (PR/FAQ) as if the product were already finished. The goal was to align customer needs and expected business outcomes before opening the editor.

Jean Muller Roloff (Starian) detailing the Working Backwards approach and PR/FAQ in Orbit.

For development with agents, the team enforced Specification-Driven Development (SDD). Instead of open-ended prompts, they defined data contracts, interfaces, and unit tests before prompting the AI to generate code. The project totaled over 200,000 lines of code with automated test coverage exceeding 90%.

The team also avoided attempting to deploy all fifteen microservices from the planned architecture at once. They isolated a single vertical slice within the Contato Seguro product, focusing purely on report triage, deployed that piece to production to gather live data, and only then expanded to other modules.

Softflow: 220 engineers and four manual gates

At Softplan, the challenge was not a lack of AI adoption, but the uncontrolled spread of custom scripts and prompts across more than 220 engineers, making collaborative codebase maintenance difficult.

Pedro Escobar introduced Softflow, a framework based on the Orchestrator-Workers pattern with eleven distinct stages. The core of the pipeline is its mandatory checkpoints (gates), where execution pauses until a developer validates what was generated.

Pedro Escobar (Softplan) presenting contextual subagent specialization starting from code review.

Stage / Gate	Agent Automation / Worker Action	Human Validation (Checkpoint)	Status / Role
Gate 1	Ingests work item and writes formal technical specification (SDD)	Manual approval of SDD before any code is written	`Specification`
├── Worker	Generates implementation and runs initial automated suites	—	`Execution`
Gate 2	Subagents inspect diff for security, performance & architecture	Developer evaluates findings and decides on fixes	`Review Findings`
Gate 3	Creates branch and executes automated integration tests	Manual approval required to merge into main	`Merge Request`
Gate 4	Prepares closure and verifies business criteria	Human verifies resolution of the business demand	`Closure`

Development pipeline and human validation checkpoints in Softflow

The pipeline organizes validation across four primary stages:

Gate 1 (Specification): The agent reads the work item and writes the formal technical specification (SDD). No code is written before this specification is approved.
Gate 2 (Review Findings): Dedicated subagents scan the diff for security flaws, performance regressions, and architectural inconsistencies. The developer reviews each finding and decides what to fix or dismiss.
Gate 3 (Merge Request): The agent creates the branch and runs the test suite, but merging into the main repository remains a manual approval.
Gate 4 (Closure): A human verifies whether the business demand was actually resolved before closing the work item.

In the live demo, Escobar showed a bug fix in a legacy integration with IBM Jazz RTC, where the API returned empty owner fields. The agent used MCP protocol calls to inspect work items and implemented the patch. Before opening the MR, a review subagent flagged that a logging line lacked an associated unit test. The adjustment was made on the spot, and the merge proceeded with all tests passing.

1Doc: public services on WhatsApp and operational controls

The presentation by Rafael Gomides and Amanda Aragão addressed municipal service delivery via WhatsApp through 1Doc (cases LIA in Limeira and TIA in Florianópolis).

Placing public services on WhatsApp takes advantage of the application's ubiquity, but introduces concrete architectural constraints:

Rafael Gomides (1Doc) explaining the read-contract architecture connecting AI to legacy backends.

In casual chat, people send fragmented messages, voice notes, and change subjects, which does not map cleanly to administrative workflows. The solution involved embedding structured forms within the conversation and programming the agent to route complex edge cases directly to in-person service desks.

Another factor is security: a phone number does not constitute legal identity. For issuing official certificates or reviewing tax debts, 1Doc decoupled authentication: the citizen clicks a temporary link to log into the official web platform, preventing passwords or personal data from circulating in chat history.

Additionally, municipal case creation does not depend on the uptime of a third-party messaging app. Records are saved transactionally to the central database before any notification is dispatched to the user.

For budget and risk control, municipal administrators have toggles to disable specific services on demand, paired with automated alerts at 50%, 70%, 90%, and 100% of contracted quota. If the cap is reached, AI processing shuts down cleanly and requests return to standard support queues.

MCP Server: connecting AI to databases without write permissions

Diogo Noschang addressed how to allow AI models to query enterprise databases without exposing sensitive records or risking accidental mutations.

Legacy databases carry decades of implicit rules and abbreviated table names that language models misinterpret when exposed to raw schemas.

At Starian, the decision was to place a Model Context Protocol (MCP) server written in Python between the model and company databases:

Architecture Layer	Component / Environment	Security Controls & Enforcement	Permission / Scope
Client Layer	AI Model / LLM Orchestrator	Issues context-specific data and metric queries	`On-Demand Tools`
├── Logical Tier	Python MCP Server	Parameter sanitization, SQL injection prevention & query limits	`Validation & Filtering`
└── Physical Tier	Enterprise Relational Database	Database user strictly restricted to `SELECT` operations	`Read-Only (No Mutations)`

Two-layer security flow via Python MCP Server

Security operates across two distinct tiers:

Logical tier (MCP Server): The Python microservice sanitizes incoming parameters, blocks SQL injection attempts, and rejects overly broad queries (such as prompts trying to dump entire tables without filters).
Physical tier (Database): The database connection user utilized by the MCP server is strictly limited to SELECT. There are no INSERT, UPDATE, or DELETE grants, preventing data mutations even in the event of model errors.

The server also manages context on demand: rather than loading entire database schemas on every prompt, the MCP layer provides only the specific tools needed to answer that particular metric. Inside the Starian Performance 360 framework at Projuris Empresa, the setup unified queries across Jira, SonarQube, GitLab, and Windsurf, logging a 27.3% increase in qualified delivery throughput and a 17.6% rework rate.

Red Bull Racing: OCI simulations

Lucas Leung's presentation covered high-performance cloud computing used by Oracle RedBull Racing in Formula 1.

During race weekends, the team provisions Kubernetes clusters running more than 500 ARM CPUs on Oracle Cloud Infrastructure (OCI). When a yellow flag or safety car alters race conditions, the system runs peaks of one million Monte Carlo simulations per second, evaluating roughly six million scenarios to determine pit stop viability.

This setup backed Max Verstappen's drive at the Miami GP, where he started from ninth on hard tires, stretched his initial stint in clean air, switched to mediums late in the race, and took the victory. The pit wall call was guided directly by these real-time probability simulations.

Lovable and Vibe Coding: rapid prototypes vs. legacy systems

Alexandre Messina discussed the growth of Lovable and the Vibe Coding approach, illustrating the generation of functional interfaces from natural language prompts.

Among the examples shared was Amosview at Amicci, a sample management tool built in two days by an operations specialist to solve an internal bottleneck without submitting tickets to central IT. For validating product concepts, creating proofs of concept, or assembling simple departmental tools, the speed of this workflow is evident.

Alexandre Messina (Lovable) presenting prototype acceleration with Vibe Coding.

The practical boundary appears when a prototype must turn into software maintained at enterprise scale. A prompt-generated interface handles initial interaction, but it does not resolve legacy databases carrying a decade of implicit business rules, asynchronous queues, auditing, or strict session control. In Lovable you can spin up a SaaS with Supabase and Stripe in an afternoon, while in scenarios like Softplan and 1Doc, the daily engineering challenge is making automation live alongside legacy systems where data corruption risks legal and tax compliance.

What remains

Generating code has become the fast and cheap part of the process. The work that continues to demand time is what it has always been: understanding business rules, drafting technical contracts before implementing, and writing tests that catch regressions.

I left the summit determined to study the MCP protocol in depth and write better specifications before asking for code. The rest is just talk.

Produzir Ficou Barato, Saber Ficou Caro: O Que o Proud Tech Summit 2026 Revela Sobre a Fronteira Entre Protótipo e Produção

Lucas Resende — Sun, 18 Oct 2026 11:00:00 +0000

Acompanhei a transmissão online do Proud Tech Summit 2026, evento organizado pela Starian e pela Softplan. Foram cerca de oito horas de apresentações focadas em engenharia de software, sistemas legados, uso de agentes em produção e arquitetura de dados.

O evento fugiu do papo genérico de inteligência artificial que domina a internet. Em vez de demonstrações prontas de chat, as palestras mostraram problemas reais: bancos relacionais legados, integrações que quebram, regras fiscais e o trabalho de colocar modelos para rodar com clientes de verdade.

As palestras que acompanhei ao longo do dia:

Carla Souza, Guilherme Brasil e Luis Fausto (Starian e Softplan): abertura e maturidade de IA em empresas.
Lucas Leung (Oracle Brasil): simulações na Fórmula 1 com a Oracle RedBull Racing.
Jean Roloff (Checklist Fácil / Starian): construção do Orbit com Working Backwards e SDD.
Pedro Escobar (Softplan): governança de agentes e o framework Softflow.
Rafael Gomides e Amanda Aragão (1Doc / Softplan): atendimento público via WhatsApp nos municípios.
Diogo Noschang (Starian): governança e segurança de dados corporativos com servidores MCP.
Alexandre Messina (Lovable / VibeLabs): prototipagem rápida e Vibe Coding.

O teste dos três prompts e os 77% empacados

Na abertura, Carla Souza apontou um descompasso claro: a velocidade de construção das ferramentas acelerou drasticamente, mas o tempo necessário para entender regras de negócio e validar sistemas continua sendo humano.

Guilherme Brasil demonstrou isso com um teste no mesmo modelo de LLM. Ele pediu um texto de 32 palavras para a abertura do evento contendo os números 5, 10, 15, 25 e 50. Com o pedido seco, o modelo gerou um chavão corporativo vazio sobre conquistas e futuro. Quando ele forneceu o contexto real - 5ª edição do evento, 10 anos de empresa, 15 anos da filha, 25 de casado e 50 de idade -, a saída virou um texto direto e bem-humorado. O modelo era exatamente o mesmo. A diferença estava apenas no contexto fornecido na entrada.

Luis Fausto trouxe dados do Gartner e da McKinsey sobre o estágio atual do mercado: cerca de 77% das empresas continuam presas a testes iniciais e provas de conceito, enquanto apenas 23% conseguiram colocar sistemas agênticos em produção.

O motivo apontado para esse gargalo é puramente operacional. Para um agente rodar em produção de verdade, ele precisa de um responsável definido, regras claras de nível de serviço (SLA) e mecanismo de rollback para reverter erros em caso de falha.

Orbit: três semanas, PR/FAQ e SDD

Jean Roloff contou como foi o desenvolvimento do Orbit, a plataforma de agentes da Starian, feita em um ciclo de três semanas.

Antes de escrever código, o time usou a abordagem Working Backwards da Amazon: redigiram o comunicado de lançamento (Press Release) e as perguntas frequentes (PR/FAQ) simulando o produto pronto. A ideia era alinhar a dor do cliente e o retorno esperado antes de abrir o editor.

Jean Muller Roloff (Starian) detalhando a metodologia Working Backwards e PR/FAQ no Orbit.

Para a construção com agentes, a equipe adotou Desenvolvimento Orientado por Especificação (SDD). Em vez de prompts abertos, definiram contratos de dados, interfaces e testes unitários antes de acionar a IA para gerar os arquivos. O projeto somou mais de duzentas mil linhas de código com cobertura de testes acima de 90%.

O time também evitou subir de uma vez os quinze microsserviços planejados na arquitetura completa. Eles isolaram uma fatia específica no produto Contato Seguro, voltada à triagem de relatos, colocaram essa parte em produção para colher dados reais e só depois expandiram para outros módulos.

Softflow: 220 desenvolvedores e quatro travas manuais

Na Softplan, o problema não era falta de uso de IA, mas o surgimento de scripts e prompts isolados espalhados entre mais de 220 engenheiros, o que complicava a manutenção compartilhada da base de código.

Pedro Escobar apresentou o Softflow, um framework baseado no padrão Orchestrator-Workers com onze etapas. O ponto central do fluxo são os pontos de parada obrigatórios (gates), onde o processo é travado até que um desenvolvedor valide o que foi gerado.

Pedro Escobar (Softplan) apresentando a divisão de subagentes por contexto a partir da revisão de código.

Etapa / Gate	Automação do Agente / Ação do Worker	Validação Humana (Ponto de Parada)	Status / Papel
Gate 1	Lê o item de trabalho e escreve a especificação técnica formal (SDD)	Aprovação manual da especificação antes de qualquer código	`Especificação`
├── Worker	Gera a implementação e executa a suíte de testes inicial	—	`Execução`
Gate 2	Subagentes analisam o diff atrás de problemas de segurança, desempenho e arquitetura	Desenvolvedor avalia achados e decide o que corrigir ou descartar	`Achados de Revisão`
Gate 3	Cria a branch e executa os testes automatizados de integração	Aprovação manual necessária para merge na main	`Merge Request`
Gate 4	Prepara o fechamento e valida os critérios de negócio	Humano confirma se a demanda de negócio foi atendida	`Fechamento`

Pipeline de desenvolvimento e pontos de parada humanos no Softflow

O fluxo organiza a validação em quatro etapas principais:

Gate 1 (Especificação): O agente lê o item de trabalho e escreve a especificação técnica formal (SDD). Nenhum código é gerado antes da aprovação dessa spec.
Gate 2 (Achados de Revisão): Subagentes dedicados analisam o diff atrás de problemas de segurança, desempenho e arquitetura. O desenvolvedor decide pontualmente o que mandar corrigir ou descartar.
Gate 3 (Merge Request): O agente monta a branch e roda a suíte de testes, mas a aprovação do merge no repositório continua manual.
Gate 4 (Fechamento): Uma pessoa confirma se a demanda de negócio foi atendida antes de encerrar o item.

Na demonstração ao vivo, Escobar mostrou a resolução de um bug em uma integração legada com o IBM Jazz RTC, em que a API retornava campos de responsável vazios. O agente usou chamadas via MCP para inspecionar os work items e aplicou a correção. Antes de abrir o MR, um subagente de revisão apontou que uma linha de log não tinha teste unitário associado. O ajuste foi feito na hora e o merge seguiu com a suíte verde.

1Doc: atendimento público via WhatsApp e controles operacionais

A apresentação de Rafael Gomides e Amanda Aragão tratou do canal de atendimento municipal da 1Doc via WhatsApp (casos da LIA em Limeira e da TIA em Florianópolis).

Colocar serviços públicos no WhatsApp aproveita o alcance do aplicativo, mas impõe desafios práticos de arquitetura:

Rafael Gomides (1Doc) explicando a arquitetura de contratos de leitura sobre sistemas legados.

Em conversas cotidianas, as pessoas mandam mensagens truncadas, áudios e mudam de assunto, o que não encaixa direto na abertura de um processo administrativo. A solução envolveu criar formulários dentro da conversa e programar o agente para encaminhar casos complexos diretamente para os canais presenciais.

Outro ponto é a segurança: número de telefone não identifica cidadão de forma jurídica. Para emissão de certidões ou consulta de débitos, a 1Doc desacoplou o acesso: o cidadão clica em um link temporário para autenticar na plataforma web oficial, sem trafegar senhas ou armazenar dados pessoais na conversa do WhatsApp.

Além disso, a abertura do processo municipal não depende da estabilidade de um aplicativo de mensagens. O registro é salvo de forma transacional no banco antes de enviar qualquer notificação ao usuário.

Para controle de custos e risco, a gestão municipal possui botões para desativar serviços específicos sob demanda e travas com alertas automáticos em 50%, 70%, 90% e 100% da cota contratada. Se atingir o limite, a IA é desativada e as solicitações voltam para a fila de atendimento padrão.

Servidor MCP: conectando IA ao banco sem permissão de escrita

Diogo Noschang abordou o problema de permitir que modelos de IA consultem bases corporativas sem expor dados confidenciais ou arriscar alterações indevidas no banco de dados.

Bancos legados acumulam décadas de regras implícitas e tabelas com nomes abreviados que modelos de linguagem interpretam mal se receberem apenas esquemas crus.

Na Starian, a opção foi colocar um servidor Model Context Protocol (MCP) em Python entre o modelo e as bases da empresa:

Camada da Arquitetura	Componente / Ambiente	Controles de Segurança & Execução	Permissão / Escopo
Camada Cliente	Modelo de IA / Orquestrador LLM	Emite consultas específicas de métricas e contexto sob demanda	`Ferramentas sob Demanda`
├── Camada Lógica	Servidor MCP em Python	Sanitização de parâmetros, prevenção de SQL injection e limites de consulta	`Validação & Filtragem`
└── Camada Física	Banco de Dados Relacional Corporativo	Usuário de conexão estritamente restrito a operações `SELECT`	`Somente Leitura (Sem Mutações)`

Fluxo de segurança em duas camadas com Servidor MCP

A separação opera em dois níveis:

Camada lógica (Servidor MCP): O serviço em Python valida os parâmetros da pergunta, barra tentativas de injeção de SQL e rejeita pedidos excessivamente amplos (como consultas que tentam listar tabelas inteiras sem filtro).
Camada física (Banco de Dados): O usuário de conexão utilizado pelo MCP no banco corporativo tem permissão restrita a SELECT. Não existem concessões de INSERT, UPDATE ou DELETE, o que impede modificações em registros de produção mesmo em caso de erro do modelo.

O servidor também carrega contexto sob demanda: em vez de injetar o esquema completo do banco a cada interação, o MCP disponibiliza apenas as ferramentas necessárias para responder àquela métrica específica. No caso do framework Starian Performance 360, no Projuris Empresa, o sistema unificou consultas cruzando Jira, SonarQube, GitLab e Windsurf, registrando alta de 27,3% na vazão qualificada e taxa de retrabalho de 17,6%.

Red Bull Racing: simulações na OCI

A apresentação de Lucas Leung trouxe o uso de computação de alto desempenho pela Oracle RedBull Racing na Fórmula 1.

Nos finais de semana de corrida, a equipe utiliza clusters com Kubernetes rodando mais de quinhentas CPUs ARM na Oracle Cloud Infrastructure (OCI). Em momentos de bandeira amarela ou safety car, o sistema chega a rodar picos de um milhão de simulações de Monte Carlo por segundo, gerando cerca de seis milhões de cenários para avaliar se vale a pena parar nos boxes.

Essa estrutura respaldou a estratégia de Max Verstappen no GP de Miami, quando o piloto largou em nono lugar com pneus duros e estendeu o stint inicial em ar limpo para colocar médios no fim da prova, vencendo a corrida. A decisão no pitwall foi guiada diretamente por esses cálculos de probabilidade em tempo real.

Lovable e Vibe Coding: protótipos rápidos vs. sistemas legados

Alexandre Messina apresentou a trajetória da Lovable e o fluxo de Vibe Coding, mostrando a criação de interfaces funcionais a partir de comandos em linguagem natural.

Entre os exemplos citados, estava o Amosview na Amicci, um sistema de gestão de amostras montado em dois dias por um profissional de operações para resolver um gargalo interno, sem depender de chamados para a equipe de TI. Para validar ideias de produtos, desenhar provas de conceito ou criar ferramentas departamentais simples, a velocidade dessa abordagem é evidente.

Alexandre Messina (Lovable) apresentando a aceleração de protótipos com Vibe Coding.

A fronteira prática aparece quando o protótipo precisa virar produto mantido em escala corporativa. Uma interface montada em linguagem natural resolve a interação inicial, mas não resolve o banco legado com regras acumuladas ao longo de dez anos, filas assíncronas, auditoria ou controle estrito de sessão. Na Lovable é viável estruturar um SaaS com Supabase e Stripe em questão de horas, enquanto nos cenários da Softplan e da 1Doc, o desafio diário é fazer a automação conviver com sistemas legados onde qualquer falha de integridade impacta processos judiciais ou fiscais.

O que fica

Gerar código virou a parte rápida e barata do processo. O trabalho que continua tomando tempo é o de sempre: entender a regra de negócio, desenhar contratos técnicos antes de implementar e garantir testes que segurem regressões.

Saí de lá decidido a estudar mais a fundo o protocolo MCP e escrever especificações melhores antes de pedir código. O resto é conversa.

Amplificador, Não Piloto Automático: Meu Ecossistema de Estudos de Programação com IA

Lucas Resende — Sat, 17 Oct 2026 11:00:00 +0000

Estava assistindo a uma análise da engenheira Karol Attekita em seu vídeo sobre a divisão do mercado tech, e uma frase me chamou muita atenção: o rio não secou, mudou de leito.

A tese dela é que o mercado em 2026 não morreu, mas sofreu uma divisão profunda. De um lado, demissões em posições de entrada focadas em tarefas repetitivas, telas simples e CRUDs padronizados, coisas que a inteligência artificial hoje entrega em segundos. Do outro lado, sobram vagas abertas para quem domina sistemas complexos, arquitetura, automação e segurança. O desenvolvimento de software não ficou mais simples nem menos técnico. Pelo contrário, ganhou camadas novas de abstração, como Spec-Driven Development e arquiteturas de agentes.

Nas minhas próprias pesquisas e na rotina de estudos, tenho percebido esse contraste com cada vez mais força. Para quem está aprendendo a programar agora, isso cria uma encruzilhada perigosa.

Com um comando de prompt, qualquer modelo de linguagem resolve os exercícios do CS50 de Harvard ou as listas de lógica da faculdade em instantes. Mas se eu usar essa facilidade para pular o esforço intelectual, estou apenas me treinando para ser substituível amanhã.

Por isso, tanto na Fatec quanto no CS50x, decidi inverter essa lógica: em vez de pedir para a IA me entregar o código pronto, uso a tecnologia como amplificador de contexto, pesquisa e fixação, mantendo 100% da construção do raciocínio nas minhas mãos.

A rotina que construí no dia a dia é o resultado prático dessa escolha, conectando o que vejo em sala de aula até a automação de memória e gestão de ferramentas.

Da lousa ao Obsidian: o que faço quando a aula da faculdade acaba

Nas aulas da Fatec, a primeira decisão acontece antes mesmo de ligar o computador: o formato do registro depende do que está acontecendo na sala.

Quando a aula é expositiva e acompanhada por slides conceituais, digito direto no Obsidian em Markdown. Mas quando o professor vai para a lousa desenhar estruturas de dados, fluxos de execução, representações de memória ou diagramas relacionais, prefiro papel e caneta. A flexibilidade do desenho livre para capturar conexões espaciais e setas lógicas em tempo real ainda supera qualquer teclado.

O ponto principal é o que acontece depois da aula. As anotações do papel não vão para uma gaveta. Eu levo esse material para o Obsidian, onde roda uma rotina automatizada com apoio de IA para me ajudar em quatro etapas bem definidas:

Primeiro, ela reorganiza as ideias dispersas. Muitas vezes o professor faz uma observação no final da aula que amarra um conceito do começo, e o script conecta esses pontos estruturando títulos claros e diagramas visuais em Mermaid.

Segundo, e essa é uma das partes mais úteis: durante a explicação em sala, sempre que surge um conceito confuso que não deu tempo de tirar dúvida na hora, anoto essa pergunta diretamente no meio do texto:

[DÚVIDA:: Por que quando passo um array pra uma função em C o sizeof só mostra o tamanho do ponteiro (8 bytes) em vez do tamanho total da lista? Lembrar de testar no código.]

Em vez de deixar essa dúvida esquecida, o agente lê essa marcação específica e busca em documentações oficiais uma contextualização rápida, trazendo a regra formal e um exemplo prático.

Mas existe uma regra inegociável nesse processo: a IA apenas organiza e contextualiza. Depois que o documento é enriquecido, leio a nota completa linha por linha com calma para re-aprender o conteúdo. Sem essa leitura ativa, a nota vira apenas um arquivo bonito ocupando espaço no disco.

Anki e repetição espaçada: como evito esquecer a sintaxe no dia seguinte

Anotar bem e revisar no mesmo dia ajuda muito, mas o cérebro humano tem uma facilidade enorme de descartar regras de sintaxe e detalhes técnicos se não for provocado com frequência.

Para resolver isso, levo esses conceitos para o Anki, usando o algoritmo FSRS (Free Spaced Repetition Scheduler), que calcula o intervalo exato de revisão para cada cartão dependendo da minha facilidade ou dificuldade ao responder.

Aqui muita gente cai numa armadilha clássica: pedir para uma IA qualquer "gerar 10 cartões de perguntas e respostas sobre a aula". O resultado costuma ser desastroso: textos longos, respostas óbvias e decoreba passiva que não dura uma semana.

Prefiro seguir os princípios clássicos de formulação de conhecimento do Piotr Wozniak. Os cartões precisam ser atômicos, cobrindo apenas um fato ou uma relação de causa e efeito através de lacunas pontuais (clozes). O foco não é memorizar definições prontas, mas entender como o código quebra e como o compilador reage.

Na prática, um cartão gerado pelo fluxo fica assim:

Em C, a função malloc retorna {{c1::NULL}} quando {{c2::não há memória suficiente disponível no heap}}, exigindo validação defensiva antes de usar o ponteiro.

Para não perder tempo copiando e colando dezenas de cartões manualmente, conectei essa rotina diretamente à API local do AnkiConnect, que roda na porta 8765 do meu computador. O agente formata os cartões a partir da nota revisada e injeta tudo no baralho certo via chamadas HTTP locais. Minha única tarefa matinal é abrir o aplicativo e fazer as revisões do dia.

O desafio do C no CS50: desenhar na lousa antes de encostar no teclado

No CS50x de Harvard, o nível de exigência sobe bastante. Atualmente estou na Semana 4, que é a virada para a linguagem C pura, lidando com ponteiros, alocação de memória com malloc e manipulação direta de endereços na RAM.

Aqui o compilador é implacável. Se você não souber exatamente para onde um ponteiro aponta ou o que acontece com um byte na memória, o programa fecha na hora com uma falha de segmentação (segmentation fault). Terceirizar a resolução desses exercícios para uma IA seria o caminho mais rápido para criar uma falsa sensação de competência e não aprender computação de verdade.

Para acompanhar as aulas longas e densas do professor David J. Malan, comecei a usar transcrições aumentadas. A transcrição automática em áudio vem com pequenos erros fonéticos e texto corrido, enquanto as notas oficiais cortam boa parte dos exemplos práticos. Peço então para a IA cruzar as duas fontes, gerando um material limpo, com os slides certos inseridos no momento em que o professor fala e os trechos de código formatados.

Com esse material aberto, meu processo antes de codificar é bem visual: antes de encostar um dedo no teclado para escrever exercícios clássicos como o cálculo de troco (Cash) ou manipulações de matrizes, abro uma lousa digital. Desenho como os loops vão rodar, onde os ponteiros começam e quais são as condições de parada.

Só depois de enxergar a lógica na tela é que abro o VS Code Spaces oficial do curso para digitar. E não tem sensação melhor do que rodar os testes automatizados do curso no terminal e ver o check50 retornar inteiramente verde, sabendo que cada linha foi pensada e depurada por mim.

Outra adaptação que fiz foi no método de foco: em vez de cortar o raciocínio a cada 25 minutos no Pomodoro clássico, sigo a minha carga mental real. Se estou focado em um problema difícil de ponteiros, fico até 2 horas direto sem pausas forçadas. No final da sessão, sempre deixo uma nota curta de bastidor no meu diário: "Hoje apanhei da sintaxe de aritmética de ponteiros, achei interessante o comportamento do buffer". Esse histórico me mostra com clareza onde estou tropeçando e o que preciso reforçar.

Meu setup diário: múltiplos modelos rodando por R$ 24 ao mês

Existe um mito de que ter um ambiente de estudos avançado com inteligência artificial exige gastar fortunas em múltiplas assinaturas todo mês. Na prática, montei uma bancada muito eficiente gastando cerca de R$ 24 mensais através de orquestração inteligente:

Camada / Ambiente	Descrição & Fluxo	Papel
Google Antigravity	IDE com orquestração de agentes e execução local	`Ambiente Principal (R$ 24/mês)`
├── Gemini 3.8 + Qwen 3.8 Max	Investigação profunda e síntese cruzada de relatórios	`Deep Research`
└── DeepSeek API + NotebookLM	Contingência via Zoo Code e consulta a PDFs técnicos	`Contingência & Consulta`

Arquitetura do ecossistema de estudos com múltiplos modelos

Como ambiente principal de desenvolvimento, uso o Google Antigravity, aproveitando o plano Pro para estudantes (que custa por volta de R$ 24 ao mês). Além de me dar acesso amplo aos modelos mais recentes da família Gemini, o pacote inclui um bom espaço de armazenamento no Google Drive, que compartilho com a minha família.

Quando preciso fazer pesquisas aprofundadas em tópicos mais complexos de arquitetura, coloco o Deep Research do Gemini 3.8 Flash e o modo investigativo do Qwen 3.8 Max para rodar. Relatórios de pesquisa profunda costumam vir cheios de ruído superficial e repetições. É aí que uso os agentes no Antigravity para comparar as duas fontes, filtrar redundâncias e resumir apenas o núcleo técnico verificado.

Meu interesse pelas tecnologias chinesas veio dos meus estudos de mandarim, e o DeepSeek me surpreendeu muito pelo custo-benefício em tarefas de raciocínio. No VS Code, utilizo a extensão Zoo Code conectada à API do DeepSeek (modelos V3 e 4.1 Flash). Quando as cotas do ambiente primário atingem o limite temporário, essa API assume o trabalho como contingência, custando centavos por milhão de tokens.

Por fim, uso o NotebookLM como cofre fechado de consulta para documentações oficiais e livros técnicos em PDF. Ele garante que as respostas fiquem restritas às fontes confiáveis que eu subi, além de gerar resumos em áudio que gosto de ouvir enquanto caminho.

Limites e segurança: por que não deixo agentes soltos na minha máquina

Participar recentemente da conferência de segurança Hack'a Valley 2026, no Vale do Paraíba, me fez olhar para o uso de IA com uma postura muito mais cuidadosa e defensiva.

Modelos de linguagem conectados a ferramentas do sistema operacional não são mágicos, mas sim sistemas probabilísticos. Se você deixa um agente rodar comandos no seu terminal ou varrer páginas da web sem travas, você está abrindo portas para problemas reais, como ataques de injeção de prompt indireta (indirect prompt injection). Uma instrução maliciosa hospedada em uma página qualquer pode desviar o objetivo do agente e tentar rodar scripts indesejados no seu sistema.

Para evitar surpresas, sigo diretrizes bem definidas no meu fluxo diário. Em primeiro lugar, agentes de leitura e pesquisa operam sempre com permissões mínimas, em modo estritamente somente leitura. Em segundo lugar, nenhuma ação que altere arquivos críticos, remova diretórios ou execute chamadas de rede roda sem a minha confirmação explícita no teclado (Human-in-the-Loop). Por fim, qualquer conteúdo externo vindo da web passa por filtros de limpeza antes de entrar no contexto dos modelos.

Aprender a programar cercado por agentes de IA também significa aprender a governar essas ferramentas com rigor técnico.

O próximo passo: fugir dos tutoriais com estudo socrático

Assistir a tutoriais em vídeo dá uma sensação confortável de progresso. O professor digita, o código compila na tela e parece tudo muito claro. Mas o teste de verdade acontece quando você fecha a janela do vídeo, abre um arquivo em branco no editor e percebe que não sabe por onde começar.

O plano para quando eu terminar o CS50x e fechar o primeiro semestre da Fatec é dar mais um passo rumo ao estudo ativo: adotar tutores com o método socrático para guiar meu aprendizado autodidata.

A ideia é alimentar o modelo com roadmaps validados e documentações oficiais, deixando que ele atue como um tutor exigente. Em vez de me entregar explicações prontas, a IA vai fazer perguntas sobre a lógica, apresentar pequenos códigos quebrados para eu corrigir e calibrar os exercícios de acordo com a minha Zona de Desenvolvimento Proximal (ZPD). O avanço para o próximo tópico só acontece quando o código e o raciocínio estiverem comprovadamente dominados na prática.

A ferramenta acelera, mas quem precisa aprender sou eu

O mercado de tecnologia de 2026 não está carente de pessoas que sabem digitar comandos em um chat para gerar códigos automáticos. O que falta são profissionais com capacidade analítica, que entendem como sistemas quebram, como a memória se comporta e como desenhar soluções seguras.

A inteligência artificial é uma das maiores aliadas que um estudante de computação pode ter hoje, desde que seja usada para tirar o trabalho burocrático da frente e abrir espaço para o que realmente importa: o atrito de pensar.

Aprender programação de verdade dá trabalho e exige paciência. Mas quando você usa as ferramentas para potencializar o seu esforço, e não para fugir dele, a base que você constrói fica sólida para o resto da jornada.

Amplifier, Not Autopilot: My AI-Powered Programming Study Ecosystem

Lucas Resende — Sat, 17 Oct 2026 11:00:00 +0000

I was watching an analysis by software engineer Karol Attekita in her video discussing the current division in the tech market, and one particular phrase stayed with me: the river didn't dry up, it shifted its course.

Her core argument is that the tech market in 2026 is far from dead, but it has split in two. On one side, layoffs in entry-level positions focused on repetitive tasks, simple screens, and boilerplate CRUDs, things artificial intelligence now delivers in seconds. On the other side, an abundance of open roles for engineers who understand complex systems, architecture, automation, and security. Software engineering did not get simpler or less technical. On the contrary, it gained new abstraction layers, such as Spec-Driven Development and agentic architectures.

In my own research and daily study routine, I see this contrast becoming clearer every week. For anyone learning to program right now, it creates a dangerous crossroad.

With a single prompt, any frontier language model can solve Harvard CS50 exercises or college computer science assignments instantly. But if I use that shortcut to bypass the intellectual friction, I am merely training myself to be replaceable tomorrow.

That is why, both at Fatec and throughout CS50x, I decided to invert this mindset: instead of asking AI to produce finished code, I use the technology as an amplifier for context, research, and retention, keeping 100% of the reasoning and implementation in my own hands.

The system I built is the practical result of that decision, connecting what happens in the classroom directly to automated memory systems and deliberate tool orchestration.

From the whiteboard to Obsidian: what happens right after class

During lectures at Fatec, the first decision happens before I even turn on my computer: the note-taking format depends on what is happening in the room.

When the class is lecture-based with conceptual slide decks, I take notes directly in Obsidian using Markdown. But whenever the professor steps up to the whiteboard to sketch data structures, execution stacks, memory layouts, or relational diagrams, I choose pen and paper. The freedom of freehand drawing to capture spatial relationships and logical flows in real time still outperforms any keyboard.

The critical step is what happens after class. Those paper notes do not end up in a drawer. I transfer them into Obsidian, where an automated routine backed by AI assists me through four distinct steps:

First, it reorganizes scattered thoughts. Often, a closing remark at the end of class ties directly back to a concept introduced at the beginning. A custom script connects these insights, generating clean headings and visual Mermaid diagrams.

Second, and this is among the most valuable parts: whenever a confusing concept comes up during lecture that cannot be answered immediately, I write down a flagged inquiry right inside the text:

[QUESTION:: Why does sizeof only return 8 bytes (pointer size) instead of the actual array length when I pass it into a function in C? Test this in code later.]

Instead of letting that question fade away, the agent parses that specific tag and retrieves concise context from official documentation, returning the formal rule alongside a practical code example.

Yet there is a non-negotiable rule in this workflow: the AI only organizes and contextualizes. Once the document is enriched, I sit down and read the complete note line by line to actively re-learn the topic. Without active reading, an enriched note is nothing more than pretty text occupying storage on a hard drive.

Anki and spaced repetition: keeping syntax sharp past day one

Taking clean notes and reviewing them on the same day helps tremendously, but the human brain easily discards syntax rules and low-level mechanics unless prompted systematically.

To solve this, I migrate these insights into Anki, running the FSRS (Free Spaced Repetition Scheduler) algorithm. FSRS calculates the optimal review interval for each card based on my retrieval performance.

Many students fall into a common trap here: prompting an LLM to "create 10 question-and-answer flashcards about today's class." The outcome is almost always counterproductive: bloated text, superficial questions, and passive memorization that evaporates within days.

Instead, I follow Piotr Wozniak's classic formulation principles. Cards must be atomic, targeting a single fact or cause-and-effect relationship through concise cloze deletions. The objective is never to memorize definitions, but to anticipate where code breaks and how the compiler behaves.

In practice, a card generated by this pipeline looks like this:

In C, the malloc function returns {{c1::NULL}} when {{c2::there is insufficient memory available on the heap}}, requiring defensive validation before using the pointer.

To eliminate the friction of manually copying and pasting dozens of cards, I wired this workflow directly into the local AnkiConnect API, running on port 8765. The agent formats the cards from the reviewed note and pushes them straight into the appropriate deck via local HTTP calls. My only morning task is opening the app and completing the scheduled reviews.

The C challenge in CS50: sketching on a whiteboard before touching the keyboard

In Harvard's CS50x, the bar is set significantly higher. I am currently in Week 4, which marks the full transition into pure C, dealing with pointers, dynamic memory allocation with malloc, and direct address manipulation in RAM.

The compiler here is unforgiving. If you are uncertain about where a pointer points or what happens to a specific byte in memory, the program crashes with a segmentation fault. Outsourcing these problem sets to an AI model would be the quickest way to engineer a false sense of competence while learning zero actual computer science.

To navigate the long, dense lectures from Professor David J. Malan, I started using augmented transcripts. Automated audio transcripts contain minor phonetic inaccuracies and continuous walls of text, while official study notes frequently omit practical walkthroughs. I have an agent cross-reference both sources, generating a clean study guide with relevant slides placed at the exact timestamp and code snippets properly formatted.

With this reference ready, my implementation workflow starts visually: before touching a single key to write classic assignments like currency calculation (Cash) or matrix manipulations, I open a digital whiteboard. I sketch how the loops will iterate, where pointers initialize, and what the boundary conditions are.

Only after visualizing the complete control flow do I open the course's official VS Code Spaces to write code. Nothing matches the feeling of running automated test suites in the terminal and seeing check50 return fully green, knowing that every single line was conceived, typed, and debugged by me.

I also adapted my focus sessions: instead of breaking momentum every 25 minutes with standard Pomodoro intervals, I adapt to my cognitive load. When tackling a challenging pointer arithmetic problem, I remain immersed for up to two hours without artificial interruptions. At the end of every session, I write a quick backstage note in my daily journal: "Fought hard with pointer arithmetic syntax today, buffer behavior was particularly interesting". That running log shows me where my friction points are and what requires deeper practice.

My daily setup: multiple frontier models for $4.50 a month

There is a widespread misconception that building an advanced AI-augmented study setup requires paying for several expensive subscriptions every month. In reality, I assembled a high-leverage workstation costing around R$ 24 monthly (roughly $4.50 USD) through strategic orchestration:

Layer / Environment	Description & Workflow	Role
Google Antigravity	IDE with local agent orchestration and execution	`Primary Environment (~$4.50/mo)`
├── Gemini 3.8 + Qwen 3.8 Max	Deep investigation and cross-synthesis of reports	`Deep Research`
└── DeepSeek API + NotebookLM	Fallback via Zoo Code and technical PDF vault	`Fallback & Knowledge`

Architecture of the multi-model AI study ecosystem

For my primary development workspace, I rely on Google Antigravity, leveraging the student tier (costing around R$ 24 / ~$4.50 per month). In addition to extensive access to frontier Gemini models, the subscription includes generous Google Drive cloud storage, which I share with my family.

Whenever I need to run deep-dive research into complex software architecture questions, I combine Deep Research on Gemini 3.8 Flash with the investigative mode in Qwen 3.8 Max. Long-form research reports often contain superficial noise and repetition. Agents inside Antigravity compare both outputs, strip out redundancies, and synthesize only the verified technical core.

My interest in Chinese tech models stems from my Mandarin studies, and DeepSeek proved remarkable in price-to-performance for reasoning tasks. Inside VS Code, I use the Zoo Code extension configured with DeepSeek API endpoints (models V3 and 4.1 Flash). Whenever primary quotas encounter temporary throttles, this API serves as an instant fallback, costing pennies per million tokens.

Finally, I use NotebookLM as a grounded reference vault for official documentation and technical textbooks in PDF format. It ensures that responses stay strictly anchored to source materials I upload, and its audio summaries make for great listening material during daily walks.

Security boundaries: why agents never run unrestricted on my machine

Attending the Hack'a Valley 2026 security conference in Paraíba Valley gave me a much more vigilant and defensive perspective on working with AI tools.

Language models hooked up to operating system tools are not magic, but rather probabilistic systems. If you allow an agent to run terminal commands or crawl arbitrary web pages without strict boundaries, you expose your system to real threats like indirect prompt injection. A malicious snippet hidden on a webpage can hijack an agent's objective and attempt to execute unintended scripts on your local machine.

To stay protected, I enforce strict guardrails in my daily routine. Reading and research agents operate strictly with minimal, read-only permissions. No command that mutates critical files, deletes folders, or initiates external network connections runs without my explicit manual approval (Human-in-the-Loop). Furthermore, external web content undergoes sanitization filters before entering any model's context window.

Learning to program surrounded by AI agents also means learning to govern these systems with engineering rigor.

Next steps: moving beyond tutorials with Socratic learning

Watching video tutorials offers a deceptive sense of mastery. The instructor types, the code compiles cleanly, and everything seems obvious. The real test only begins when you close the video, open a blank file, and realize you do not know where to start.

My roadmap after completing CS50x and wrapping up my first semester at Fatec is to deepen active learning by using AI as a Socratic mentor for self-directed study.

The goal is to feed the model curated roadmaps and official documentation, configuring it to act as a demanding tutor. Rather than providing ready-made solutions, the AI asks targeted architectural questions, introduces subtle bugs into code for me to isolate, and calibrates difficulty according to my Zone of Proximal Development (ZPD). Advancing to the next topic only occurs when the concepts and code are demonstrably mastered in practice.

The tool accelerates, but the engineer must do the learning

The tech market of 2026 does not need more people who can type prompts into a chat box to generate automated code. What it demands are analytical problem-solvers who understand how systems fail, how memory behaves, and how to engineer secure software.

Artificial intelligence is one of the most powerful tools a computer science student can have today, as long as it is applied to eliminate administrative friction and protect space for what truly counts: the cognitive effort of deep thinking.

Learning computer science thoroughly takes dedication and patience. But when you employ these tools to amplify your effort rather than escape it, the technical foundation you build will stand resilient throughout your career.

Além do Código: O que o Hack'a Valley 2026 Revela Sobre Arquitetura, IA e Segurança

Lucas Resende — Fri, 16 Oct 2026 11:00:00 +0000

A maioria dos tutoriais de programação ensina a construir no cenário ideal: a tela abre, o botão responde e o banco de dados salva a informação. O problema é que o ambiente de produção não perdoa pequenos descuidos de arquitetura.

Neste fim de semana, acompanhei as nove palestras da Trilha Técnica do Hack'a Valley Security Conference 2026, no Vale do Paraíba. Em um único dia, vi demonstrações práticas de um Rádio Definido por Software (SDR) manipulando a localização de um smartphone via radiofrequência, e um API Gateway vazando a memória de uma aplicação bancária por causa de uma rota coringa mal configurada.

Chegada e credenciamento no Hack'a Valley 2026: imersão na trilha técnica de segurança ofensiva e defensiva.

Mesmo estando no primeiro semestre de Análise e Desenvolvimento de Sistemas (ADS) na FATEC, minha decisão de participar da conferência teve um objetivo claro: observar a tecnologia pela perspectiva de quem testa limites, identifica falhas estruturais e projeta defesas em ambientes críticos.

A experiência reforçou uma conclusão prática: segurança não é uma camada adicionada no final do projeto, mas parte inseparável da engenharia de software. Compreender redes, concorrência, gerenciamento de memória e permissões é o que sustenta um sistema estável.

Abaixo, reuni os principais aprendizados técnicos e arquiteturais de cada apresentação.

1. Agentes de IA em Ação: Desafios da Segurança na Era da Autonomia

Palestrante: Poliana Moraes (Especialista em InfoSec & Governança na CI&T)

A apresentação abordou a transição da inteligência artificial dos chatbots de texto para os agentes autônomos. Esses modelos recebem objetivos em alto nível, planejam etapas de forma dinâmica e acionam ferramentas externas como APIs, bancos de dados e interpretadores de comando com intervenção humana reduzida.

Poliana Moraes (CI&T) detalhando o fluxo de percepção, centro de controle e atuadores em sistemas agênticos.

O ponto central foi o contraste entre dois modelos fundamentais de computação:

Computação Clássica: Determinística, onde regras lógicas estritas aplicadas às entradas sempre produzem rigorosamente a mesma saída.
Sistemas com IA: Probabilísticos, onde o modelo deduz padrões a partir de dados e pode tomar decisões e caminhos diferentes a cada ciclo de execução.

Proteger arquiteturas probabilísticas exige novos critérios de desenho:

Isolamento de Blast Radius: O agente não deve herdar permissões administrativas totais da conta do usuário. Ele precisa de uma identidade de serviço própria, restrita ao menor privilégio necessário para a tarefa.
Mitigação de Goal Hijacking: Quando um agente processa conteúdos externos da web ou de bancos de dados, instruções maliciosas ocultas podem desviar seu objetivo primário.
Human-in-the-Loop (HITL): Ações de alto impacto, como transações financeiras, exclusão de dados ou alterações de infraestrutura, precisam de validação humana explícita antes da execução.

2. Back to the Roots: CTI e a Maestria dos Fundamentos

Palestrante: Thiago Bordini (Diretor de CTI no Cyber Horizon Group)

Com mais de duas décadas de experiência na resposta a incidentes críticos no Brasil, Bordini analisou como operam os grupos de ataque que visam o sistema financeiro e corporativo nacional.

Thiago Bordini (Cyber Horizon Group) mapeando o ciclo de ataque real contra o sistema financeiro e corporativo brasileiro.

Ele demonstrou que as invasões mais graves raramente dependem de técnicas cinematográficas. Na prática, os atacantes exploram descuidos comuns de desenvolvimento:

Chaves de acesso e variáveis de ambiente esquecidas em coleções públicas do Postman.
Repositórios de código corporativo publicados sem proteção em contas pessoais do GitHub.
Credenciais capturadas por InfoStealers associadas à falta de autenticação multifator em acessos via linha de comando.
Injeção de mensagens diretamente em filas corporativas como RabbitMQ e Azure ServiceBus para emitir ordens fraudulentas de liquidação via PIX.

O recado principal foi a valorização do básico bem executado. Adquirir ferramentas caras não resolve falhas estruturais de visibilidade de logs, excesso de privilégios e desconhecimento dos fluxos do próprio negócio.

Bordini destacou a importância do brio intelectual, lembrando que dominar a computação exige a disciplina de estudar documentações densas e fundamentos de arquitetura, sem depender de atalhos superficiais.

3. Explorando Vulnerabilidades em APIs Gateways

Palestrante: Fepame (Especialista em API Security & OffSec)

Uma análise prática de como decisões de roteamento em arquiteturas de microsserviços afetam a segurança da aplicação. O API Gateway funciona como ponto central de entrada, validando requisições públicas e distribuindo o tráfego para serviços internos.

O palestrante destacou os riscos de configurações permissivas:

Uso de Wildcards (`/`):** Mapeamentos genéricos de rotas repassam caminhos arbitrários para a rede interna, expondo serviços que nunca deveriam ser acessíveis externamente.
Exposição de Endpoints de Diagnóstico: Manter ativas rotas do Spring Boot Actuator em produção expõe variáveis de ambiente (/actuator/env) e permite o download do heapdump da memória da JVM (/actuator/heapdump).
Path Traversal e WAF Bypass: Manipulações de codificação na URL (como Double URL Encoding) que contornam filtros do firewall de aplicação, permitindo extrair da memória tokens JWT e cabeçalhos de autenticação de sessões ativas para assumir contas de clientes bancários.

A lição para quem projeta software é direta: a segurança das rotas precisa ser validada tanto no Gateway quanto individualmente em cada microsserviço de retaguarda.

4. Além dos Prompts: Integrando Agentes de IA em OSINT

Palestrante: Vinícius Vieira (SecOps Manager na Trustly)

Apresentação voltada para o uso de agentes de IA em operações de OSINT (Open Source Intelligence), estruturando investigações em fontes abertas de maneira modular.

Vinícius explicou a diferença entre consultas isoladas em chatbots e a construção de pipelines agênticas especializadas. Em vez de concentrar instruções em um único prompt extenso, a arquitetura recomendada utiliza um orquestrador central que distribui tarefas para agentes com funções delimitadas: coleta de registros, cruzamento de dados públicos, detecção de anomalias e consolidação de relatórios com persistência de contexto entre execuções.

O palestrante também tratou do rigor de segurança operacional (OPSEC):

Dados corporativos confidenciais ou evidências sensíveis não devem ser enviados para provedores de modelos em nuvem pública sem garantias contratuais de retenção zero.
O uso de modelos abertos executados localmente, como a família Llama via ferramentas de inferência local, garante que nenhuma informação saia da infraestrutura própria.
A responsabilidade pelas conclusões de uma análise permanece com o operador humano, que deve checar a veracidade das fontes e não tratar probabilidades de modelos como fatos comprovados.

5. A História da Segurança da Informação: De 1940 aos Dias de Hoje

Palestrante: Felipe Prado (Head de IA & Cyber Analytics na Credicorp)

Uma retrospectiva histórica que conectou as origens da computação aos desafios atuais de nuvem e inteligência artificial.

Prado destacou marcos fundamentais ao longo das décadas:

Décadas de 1940 a 1970: Os trabalhos pioneiros de John von Neumann e Alan Turing, a criação da ARPANET e a era do phreaking, quando John Draper descobriu que o apito de brinquedo do cereal Cap'n Crunch (na frequência de 2600 Hz) permitia controlar comutadores telefônicos para efetuar chamadas gratuitas.
Décadas de 1980 e 1990: A chegada dos computadores pessoais, a disseminação dos primeiros vírus em disquetes, o AIDS Ransomware (1989) e as práticas de engenharia social física (dumpster diving), em que informações corporativas eram obtidas diretamente de documentos descartados no lixo de instituições financeiras.

A principal observação foi o caráter cíclico da área: novas tecnologias frequentemente recriam problemas conhecidos de validação, identidade e controle de acesso, apenas sob novas camadas de abstração.

6. Quebrando o Air-Gap com Suporte de IA: Engenharia de Detecção em SOC de TO

Palestrante: Osmany Arruda (Incident Response Specialist na Tempest e Docente na FATEC)

Uma análise sobre a segurança em ambientes de Tecnologia Operacional (TO), que controlam processos industriais, redes elétricas e linhas de produção fabris.

Arruda detalhou o contraste de prioridades operacionais entre os dois mundos:

Em TI Tradicional: A prioridade central costuma ser a Confidencialidade dos dados.
Em TO Industrial: A prioridade máxima é a Disponibilidade e a Integridade Física (Safety), pois paralisar uma linha de produção ou maquinário pesado para aplicar correções de sistema pode gerar prejuízos elevados e riscos diretos às pessoas.

O palestrante desmistificou o isolamento total (Air-Gap), mostrando que redes sem fio de manutenção e dispositivos temporários criam pontes de entrada. Em seguida, demonstrou como o uso orientado de IA auxilia na escrita rápida de consultas KQL (Kusto Query Language) dentro de plataformas de SIEM, identificando anomalias em protocolos industriais legados (como Modbus e CIP) sem causar interrupções operacionais.

7. É Possível Hackear o Sistema de GPS em Casa? (SDR & Aviação)

Palestrante: Alberto Magno (Pesquisador e Especialista em Cibersegurança Aeroespacial)

Apresentação técnica sobre a camada física de transmissões de radiofrequência e a vulnerabilidade das constelações de satélites GNSS (GPS, GLONASS, Galileo e BeiDou).

Alberto explicou os dois principais tipos de interferência:

Jamming: Emissão de ruído contínuo na mesma frequência do sinal (Banda L1 em 1575.42 MHz) com potência suficiente para encobrir o sinal dos satélites, resultando em perda de rastreio.
Spoofing: Transmissão de sinais forjados com potência ligeiramente superior à dos satélites legítimos, induzindo receptores a aceitarem coordenadas, velocidade e horários incorretos.

Utilizando um Rádio Definido por Software (HackRF One) e scripts em Python, ele demonstrou na prática:

A alteração das coordenadas de smartphones e módulos GPS para qualquer localização global em tempo real, contornando proteções em nível de software por atuar diretamente na camada física de rádio.
A criação de trajetórias dinâmicas contínuas através da fórmula matemática de Haversine, simulando o deslocamento suave de veículos e aeronaves com controle de velocidade e altitude.

O experimento reforçou os riscos para frotas autônomas e a aviação civil, destacando a necessidade de redundância com Sistemas de Navegação Inercial (INS) que não dependem exclusivamente de sinais externos.

8. Crime e Castigo: O Funeral do OPSEC

Palestrantes: Cybelle Oliveira (La Villa Hacker DEF CON) e Divina Vitorino (Coordenadora de InfoSec LATAM)

Estudo de caso investigativo sobre o modelo comercial de Malware-as-a-Service (MaaS), focado na operação do RedLine Stealer, um dos malwares mais disseminados para captura de credenciais, cookies de sessão e carteiras digitais.

Cybelle Oliveira (La Villa Hacker) detalhando a arquitetura de infecção e exfiltração de dados do RedLine Stealer.

A apresentação detalhou como operadores de ataques foram identificados por equipes de inteligência de ameaças (CTI) e autoridades policiais devido a falhas de segurança operacional (OPSEC):

Reuso de Identidade Digital: Associação de e-mails antigos utilizados em fóruns e redes sociais pessoais aos servidores de compilação do malware.
Contaminação de Endereço IP: Uso do mesmo IP residencial para atividades de lazer e, minutos depois, para autenticação na infraestrutura de controle do código malicioso.
Rastreabilidade Financeira: Aceitação de transações em Bitcoin vinculadas a contas em corretoras com verificação formal de identidade (KYC).

A conclusão reforçou que a sofisticação técnica de um software não anula falhas humanas de disciplina e processo.

9. macOS Doesn't Get Malware... Until It Does

Palestrante: Zoziel Freire (CSIRT Manager na Telefônica Brasil)

Apresentação que desconstruiu a ideia de invulnerabilidade do ecossistema Apple, analisando mecanismos internos de segurança (como Gatekeeper, SIP e XProtect) e apresentando técnicas utilizadas por ameaças direcionadas à plataforma.

Entre os conceitos explorados, destacaram-se:

Uso de LOLBins (Living off the Land Binaries): Emprego do interpretador Python assinado nativamente pelo sistema para rodar rotinas maliciosas sem disparar alertas de execução não autorizada.
Persistência no Nível do Usuário: Inclusão de arquivos .plist no diretório ~/Library/LaunchAgents, permitindo que o script inicie automaticamente a cada login sem exigir privilégios de administrador (root).
Execução em Memória (In-Memory): Injeção de código diretamente na memória RAM sem salvar binários no disco rígido, contornando a detecção por assinaturas estáticas de antivírus convencionais.

O encerramento destacou a importância de telemetria comportamental contínua integrada ao Endpoint Security Framework (ESF) da Apple.

Experiências Práticas e Conexões

Além das palestras no palco principal, o evento proporcionou contato direto com tecnologias emergentes e profissionais da área.

Testando na prática a interface de leitura de ondas cerebrais (EEG) para controle de dispositivos no estande da FIAP.

Nos espaços de comunidade e estandes, como a demonstração de interfaces cérebro-computador (BCI / EEG) da FIAP conectando sinais neurais ao acionamento físico de lâmpadas, ficou evidente como as fronteiras entre hardware, software e dados biométricos estão se estreitando, e como cada nova interface amplia os requisitos de segurança e confiabilidade.

Conclusões e Direcionamento Técnico

Acompanhar a conferência consolidou uma certeza prática: o desenvolvedor que compreende como a infraestrutura opera por baixo dos panos escreve software mais confiável, performático e escalável.

Entender falhas de roteamento em gateways de API, governança de modelos de inteligência artificial, segmentação de redes e retenção de logs não é um tema restrito a especialistas em segurança. É a base técnica necessária para tomar decisões conscientes de arquitetura.

Cada uma das palestras abriu tópicos de aprofundamento que continuarei explorando na FATEC e aplicando no desenvolvimento dos meus projetos práticos.

Beyond the Code: What Hack'a Valley 2026 Reveals About Architecture, AI, and Security

Lucas Resende — Fri, 16 Oct 2026 11:00:00 +0000

Most programming tutorials teach us how to build in ideal conditions: the page loads, the button clicks, and the database saves without a glitch. The reality of production, however, does not forgive architectural oversights.

This past weekend, I attended all nine presentations on the Technical Track of the Hack'a Valley Security Conference 2026 in Paraíba Valley, Brazil. In a single day, I watched live demonstrations of Software-Defined Radio (SDR) spoofing smartphone GPS coordinates over radio frequencies, and an API Gateway dumping JVM memory contents of a banking system due to a misconfigured wildcard route.

Arrival and badge check-in at Hack'a Valley 2026: full immersion in offensive and defensive security tracks.

Even though I am in my first semester of Systems Analysis and Development (ADS) at FATEC, my goal in attending was clear: to examine technology through the lens of engineers who stress-test systems, identify structural weaknesses, and design resilient defenses for mission-critical environments.

The conference reinforced a crucial principle: security is not a separate layer bolted on at the end of a project. It is an integral part of software engineering. Understanding networking, concurrency, memory management, and access controls is what keeps production systems standing.

Below is a breakdown of the key technical and architectural insights from each session.

1. AI Agents in Action: Security Challenges in the Era of Autonomy

Speaker: Poliana Moraes (InfoSec & Governance Specialist at CI&T)

This session covered the industry shift from simple text chatbots to autonomous AI agents. These systems receive high-level objectives, dynamically plan multi-step workflows, and trigger external tools such as APIs, databases, and CLI environments with minimal human intervention.

Poliana Moraes (CI&T) explaining the perception cycle, control center, and actuator layers in agentic systems.

The core discussion centered on the difference between two computing paradigms:

Classical Computing: Deterministic. Strict logical rules applied to fixed inputs consistently generate identical outputs.
AI Systems: Probabilistic. Models infer patterns from data, meaning decisions and execution paths can vary across runs.

Securing probabilistic architectures requires new design patterns:

Blast Radius Isolation: An agent must never inherit full admin privileges from the user. It requires a dedicated service identity restricted to the principle of least privilege.
Mitigating Goal Hijacking: When an agent ingests untrusted web content or third-party database records, hidden prompt injections can hijack its primary directive.
Human-in-the-Loop (HITL): High-impact actions such as financial transactions, data deletions, or infrastructure updates must strictly require explicit human confirmation before execution.

2. Back to the Roots: CTI and Mastery of the Fundamentals

Speaker: Thiago Bordini (CTI Director at Cyber Horizon Group)

Drawing on over two decades of incident response experience in Brazil, Bordini analyzed the operational tactics of threat actors targeting enterprise and financial institutions.

Thiago Bordini (Cyber Horizon Group) mapping real-world attack lifecycles against enterprise infrastructure.

He highlighted that major breaches rarely stem from cinematic zero-days. Instead, attackers exploit simple developer oversights:

API keys and environment secrets committed to public Postman collections.
Proprietary source code pushed to public personal GitHub accounts.
Credentials harvested by InfoStealers paired with a lack of multi-factor authentication on CLI access tokens.
Direct message injection into enterprise message brokers like RabbitMQ and Azure ServiceBus to trigger fraudulent PIX settlements.

The key takeaway was the power of mastering the basics. Expensive security tooling cannot compensate for absent log visibility, excessive IAM permissions, and an incomplete understanding of business domain flows.

Bordini emphasized the value of intellectual rigor, reminding developers that mastering computer science demands digging into dense technical documentation and core foundations rather than relying on surface-level shortcuts.

3. Exploiting Vulnerabilities in API Gateways

Speaker: Fepame (API Security & OffSec Specialist)

A hands-on breakdown of how routing choices in microservice architectures directly impact application security. The API Gateway serves as the single public entry point, validating incoming requests and routing traffic to downstream backend services.

The presentation exposed the risks of overly permissive route configurations:

Wildcard Routing (`/`):** Broad routing patterns pass arbitrary URL paths downstream, exposing internal endpoints that should never be reachable from the internet.
Exposing Diagnostic Endpoints: Leaving Spring Boot Actuator endpoints enabled in production exposes runtime environment variables (/actuator/env) and allows unauthenticated heapdump downloads (/actuator/heapdump).
Path Traversal and WAF Bypasses: URL encoding tricks such as Double URL Encoding that bypass Web Application Firewall filters, enabling attackers to extract JWT tokens and session headers directly from JVM memory to hijack banking accounts.

For software engineers, the message is clear: routing security must be enforced both at the gateway level and inside each downstream microservice.

4. Beyond Prompts: Integrating AI Agents into OSINT

Speaker: Vinícius Vieira (SecOps Manager at Trustly)

A technical blueprint on leveraging AI agents for Open Source Intelligence (OSINT) investigations in a structured, modular pipeline.

Vinícius contrasted one-off chatbot prompts with specialized agentic architectures. Rather than stuffing instructions into a massive single prompt, the recommended approach uses a central orchestrator that assigns discrete tasks to dedicated sub-agents: record collection, public data cross-referencing, anomaly detection, and automated report drafting with persistent state.

The session also addressed strict operational security (OPSEC) guidelines:

Confidential enterprise data or investigative evidence must not be sent to public cloud LLM endpoints without verified zero-retention data agreements.
Running open-weights models locally (such as the Llama family on private inference engines) ensures data never leaves internal infrastructure.
Accountability remains with human analysts, who must verify source facts and never accept probabilistic model assertions as guaranteed truth.

5. The History of Information Security: From 1940 to the Present Day

Speaker: Felipe Prado (Head of AI & Cyber Analytics at Credicorp)

A historical retrospective connecting early computing milestones to modern cloud and AI challenges.

Prado traced key turning points across computing history:

1940s to 1970s: Foundational theoretical work by John von Neumann and Alan Turing, the birth of ARPANET, and early phreaking culture, including John Draper's discovery that a 2600 Hz toy whistle from Cap'n Crunch cereal could control telephone switching networks for free calls.
1980s and 1990s: The rise of personal computers, floppy disk viruses, the AIDS Ransomware of 1989, and physical dumpster diving techniques used to extract confidential financial records from corporate waste.

The main takeaway was the cyclical nature of cybersecurity: emerging technologies frequently reintroduce classic problems of input validation, identity verification, and access controls under new abstraction layers.

6. Breaking the Air-Gap with AI: Detection Engineering in OT SOCs

Speaker: Osmany Arruda (Incident Response Specialist at Tempest and Professor at FATEC)

An exploration of cybersecurity in Operational Technology (OT) environments, which govern industrial processes, electrical grids, and automated factory production lines.

Arruda contrasted operational priorities between traditional IT and industrial OT:

Traditional IT: Priority is typically placed on data Confidentiality.
Industrial OT: Priority is firmly on Availability and Physical Safety. Shutting down an active manufacturing assembly line to apply security patches can cause severe financial damage and create direct physical hazards.

The presentation debunked the myth of the impenetrable Air-Gap, showing that maintenance wireless networks and transient field devices frequently bridge the gap. Arruda demonstrated how AI accelerates writing Kusto Query Language (KQL) rules in SIEM platforms to catch anomalies in legacy industrial protocols like Modbus and CIP without interrupting plant operations.

7. Can You Hack GPS at Home? (SDR & Aerospace Security)

Speaker: Alberto Magno (Aerospace Cybersecurity Researcher)

A deep dive into the physical layer of radiofrequency transmissions and the vulnerability of Global Navigation Satellite Systems (GPS, GLONASS, Galileo, and BeiDou).

Alberto clarified two primary interference methods:

Jamming: Flooding the L1 frequency band (1575.42 MHz) with continuous high-power noise to overpower satellite signals and cause receiver tracking loss.
Spoofing: Transmitting crafted fake signals with slightly higher power than genuine satellites, fooling receivers into accepting false coordinates, velocity readings, and timestamps.

Using a Software-Defined Radio (HackRF One) and custom Python scripts, he demonstrated:

Shifting live smartphone and GPS module coordinates to any global location in real time, bypassing software security layers by operating directly at the RF physical layer.
Generating smooth, continuous trajectories using the Haversine mathematical formula to simulate realistic vehicle and aircraft movement with accurate velocity and altitude.

The demonstration underscored the security risks for autonomous fleets and commercial aviation, emphasizing the necessity of redundant Inertial Navigation Systems (INS) that do not rely solely on external radio signals.

8. Crime and Punishment: The Funeral of OPSEC

Speakers: Cybelle Oliveira (La Villa Hacker DEF CON) and Divina Vitorino (LATAM InfoSec Coordinator)

An investigative case study into the Malware-as-a-Service (MaaS) business model, centering on the operation of the RedLine Stealer, one of the most widespread tools for extracting saved browser credentials, session cookies, and crypto wallet data.

Cybelle Oliveira (La Villa Hacker) breaking down the operational infection and data exfiltration flow of RedLine Stealer.

The speakers detailed how threat actors were unmasked by Cyber Threat Intelligence (CTI) teams and law enforcement through elementary operational security (OPSEC) failures:

Digital Identity Reuse: Linking personal emails used on gaming forums and social networks to the build servers compiling the malware.
IP Address Contamination: Using the same residential IP for leisure browsing and, minutes later, authenticating into malicious Command and Control infrastructure.
Financial Footprints: Withdrawing Bitcoin payments into centralized crypto exchanges with formal Know Your Customer (KYC) identity verification.

The conclusion was unequivocal: technical malware sophistication is useless when paired with poor operational discipline and process failures.

9. macOS Doesn't Get Malware... Until It Does

Speaker: Zoziel Freire (CSIRT Manager at Telefônica Brasil)

A session debunking the perception of invulnerability surrounding Apple's operating system, examining built-in defenses (Gatekeeper, SIP, and XProtect) and real-world attack vectors targeting macOS.

Key concepts discussed included:

Living off the Land Binaries (LOLBins): Utilizing Apple's built-in, signed Python interpreter to execute malicious scripts without triggering untrusted binary alerts.
User-Level Persistence: Dropping .plist configuration files into ~/Library/LaunchAgents to persist across system reboots without requiring elevated root privileges.
In-Memory Execution: Injecting malicious code directly into RAM without saving binaries to the local disk, evading signature-based antivirus scanners.

The talk concluded with an emphasis on behavioral telemetry and deep integration with Apple's Endpoint Security Framework (ESF).

Hands-On Experiences and Community

Beyond the main-stage talks, the conference provided direct interaction with emerging hardware and security practitioners.

Testing a brain-computer interface (BCI / EEG) to control hardware devices at the FIAP booth.

In the community exhibition hall, interactive demonstrations such as FIAP's Brain-Computer Interface (BCI / EEG) rig, which translated neural activity into physical lamp switching, illustrated how boundaries between hardware, software, and biometric telemetry continue to blur, introducing fresh challenges for reliability and secure system design.

Conclusions and Engineering Direction

Attending Hack'a Valley confirmed an essential engineering reality: developers who understand how underlying infrastructure operates write software that is significantly more resilient, performant, and scalable.

Grasping API gateway routing quirks, AI agent governance, network segmentation, and log retention is not something exclusive to security researchers. It is the technical foundation required to make sound architectural decisions every day.

Each presentation opened valuable areas of study that I will continue exploring at FATEC and applying directly to my production projects.

Do Scratch ao C: Como Foram Minhas Primeiras 3 Semanas no CS50 de Harvard

Lucas Resende — Thu, 15 Oct 2026 12:24:52 +0000

Quando comecei as primeiras aulas do CS50x (o curso introdutório de Ciência da Computação de Harvard), o professor David J. Malan avisou logo de cara: aprender programação pode parecer como tentar beber água diretamente de um hidrante.

Três semanas depois, posso confirmar: o volume de informação é enorme. De início, confesso que bateu um leve receio pelo fato das aulas serem 100% em inglês, mas as explicações eram tão didáticas que, com uma ou outra pesquisa rápida, deu para acompanhar super bem.

Para não me afogar, precisei de um ritmo próprio: dividi as sessões de estudo ao longo de 2 a 3 dias por aula, sempre parando o vídeo, entendendo a lógica, anotando e testando no código. No fim das contas, encarar as dificuldades e ver a solução funcionar por conta própria traz uma satisfação indescritível.

Quero compartilhar como foi vivenciar essa maratona inicial, da lógica visual no Scratch até os primeiros desafios em C, com meus comentários de bastidor, erros e pequenas vitórias.

Week 0: Aprendendo a pensar como programador (e brincando no Scratch)

A Semana 0 me fez virar uma chave importante: Ciência da Computação não é sobre memorizar sintaxe, mas sobre resolver problemas. É o processo que acontece no espaço entre o input (o problema) e o output (a solução).

Entender como os computadores funcionam por baixo dos panos, do binário até a forma como imagens e textos são guardados na memória, me deu uma perspectiva totalmente nova. Mas o momento em que a chave virou de verdade foi na prática.

Para treinar a lógica sem as barreiras do código em texto, o curso usa o Scratch, uma ferramenta desenvolvida pelo MIT em que programamos juntando blocos visuais coloridos, quase como montar um quebra-cabeça. Nele, criei meu primeiro projeto interativo (Starting from Scratch). Montei blocos customizados com parâmetros, criei variáveis e condicionais. Parecia um jogo simples de início, mas me forçou a pensar em estrutura e abstração antes de encostar em uma linha de código textual.

Week 1: O choque com a linguagem C e o amor pelo terminal

Se no Scratch tudo era visual e amigável, a Semana 1 nos joga direto na linguagem C. De repente, um simples ponto e vírgula esquecido paralisa o programa inteiro.

Conforme fui avançando nos vídeos, me peguei me desafiando a ir além do que o professor mostrava na tela. Tiveram pequenos tropeços, como descobrir na prática que para declarar um char eu precisava usar aspas simples ('a'), mas cada erro virava um aprendizado imediato.

Dois momentos se destacaram muito para mim:

Adeus mouse, olá Terminal: Aprendi a interagir direto com a linha de comando (ls, cd, make, ./hello). No começo é estranho não usar a interface gráfica, mas você percebe rapidamente como o teclado torna a navegação muito mais fluida.
A lógica na lousa digital: Nos exercícios da pirâmide do Mario e do cálculo de troco (Cash), a cabeça deu um nó. A saída foi abrir uma lousa digital, desconstruir a lógica linha por linha e desenhar como os loops se comportavam. Me desafiei até a criar funções próprias para renderizar os blocos, e ver o código rodar sem iterações desnecessárias foi recompensador.

Week 2: Arrays, strings e a resiliência nos problemas

Na Semana 2, entramos em conceitos mais profundos: como a memória RAM organiza dados em blocos (arrays), como strings são apenas sequências de letras terminadas por um caractere invisível (\0), e como funciona a criptografia.

Organizei meus estudos em blocos de foco de 25 minutos e passei por uma verdadeira montanha-russa de sentimentos. Anotei no meu diário de estudos, por exemplo: "Aprendi o que são Arrays, achei muito legal!" e, 25 minutos depois: "Tá, arrays não são tão fáceis assim kkk, começou a ficar complexo".

Nos exercícios da semana, o bicho pegou:

No Scrabble, penei para mapear as pontuações das letras na tabela ASCII. Cheguei a anotar frustrado: "Minha nossa senhora, esse negócio é MUITO difícil kk. Vou continuar amanhã de cabeça fresca". E foi a melhor decisão. Voltei no dia seguinte, desenhei a lógica na lousa e o código finalmente fluiu.
No Readability e no Caesar, a satisfação foi ver que desconstruir o problema em etapas menores fazia tudo se encaixar, desde a rotação de caracteres da criptografia até os ajustes de arredondamento da fórmula de leitura.

O que tiro dessas 3 primeiras semanas

Se eu pudesse resumir meu principal aprendizado até aqui em três pontos, seriam estes:

Desenhar antes de codificar: Tentar resolver um problema digitando direto no editor gera frustração. Escrever o raciocínio no papel ou numa lousa digital economiza horas.
Aprender a gostar dos erros: O compilador reclamando não é um puxão de orelha, é um guia. Ver o check50 mudar de vermelho para verde depois de tanto testar e ajustar é a melhor recompensa.
Paciência e processo: Como anotei após terminar uma das aulas: parar, entender, anotar e voltar. Fazer os exercícios, enfrentar dificuldades e conseguir achar a solução conectando conceitos de múltiplas aulas dá uma sensação boa demais.

Sinto que a base que estou construindo aqui vai sustentar muito do que vou aplicar na FATEC e nos meus projetos futuros. A decisão do reset de carreira faz cada vez mais sentido.

From Scratch to C: My First 3 Weeks Inside Harvard’s CS50

Lucas Resende — Thu, 15 Oct 2026 12:22:14 +0000

When I attended the opening lectures of CS50x (Harvard's flagship Introduction to Computer Science course), Professor David J. Malan gave an upfront disclaimer: learning to program can feel like attempting to drink water straight from a firehose.

Three weeks in, I can wholeheartedly confirm: the sheer volume and density of information is staggering. Initially, there was a momentary pause knowing the entire curriculum is delivered in English, but the pedagogical clarity and structure made the immersion deeply engaging with just the occasional targeted search.

To avoid getting overwhelmed, I established a deliberate study cadence: splitting each lecture and problem set across 2 to 3 days, pausing the videos frequently, analyzing the underlying control flow, sketching on paper, and iteratively implementing in code. In the end, wrestling with difficult bugs and arriving at an elegant solution entirely on your own provides an incomparable sense of fulfillment.

Here is my honest logbook of that intense opening sprint: from visual logic in Scratch to low-level engineering in C, along with behind-the-scenes thoughts, hurdles, and breakthroughs.

ended the ope

Week 0: Computational Thinking (and Experimenting in Scratch)

Week 0 flipped a crucial mental switch: Computer Science is not about memorizing syntax rules, but about algorithmic problem-solving. It is the structured process that occurs in the space between the input (the problem statement) and the output (the verified solution).

Grasping how hardware and software operate under the hood (from binary representation to how text and images are encoded in volatile memory) provided a grounding foundation. But the concepts solidified during the practical problem set.

To cultivate algorithmic logic without the cognitive load of syntax errors, the curriculum begins with Scratch, a visual block-based environment developed at MIT. I built my first interactive project (Starting from Scratch), defining custom procedures with parameter passing, managing variable state, and nesting conditionals. While it resembles a colorful game on the surface, it forces you to think about abstraction, modularity, and control flow before typing a single line of raw text.

Week 1: The Shock of C and Embracing the Terminal

Moving from Scratch's forgiving UI to low-level C in Week 1 was an immediate reality check. Suddenly, a single misplaced semicolon halts compilation in its tracks.

As the lectures progressed, I pushed myself to experiment beyond the code displayed on screen. There were natural friction points, such as discovering firsthand that declaring a char literal strictly requires single quotes ('a'), whereas strings use double quotes, but every compiler warning quickly translated into durable knowledge.

Two milestones stood out during this phase:

Leaving the GUI Behind for the CLI: Interacting directly with the command line (ls, cd, make, ./hello). While navigating without a mouse feels foreign at first, you quickly realize how much faster and more precise keyboard-driven workflows become.
Digital Whiteboard Modeling: When tackling the Mario pyramid generation and the Cash greedy coin-change algorithm, mental simulation hit a wall. The breakthrough was opening a digital whiteboard, drawing the coordinate axes, and plotting iteration bounds for outer and inner loops. I challenged myself to extract modular helper functions, and watching the test suites execute with optimal complexity was immensely rewarding.

Week 2: Arrays, Strings, and Building Engineering Resilience

Week 2 plunged into deeper hardware and memory concepts: how RAM organizes contiguous blocks of data (arrays), why strings in C are simply byte sequences terminated by an invisible null byte (\0), and the mathematical foundations of cryptography.

I structured my study into 25-minute Pomodoro focus blocks and experienced the classic developer emotional rollercoaster. In my study log, I wrote: "Just learned about Arrays, super intuitive and clean!" - followed 25 minutes later by: "Okay, multidimensional arrays and pointer boundaries are definitely not trivial anymore."

The problem sets presented genuine challenges:

In Scrabble, translating character ASCII values into localized letter scoring tables required careful boundary checking. At one point, I jotted down: "This logic is genuinely tricky tonight. Stepping away to reset and tackling it with a clear head tomorrow." That proved to be the right call. The next morning, mapping the array indexes on the whiteboard made the implementation fall into place seamlessly.
In Readability and Caesar, decomposing the problem into discrete pipeline stages made everything click: from character-by-character ASCII rotation with modulo arithmetic to floating-point rounding for readability index formulas.

Core Takeaways from the First 3 Weeks

If I had to distill the most valuable lessons from this initial marathon into three principles, they would be:

Diagram Before You Code: Trying to write code directly in the editor before clarifying the algorithmic flow leads to compounding bugs. Sketching inputs, outputs, and edge cases on paper or a whiteboard saves hours of refactoring.
Treat Compiler Warnings as Mentors: The compiler is not an obstacle. It is an infallible pair programmer. Seeing check50 transform from red failures to all-green assertions after rigorous iteration is one of the most rewarding feelings in tech.
Trust the Process and Cadence: As I noted in my journal: pause, comprehend, document, and execute. Working through problem sets from first principles and connecting concepts across lectures builds genuine, unshakeable confidence.

The foundational computer science principles I am cultivating here will directly anchor my coursework at FATEC and my ongoing full-stack projects. The career reset continues to prove itself as the best decision I've made.