Em 2016, assisti uma palestra da IBM sobre o Watson, passei alguns finais de semana estudando e pensei: "Esse negócio de IA tem futuro."

Em 2018 criei um chatbot usando o IBM Watson. Ofereci para a Unimed Fortaleza. Eles gostaram muito da ideia e colocaram em produção. Foi um sucesso!

Mas toda vez que precisava testar uma ideia nova, ajustar o bot, experimentar abordagens diferentes, eu esbarrava no mesmo muro: era preciso programar.

Resultado? Dependia de terceiros pra tudo.

E quando você tá lidando com tecnologia nova - especialmente IA - precisa experimentar. Testar 10 coisas pra 1 funcionar. Pivotar rápido. Iterar sem parar.

O problema não era a IA - era eu.

Terceiros não funcionam nesse ritmo. Freelancer cobra por hora. Agência tem fila de 2 semanas. Sócio técnico quer equity.

Eu ficava preso.

A ficha que caiu

Não era óbvio na época. A galera falava que IA era hype, que ia passar.

Lembro de um caso engraçado: o dono de uma empresa que trabalhei só entendeu IA depois que fiz uma apresentação interna. Anos depois, encontrei ele no aeroporto. Contei que tinha entrado de cabeça na programação.

Resposta dele? "Justo agora que as IAs vão acabar com os programadores?"

Eu ri. Porque minha aposta era o oposto.

Eu sentia que IA não substituiria profissionais. Iria amplificar o que cada um faz melhor.

Designer + IA = iteração 10x mais rápida Dev + IA = protótipo em horas, não semanas Escritor + IA = mais conteúdo sem perder voz

Humano e IA juntos sempre seriam mais fortes que separados.

Na época, eu não tinha ideia de quando isso aconteceria. Mas aconteceu em 2025.

Como designer, eu tinha visão de produto, sabia vender ideias. Mas faltava uma peça do quebra-cabeça: saber programar.

A decisão

Minha meta de 2019 foi focar em aprender a programar. Comecei na segunda semana de janeiro. Parei com tudo e fui direto pro código.

Não fiz faculdade de novo. Não fiz bootcamp caro.

Escolhi iOS porque:

  • Apps mobile eram meu negócio
  • Swift era moderna, fortemente tipada (o que obviamente eu não tinha ideia do que era), bem documentada
  • Ecossistema maduro (não ia ficar reaprendendo tudo a cada 6 meses)

Hoje, sou dev iOS numa grande fintech brasileira, atuando em um ecossistema com dezenas de squads e mais de 100 desenvolvedores iOS.. Ainda tem os de Android e de backend.

Usamos as melhores práticas do mercado: arquitetura limpa, VIP-C, SOLID, testes, CI/CD - o pacote completo de empresa de escala.

Mas tem um problema que nunca foi embora.

O problema que voltou

Apps não existem sozinhos.

Todo app precisa de backend. Ainda dependemos de outros times:

  • Nova feature? "Abre ticket pro backend, espera a sprint deles"
  • Bug na API? "Não é mobile, fala com o squad X"
  • Quer prototipar localmente? "Boa sorte subindo 15 microsserviços"

Nesse contexto de escala, processos são minuciosos. RFC leva semanas. Aprovação passa por vários níveis. Deploy tem janela específica.

Não é culpa de ninguém - é escala. Centenas de devs não trabalham como 5, e processos existem por boas razões - não pode ser bagunça.

Aquela sensação voltou: "tenho a ideia, quero testar, agora sei programar, mas, por motivos óbvios, não se pode usar a infraestrutura da empresa pra 'brincar'".

Não dá pra chegar pro time de infra e falar "ó, baixei esse modelo de IA aqui, vamos subir um micro-serviço".

Isso me travava. Queria experimentar. Validar ideias. Quebrar coisas. Aprender errando.

Solução? Simular o ambiente de empresa grande, mas na minha escala. Experimentar, validar ideias, quebrar coisas, aprender errando - sem medo.

Criar dairan.dev com os mesmos processos que uso no dia a dia:

  • Ambientes separados (local, preview, prod)
  • CI/CD automático
  • Documentação de decisões (ADRs)
  • Code review (eu mesmo, 1 dia depois)
  • Deploy controlado
  • Monitoramento

Tudo que uma fintech tem. Só que gratuito.

O experimento

IA finalmente chegou. Mas vejo muita gente usando de forma que não funciona pra mim:

❌ "Escreva código pra mim" → eu copio, colo, quebra depois ❌ "Corrija esse bug" → não entendo o fix, repito o erro ❌ "Faça meu trabalho" → viro dependente, não aprendo

Eu queria diferente.

Queria usar IA como pair programmer. Igual aquele dev senior que:

  • ✅ Sugere abordagens
  • ✅ Explica trade-offs
  • ✅ Gera boilerplate
  • ❌ Mas não decide nada sozinho

Eu decido. IA executa.

Decidi criar um projeto real do zero usando IA em todos os fluxos:

  • Ideação
  • Backend (FastAPI + PostgreSQL)
  • Frontend (Astro + SSG)
  • Infra (Cloudflare + Render + Neon)
  • Deploy (CI/CD automático)
  • Documentação (ADRs → Posts)
  • Conteúdo (este blog)

Mas com um detalhe: eu sabia muito pouco de backend e menos ainda de infra baseada em serviço.

Nunca tinha feito API REST de verdade. Não manjava de:

  • CORS
  • Migrations
  • Webhooks
  • Rate limiting
  • Ambientes (local, preview, staging, prod)

Perfeito pra aprender.

A abordagem

Em vez de fazer curso de 40 horas ou tutorial do YouTube, fiz assim:

1. Defino o que preciso

  • "Preciso autenticar requests via API key"

2. IA sugere opções

  • Claude/ChatGPT/Qwen (modelo local) me dão 3-4 abordagens diferentes
  • Explicam trade-offs de cada uma
  • Mostram código exemplo

3. Eu escolho

  • Baseado em: simplicidade, segurança, manutenibilidade

4. IA gera implementação

  • Boilerplate completo
  • Configurações
  • Testes básicos

5. Eu valido e ajusto

  • Leio cada linha
  • Entendo o que faz
  • Refatoro se necessário
  • Não aceito código que não entendo

6. Documento decisão

  • ADR (Architecture Decision Record)
  • Por que escolhi X em vez de Y
  • Consequências (positivas e negativas)

Resultado

1 mês (fins de semana) depois:

  • ✅ API REST completa rodando
  • ✅ Frontend estático deployado
  • ✅ CI/CD automático
  • ✅ Posts sendo publicados
  • ✅ Custo: $0/mês (só free tiers)

Mas o mais importante: aprendi fundamentos.

Não decorei comandos. Entendi:

Docker: Lembro quando XAMPP era novidade sensacional - finalmente não precisava configurar MySQL e PHP manualmente. Docker é isso, mas sem gambiarra. Hoje rodo backend, banco, Redis, tudo isolado. Funciona no meu Mac? Funciona em produção.

Infra de verdade: Backend no Render, frontend no Cloudflare Pages, banco no Neon. Ambientes: local, preview, produção. Deploy automático. Antigamente era FTP e reza. Hoje é git push e confia.

Async: Como funciona de verdade (não só decorar `async def`)

CORS: Por que existe (não só "adiciona esse header e torce")

Webhooks: Como funcionam (não só "cola esse endpoint")

SSG vs SSR: Trade-offs reais (não só "usa framework X")

Por que isso importa além de mim

É relativamente comum em grandes empresas terem esses problemas:

Problema 1: Conhecimento concentrado

  • 1-2 pessoas sabem como funciona cada sistema
  • Se saem, leva meses pra transferir conhecimento
  • Documentação desatualizada ou inexistente

IA pode ajudar:

  • Onboarding: IA explica código legado
  • Documentação: ADRs geradas automaticamente
  • Transfer knowledge: IA extrai contexto de PRs antigos

Problema 2: Experimentação lenta

  • Protótipo precisa envolver 3 squads
  • "Vamos testar" vira projeto de 2 meses
  • Ideia morre antes de ser validada

IA pode ajudar:

  • Protótipo local em horas (não semanas)
  • Testa, quebra, aprende - sem abrir ticket
  • Prova conceito antes de escalar

Problema 3: Dependências entre times

  • Mobile travado esperando backend
  • Backend travado esperando infra
  • Infra travado esperando segurança

IA pode ajudar:

  • Dev mobile faz mock de API, Dev backend testa infra localmente, ciclos de feedback mais rápidos

IA não resolve processos ruins. Mas acelera os bons.

O que vem por aí

Este site é meu laboratório público.

Vou documentar cada decisão técnica que tomo:

📝 Posts curtos (300-500 palavras) - este foi exceção, próximos serão diretos

  • 1 tópico por post
  • Problema real que enfrentei
  • Como resolvi (código incluído)
  • Como usei IA no processo
  • Um workflow para você copiar e colar na sua IA favorita e se aprofundar

🔧 Temas dos próximos posts:

  • CORS: 2 dias quebrando cabeça (o que aprendi)
  • Gestão de 4 ambientes sem pirar
  • Webhooks do GitHub com validação HMAC
  • Como IA gerou 80% da API (e eu validei os outros 20%)
  • Rate limiting sem Redis (in-memory first)

🎯 Não é sobre "IA fez tudo", é sobre "IA me ajudou a aprender mais rápido".

Este blog não é sobre código, frameworks ou stacks.

É sobre processos: como integro IA em cada etapa do ciclo de produto e o que isso muda na forma de pensar, decidir e executar.

Ideação: Brainstorm de features no Linear com IA sugerindo prioridades Planejamento: IA ajuda a quebrar tarefa grande em subtarefas viáveis Arquitetura: Proponho solução, IA sugere alternativas, eu decido Código: IA gera boilerplate, eu valido e refino Debug: IA analisa erro, sugere causa, eu confirmo e corrijo

Documentação: ADRs → Posts, Deploy: CI/CD automático.

Este blog documenta exatamente isso: como integrei IA em todo ciclo de produto, não só na parte de código.