Se você nunca programou, este livro começa no capítulo 0.0.

E o capítulo 0 não tem código.

A objeção que mata quase toda venda de livro de programação

"Mas eu não sei programar."

É a frase que a pessoa pensa e não escreve. E ela é a razão de existirem trinta mil livros de Python, todos começando com print("Hello World") e nenhum explicando por que aquilo é uma instrução.

Os treze primeiros capítulos deste livro existem para matar essa objeção (eles são numerados de 0.0 a 0.12). São treze capítulos, sem pressa, sem pressupor nada. O 0.0 explica o que é um programa usando uma receita de bolo. O 0.1 instala o Python no seu Windows, passo a passo, incluindo o que fazer quando dá erro. O 0.8 ensina a ler um traceback sem pânico. O 0.12 ensina a abrir o terminal sem medo — é onde quase todo mundo trava.

Você não precisa saber nada para começar. Comece pelo 0.

O que acontece depois que você aprendeu

Aí vem a parte que ninguém escreve.

Você integra um modelo de linguagem num Django. Roda. Você testa, vê a resposta boa, e mostra pro cliente.

Aí vai para produção.

Na primeira semana:

json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

O modelo devolveu o JSON certinho — dentro de um bloco de código.

No primeiro mês:

Um cliente recebeu dois estornos. O botão foi clicado duas vezes porque a tela demorou nove segundos. Você repetiu a chamada porque o modelo errou uma vez.

No segundo mês:

A conta da API chegou com cinco dígitos. Você descobriu que estava pagando por 8.500 tokens de contexto para receber 300 tokens de resposta — e que o retry do primeiro mês multiplicou tudo.

Nenhum desses era bug de lógica. Todos eram decisões de arquitetura tomadas antes de saber o que ia dar errado.

Este livro é sobre os 12 momentos em que isso acontece.

Não é sobre como chamar a API. Isso tem mil tutoriais e leva cinco minutos. É sobre o que acontece depois que funcionou — e é o que separa um sistema que sobrevive de um sistema que você reescreve.

Um livro, dois caminhos

Onde O quê
Nunca programou Parte 0, caps. 0.0 a 0.12 Do zero absoluto até rodar um servidor web
Já programa e quer a parte difícil Partes 1 a 5, caps. 1 a 15 Django de verdade e os 12 erros de IA em produção

Você pode ler na ordem. Você pode pular direto para a dor que está sentindo. Os capítulos são numerados pelo erro justamente para isso.

Se você sabe Django mas nunca integrou IA, o caminho mais rápido é o capítulo 7 e depois o 12.

O que você vai construir

Uma central de atendimento completa:

Django de verdade: admin configurado, permissões por papel, escopo de ticket no código, formulários, transaction.atomic, migrações.

E o pagamento funciona de verdade: o cartão do cliente nunca passa pelo servidor, e o webhook que chega não consegue cobrar duas vezes — que é o erro que o capítulo 9 inteiro existe para evitar.

O sistema não é o assunto — ele é o cenário onde cada erro acontece e onde você vê a correção funcionando.

Os 12 erros

O que você vê Capítulo
O modelo devolve JSON dentro de um bloco de código 7
O campo às vezes vem, às vezes não 7
Repetir não resolve, e a conta dobra 7
A ação disparou duas vezes 9
Você não sabe se a IA acertou 8
A IA dá resposta errada com muita confiança 8
A conta do cartão disparou 10
Testar prompt em produção sai caro 10
A página trava porque a IA demora 8 segundos 11
O cliente escreveu "ignore as instruções anteriores" 12
Você não sabe se melhorou ou só mudou 13
Funciona na sua máquina, morre no servidor 14

E mais um: o que fazer às 3 da manhã quando a IA alucinar — margem por cliente, circuit breaker, cobrança por assinatura e o post-mortem que você agradece numa madrugada. É o capítulo 15, e ele é o que transforma os outros 14 em um sistema.

O que você sai sabendo

Validação em duas camadas — structured outputs para eliminar cinco modos de falha na geração, validação no seu lado para o que sobrar.

Confiança não é probabilidade — a tabela que mostra que o número que o modelo declara quase não separa acerto de erro, e onde os erros se concentram.

Efeito no mundo nunca repete — chave de idempotência, constraint única, outbox, skip_locked, reconciliação. A diferença entre uma falha e um prejuízo financeiro.

Webhook não é integração, é o caminho do dinheiro — por que a corrida entre dois deliveries simultâneos precisa ser resolvida pela constraint do banco, e não por um if, e por que quem perde a corrida responde 200 em vez de 500.

Custo é arquitetura, não otimização — por que 8.500 tokens de contexto custam 8,3× mais que 200, e o que cortar primeiro. Os três números do livro (8,3×, 73% e 92%) têm testes que fazem a conta, com a tabela de preço que está no código que você recebe.

Fila é o que salva a latência — select_for_update(skip_locked=True), backoff exponencial, heartbeat, watchdog, backpressure.

Prompt não é fronteira de segurança — as cinco defesas que não dependem do modelo se comportar.

Decisão com número — conjunto de casos, comparador de versões, limiar de significância. Por que três semanas de ajuste sem comparação não provam nada.

Configuração testada — por que os.environ["X"] sem default salva o deploy, e por que worker que não se recupera te custa um cliente.

Uma coisa que nenhum outro livro faz

O código deste livro foi rodado antes de ser publicado. Não é um exemplo digitado e conferido com os olhos: são 165 testes que passam, e você mesmo roda python manage.py test no projeto que recebe.

Isso não é bobagem. Enquanto escrevia, o código tinha 29 defeitos que só apareceram na execução:

billing/models.py  usa Decimal('0') sem importar Decimal     → NameError
cap. 8             importa knowledge.models, que não existia  → ModuleNotFoundError
cap. 10            grava custo_usd, campo ausente no modelo  → FieldError
cap. 14            o roteador lê LLM_MODEL_GRANDE, sem existir → AttributeError
cap. 12            o detector deixa passar 9 dos 12 ataques → falha silenciosa
cap. 15            assinatura nasce "ativa" sem pagamento nenhum → serviço grátis
cap. 15            busca do webhook só tenta um identificador → assinatura nunca atualiza
billing/models.py  renova_em é NOT NULL sem default           → toda criação quebra
cap. 6             a view renderiza um template que não existe → erro 500 na primeira tela

Todos foram corrigidos e entraram no texto, com o erro explicado. Um livro que mostra o próprio código quebrando e consertando ensina mais do que um que mostra só o resultado.

E o teste é honesto sobre o que ele cobre: o que reproduz a corrida entre dois webhooks simultâneos pula no SQLite, com o motivo escrito no próprio teste. Você encontra essa ressalva em vez de descobrir sozinho, meses depois, que aquele teste nunca rodou.

Formato

Leitura no celular funciona: é PDF com fonte grande e diagramas que não dependem de imagem.

Para quem é

Para você que nunca programou. A Parte 0 foi escrita para você. Não é apenas uma introdução rápida: são treze capítulos, do "o que é um programa" até o "o que é um servidor web".

Para você que programa e quer a parte que ninguém ensina. Se você já entrega sistema com IA e nunca parou para pensar em idempotência, em custo de contexto e em o que o modelo faz quando é manipulado — este livro é sobre exatamente isso.

Para você que só quer um prompt melhor. Não é um curso de prompt engineering. Você vai aprender a não depender do prompt para segurança, custo ou idempotência.

Requisitos

Para ler: você não precisa de nada.

Para rodar os códigos, o mínimo real é menor do que a maioria dos livros de Django pede:

O que é opcional:

Os capítulos 0.0 a 0.9 não precisam de nenhum deles.

Perguntas que eu sempre recebo

"Nunca programei. Esse livro é mesmo para mim?" Os treze primeiros capítulos (0.0 a 0.12) são exatamente para isso. Você vai instalar o Python, escrever um programa, aprender a decidir, repetir e guardar informação, ler um erro e entender o que é um servidor web. Se você leu um receituário de bolo sem saber cozinhar, você consegue.

"Vou usar Django básico, não preciso disso." O custo do incidente é maior que o custo do livro. E os erros 9, 10 e 12 não têm a ver com Django ser básico ou avançado.

"Tem exemplo de RAG / vector database?" Tem. É o capítulo 8, com citação de documento e conferência de trecho literal. Mas o foco é o grounding verificável, não a biblioteca de embedding.

"E se meu provedor não suporta structured outputs?" O capítulo 7 mostra o caminho alternativo e explica por que ele é mais frágil. O capítulo 12 mostra o que fazer quando o modelo não respeita schema.

"Os preços dos tokens estão atualizados?" Não, e nenhum livro consegue garantir isso. O capítulo 10 mostra exatamente onde trocar e por que o custo importa mais que o preço unitário.

"Preciso ler tudo?" Não. Os capítulos são numerados pelo sintoma. Vá direto no que está te doendo e use a tabela do índice. A única parte que é sequencial é a Parte 0 (0.0 a 0.12), e é porque ela é a única que você não pode pular se nunca programou.

"O pagamento funciona mesmo, ou é exemplo?" Funciona. O cartão nunca passa pelo servidor: você cria a cobrança, o cliente paga na página do provedor, e o provedor avisa por webhook. O capítulo 9 dedica a seção mais longa ao problema difícil — dois avisos simultâneos do mesmo pagamento — e a solução é a mesma que protege qualquer ação que muda dinheiro.

"Preciso de servidor para rodar o projeto?" Não. Sem variável de banco no ambiente, ele roda em SQLite, que é um arquivo na sua pasta. Postgres só é necessário a partir do capítulo 11.

Sobre o autor

MDEV Tecnologia e Inovação

Trabalhamos com sistemas Django em produção e com integração de IA em produtos que precisam operar. Este livro é o que documentamos enquanto cometíamos esses erros, para você não precisar.

Garantia

15 dias. Se não te servir, devolvemos o valor integral — você escreve um e-mail e pronto, sem formulário e sem justificativa. A garantia só vale alguma se for fácil de usar.

Perguntas antes de comprar

Dúvida que ficou, escreva para a gente antes. Compra na dúvida é dinheiro perdido, e é melhor responder em um e-mail do que devolver depois.

MDEV Tecnologia e Inovação