Engenharia de software
para a era da IA.

Fundamentos da IA

Do zero ao LLM — entenda como a IA realmente funciona

• O que é Inteligência Artificial?
• Dados: o Combustível da IA
• Como a IA Aprende (Machine Learning)
• Redes Neurais: o Cérebro Artificial
• + 3 posts

IA Além do LLM

KV Cache, MoE, Tool Calling, avaliação — como modelos funcionam em produção

• KV Cache: Memória Eficiente
• Mixture of Experts (MoE)
• Tool Calling e Agentes
• Harness: a Infraestrutura do Agente
• + 1 posts

Ferramentas de IA para Código

Claude Code, Codex, Cursor, Kiro — as diferenças reais entre os coding agents

• O Panorama dos Coding Agents
• Claude Code: Filosofia e Arquitetura
• OpenAI Codex: o Agente na Nuvem
• Cursor, Copilot e os IDEs Aumentados
• + 2 posts

AWS Cloud Practitioner

Fundamentos da AWS alinhados ao exame CLF-C02 — do zero ao certificado

• O que é Cloud Computing?
• Infraestrutura Global: Regiões, AZs e Edge
• Modelo de Responsabilidade Compartilhada
• IAM: Identidade, Grupos, Roles e Policies
• + 13 posts

AWS Solutions Architect Associate

Arquitetura profissional de soluções AWS alinhada ao exame SAA-C03

• SAA-C03: Da Teoria à Arquitetura Real
• IAM Avançado: Policies JSON, STS e Organizations
• VPC em Profundidade: NAT, Peering e Transit Gateway
• Route 53, CloudFront e Global Accelerator
• + 16 posts

Como Aprender

Psicologia do aprendizado: as técnicas com maior evidência científica para fixar conhecimento de verdade.

• Revisão Espaçada: a técnica mais eficaz do mundo
• Recall Ativo: por que reler é quase inútil
• Técnica Feynman: se não explica, não entendeu
• Interleaving: por que misturar tópicos é melhor
• + 2 posts

DevOps & Containers

Docker e Kubernetes do zero ao avançado — os dois pilares de toda infra moderna, explicados para durar.

• Docker Completo: do zero ao production-ready
• Kubernetes Completo: do Pod ao cluster de produção
• GitHub Actions: CI/CD profissional do zero
• Jenkins Pipelines: o CI/CD da era enterprise
• + 2 posts

Engenharia de Software Moderna

SDD, gerenciamento e criação de agents, testes profissionais, segurança real e arquitetura — deixar de ser coder e virar engenheiro de software de verdade.

• Engenheiro vs Coder: o que mudou na era dos agents
• Spec-Driven Development (SDD): a nova espinha dorsal
• Gerenciando Agents: orquestração, contexto e custo
• Criando Agents Customizados: do subagent ao MCP
• + 3 posts

Engenharia AI-Native

RAG real, agent patterns, MCP, LLMOps, evaluation — o que separa um protótipo de IA de um sistema AI-native em produção.

• RAG: por que "só jogar tudo no LLM" não funciona
• Chunking e Embeddings: as decisões que fazem ou quebram seu RAG
• Hybrid Search + Reranking: do BM25 ao cross-encoder
• Avaliando RAG: recall@k, nDCG e LLM-as-judge
• + 6 posts

Sistemas Distribuídos

CAP, consensus, idempotência, sagas, event sourcing — a base técnica que separa "funciona no localhost" de "funciona com 3 nós e 1000 req/s".

• CAP e PACELC: o teorema que define toda arquitetura distribuída
• Modelos de Consistência: strong, eventual, causal, read-your-writes
• Consensus e Raft: como nós discordam e chegam a acordo
• Idempotência e Retries: o antídoto pra rede que quebra
• + 4 posts

Observabilidade & SRE

Métricas RED/USE, OpenTelemetry, SLOs, error budgets, incident response — o que separa "fazer deploy" de operar sistema em produção.

• Observability: os 3 pilares (logs, métricas, traces) e por que não basta
• Métricas RED e USE: os frameworks que cobrem 90% dos casos
• OpenTelemetry end-to-end: instrumentação app → backend
• Logs Estruturados: JSON, correlation IDs e levels com propósito
• + 3 posts

Fundamentos Técnicos

CLI, Git, HTTP, SSH, JSON/YAML — a base inegociável que todo dev precisa antes de qualquer outra coisa.

• Como o computador roda seu código (do teclado ao pixel)
• Linux no terminal: os 30 comandos que valem por 300
• Filesystem e permissões: rwx, chown, symlink, hardlink
• Processos, jobs, sinais: como o SO organiza execução
• + 7 posts

Claude & Anthropic na Prática

Do terminal ao deploy: tudo sobre Claude Code, API da Anthropic, MCP, hooks, prompt engineering e como usar IA da Anthropic em workflows profissionais reais.

• O ecossistema Anthropic: Claude, modelos, produtos e roadmap
• Claude Code: instalação, autenticação e primeiro uso real
• Modos de uso: interativo, não-interativo, pipe e headless
• CLAUDE.md: como dar memória, contexto e personalidade ao agente
• + 8 posts

SQL & Databases

SQL real com PostgreSQL: JOINs, índices, EXPLAIN ANALYZE, transações ACID e modelagem de dados. A base que todo backend developer precisa antes de escalar.

• Relacional vs NoSQL: quando cada um ganha
• SELECT e JOIN na prática: INNER, LEFT, self-join
• GROUP BY, HAVING e agregações que resolvem 80% dos casos
• Window functions: ranking, running totals, lead/lag
• + 6 posts

Como o Computador Funciona

CPU, memória, processos, I/O, containers por baixo. O modelo mental que transforma debugging de "mistério" em ciência — e faz você entender observabilidade, performance e sistemas distribuídos de verdade.

• CPU: pipeline, cache L1/L2/L3, branch prediction
• Memória: stack, heap, virtual memory, page fault
• Syscalls: a fronteira entre user-space e kernel
• File descriptors e I/O: o que todo processo compartilha
• + 5 posts

Redes & Web

TCP/IP, HTTP/1-2-3, TLS, DNS, CORS — o que acontece entre o teclado e a resposta. A fundação que faz arquitetura de nuvem, APIs e observabilidade fazerem sentido.

• OSI e TCP/IP: as camadas que explicam tudo
• TCP de verdade: handshake, congestion control, retransmissão
• UDP, QUIC e HTTP/3: por que Google jogou TCP fora
• HTTP/1.1, /2, /3: multiplexing, HPACK, server push
• + 5 posts

O que é Inteligência Artificial?

Do conceito à realidade: o que é IA, o que não é, e por que você precisa entender isso agora.

Dados: o Combustível da IA

Por que "dados são o novo petróleo" — e o que isso significa na prática para treinar um modelo.

Como a IA Aprende (Machine Learning)

Gradiente descendente, loss function, backpropagation — explicados sem complicar.

Redes Neurais: o Cérebro Artificial

Neurônios, camadas, ativações — a arquitetura que imita (e supera) o cérebro em tarefas específicas.

O que é um LLM?

Large Language Models: o que os torna diferentes, como foram treinados e por que o ChatGPT foi um divisor de águas.

Tokens e Tokenização

A IA não lê palavras — ela lê tokens. Entenda o que isso muda em custo, velocidade e limites de contexto.

Transformers e Mecanismo de Atenção

A arquitetura que mudou tudo em 2017 — Attention Is All You Need e por que o transformer é onipresente.

KV Cache: Memória Eficiente

Por que um modelo de 30GB pode precisar de 60GB de VRAM — e como o KV Cache resolve isso.

Mixture of Experts (MoE)

200B parâmetros que não cabem na GPU — veja como o MoE ativa só o que é necessário.

Tool Calling e Agentes

Como a IA aprendeu a usar ferramentas externas — e por que isso transformou LLMs em agentes.

Harness: a Infraestrutura do Agente

Os 6 componentes que fazem um agente de IA funcionar de verdade.

Como Avaliar Modelos de IA

MMLU, HumanEval, benchmark contamination — como saber se um modelo é realmente melhor.

O Panorama dos Coding Agents

De Copilot ao Claude Code — como os assistentes de código evoluíram de autocomplete para agentes autônomos.

Claude Code: Filosofia e Arquitetura

Como o Claude Code funciona por dentro — o loop agêntico, as ferramentas, o modelo de confiança e por que é diferente dos IDEs.

OpenAI Codex: o Agente na Nuvem

O novo Codex (2025) é completamente diferente do antigo — roda em sandbox na nuvem, é assíncrono e paralelo. Entenda o que isso muda.

Cursor, Copilot e os IDEs Aumentados

A abordagem IDE-first — como Cursor e Copilot integram IA no editor e por que isso é uma filosofia diferente dos agentes de terminal.

Amazon Q e Kiro: a Aposta da AWS

O Amazon Q Developer e o novo Kiro têm filosofias distintas — um é extensão de IDE corporativo, o outro é spec-driven development.

O que é Cloud Computing?

IaaS, PaaS, SaaS, deployment models, economia de escala — o que a nuvem realmente muda e por que a AWS venceu.

Infraestrutura Global: Regiões, AZs e Edge

Regions, Availability Zones, Edge Locations, Local Zones, Wavelength — como a AWS distribui capacidade no planeta.

Modelo de Responsabilidade Compartilhada

O que é responsabilidade da AWS e o que é sua. A linha que cai em metade das questões de segurança do exame.

IAM: Identidade, Grupos, Roles e Policies

Users, Groups, Roles, Policies, MFA, root account — os blocos fundamentais de segurança na AWS.

Compute: EC2, Lambda e Containers

EC2 instance types, purchasing options, Lambda, Fargate, ECS e EKS — os serviços de compute que todo practitioner precisa dominar.

Storage: S3, EBS, EFS e Glacier

Object, block, file storage — S3 storage classes, EBS volume types, EFS, Glacier, Storage Gateway. Como escolher.

Databases: RDS, Aurora, DynamoDB e Redshift

Relacional vs NoSQL vs analítico. RDS, Aurora, DynamoDB, ElastiCache, Redshift — quando usar cada um no CLF-C02.

Networking: VPC, Route 53 e CloudFront

VPC, subnets, Internet Gateway, NAT, Route 53 DNS, CloudFront CDN, Direct Connect, VPN — a rede da AWS demistificada.

Segurança AWS: KMS, GuardDuty, Shield e WAF

KMS, Secrets Manager, GuardDuty, Shield, WAF, Inspector, Macie — o arsenal de segurança que cobre 30% do exame.

Monitoramento: CloudWatch, CloudTrail e Config

CloudWatch (métricas e logs), CloudTrail (auditoria de API) e Config (compliance) — o tripé de observabilidade.

Well-Architected: os 6 Pilares

Operational Excellence, Security, Reliability, Performance, Cost Optimization, Sustainability — o framework que guia toda decisão AWS.

CAF e os 7 Rs da Migração

Cloud Adoption Framework (6 perspectivas) e as 7 estratégias de migração — Rehost, Replatform, Refactor, Relocate, Retire, Retain, Repurchase.

Precificação, Free Tier e Planos de Suporte

Pay-as-you-go, Free Tier, Pricing Calculator, Cost Explorer, Budgets, TCO Calculator e os 4 Support Plans — tudo sobre a fatura da AWS.

Migração: Migration Hub, DMS, MGN e DataSync

Migration Hub, Application Migration Service (MGN), DMS, Application Discovery Service, DataSync e Mainframe Modernization — o arsenal de migração AWS.

IA e ML na AWS: Bedrock, SageMaker, Q e Amigos

SageMaker, Rekognition, Comprehend, Polly, Transcribe, Translate, Lex, Kendra, Bedrock e Amazon Q — o stack de IA da AWS para o CLF-C02.

Developer Tools: CodePipeline, CDK, CloudFormation e SAM

CodeCommit, CodeBuild, CodeDeploy, CodePipeline, CloudFormation, CDK, SAM, Amplify e X-Ray — os serviços de CI/CD e IaC da AWS.

Simulado CLF-C02 Comentado

20 questões no estilo oficial do exame, cada uma com explicação detalhada de por que a resposta certa é certa e as erradas são erradas.

SAA-C03: Da Teoria à Arquitetura Real

O que muda do Practitioner para o SAA-C03, os 4 domínios do exame, pré-requisitos e a mentalidade do arquiteto AWS.

IAM Avançado: Policies JSON, STS e Organizations

Policy JSON em profundidade, STS AssumeRole, cross-account access, AWS Organizations, SCPs, Identity Center (SSO).

VPC em Profundidade: NAT, Peering e Transit Gateway

VPC design real, subnets públicas/privadas, NAT Gateway vs NAT Instance, VPC Peering, Transit Gateway, PrivateLink, VPN vs Direct Connect.

Route 53, CloudFront e Global Accelerator

Route 53 routing policies (simple, weighted, latency, failover, geo, multi-value), CloudFront behaviors, Global Accelerator.

EC2 Profissional: Auto Scaling e Load Balancers

Purchasing options profundos, Auto Scaling Groups, ALB vs NLB vs GWLB, target groups, placement groups, health checks.

ECS vs EKS: Orquestração de Containers

ECS (Fargate vs EC2 launch type), EKS (Kubernetes managed), service discovery, service mesh, quando escolher cada um.

Serverless Avançado: Lambda, API GW e Step Functions

Lambda deep dive (cold start, concurrency, layers, destinations), API Gateway (REST vs HTTP), Step Functions workflows.

S3 Profundo: Classes, Lifecycle e Object Lock

Todas storage classes, lifecycle policies, versioning, replication (CRR/SRR), Object Lock, encryption (SSE-S3, SSE-KMS, SSE-C, CSE).

EBS, EFS e FSx: Quando Usar Cada Um

EBS volume types (gp3, io2, st1, sc1), snapshots, EFS performance/throughput modes, FSx Windows/Lustre/NetApp, Storage Gateway.

Bancos: Multi-AZ, Read Replicas e DynamoDB

RDS Multi-AZ vs Read Replicas, Aurora (cluster + Serverless v2), DynamoDB (GSI/LSI, DAX, Streams, on-demand vs provisioned).

Caching: ElastiCache, DAX e CloudFront

ElastiCache Redis vs Memcached, DAX para DynamoDB, CloudFront cache behaviors, patterns (cache-aside, write-through).

Messaging: SQS, SNS, EventBridge e Kinesis

SQS (Standard vs FIFO, DLQ), SNS (topic fanout), EventBridge (event bus, rules, schedules), Kinesis (Streams vs Firehose vs Analytics).

Segurança Avançada: KMS, Secrets Manager e WAF

KMS envelope encryption, CMK vs AWS managed key, Secrets Manager vs Parameter Store, WAF rules, Shield Standard vs Advanced.

Disaster Recovery: RPO, RTO e 4 Estratégias

Backup & Restore, Pilot Light, Warm Standby, Multi-Site Active-Active — custo vs RTO/RPO, AWS Backup, cross-region DR.

Otimização de Custos: RI, Savings Plans e Spot

Reserved Instances (standard/convertible), Savings Plans (compute/EC2), Spot Instances, Instance Scheduler, Trusted Advisor, Cost Allocation Tags.

Analytics: Athena, EMR, Kinesis e Glue

Athena (serverless SQL on S3), EMR (Hadoop/Spark), Kinesis Data Streams vs Firehose, Glue ETL, Redshift Spectrum, QuickSight.

Migração para o Arquiteto: DMS, SCT, MGN e DRS

DMS + SCT para migração de bancos heterogêneos, MGN para lift-and-shift, DRS para DR, DataSync, Transfer Family e Snow Family em cenários arquiteturais.

Rede Híbrida: Direct Connect, VPN, PrivateLink e VPC Endpoints

Direct Connect + VIFs, Site-to-Site VPN, Client VPN, PrivateLink, Gateway vs Interface Endpoints, Route 53 Resolver híbrido e Transit Gateway inter-region.

ML/IA para Arquiteto: SageMaker, Bedrock e Pipelines

Arquiteturas de inferência (real-time endpoint, serverless, async, batch), SageMaker + MLOps, integração com Bedrock e data lake alimentando pipelines de ML.

Simulado SAA-C03 Comentado

25 questões no estilo oficial SAA-C03 com explicações detalhadas. Arquitetura, decisões de design, trade-offs de custo e resiliência.

Revisão Espaçada: a técnica mais eficaz do mundo

Por que revisar 5 min hoje vale mais que estudar 2h amanhã — e como o algoritmo SM-2 do seu Hub aplica isso automaticamente.

Recall Ativo: por que reler é quase inútil

A diferença entre reconhecer e lembrar. Por que o quiz é mais poderoso que o grifo, e como praticar recall ativo todos os dias.

Técnica Feynman: se não explica, não entendeu

Como Richard Feynman aprendia qualquer coisa: ensinar para um iniciante imaginário expõe todas as lacunas.

Interleaving: por que misturar tópicos é melhor

Estudar A-A-A-B-B-B é intuitivo mas inferior a A-B-A-B-A-B. A ciência da variabilidade no aprendizado.

Deep Work e Pomodoro: o combo da concentração

Cal Newport + Cirillo: como criar blocos de foco profundo que realmente produzem conhecimento, sem queimar.

Hábito diário: como estudar sem depender de motivação

Atomic Habits aplicado ao aprendizado: sistema > motivação. Streak, fricção zero, identidade e o poder dos 5 minutos diários.

Docker Completo: do zero ao production-ready

Imagens, containers, Dockerfile, Compose, volumes, redes, multi-stage builds, segurança e otimização — tudo que um dev precisa saber sobre Docker em um só lugar.

Kubernetes Completo: do Pod ao cluster de produção

Arquitetura do control plane, Pods, Deployments, Services, Ingress, ConfigMaps/Secrets, Storage, RBAC, autoscaling, Helm e troubleshooting — o guia definitivo do K8s.

GitHub Actions: CI/CD profissional do zero

Workflows, jobs, matrix, reusable workflows, secrets, OIDC para cloud, cache inteligente, release automatizado e deploy em Kubernetes — GH Actions como plataforma de CI/CD séria.

Jenkins Pipelines: o CI/CD da era enterprise

Jenkinsfile declarativo, agents dinâmicos, shared libraries, Blue Ocean, credentials, integração com K8s e o porquê do Jenkins ainda ser o padrão em grandes empresas.

Azure DevOps Pipelines: CI/CD na Microsoft Cloud

Azure Pipelines em YAML, stages, approvals, environments, service connections, templates, variable groups e deploy em AKS + App Service com gate de aprovação.

Rancher: gerenciando múltiplos clusters K8s sem sofrer

Rancher Manager, RKE2, importar clusters, Fleet para GitOps multi-cluster, RBAC unificado, projetos, monitoring e quando Rancher vale (ou não) a pena.

Engenheiro vs Coder: o que mudou na era dos agents

Por que 80% do que você faz vai ser automatizado — e o que sobra como skill real: decompor problema, ler sistema, escrever spec, revisar PR de agent, tomar decisão de arquitetura.

Spec-Driven Development (SDD): a nova espinha dorsal

SDD não é documento morto: é spec executável que vira teste, código e PR. Anatomia de uma spec, workflow com agent, templates reais, controle de qualidade.

Gerenciando Agents: orquestração, contexto e custo

Agent não é mágica — é processo com contexto, memória, ferramentas, orçamento e política. Como orquestrar múltiplos agents, controlar token, definir limites e auditar resultado.

Criando Agents Customizados: do subagent ao MCP

Como criar agents de verdade: subagents com system prompt curto, integração com tools via MCP (Model Context Protocol), sandbox, permissões, ciclos de vida.

Testes Profissionais: pirâmide, propriedades, contrato e fuzz

Unit, integração, contrato, E2E, property-based, snapshot, mutation, fuzz, chaos. Qual usar, onde usar e por que cobertura sozinha mente.

Segurança de Software de Verdade: threat model ao SBOM

Threat modeling (STRIDE), OWASP Top 10 de verdade, secrets, supply chain (SBOM, SLSA, SHA pinning), shift-left vs shift-right, DAST/SAST/IAST.

Arquitetura Moderna: trade-offs, ADRs, C4 e evolução

Monolito modular vs microserviços, DDD pragmático, ADRs (Architecture Decision Records), modelo C4, evolução sem big-rewrite, fitness functions.

RAG: por que "só jogar tudo no LLM" não funciona

Retrieval-Augmented Generation na prática: limite de contexto, alucinação, arquitetura em dois estágios (retrieve → generate), quando RAG vence fine-tuning.

Chunking e Embeddings: as decisões que fazem ou quebram seu RAG

Fixed vs semantic vs recursive chunking, overlap, contextual retrieval, escolha de embedding (OpenAI, Voyage, BGE), redução de dimensão, cosine vs dot product.

Hybrid Search + Reranking: do BM25 ao cross-encoder

BM25 + vector, reciprocal rank fusion, cross-encoder reranking (Cohere, Jina, Voyage), HyDE, query expansion — o pipeline de retrieval de produção.

Avaliando RAG: recall@k, nDCG e LLM-as-judge

Golden dataset, métricas de retrieval (recall@k, MRR, nDCG), métricas de generation (faithfulness, context relevance, answer relevance), RAGAS, LLM-as-judge sem vazamento.

Agent Patterns: ReAct, Reflexion e Tree of Thoughts

ReAct (think-act-observe), Reflexion (self-critique), Tree of Thoughts, Plan-and-Execute, Router — padrões empíricos com quando cada um funciona e quando quebra.

Multi-Agent Systems: orchestrator-worker, swarms e handoffs

Orchestrator-worker, swarm com handoffs (OpenAI Swarm), CrewAI, hierarquias, quando multi-agent vale (e quando só aumenta custo).

Context Engineering: prompt caching, subagents e skills

Anthropic prompt caching, janela de contexto, compaction, subagent delegation, skills (Agent Skills), CLAUDE.md/AGENTS.md, context window budget.

MCP Deep Dive: construindo um servidor profissional

Model Context Protocol em profundidade: stdio vs HTTP, tools/resources/prompts, autenticação, rate limit, logging, exemplo real em TypeScript e Python.

LLM APIs em Produção: streaming, structured output, batch e cache

Streaming SSE, tool use, structured output com JSON schema/Zod, batch API (50% desconto), prompt caching, retry com jitter, rate limit handling.

LLMOps: eval harness, drift detection e canary de prompts

Eval harness (promptfoo, LangSmith, custom), regressão de prompt, canary/A-B de prompts, drift detection, cost attribution, SLO de qualidade.

CAP e PACELC: o teorema que define toda arquitetura distribuída

Partition tolerance, availability, consistency — e por que você sempre escolhe entre 2. PACELC estende para latência. Decisões reais: Dynamo vs Spanner, Cassandra vs HBase.

Modelos de Consistência: strong, eventual, causal, read-your-writes

Linearizability, sequential consistency, causal, eventual. Session guarantees (read-your-writes, monotonic reads, bounded staleness). Qual usar em cada cenário.

Consensus e Raft: como nós discordam e chegam a acordo

FLP impossibility, intuição do Paxos, Raft explicado (leader election, log replication, safety). Por que etcd, Consul, K8s, CockroachDB usam Raft.

Idempotência e Retries: o antídoto pra rede que quebra

Idempotency keys, exponential backoff com jitter, circuit breaker, deadline propagation, dedup via Redis/Postgres, at-least-once vs exactly-once.

Sagas vs 2PC: transações distribuídas sem perder o sono

Por que 2PC trava tudo, saga orchestration vs choreography, compensating actions, outbox pattern, idempotência nas compensações.

Event Sourcing e CQRS: quando eventos são a fonte da verdade

Event log como source of truth, projections, CQRS (command vs query), event store (Kafka, EventStoreDB), vantagens, armadilhas, quando evitar.

Postgres Profundo: MVCC, Isolation Levels e Locks

Como MVCC funciona por dentro, read committed vs repeatable read vs serializable, SELECT FOR UPDATE, advisory locks, VACUUM e bloat.

Rate Limiting Distribuído: token bucket, sliding window, Redis

Token bucket, leaky bucket, sliding window log, sliding window counter, implementação com Redis + Lua script atômico, distributed rate limit em produção.

Observability: os 3 pilares (logs, métricas, traces) e por que não basta

Os 3 pilares clássicos, por que "observability" > monitoring, cardinalidade, events como 4º pilar, profiles (pprof, Pyroscope) como 5º, o que realmente medir.

Métricas RED e USE: os frameworks que cobrem 90% dos casos

RED (Rate, Errors, Duration) para serviços, USE (Utilization, Saturation, Errors) para recursos, Golden Signals do Google SRE, quando aplicar cada um.

OpenTelemetry end-to-end: instrumentação app → backend

OpenTelemetry SDK (auto vs manual), Collector (receivers, processors, exporters), context propagation, resource detection, pipelines reais em Node, Python e Go.

Logs Estruturados: JSON, correlation IDs e levels com propósito

JSON logs, trace_id/span_id correlation, log levels (o que DEBUG, INFO, WARN, ERROR realmente significam), structured logging libs, formatter cost.

Distributed Tracing: spans, baggage e sampling strategies

Spans, parent-child, context propagation (W3C Trace Context), baggage, head vs tail sampling, probabilistic vs rule-based, Jaeger e Tempo comparados.

SLOs e Error Budgets: a contabilidade da confiabilidade

SLI → SLO → SLA, error budget, burn rate alerts multi-window/multi-burn, toil budget, política de freeze quando orçamento estoura.

Incident Response: comando, comunicação e postmortem blameless

Incident Commander, Comms Lead, Ops Lead, timeline, postmortem blameless, 5 whys, action items com SLA, learning review mensal.

Como o computador roda seu código (do teclado ao pixel)

Do clique de tecla ao pixel na tela: CPU, memória, sistema operacional, processo, e por que tudo isso importa para quem programa.

Linux no terminal: os 30 comandos que valem por 300

ls, cd, grep, find, pipe, redireção, man — os comandos que você vai usar todo dia com fluência real, não decoreba.

Filesystem e permissões: rwx, chown, symlink, hardlink

Como o Linux organiza arquivos, o que significa rwxr-xr-x, chown, chmod, ln -s vs ln — e por que isso quebra deploys.

Processos, jobs, sinais: como o SO organiza execução

PID, fork, exec, foreground/background, kill, SIGTERM vs SIGKILL, ps, top, htop — entenda o que roda no seu sistema.

SSH e chaves: como acessar máquinas remotas com segurança

Par de chaves RSA/Ed25519, ssh-keygen, authorized_keys, ssh-agent, config file, tunelamento — tudo que você precisa para nunca mais digitar senha.

Git de verdade: commit, branch, merge, rebase, reflog

Não só os comandos — o modelo mental de commits como snapshots, DAG de objetos, staging area, rebase vs merge, reflog como rede de segurança.

GitHub profissional: PR, review, issues, Actions básico

Fork vs clone, Pull Request, code review, issues, labels, milestones, GitHub Actions para CI/CD básico — o fluxo que empresas usam.

HTTP do zero: request, response, status, headers, cookies

GET, POST, PUT, DELETE, status codes, headers, cookies, CORS, REST vs GraphQL básico — o protocolo que move a web inteira.

DNS, TLS e certificados: o que acontece antes do seu request

Resolução DNS (recursivo, autoritativo, TTL), handshake TLS 1.3, certificados X.509, CA, HTTPS — tudo antes do seu código rodar.

JSON, YAML e variáveis de ambiente: config moderna

JSON e YAML como formatos universais de config, variáveis de ambiente e .env, 12-factor app — como configurar sistemas sem hardcode.

VSCode/Vim produtivos: atalhos, plugins, multi-cursor

Os atalhos de teclado que mudam tudo, plugins essenciais, multi-cursor, terminal integrado, Vim básico para quando não tem outra opção.

O ecossistema Anthropic: Claude, modelos, produtos e roadmap

Claude 3, 3.5, 4 — o que diferencia Haiku, Sonnet e Opus. API, Claude.ai, Claude Code, MCP: o mapa completo do que a Anthropic oferece e quando usar cada produto.

Claude Code: instalação, autenticação e primeiro uso real

Como instalar o Claude Code, autenticar com sua conta Anthropic, os primeiros comandos no terminal e como Claude Code difere de outros assistentes de IA.

Modos de uso: interativo, não-interativo, pipe e headless

Claude Code tem 4 modos principais. Interativo (chat), não-interativo (scripts), pipe (stdin/stdout) e headless (automação CI/CD). Quando e como usar cada um.

CLAUDE.md: como dar memória, contexto e personalidade ao agente

O CLAUDE.md é o arquivo que define como Claude age no seu projeto — comandos, contexto, regras e preferências. Como criar um CLAUDE.md eficaz e o que evitar.

Permissões e segurança: o que Claude pode e não pode fazer

Sistema de permissões do Claude Code: trust levels, o que é permitido por padrão, como configurar limites, sandbox e boas práticas de segurança ao usar IA no terminal.

MCP na prática: conectar Drive, GitHub, Slack e bancos de dados

Model Context Protocol (MCP) permite que Claude acesse ferramentas externas. Como configurar servidores MCP prontos para Google Drive, GitHub, Postgres, Slack e mais.

Hooks: automatizar revisões, validações e ações customizadas

Hooks são scripts que rodam automaticamente em eventos do Claude Code (antes/depois de editar, submeter, etc.). Como criar hooks para lint, testes, validação e notificações.

Skills e slash commands: criar seus próprios workflows

Skills são workflows customizados invocados via /nome-do-comando. Como criar skills para tarefas repetitivas: deploy, revisão de código, geração de documentação.

API da Anthropic: messages, streaming, vision, batch e cache

A API Messages da Anthropic: como enviar conversas, streaming de respostas, processar imagens, batch de milhares de requests e prompt caching para reduzir custo.

Prompt engineering para Claude: técnicas que realmente funcionam

Claude tem características únicas de prompt engineering. Chain-of-thought, XML tags para estrutura, prefill, few-shot, como evitar alucinações e extrair JSON confiável.

Claude em produção: custo real, rate limits, caching e segurança

Como operar Claude em produção: calcular e controlar custo por token, lidar com rate limits, implementar prompt caching, moderação de conteúdo e boas práticas de segurança.

Workflows profissionais: do problema ao resultado com Claude Code

Como estruturar workflows reais com Claude Code: spec → implementação → revisão → deploy. Casos práticos de uso no dia a dia — com e sem experiência em código.

Relacional vs NoSQL: quando cada um ganha

PostgreSQL vs MongoDB vs Redis vs DynamoDB: modelos de dados, trade-offs de consistência e quando a escolha importa de verdade.

SELECT e JOIN na prática: INNER, LEFT, self-join

Os JOINs que resolvem 90% dos problemas reais: INNER, LEFT/RIGHT, FULL OUTER, self-join para hierarquias, CTEs para legibilidade.

GROUP BY, HAVING e agregações que resolvem 80% dos casos

COUNT, SUM, AVG, GROUP BY, HAVING, ROLLUP — as funções de agregação que transformam dados brutos em métricas de negócio.

Window functions: ranking, running totals, lead/lag

ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD, FIRST_VALUE, SUM OVER — as funções de janela que eliminam subqueries e self-joins complicados.

Índices que funcionam: B-tree, hash, GIN, covering, composto

Quando um índice é usado (e quando não é). B-tree vs hash vs GIN, índice composto e a ordem importa, covering index para evitar heap scan.

EXPLAIN ANALYZE: lendo o plano e otimizando query

Seq Scan vs Index Scan vs Bitmap Scan, Nested Loop vs Hash Join vs Merge Join — como ler o plano de execução e transformar queries lentas em rápidas.

Transações e isolation levels: ACID sem decoreba

ACID não é decoreba — é o que evita dirty reads, non-repeatable reads e phantom reads. Read Committed, Repeatable Read, Serializable: quando usar cada um.

Modelagem e normalização: 1NF–3NF + quando desnormalizar

Primeira, segunda e terceira formas normais com exemplos reais. Quando desnormalizar intencionalmente (analytics, performance). ERD na prática.

Migrations profissionais: reversíveis, zero-downtime

Alembic, Flyway e Liquibase. Migrations reversíveis com up/down. Zero-downtime em produção: adicionar coluna nullable, backfill, NOT NULL depois.

Connection pool, N+1 e o que mata sua API

Por que 100 queries são piores que 1 query com JOIN. N+1 query problem e como detectar. PgBouncer, SQLAlchemy pool, asyncpg — configuração correta.

CPU: pipeline, cache L1/L2/L3, branch prediction

Fetch-Decode-Execute em detalhe, por que cache miss mata performance, como branch prediction funciona — e o que isso significa para o código que você escreve.

Memória: stack, heap, virtual memory, page fault

Stack vs heap, por que stack overflow acontece, virtual memory como abstração, page fault e swapping — como o SO gerencia memória de todos os processos.

Syscalls: a fronteira entre user-space e kernel

O que é uma syscall, por que trocar entre user mode e kernel mode tem custo, como strace revela o que seu programa faz de verdade.

File descriptors e I/O: o que todo processo compartilha

stdin/stdout/stderr como file descriptors, por que tudo é arquivo no Linux, pipes, redirecionamento — e como isso afeta performance de I/O.

I/O bloqueante, não-bloqueante, async: select/poll/epoll

Por que servidores web usam epoll em vez de um thread por conexão. Blocking vs non-blocking vs async I/O — o fundamento de event loops como asyncio e Node.js.

Threads vs processos vs fibras: modelo de concorrência

O que diferencia um thread de um processo no SO, context switch, por que green threads existem, e como Go goroutines e Python asyncio resolvem diferente.

Containers por baixo: namespaces e cgroups no Linux

Docker não é mágica — é Linux namespaces + cgroups + union filesystem. Entender isso explica por que containers são mais leves que VMs e como security funciona.

Serialização, endianness, UTF-8: os bytes que viajam

Por que "olá" tem bytes diferentes em UTF-8 e Latin-1. Big-endian vs little-endian. JSON vs Protobuf vs MessagePack — trade-offs de serialização.

Tempo distribuído: NTP, clock skew, monotonic vs wall

Por que relógios em servidores diferentes mentem. NTP e PTP, clock drift, por que nunca usar wall clock para medir duração, e como sistemas distribuídos lidam com tempo.

OSI e TCP/IP: as camadas que explicam tudo

Por que o modelo OSI de 7 camadas existe (e por que ninguém usa), como TCP/IP realmente funciona em 4 camadas, e o que cada camada encapsula.

TCP de verdade: handshake, congestion control, retransmissão

O 3-way handshake passo a passo, como TCP garante entrega ordenada, sliding window, slow start e congestion avoidance — por que TCP fica lento em alta latência.

UDP, QUIC e HTTP/3: por que Google jogou TCP fora

UDP não é TCP sem garantias — é um protocolo diferente. QUIC reimplementa confiabilidade em user-space sobre UDP, resolvendo head-of-line blocking do TCP.

HTTP/1.1, /2, /3: multiplexing, HPACK, server push

Por que HTTP/1.1 força 6 conexões paralelas por domínio, como HTTP/2 resolve com multiplexing, e o que HTTP/3 muda no transporte.

TLS 1.3: handshake, chaves, certificados, SNI, ALPN

O handshake TLS 1.3 em detalhe: ECDHE para troca de chaves, certificados X.509, SNI para virtual hosting, ALPN para negociar protocolo. Por que HTTPS é mais rápido hoje.

DNS: recursivo, autoritativo, registros, TTL, DNSSEC

O que acontece quando você digita um URL: resolver recursivo, root servers, TLD, authoritative. Registros A, AAAA, CNAME, MX, TXT, CAA. Cache e TTL.

Proxies, reverse proxies, load balancers L4 vs L7

Forward vs reverse proxy, Nginx como reverse proxy, load balancer L4 (TCP) vs L7 (HTTP), algoritmos de balanceamento, health checks e sticky sessions.

WebSocket, SSE, streaming: comunicação bidirecional

Long polling vs SSE vs WebSocket: quando cada protocolo se encaixa. O handshake de upgrade do WebSocket, back-pressure em streaming, e SSE para updates unidirecionais.

CORS, CSRF, cookies seguros: segurança web fundamental

Same-origin policy e por que existe, preflight CORS, CSRF tokens vs SameSite cookies, HttpOnly/Secure/SameSite — o mínimo de segurança web que todo dev precisa.