Artigos e Playbooks

A porta de entrada para dados e IA: do básico ao avançado.

Formato compacto: os fundamentos de Python 3.10+ como checklist — tipos, escopo, estruturas de dados, funções, classes, exceções, ambientes e armadilhas. Remete às apostilas completas.

Os fundamentos que sustentam qualquer agente de IA que vale a pena construir.

Do neurónio artificial ao deep learning: o motor por trás da IA generativa, explicado do zero.

Transforme dados brutos em decisões, do básico ao nível expert.

Volume I de uma série de quatro. Antes de qualquer inferência há uma etapa que quase toda a gente salta: olhar honestamente para os dados. Porque a média mente e mente de forma previsível, de onde vêm as formas das distribuições, porque a latência média é má prática, os três tipos de outlier, e o paradoxo que faz duas médias verdadeiras contradizerem-se. Com uma demo ao vivo de uma métrica descascada em seis camadas — até se descobrir que a seta verde apontava para o lado errado.

Volume II de quatro. Mediu 340 pessoas e quer dizer algo sobre um milhão: toda a inferência existe para tornar esse salto defensável — e para dizer até onde pode ir. Variação amostral, erro-padrão e a tirania da raiz quadrada, o que um intervalo de confiança afirma mesmo, as cinco leituras erradas do valor-p, poder e a maldição do vencedor, comparações múltiplas, e porque tantos resultados não se repetem. Com uma demo ao vivo de um teste A/B «significativo» desmontado em quatro perguntas.

Volume III de quatro. Por baixo do nome intimidante está uma operação simples: comparar médias de forma contínua e com várias variáveis ao mesmo tempo. Prever ou explicar são dois ofícios com o mesmo maquinismo e regras opostas. Ler um coeficiente sem dizer mais do que ele diz, porque a recta não é a relação, o que muda ao acrescentar uma variável, o que os resíduos denunciam, e porque o R² sobe mesmo com colunas de ruído puro. Com uma demo ao vivo de um modelo que «prova» que o apoio ao cliente prejudica a retenção.

Volume IV e último. Toda a afirmação causal compara o que aconteceu com o que teria acontecido de outra forma — e o segundo termo nunca é observável. Confundimento e autosseleção, os três padrões que decidem o que controlar (e porque «controlar por tudo» estraga em dois dos três casos), porque a aleatorização funciona tão bem, e o catálogo de desenhos para quando ela é impossível. Com uma demo ao vivo da campanha que rendia 4,2× no painel e nada na realidade.

Toda a estatística clássica assenta num pressuposto que numa série temporal é falso por construção: o de que as observações são independentes. Decompor em tendência, sazonalidade e resto; estacionariedade e o passeio aleatório que não se prevê; a linha de base trivial que quase ninguém bate; as métricas que ensinam o modelo a subestimar; validação por origem móvel e as cinco fugas de informação. Com uma demo ao vivo de uma previsão com 4% de erro que não valia nada.

Dados que contam histórias: Python, D3.js e dashboards profissionais, do básico ao muito avançado.

A espinha dorsal de qualquer arquitetura de dados fiável, do básico ao muito avançado.

Escale para além do relacional quando o volume e a velocidade dos seus dados exigem outra abordagem.

O aprofundamento aplicado do banco de documentos nº 1 do mercado: modelagem, aggregation pipeline, índices e explain(), replica set, sharding e Atlas Search, do básico ao muito avançado.

Formato compacto: as 4 famílias e a matriz de decisão, o vocabulário de CAP/BASE/quóruns, modelagem query-first, CDC vs dual-write e operação — o essencial, com ponteiros para aprofundar.

A disciplina de modelar a partir dos padrões de acesso: embedding vs referencing decidido, o catálogo de padrões, single-table design, coluna larga, grafo e evolução de schema sem downtime, do básico ao muito avançado.

Do primeiro cache-aside ao Redis Cluster: os cinco problemas clássicos (stampede, avalanche, hot key…), consistência cache+banco, rate limiting, locks, Streams, Sentinel/Cluster e cache de LLM, do básico ao muito avançado.

Os quatro mundos dos grafos num só lugar: BFS/DFS/Dijkstra, fluxo e emparelhamento, ciência de redes (centralidade, comunidades), node2vec e GNNs, e Knowledge Graphs com GraphRAG, do básico ao muito avançado.

Dos qubits e da esfera de Bloch a Grover, Shor e correção de erros: hardware real, criptografia pós-quântica e QML, com Qiskit na prática e o que já é vantagem versus o que ainda é promessa.

Da primeira ingestão em batch ao lakehouse transacional: dbt, Airflow, Spark, Kafka e governança, do básico ao muito avançado.

Versionamento de dados, feature store, model registry, serving, CI/CD/CT e monitoramento de drift: o ciclo de vida completo de ML, do básico ao muito avançado.

Modelagem em estrela, DAX e LOD, design de dashboards, performance, governança, RLS e camada semântica, do básico ao muito avançado.

Formato compacto: dimensões vs medidas, azul/verde, a ordem de operações dos filtros, LOD, dashboards e publicação — o essencial, com ponteiros para aprofundar.

Vision-language models e entendimento de imagem, o pipeline de Document AI (OCR, layout, tabelas), extração estruturada com schema e validação, RAG multimodal com citação por página, vídeo e áudio como entrada, agentes multimodais, e produção (avaliação, custo, privacidade), do básico ao muito avançado.

Prospectiva do campo: escrever a consulta barateou, acordar o que "cliente ativo" significa não. A camada semântica como gargalo real, o erro que não falha (consulta errada devolve número, não exceção), a origem dos dados sob pressão e o valor que migra para a causalidade. Quatro cenários para 2032 e sete ações que não exigem comprar nada.

Do autocomplete ao design de sistemas multiagente: AI-Assisted Development orientado ao mercado.

Tool use, loops agênticos, RAG e multiagentes: engenharia de IA do básico ao expert.

O corte profundo da autonomia: planejamento e replanejamento, execução durável, auto-correção, budget e kill switch, sandbox e computer-use, swarm e avaliação por trajetória, do básico ao muito avançado.

De um script no Telegram a um agente em produção, com RAG, deploy e monetização.

O protocolo aberto que liga modelos de IA a ferramentas e dados reais, do handshake à produção.

Volume I de seis. Uma skill é uma pasta com instruções que o agente sabe que existem e só lê quando a tarefa as pede — a resposta a um dilema concreto: o contexto é finito e o conhecimento não. Desde dezembro de 2025 o formato SKILL.md é norma aberta, lida por Claude Code, Codex, Cursor, Gemini CLI, Copilot e dezenas de outros. A especificação campo a campo, os três níveis de divulgação progressiva, como escrever uma descrição que dispara, e como saber se acrescenta alguma coisa.

Volume II de seis. O SKILL.md é o mesmo em toda a parte; o que muda é onde se põe, como se chama e o que cada ferramenta acrescenta por cima. Claude Code, Codex e ChatGPT, Cursor, Gemini CLI, claude.ai e a API — pastas, comandos, campos próprios e limites de contexto, verificados nas fontes primárias. Inclui o caminho para quem não programa, a armadilha de nada sincronizar entre superfícies, e como escrever uma skill que funcione em todas.

Volume III de seis. Skills não tornam o agente melhor a programar — tornam-no melhor a programar como se programa aqui, e é aí que está a diferença que se sente. Convenções, procedimentos com verificação, referência que resolve o corte de conhecimento, MCP com as convenções de uso ao lado, e a categoria de maior retorno de todas: as skills que verificam o que foi construído. Com uma demo ao vivo do mesmo pedido com e sem skills — 120 linhas de diferença.

Volume IV de seis. O trabalho de marca tem duas metades — decidir e aplicar — e skills são medíocres na primeira e excelentes na segunda. A skill de identidade que impede três anos de deriva, derivação de paletas em OKLCH, verificação de contraste por cálculo, tom de voz, e o que uma skill não deve fazer com um logótipo. Com uma demo ao vivo de uma apresentação de cliente com e sem skills — seis desvios, nenhum deles grosseiro.

Volume V de seis. A categoria mais estranha da série: skills cujo produto não é um ficheiro, é uma decisão melhor — e onde o risco não é produzir errado, é produzir plausível. Estruturar um problema antes de o resolver, gerar opções por eixos para rejeitar, planear pondo primeiro o passo que pode matar o plano, e criticar em passagem separada. Com uma demo ao vivo de uma decisão cuja conclusão se inverte — e a diferença é inteiramente de processo, não de conhecimento.

Volume VI e último. Os jogos reúnem as dificuldades dos três volumes temáticos e acrescentam duas próprias: o motor muda entre versões, e «está bom» significa «é divertido», que não se compila. Skills de motor com versão declarada, o ficheiro de armadilhas, proibições de desempenho medidas pelo pior fotograma, pipeline de recursos e o padrão do roteador para muitos motores. Com uma demo ao vivo de um inimigo novo — seis problemas que nenhum deles dá erro.

Embeddings, RAG avançado e arquiteturas de ponta como GraphRAG, do zero ao muito avançado.

Transformers, fine-tuning e bases vetoriais: o que separa um protótipo de um sistema em produção.

Modelos abertos e licenças, a matemática de VRAM, quantização (GGUF/Q4), runtimes (Ollama, llama.cpp, vLLM, MLX), IA no navegador e no dispositivo, servir e integrar, avaliação e roteamento local↔nuvem, produção e edge, do básico ao muito avançado.

A escada prompt → RAG → fine-tune, tipos de customização, dados como o ativo central, PEFT com LoRA e QLoRA, preference tuning com DPO, ferramentas e o loop de treino, avaliação e regressão, distillation para SLMs especializados, e produção (servir adapters, versionar, segurança, licença), do básico ao muito avançado.

Reconhecimento de fala (Whisper, WER, diarização), síntese (TTS, SSML, streaming), voice agents em tempo real, orçamento de latência e barge-in, clonagem de voz, pipelines de áudio, voz no navegador e on-device, avaliação, segurança e acessibilidade, do básico ao muito avançado.

IA como multiplicador de produtividade para quem já programa, sem abrir mão de qualidade e segurança.

Geração, dublagem e edição assistida por IA: um pipeline profissional do briefing à entrega.

Áudio, vídeo e imagem com IA integrados num pipeline único, do prompt ao portefólio.

A face técnica da geração de imagem: como a difusão funciona, os parâmetros (steps, CFG, sampler, seed), rodar localmente, o grafo do ComfyUI, controle fino (img2img, inpainting, ControlNet, IP-Adapter), treinar LoRAs, vídeo, pipelines de produção, e direitos/ética, do básico ao muito avançado.

Prompt injection, agência excessiva, RAG e segurança de agentes e MCP: red teaming, guardrails e governança, do básico ao muito avançado.

Avaliação offline e online, LLM-as-judge, RAGAS, tracing e CI de prompts: operar e medir IA em produção, do básico ao muito avançado.

Princípios, NIST AI RMF, ISO/IEC 42001 e o EU AI Act (risco, alto risco, GPAI): fairness, FRIA, model cards e o programa na prática, do básico ao muito avançado.

É a área com maior densidade de discurso e menor prazo de validade de qualquer afirmação concreta. Por isso esta apostila tem uma regra: não afirma o que os modelos conseguem — afirma o que decide se conseguem, e como reconhecer que mudou. A aritmética da composição de erros, a integração como verdadeiro gargalo, o que a delegação faz a quem delega, e quatro cenários para 2032. Inclui o capítulo desconfortável: o que esta apostila tem razões para não querer dizer.

Formato compacto: o mínimo para programar bem com IA — prompts, contexto, revisão, testes e limites — remetendo às apostilas completas onde aprofundar.

Formato compacto: sequência e codecs, edição em 3 pontos e JKL, trim tools, Lumetri, Essential Sound e export — o essencial para montar, com ponteiros para aprofundar.

JavaScript, TypeScript, React e Next.js do zero, para quem já sabe HTML e CSS.

De HTML e CSS a aplicações React de produção, com foco profissional.

React Server Components, Prisma e autenticação: full stack sénior com TypeScript e Next.js.

APIs Python de alta performance, do primeiro endpoint à arquitetura pronta para produção.

O básico que ainda derruba metade das interfaces corporativas, do zero ao mercado de trabalho.

Interfaces que respiram: animações, SVG, CSS moderno e o impacto da IA no front-end.

CSS utilitário sem enrolação, do primeiro utility-class ao design system em produção.

Prototipagem responsiva e consistente sem reinventar a roda a cada projeto.

Colaboração sem caos: controlo de versões do básico ao avançado, focado no mercado de trabalho.

Estruturas de dados, complexidade e os padrões que decidem entrevistas técnicas.

Ainda move grande parte da web empresarial, do zero ao mercado de trabalho.

Robustez orientada a objetos para sistemas críticos, do básico ao avançado.

A pilha que sustenta a banca, os seguros e a logística — e sobre a qual quase tudo o que se lê descreve uma versão que já não existe. Do record às threads virtuais, da auto-configuração do Spring Boot ao reservatório de ligações que explica a latência que ninguém localiza. Inclui uma demo interativa: 800 ms desmontados em seis medições, terminando na «melhoria» que piorou o sistema.

Glossário avançado de UI/UX e front-end: HTML, CSS, JS, Atomic Design e acessibilidade.

Front-end, design de interfaces e o impacto da IA na Web, num só percurso até ao mercado.

Android & iOS: do zero ao sénior, para equipas que querem levar o produto ao bolso do cliente.

Um código, duas lojas: mobile multiplataforma comparado lado a lado, do zero ao mercado.

Narrativas que se movem com o scroll: Intersection Observer, GSAP e frameworks modernos.

Do monólito modular ao distribuído: acoplamento, estilos, saga, CQRS, escala, resiliência e a entrevista de system design, do básico ao muito avançado.

Semântica HTTP, design RESTful, OpenAPI, modelo de erros, GraphQL, gRPC, segurança (OWASP API Top 10) e versionamento, do básico ao muito avançado.

Montar a loja resolve-se numa tarde; o difícil é tudo o que acontece entre o clique e a devolução. Catálogo e variantes, existências sem sobrevenda, checkout retomável, autorizar contra capturar, idempotência, SCA, IVA transfronteiriço, máquinas de estados e logística inversa — incluindo as obrigações europeias que o material americano não menciona. Demo: 60 segundos de Black Friday e as cinco avarias que revela.

Sintaxe minimalista, interfaces, erros como valores, concorrência com goroutines e context, serviços HTTP/gRPC, Docker distroless e runtime, do básico ao muito avançado.

Ownership e borrow checker, enums e traits, Result e ?, concorrência sem data races, async, cargo e as trilhas de CLI, WASM e FFI, do básico ao muito avançado.

TDD, test doubles, testes de contrato e integração com Testcontainers, Playwright para E2E, property-based e mutation testing, e testes na era da IA, do básico ao muito avançado.

Código legado é código sem testes — e código sem testes é código que ninguém tem coragem de mudar. Doze capítulos sobre o trabalho que é a maior parte do trabalho: caracterizar um sistema que não se percebe, montar uma rede de segurança antes de mexer, quebrar dependências, refatorar em passos pequenos de mais, substituir o que não se pode desligar e migrar dados sem parar nada. Com uma demo ao vivo de uma função de 300 linhas desmontada em seis movimentos — e um bug de quatro anos resolvido pelo caminho.

Sistema de arquivos e permissões, pipes e grep/sed/awk/jq, processos e sinais, quoting, scripts robustos e as ferramentas do dia a dia (ssh, rsync, tmux, systemd), do básico ao muito avançado.

Programar isto não é programar com menos memória: é programar sob restrições que não existem do outro lado — e a primeira é que não há como desfazer. Ler sensores sem acreditar neles, comandar potência sem destruir hardware, o que tempo real significa mesmo, controlo em malha fechada sem misticismo, o orçamento de energia que decide o produto, e como falhar bem quando ninguém lá está. Com uma demo ao vivo de um sensor ruidoso a virar um comando que não estraga o compressor.

O DevTools do browser a fundo (Elements, Sources, Network, Performance, Memory), o debugger do editor e do Node, os DevTools de frameworks e o ferramental de rede e bundle, do básico ao muito avançado.

Formato compacto: os fundamentos de JS moderno como checklist — tipos, escopo, this, async, classes, módulos e armadilhas. Aponta as apostilas completas para aprofundar.

Os ideais do local-first, o modelo de dados no dispositivo, resolução de conflito, CRDTs a fundo, Yjs/Automerge e sync engines, persistência e transporte no cliente, colaboração em tempo real (presence, rich text, undo), sync com backend autoritativo e produção, do básico ao muito avançado.

Anatomia de um workflow, n8n na prática, integrar qualquer API sem SDK, webhooks, idempotência e tratamento de erro, IA dentro do fluxo (classificar, rotear, agentes), padrões de automação de negócio, operação em produção e governança, do básico ao muito avançado.

O que blockchain resolve (e o que não), como funciona por baixo, Ethereum/EVM e L2s, smart contracts em Solidity com Foundry, a segurança onde um bug custa milhões, dApps com viem/wagmi, DeFi/NFT/DAO, escala e o stack, e produção (custódia, regulação, ética), do básico ao muito avançado.

Prospectiva da disciplina, não da carreira: o gargalo que se deslocou de escrever para verificar, o problema da garantia quando ninguém lê todo o código, o que a história da abstração realmente ensina, o código que ninguém escreveu e a pressão por rastreabilidade. Quatro cenários para 2032 — e seis ações que valem em todos eles.

Do primeiro docker run à operação de clusters em produção, com GitOps e observabilidade.

O IP não garante nada — nem que chegue, nem por ordem, nem uma só vez. Tudo o que parece fiável é fiabilidade construída por cima de uma base que não a oferece, e perceber isso é o que permite diagnosticar o que corre mal. Camadas, endereços e encaminhamento, TCP contra UDP, DNS e a «propagação» que não existe, HTTP e cache, TLS e o que fica visível apesar da cifra, e porque latência é distância. Com uma demo ao vivo das sete etapas entre carregar Enter e ver a primeira letra.

Da linha de comando ao pipeline blindado: pentest, cloud security e Zero Trust.

Do primeiro deploy à arquitetura em produção na plataforma que move a web moderna.

O backend inteiro sobre PostgreSQL: base de dados, autenticação, storage e tempo real.

Visibilidade e alocação, unit economics, commitments, rightsizing e cultura de custo: o FinOps Framework completo, do básico ao muito avançado.

Rightsizing, spot, commitments, egress, storage, warehouse, Kubernetes e custo de inferência de LLM (tokens, GPU, caching), do básico ao muito avançado.

Logs, métricas e traces, OpenTelemetry, Prometheus e PromQL, SLI/SLO/error budget, alerting, on-call e gestão de incidentes, do básico ao muito avançado.

Terraform / OpenTofu, state, módulos, CI/CD de infra e policy as code, mais Internal Developer Platform, golden paths e GitOps, do básico ao muito avançado.

Prospectiva do equilíbrio entre ataque e defesa: a assimetria e o que a automação lhe faz em cada fase, o elo humano agora personalizável em escala, a cadeia de fornecimento, a transição pós-quântica reformulada pela longevidade do segredo, e a responsabilidade legal a mudar de mãos. Quatro cenários para 2032 e sete ações que resolvem a maioria em todos eles.

Do wireframe ao design system, do zero ao avançado, para o mercado de trabalho.

Vetores profissionais para marcas que não se apagam, do básico ao avançado.

Edição de imagem de nível profissional, atualizada até ao muito avançado.

Do posicionamento à identidade visual, do básico ao avançado, para marcas que não se apagam.

Anatomia da letra, classificação, escolha e pareamento de fontes, escala e hierarquia, tipografia web com CSS, fontes variáveis, OpenType, acessibilidade e tokens, do básico ao muito avançado.

Percepção, modelos e espaços (RGB, HSL, OKLCH, CMYK, gamutes), teoria e harmonias, construção de paleta com escalas OKLCH, acessibilidade e daltonismo, cor em CSS e tokens, e cor para web, jogos e animação, do básico ao muito avançado.

Espaço em branco e Gestalt, C.R.A.P., escala de espaçamento base 4/8, sistemas de grade, hierarquia e composição, Flexbox e Grid, responsivo com container queries e primitivas de layout, do básico ao muito avançado.

O que é um design system, design tokens e a spec do W3C, as três camadas (primitivo/semântico/componente), temas e white-label, pipeline com Style Dictionary, componentes, governança e a ponte com o Figma, do básico ao muito avançado.

Tipos de logo, processo e ideação, construção vetorial e a verdade sobre grelhas, ajuste óptico, monogramas e lettermarks, wordmarks e lettering custom, sistema de versões e logo responsivo, teste e entrega, do básico ao muito avançado.

A metade do ofício que quase ninguém ensina: converter o briefing em critérios verificáveis antes de mostrar, construir o rationale, escolher entre territórios e opções, a ordem da apresentação, traduzir o feedback do sintoma ao problema real, e conduzir o ciclo de revisões sem sangrar. Com tabela de tradução, oito situações difíceis e guiões prontos.

As pessoas não sabem dizer o que querem — e o método existe por causa disso. Doze capítulos sobre recrutar quem interessa, entrevistar sem ensinar a resposta, observar o que ninguém conta, testar usabilidade a sério e transformar doze horas de gravação em decisões que a equipa aceita. Com uma demo ao vivo de uma pergunta de inquérito a fabricar o próprio resultado, e o capítulo de ética que decide se pode usar o que recolheu.

Numa aplicação, quase tudo o que se vê são palavras — e são a única parte que costuma ser escrita depois de tudo estar decidido. Doze capítulos sobre botões que prometem o que fazem, formulários que não acusam, mensagens de erro com as três partes que resolvem, os estados que ninguém desenha, tom de voz sem cair na personalidade, e a microcópia que não é frase — datas, plurais, nomes. Com uma demo ao vivo do mesmo ecrã reescrito cinco vezes.

Onde a IA encaixa — e onde não encaixa — num processo de identidade: as quatro incompatibilidades que fazem a difusão falhar em logótipos, a fronteira entre explorar e construir, o custo real da vetorização automática, o ponto fraco das letras, e a distinção entre direito de autor e marca registada que decide o que você tem mesmo em mãos.

O movimento como atributo de identidade, ao lado da cor: em que difere do motion de interface, os quatro momentos (build-in, idle, transição, assinatura), a curva de aceleração como assinatura reconhecível, o som de marca, formatos e entrega, acessibilidade, e como documentar movimento em números para que outra pessoa o consiga reproduzir.

Função e mitos do ícone, grid e keyline shapes, estilos, desenho, ajuste óptico e consistência da família, SVG e acessibilidade, sistemas com tokens e pipeline, ícones em movimento e governança, do básico ao muito avançado.

Funções e custo do movimento, princípios da animação aplicados a UI, timing e easing, tipos de transição, coreografia, micro-interações, motion na web e performance, spec e handoff, motion tokens e reduced-motion, do básico ao muito avançado.

Papel da imagem na marca, estilo e sistema de ilustração, fundamentos de desenho, ilustração aplicada, fotografia e seleção, direção de arte, imagem + texto e otimização na web, e IA generativa num fluxo híbrido, do básico ao muito avançado.

Formato compacto: hierarquia, Gestalt, equilíbrio, contraste, ritmo, alinhamento, enquadramento e cor/valor — mais um panorama de linguagens visuais — remetendo às apostilas completas onde aprofundar.

Formato compacto: um checklist único que costura tipografia, cor, layout, composição, ícones, logótipo, imagem, motion e design system — cada seção é o resumo de uma apostila completa.

Projetar para o probabilístico: padrões de entrada e saída, streaming, confiança e fontes, tratamento de erro, human-in-the-loop e níveis de automação, latência e custo na interface, padrões de conversa e de agente, avaliação de UX, ética e componentes de IA, do básico ao muito avançado.

Princípios POUR, HTML semântico, foco por teclado, ARIA, contraste e formulários, testes com leitor de tela e o European Accessibility Act, do básico ao muito avançado.

Formato compacto: vetor e paths, a Pen tool, Pathfinder e Shape Builder, Appearance, tipografia e export — o essencial para trabalhar, com ponteiros para aprofundar.

Formato compacto: pixels e resolução, camadas e máscaras, seleções, ajustes não-destrutivos, Smart Objects, retoque e export — o essencial, com ponteiros para aprofundar.

O acabamento que separa o competente do impecável: layout intrínseco (container queries, subgrid, :has()), tipografia fluida e variable fonts, cor perceptual (oklch, color-mix, APCA), composição com blend e máscara, os oito estados, movimento nativo (view transitions, scroll-driven) e performance percebida como decisão de design.

Prospectiva, não previsão: o método (sinal ≠ tendência ≠ incerteza), o inventário do que já acontece, cinco forças em curso (IA no processo, interfaces adaptativas, o visitante que é um agente, a plataforma engolindo o framework, regulação e o pêndulo estético), quatro cenários para 2032 e o que provavelmente não vai mudar.

Modelação 3D do zero ao mercado de trabalho.

O motor por trás de jogos e simulações imersivas, do zero ao mercado de trabalho.

De GLB e glTF a um personagem interativo: câmara, animações, hotspots, AR e publicação acessível, com demonstração guiada pelo scroll.

3D no browser, do zero ao estado da arte.

WebGL, Three.js, GSAP e WebGPU organizados numa trilha única até ao portefólio que contrata.

A próxima camada da aprendizagem imersiva, do zero ao mercado de trabalho.

Formato compacto: navegação, G/R/S e Apply Transform, Edit Mode, modifiers, Principled BSDF, luz, Eevee/Cycles e export glTF/FBX — o essencial, com ponteiros para aprofundar.

Formato compacto: GameObject/Component, o ciclo de vida do MonoBehaviour, prefabs, física, UI, URP e build — o essencial, com ponteiros para aprofundar.

A ponte entre a apostila de C# e a de Unity: ciclo de vida, serialização, o null falso, corrotinas e Awaitable, eventos, alocações e GC, Jobs e Burst, IL2CPP, stripping e domain reload.

Unity além dos jogos: arquitetura testável, UI Toolkit, dados em tempo real (REST, MQTT), pipeline de CAD/BIM, performance de sessões longas, Unity as a Library, XR e um gêmeo digital de ponta a ponta.

VR e realidade mista standalone em Unity: OpenXR e Meta XR SDK, conforto e locomoção, controles e mãos, passthrough e compreensão da sala, o orçamento de cada quadro, medição no headset, multiplayer colocalizado e publicação na loja.

AR/VR/MR e o ecossistema (Vision Pro, Quest, Android XR), conforto e frame rate como saúde, interação por mãos/olhar/voz, UI espacial e âncoras, WebXR com three.js/R3F, assets 3D e performance, plataformas nativas, occlusion e multiusuário, e a ética do XR, do básico ao muito avançado.

Design de VR independente de plataforma: presença, o corpo como interface, locomoção como decisão de design, mãos, espaço e som, narrativa imersiva, casos de treino, saúde e arquitetura, testes com pessoas, ética e inclusão.

A API gráfica moderna da web e os compute shaders: o modelo adapter/device/queue, a linguagem WGSL e workgroups, compute e render pipelines, performance e memória, ML no navegador, simulação e visualização massiva, e a produção (fallback, device lost, limites), do básico ao muito avançado.

Prospectiva da indústria: o método, o inventário do presente, cinco forças (a economia do AAA sob tensão, ferramentas melhores com times menores, IA na produção, o jogo como lugar, distribuição e atenção), quatro cenários para 2032 e o que provavelmente não vai mudar.

O ofício entre a ferramenta e o mercado: o designer desenha as regras, não o divertimento. Verbos e os três loops, escolhas significativas e a estratégia dominante que as mata, economia interna com torneiras e ralos, equilíbrio medido com escolha e hesitação, a diversão como aprendizagem, o espaço que ensina, e a linha ética da recompensa — com oito casos e a disciplina de testar com pessoas.

Não como escrever uma história, mas como fazer uma que se joga: ludonarrativa, agência e estruturas de escolha, narrativa ambiental, diálogo e barks, estado narrativo com Ink, missões, narrativa emergente e oito casos.

Quando modelar deixa de ser o gargalo: geração text→3D, captura e gaussian splatting, fluxos procedurais, a convergência tempo real × offline, padrões de pipeline e a economia de ativos — quatro cenários para 2032 e o que não muda no ofício.

O custo de produzir uma imagem plausível caiu a quase zero — e é só isso que o sinal diz. Não diz que é boa, que serve, nem que quem a produziu sabe julgá-la. A proveniência como novo atributo, as duas perguntas jurídicas que não são a mesma, a inundação que faz o piso subir e o meio esvaziar-se, e as três velocidades do som, da imagem e do vídeo. Quatro cenários para 2032, oito posições analisadas, e o problema do degrau de entrada dito sem eufemismo.

Prospectiva a partir de trinta anos de previsões falhadas: as cinco barreiras e a única que não cedeu, o problema da tarefa-âncora, onde a tecnologia funciona mesmo (treino, saúde, projeto, campo) e a RA de massa que já aconteceu — no telemóvel. Quatro cenários para 2032 e a regra que vale muito além do tema: nunca prever adoção a partir de uma demonstração.

Publicar jogos Unity no navegador com build leve e carregamento honesto: onde o tempo vai, orçamento de tamanho, stripping, assets, compressão e servidor, Addressables e tela de loading. Depois, empacotar para o LMS (SCORM 1.2/2004) e registrar a aprendizagem com xAPI, LRS e cmi5, com desenho de evidência, LGPD e acessibilidade, do básico ao muito avançado.

Unity como peça de sites reais: a ponte JavaScript ↔ C# nos dois sentidos, React e Next.js sem vazar memória, canvas responsivo, input que não briga com a página, mobile web, WebGPU, acessibilidade e o funil de medição.

Da anatomia percepção-decisão-ação aos modelos de visão-linguagem-ação, simulação e o gap sim-to-real, dados de robótica, controlo híbrido e segurança, humanoides e o que já funciona versus o que ainda é promessa.

Do básico ao expert em growth mensurável, com métricas que importam.

Google Ads, Meta, TikTok e LinkedIn com profundidade técnica real, do planeamento à escala.

O catálogo já ensina a comprar atenção — esta apostila trata de a manter. Consentimento à luz da lei portuguesa (onde quase todo o material internacional descreve o regime contrário), entregabilidade, modelo de dados, ciclo de vida, coortes e a aritmética de decidir quando não enviar. Inclui demo interativa: a melhor campanha do ano desmontada em seis verificações, até se descobrir que valeu menos do que zero.

Ser encontrado por humanos e por motores de IA, do zero ao avançado.

Criação e gestão de canal com estratégia, não com improviso.

A ciência por trás de histórias que convencem: pitch, vendas e narrativa com dados.

Do briefing ao guião de produção: formatos (duas colunas, podcast, storyboard instrucional, ramificado), escrever para o ouvido, imagem e palavra, vídeo curto, e-learning, e legendas e audiodescrição pensadas desde o guião.

A ciência por trás da motivação intrínseca, do básico ao avançado.

A pedagogia que sustenta os nossos próprios ecossistemas de formação corporativa.

Cultura e tipos de experimento, feature flags (separar deploy de release), a anatomia de um A/B test, a estatística sem dor (poder, MDE, SRM), rodar o experimento certo, a hierarquia de métricas, desenhos além do A/B (redes, holdouts, bandits), a plataforma e as armadilhas éticas, do básico ao muito avançado.

Prospectiva do setor: IA como tutor e como fábrica de conteúdo, a credencial sob pressão, o ciclo de requalificação encurtando, quem paga, e — o capítulo central — o que cinquenta anos de tecnologia educacional nunca resolveram. Quatro cenários para 2032.

Prospectiva das carreiras técnicas, sem pânico e sem "vai ficar tudo igual": a automação do trabalho de conhecimento, o degrau de entrada sob pressão, a geografia do trabalho, a forma da empresa e o que a automação não absorve. Quatro cenários para 2032 — e a estratégia que vale nos quatro.

Há décadas de vídeos de robôs a dar cambalhotas e uma adoção real concentrada em armazém, indústria, agricultura e inspeção. Esse descompasso não é falha de execução: é informação sobre o que separa demonstração de adoção. O paradoxo de Moravec, a manipulação como verdadeiro gargalo, as seis parcelas do custo que não seguem a curva do software, e a escassez demográfica que empurra sozinha. Quatro cenários para 2032, e uma demo ao vivo de um sinal banal a virar decisão de investimento.

O outro futuro do trabalho: não a carreira, mas a estrutura. Por que existem empresas e o que acontece quando coordenar barateia, a diferença entre coordenar e alinhar, o problema de medir trabalho de conhecimento e a vigilância como resposta preguiçosa, o híbrido por atividade e a camada média sob pressão. Quatro cenários para 2032 e sete ações robustas.

Prospectiva do campo que promete mudar comportamento: o esgotamento da gamification superficial, a economia da atenção sob escrutínio, a regulação chegando ao design da escolha, a persuasão personalizada por IA e o campo aplicado (saúde, dinheiro, trabalho). Quatro cenários para 2032 — e uma bússola ética que vale em todos eles.

Prospectiva de duas coisas em risco ao mesmo tempo: o tráfego que vem da busca e a capacidade de saber o que funcionou. A resposta antes do clique (analisada por intenção, não por volume), o colapso da atribuição, a inversão da economia do conteúdo, a descoberta fragmentada e a pressão regulatória. Quatro cenários para 2032 e seis ações que valem em todos.

Prospectiva da transação, não da atração: o que muda quando quem lê a ficha é uma máquina, a taxa efetiva que só sobe, os trilhos de pagamento e a regulação, o custo de servir e as devoluções, e a confiança que se degrada quando as avaliações deixam de ser verificáveis. Quatro cenários para 2032, com a margem como fio condutor.

Da pergunta vaga ao plano de análise: enunciar o problema, árvores de questões e MECE, hipóteses, priorização, síntese (Princípio da Pirâmide) e as armadilhas cognitivas, do básico ao muito avançado.

Proporcionar a crença à evidência: avaliar uma afirmação, um número, um estudo, uma fonte e uma história causal — vieses, falácias e o ambiente de desinformação e IA, do básico ao muito avançado.

Produzir números quando não há dado: quebrar em fatores, estimativa de Fermi, ordens de grandeza, intervalos em vez de ponto, classes de referência e conta de guardanapo para negócio, do básico ao muito avançado.

Escolher bem sem ter certeza: gerar opções de verdade, valor esperado e quando ele é a ferramenta errada, portas reversíveis, valor da informação, pré-mortem e critérios de abandono, do básico ao muito avançado.

A estrutura por trás do comportamento: estoques e fluxos, ciclos de reforço e de equilíbrio, atrasos, arquétipos de sistema, por que a intervenção óbvia tem efeito contrário e os pontos de alavancagem, do básico ao muito avançado.

Construir um caso que se sustenta: premissas e conclusão, validade e força, mapa de argumento, a premissa oculta, raciocínio condicional, definições, e discordar de forma produtiva (steelman, double-crux), do básico ao muito avançado.

Transformar análise em documento que move decisão: BLUF e a pirâmide, títulos que afirmam, o parágrafo de uma ideia, raciocínio auditável, precisão sem falsa confiança, e a revisão por outline reverso, do básico ao muito avançado.

Investigar por que algo falhou e evitar que volte: cultura sem culpa, linha do tempo de fatos, 5 porqués e Ishikawa, o modelo do queijo suíço, teste de contrafactual e a hierarquia de controles, do básico ao muito avançado.

Prever com número, data e placar: calibração vs. resolução, o Brier score, a visão de fora e a decomposição, atualização incremental, os hábitos do superforecaster e a previsão em grupo, do básico ao muito avançado.

Escolher a lente certa e reconstruir a partir do fundamental: analogia vs. primeiros princípios, o mapa não é o território, um kit de ~14 modelos com domínio de validade, a heurística de roteamento e a inversão, do básico ao muito avançado.

Raciocínio estratégico quando o outro também pensa em você: ler um jogo e seus payoffs, estratégias dominantes, equilíbrio de Nash, os jogos-modelo do trabalho, jogos repetidos, compromisso crível e barganha (BATNA), do básico ao muito avançado.

Preparar, conduzir e fechar criando valor antes de dividir: interesses vs. posições, BATNA e ZOPA, ancoragem, trocas multi-questão, concessões calibradas, a camada humana, táticas comuns e defesas, e o pós-acordo, do básico ao muito avançado.

Fazer um número ser entendido e virar decisão por quem não é analista: conhecer a audiência, uma mensagem por gráfico, tornar o número tangível, o arco de uma apresentação de dados, enquadramento honesto e dashboard ≠ história, do básico ao muito avançado.

Da pergunta à síntese defensável: definir a pergunta de pesquisa, planejar a busca, onde procurar e em que ordem, um sistema de notas, resolver contradições entre fontes, saber quando parar (saturação) e sintetizar — que não é resumir, do básico ao muito avançado.