☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta Fintech. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Fintech. Mostrar todas as mensagens

terça-feira, 15 de setembro de 2026

🕶️ DIABOLIK NO MAINFRAME — Risk Scoring Humano

 

Bellacosa Mainframe e o risk scoring humano

☕ Um Café no Bellacosa Mainframe

🕶️ DIABOLIK NO MAINFRAME — Risk Scoring Humano

Quando o sistema deixa de perguntar “o que você fez?” e começa a perguntar “por que você deixou de se comportar como você mesmo?”

Há uma coisa que Diabolik entende melhor do que muitos sistemas antifraude.

A melhor maneira de atravessar uma porta protegida não é necessariamente arrombá-la.

É fazer com que a porta acredite que você deveria estar entrando por ela.

Máscara correta.

Documento correto.

Horário plausível.

Comportamento esperado.

Uma história suficientemente coerente.

Separadamente, cada detalhe parece normal.

E justamente aí começa nossa história.

Porque, em algum lugar dentro de uma enorme instituição financeira, existe um IBM Mainframe processando milhões de eventos e tentando responder a uma pergunta aparentemente simples:

este comportamento faz sentido para esta pessoa?

Bem-vindo ao Risk Scoring Humano.

E nosso guia será Diabolik.



🕶️ CAPÍTULO 1 — Diabolik não quer parecer Diabolik

Imagine um sistema antifraude bastante primitivo.

Sua lógica poderia ser parecida com:

IF TRANSACTION-AMOUNT > 10000
    MOVE 'HIGH-RISK' TO RISK-LEVEL
END-IF.

Funciona?

Às vezes.

Mas qualquer pessoa que conheça a regra aprende rapidamente que R$ 10.001 chama atenção e R$ 9.999 talvez não.

Esse é o problema das regras determinísticas isoladas.

Diabolik olha para isso e sorri.

Ele não precisa destruir a regra.

Precisa apenas parecer normal para ela.

Um sistema moderno precisa fazer outra pergunta:

R$ 9.999 é normal para quem está fazendo essa operação?

Para uma grande empresa, talvez seja banal.

Para uma conta que recebe R$ 1.800 por mês e nunca movimentou mais de R$ 3.000, pode ser extraordinário.

Portanto:

RISCO ≠ apenas EVENTO

Uma aproximação muito melhor seria:

RISCO =
    EVENTO
  + PESSOA
  + HISTÓRICO
  + CONTEXTO
  + RELACIONAMENTOS
  + TEMPO

É aqui que nasce o Risk Scoring Humano.



🎭 CAPÍTULO 2 — A melhor máscara é uma identidade verdadeira

Sistemas antigos frequentemente tentavam responder:

“Essa pessoa é criminosa?”

Sistemas modernos precisam responder algo mais sutil:

“Esse comportamento combina com essa identidade?”

Essa diferença é gigantesca.

João pode ser um cliente perfeitamente legítimo há quinze anos.

Recebe salário.

Paga supermercado.

Abastece o carro.

Paga escola.

Compra medicamentos.

Viaja uma vez por ano.

Seu comportamento produz uma espécie de impressão digital financeira.

Não precisamos conhecer João pessoalmente para perceber padrões.

JOÃO
│
├── salário mensal
├── supermercado
├── combustível
├── contas domésticas
├── escola
├── financiamento
└── viagens ocasionais

Nenhuma dessas informações isoladamente define João.

Mas juntas produzem seu baseline comportamental.

Agora imagine que alguma coisa muda.

Em uma semana:

JOÃO
│
├── recebe 8 transferências incomuns
├── acessa de novo dispositivo
├── muda telefone
├── realiza operação internacional
├── adiciona beneficiário
└── transfere praticamente todo o saldo

Talvez cada evento seja legítimo.

O problema é a combinação.

Diabolik conseguiu uma identidade verdadeira.

Mas ainda precisa aprender a ser João.



📸 CAPÍTULO 3 — O velho sistema guardava fotografias

Durante décadas, instituições trabalharam muito bem com fotografias cadastrais.

NOME
CPF
ENDEREÇO
RENDA
PROFISSÃO
IDADE
TELEFONE

É uma fotografia.

Ela responde:

Quem é Vagner?

Mas Risk Scoring moderno quer assistir ao filme.

08:03 login
08:04 consulta saldo
08:06 novo favorecido
08:07 alteração cadastral
08:11 transferência
08:13 segunda transferência
08:17 tentativa internacional

Agora temos comportamento.

E comportamento possui uma propriedade fascinante:

ele possui sequência.

Isso significa que:

A + B + C

pode ter significado completamente diferente de:

C + A + B

Exemplo:

troca telefone
→ cadastra dispositivo
→ transfere dinheiro

é diferente de:

transfere dinheiro
→ meses depois troca telefone

Os eventos são semelhantes.

A narrativa é diferente.



🎬 CAPÍTULO 4 — Risk Scoring transforma fotografia em filme

Vamos imaginar um cliente chamado Marco.

Durante 36 meses:

salário → conta
conta → despesas
conta → cartão
conta → investimento

Tudo relativamente previsível.

Então:

DIA 1
novo dispositivo

DIA 2
novo telefone

DIA 3
novo favorecido

DIA 3 + 4 minutos
transferência

DIA 3 + 7 minutos
segunda transferência

Um sistema baseado exclusivamente em valores pode não encontrar nada.

O Risk Engine comportamental observa:

DEVICE_RISK        +15
PROFILE_CHANGE     +10
NEW_BENEFICIARY    +20
VALUE_DEVIATION    +25
VELOCITY           +20
--------------------------------
RISK SCORE          90

Mas atenção.

Isso é apenas um exemplo didático.

Na vida real, scores podem ser produzidos por regras, modelos estatísticos, machine learning, modelos híbridos e sistemas especializados.

O conceito importante é:

sinais pequenos acumulam contexto.



🧮 CAPÍTULO 5 — O Risk Score entra em cena

Vamos criar nosso fictício:

BELLACOSA HUMAN RISK ENGINE — BHRE

Ele recebe eventos:

LOGIN
TRANSACTION
PROFILE_CHANGE
DEVICE_CHANGE
PASSWORD_RESET
BENEFICIARY_ADD
CARD_PURCHASE
PIX
TED
TRANSFER
ATM

Cada evento entra no motor.

No Mainframe poderíamos imaginar componentes como:

CICS
  ↓
COBOL
  ↓
Db2 / VSAM
  ↓
Risk Engine
  ↓
Decision

Para transações financeiras modernas, também poderíamos integrar APIs, mensageria e plataformas analíticas externas.

O mainframe não precisa fazer sozinho toda a ciência de dados.

Ele pode ser justamente o coração transacional que pergunta:

“Posso autorizar?”

E recebe:

APPROVE
REVIEW
CHALLENGE
DECLINE

💳 CAPÍTULO 6 — 200 OK não significa “é confiável”

Imagine:

CLIENTE
   ↓
APP
   ↓
API
   ↓
BANK
   ↓
MAINFRAME

A autenticação está correta.

Token correto.

Senha correta.

Dispositivo reconhecido.

Isso demonstra que determinadas credenciais foram aceitas.

Não demonstra necessariamente que a intenção seja legítima.

Essa distinção é fundamental:

AUTHENTICATION
      ≠
AUTHORIZATION
      ≠
TRUST

Diabolik adora quando confundimos essas três coisas.

Ele não precisa falsificar necessariamente tudo.

Talvez tenha acesso legítimo a uma credencial comprometida.

O sistema precisa analisar contexto.


🧠 CAPÍTULO 7 — Risk Scoring não deveria perguntar apenas “quem é você?”

Perguntas melhores:

Quem é você?

De onde costuma acessar?

Quando costuma acessar?

Quanto costuma movimentar?

Para quem costuma transferir?

Quais dispositivos utiliza?

Qual é sua velocidade normal de operações?

Que relacionamento possui com o destinatário?

Esse comportamento já aconteceu anteriormente?

Isso produz uma identidade dinâmica.

Chamaremos de:

Behavioral Identity.

Não é simplesmente CPF.

É uma combinação histórica de comportamentos.


🕸️ CAPÍTULO 8 — E então descobrimos o grafo

Diabolik consegue imitar Marco.

Excelente.

Mas existe um problema.

Ele precisa mandar o dinheiro para algum lugar.

Surge Maria.

MARCO → MARIA

Nada necessariamente estranho.

Mas Maria recebe também de:

JOÃO ──┐
PEDRO ─┤
ANA ───┼──→ MARIA
LUÍS ──┤
MARCO ─┘

Interessante.

Maria envia para Empresa X.

MARIA → EMPRESA X

Empresa X está relacionada a outras entidades.

Agora nossa análise deixa de olhar somente para transações.

Estamos construindo um:

GRAPH.


🕷️ CAPÍTULO 9 — O grafo destrói algumas máscaras

Uma pessoa pode alterar:

nome utilizado,

telefone,

conta,

empresa,

dispositivo,

endereço.

Mas relacionamentos podem revelar padrões.

Imagine:

PESSOA A
   │
   ├── telefone → PESSOA B
   │
   ├── endereço → EMPRESA C
   │
   ├── dispositivo → CONTA D
   │
   └── transferência → PESSOA E

Cada aresta adiciona contexto.

Agora descobrimos:

PESSOA E
   ↓
EMPRESA F
   ↓
CONTA G
   ↓
PESSOA B

Fechamos um ciclo.

É por isso que Graph Analytics é tão poderoso em fraude e AML.

Ele não pergunta apenas:

Quem recebeu dinheiro?

Pergunta:

Como essas entidades estão relacionadas?


🧩 CAPÍTULO 10 — Risk Scoring humano não significa julgar pessoas

Aqui existe uma distinção ética essencial.

Um sistema não deveria concluir:

“Essa pessoa é criminosa.”

Risk Scoring deve trabalhar com algo muito mais limitado:

“Esta operação apresenta características que justificam controles adicionais.”

Essa diferença protege clientes e instituição.

Score não deveria ser sentença.

Deveria ser sinal.

Por isso podemos ter:

LOW RISK
   ↓
PROCESS

MEDIUM RISK
   ↓
ADDITIONAL AUTHENTICATION

HIGH RISK
   ↓
MANUAL REVIEW

CRITICAL
   ↓
BLOCK / INVESTIGATION

Dependendo da política, legislação e natureza da operação.


🔎 CAPÍTULO 11 — O caso Gritzbach mostra outro tipo de Risk Scoring

Aqui podemos utilizar o caso apenas como analogia analítica, sem transformar acusações ainda controvertidas em fatos.

Segundo a reconstrução jornalística, Antônio Vinícius Lopes Gritzbach teria atravessado simultaneamente diferentes redes de relacionamento envolvendo integrantes do PCC, negócios, dinheiro, criptomoedas, autoridades e policiais. Ele posteriormente tornou-se colaborador do Ministério Público.

A questão interessante para nosso estudo não é tentar reproduzir qualquer “score do PCC”.

É observar algo universal:

pessoas também existem dentro de grafos de confiança.

Imagine abstratamente:

PESSOA
│
├── dinheiro
├── parceiros
├── clientes
├── fornecedores
├── instituições
├── autoridades
└── informações

Quando uma relação muda, outras podem ser afetadas.


⚖️ CAPÍTULO 12 — Trust Score é contextual

Essa é uma descoberta importantíssima.

Uma pessoa não possui universalmente:

TRUST = 72

Ela pode ser simultaneamente:

Banco A       → LOW RISK
Banco B       → UNKNOWN
Empresa C     → TRUSTED
Sistema D     → HIGH RISK

Porque risco depende de contexto.

O mesmo vale para comportamento.

Comprar R$ 8.000 em um restaurante pode ser extraordinário para mim.

Para uma empresa realizando jantar corporativo para 80 pessoas, talvez seja normal.

Portanto:

RISK = EVENT / CONTEXT

e não simplesmente:

RISK = EVENT

🧠 CAPÍTULO 13 — O programador COBOL precisa entender isso

Aqui chegamos ao ponto que frequentemente falta nas formações Mainframe.

O iniciante recebe:

01 WS-RISK-SCORE PIC 9(03).

E pensa:

É um campo numérico de três posições.

Não.

Talvez você esteja olhando para a conclusão de centenas de sinais.

Por trás daqueles três bytes conceituais podem existir:

histórico
perfil
device
geolocalização aproximada
velocity
valor
merchant
beneficiário
produto
canal
horário
relacionamentos
alertas anteriores

O programador Mainframe precisa compreender semântica de negócio, não somente PIC clauses.


💻 CAPÍTULO 14 — Vamos programar um pequeno exemplo

Imagine:

01 WS-RISK-SCORE       PIC 9(03) VALUE ZERO.
01 WS-NEW-DEVICE       PIC X.
01 WS-NEW-BENEFICIARY  PIC X.
01 WS-HIGH-AMOUNT      PIC X.
01 WS-PROFILE-CHANGE   PIC X.

Então:

IF WS-NEW-DEVICE = 'Y'
   ADD 15 TO WS-RISK-SCORE
END-IF

IF WS-NEW-BENEFICIARY = 'Y'
   ADD 20 TO WS-RISK-SCORE
END-IF

IF WS-HIGH-AMOUNT = 'Y'
   ADD 25 TO WS-RISK-SCORE
END-IF

IF WS-PROFILE-CHANGE = 'Y'
   ADD 10 TO WS-RISK-SCORE
END-IF.

Depois:

EVALUATE TRUE
   WHEN WS-RISK-SCORE >= 70
        MOVE 'REVIEW' TO WS-DECISION

   WHEN WS-RISK-SCORE >= 40
        MOVE 'CHALLENGE' TO WS-DECISION

   WHEN OTHER
        MOVE 'APPROVE' TO WS-DECISION
END-EVALUATE.

Didaticamente funciona.

Mas Diabolik imediatamente descobriria um problema.


😈 CAPÍTULO 15 — Diabolik aprende nossas regras

Se:

70 = REVIEW

ele tentará permanecer em:

69

Esse fenômeno é fundamental em sistemas antifraude.

Quando atacantes compreendem controles, adaptam comportamento.

Por isso sistemas precisam evoluir.

Podemos combinar:

RULES
+
STATISTICS
+
BEHAVIOR
+
MACHINE LEARNING
+
GRAPH ANALYTICS
+
HUMAN REVIEW

Nenhum componente precisa ser mágico.

O poder está na combinação.


⏱️ CAPÍTULO 16 — Velocity: Diabolik tem pressa

Um conceito maravilhoso para ensinar ao programador COBOL iniciante é velocity.

Imagine:

09:00 R$ 800
09:03 R$ 900
09:05 R$ 700
09:07 R$ 950
09:09 R$ 850

Nenhuma transação ultrapassa R$ 1.000.

Uma regra:

IF AMOUNT > 10000

não detecta nada.

Mas:

5 TRANSFERS
IN 9 MINUTES

é outro sinal.

Risk Scoring precisa compreender também:

quanto aconteceu em quanto tempo.


🕰️ CAPÍTULO 17 — O tempo transforma o grafo

Agora acrescentamos timestamps:

09:00 A → B
09:02 B → C
09:04 C → D
09:07 D → E

Temos um fluxo.

O grafo agora não mostra apenas:

A — B — C — D — E

Mostra movimento.

Chamamos conceitualmente isso de:

Temporal Graph.

Ele pode revelar mudanças que um grafo estático esconderia.


🏦 CAPÍTULO 18 — E onde entra o IBM Mainframe?

No lugar mais interessante possível.

No coração das operações.

Imagine uma arquitetura:

                 MOBILE
                    │
                 INTERNET
                    │
                    ▼
                 API LAYER
                    │
              z/OS Connect
                    │
                    ▼
┌─────────────────────────────────┐
│            IBM Z                │
│                                 │
│   CICS                          │
│     │                           │
│     ▼                           │
│   COBOL ───────► Db2            │
│     │                           │
│     ▼                           │
│   RISK REQUEST                  │
│     │                           │
└─────┼───────────────────────────┘
      │
      ▼
 ANALYTICS / GRAPH / ML
      │
      ▼
 RISK SCORE
      │
      ▼
 IBM Z
      │
      ▼
DECISION

E isso é importante:

modernização não significa necessariamente retirar o COBOL.

Pode significar permitir que COBOL converse com tecnologias especializadas.


⚡ CAPÍTULO 19 — Porque autorização não pode tomar café

Imagine cartão.

Cliente encosta na máquina.

TAP
 ↓
ACQUIRER
 ↓
NETWORK
 ↓
ISSUER
 ↓
AUTHORIZATION

O cliente está olhando para o terminal.

Não podemos dizer:

“Aguarde vinte minutos enquanto nosso algoritmo termina.”

A decisão precisa ocorrer rapidamente.

É exatamente aí que sistemas transacionais de alta disponibilidade continuam extremamente relevantes.

Risk Scoring precisa entrar no fluxo sem destruir SLA.


🔐 CAPÍTULO 20 — False Positive: quando prendemos o mordomo

Existe outro perigo.

Se o sistema ficar paranoico:

QUALQUER COISA DIFERENTE
        ↓
      BLOCK

teremos milhares de clientes legítimos irritados.

Chamamos isso de:

false positive.

O cliente viajou para Roma.

Compra jantar.

Sistema:

FRAUDE!

Cliente:

Estou com fome!

😄

Risk Scoring precisa equilibrar:

FRAUD LOSS
     ↕
CUSTOMER FRICTION

Bloquear tudo é fácil.

Autorizar corretamente é difícil.


🎯 CAPÍTULO 21 — Risk Score não é prova

Isso merece ficar gravado no monitor do programador:

RISK SCORE ≠ GUILT

Score 92 não significa:

“92% criminoso.”

Pode significar apenas que um modelo específico identificou uma combinação de sinais considerada de alto risco segundo sua própria calibração.

A interpretação depende do modelo.

Esse cuidado torna-se ainda mais importante quando falamos em Risk Scoring Humano.

Algoritmos podem produzir vieses.

Dados podem estar errados.

Cadastros podem estar desatualizados.

Relacionamentos podem ser coincidências.

Por isso decisões de grande impacto precisam de governança adequada.


🧪 CAPÍTULO 22 — Explainability: por que deu 92?

Imagine o analista recebendo:

RISK SCORE = 92

Ele pergunta:

Por quê?

Sistema:

Porque sim.

Inaceitável.

Precisamos de reason codes.

R01 NEW DEVICE
R07 NEW BENEFICIARY
R13 UNUSUAL AMOUNT
R22 HIGH VELOCITY
R31 GRAPH RELATION

Então:

SCORE 92

REASONS:
HIGH VELOCITY
NEW DEVICE
NEW BENEFICIARY
BEHAVIOR DEVIATION

Agora existe explicabilidade operacional.

E o COBOL pode desempenhar papel importantíssimo na integração desses reason codes ao fluxo transacional.


🗃️ CAPÍTULO 23 — Não jogue fora os dados antigos!

Aqui existe uma vantagem maravilhosa dos ambientes Mainframe.

Histórico.

Décadas de histórico podem existir.

Isso é ouro para análise comportamental — desde que seja utilizado com governança, finalidade legítima, qualidade e respeito às regras de proteção de dados.

Porque comportamento exige comparação:

HOJE
versus
ONTEM
versus
30 DIAS
versus
1 ANO

Um sistema que conhece apenas hoje não conhece comportamento.

Conhece eventos.


🕵️ CAPÍTULO 24 — Diabolik finalmente comete seu erro

Nosso Diabolik conseguiu:

credencial,

identidade,

dispositivo,

horário plausível,

valor plausível.

Ele parece perfeito.

Mas precisa transferir recursos.

O sistema observa:

DIABOLIK-AS-MARCO
        ↓
     CONTA X
        ↓
     CONTA Y
        ↓
     EMPRESA Z

E o Graph Engine percebe:

EMPRESA Z
   ↑
CONTA Q
   ↑
CASO ANTERIOR

A transação não era necessariamente anormal.

O relacionamento era.

E finalmente encontramos aquilo que Diabolik não conseguiu falsificar perfeitamente:

o contexto.


🧠 CAPÍTULO 25 — A verdadeira evolução do antifraude

Primeira geração:

TRANSACTION RULES

Segunda:

TRANSACTION + PROFILE

Terceira:

TRANSACTION + PROFILE + BEHAVIOR

Quarta:

TRANSACTION
+
PROFILE
+
BEHAVIOR
+
DEVICE
+
NETWORK
+
GRAPH
+
TIME

E então entramos no território que chamo aqui de:

HUMAN RISK SCORING

Não porque estejamos julgando o ser humano.

Mas porque estamos tentando compreender o comportamento dentro de seu contexto humano e relacional.


🧑‍💻 CAPÍTULO 26 — O que o COBOLista iniciante deve aprender

Quando encontrar:

IF RISK-SCORE > 80

não continue lendo imediatamente.

Pergunte:

Quem calculou esse score?

Quais eventos participaram?

Qual janela temporal?

O score expira?

É transacional ou cadastral?

Quais reason codes existem?

O que acontece quando o serviço de risco está indisponível?

Essa última pergunta é especialmente Mainframe.

RISK ENGINE DOWN

E agora?

FAIL OPEN?

Autoriza?

FAIL CLOSED?

Recusa?

FALLBACK RULES?

Usa regras locais?

Essa decisão pode valer milhões.


🚨 CAPÍTULO 27 — 03:17

Nosso easter egg Bellacosa aparece.

03:17 da manhã.

O telefone toca.

War Room.

Fraud Decision Service latency: 4.8 seconds
Authorization queue increasing
Timeout rate: 17%

Alguém diz:

“Vamos bypassar o Risk Engine.”

Silêncio.

Porque isso resolveria performance.

Mas poderia abrir a porta.

Outro propõe:

“Vamos bloquear tudo.”

Também resolveria fraude.

E destruiria o negócio.

O verdadeiro engenheiro Mainframe pergunta:

Qual é o fallback aprovado?

Essa frase separa improvisação de engenharia.


☕ CAPÍTULO 28 — A lição de Diabolik

Durante toda a história procurávamos o homem de máscara preta.

Esse era nosso erro.

Diabolik nunca quis que víssemos a máscara.

Queria que víssemos:

CLIENTE NORMAL

Risk Scoring evoluiu justamente porque fraude sofisticada não precisa parecer fraude.

Pode parecer:

uma compra,

uma transferência,

um login,

uma empresa,

uma conta,

um cliente.

Tudo aparentemente legítimo.

Até observarmos:

QUEM
+
O QUÊ
+
QUANDO
+
ONDE
+
COMO
+
COM QUEM
+
QUANTAS VEZES
+
EM QUE SEQUÊNCIA

Então surge uma história.


🕶️ EPÍLOGO — O Mainframe não procura criminosos

Essa talvez seja a mensagem mais importante para o programador iniciante.

O IBM Mainframe não deveria funcionar como juiz.

O Risk Engine também não.

Eles processam sinais.

EVENT
   ↓
CONTEXT
   ↓
HISTORY
   ↓
RELATIONSHIP
   ↓
RISK
   ↓
DECISION
   ↓
EVIDENCE

E boas arquiteturas mantêm algo fundamental:

rastreabilidade.

Precisamos saber:

qual informação entrou,

qual regra executou,

qual modelo respondeu,

qual score retornou,

qual reason code apareceu,

qual decisão foi tomada,

quando aconteceu

e qual versão estava em produção.

Porque um dia alguém perguntará:

“Por que essa transação foi recusada?”

E PORQUE WS-RISK > 80 não será resposta suficiente.

Diabolik talvez consiga enganar uma regra.

Talvez consiga enganar uma câmera.

Talvez consiga uma identidade perfeita.

Talvez consiga inclusive parecer estatisticamente normal durante algum tempo.

Mas quanto mais dimensões independentes um sistema correlaciona — histórico, comportamento, dispositivo, velocidade, relacionamentos e tempo — mais difícil se torna sustentar uma identidade artificial coerente.

Essa é a batalha moderna.

Não é:

COBOL contra inteligência artificial.

É:

COBOL
+
CICS
+
Db2
+
APIs
+
EVENTS
+
RULES
+
ML
+
GRAPH ANALYTICS
+
HUMAN ANALYST

Cada tecnologia fazendo aquilo que sabe fazer melhor.

E no centro de tudo continua existindo aquela pergunta simples que começou nossa investigação:

“Isto é normal?”

Diabolik ajusta a gravata, olha para o terminal e sorri.

O terminal responde:

TRANSACTION........... VALID
IDENTITY.............. VALID
AUTHENTICATION........ VALID
AMOUNT................ NORMAL

BEHAVIOR.............. UNUSUAL
VELOCITY.............. UNUSUAL
GRAPH RELATION........ HIGH RISK

RISK SCORE............ 92
DECISION.............. REVIEW

Pela primeira vez, Diabolik para de sorrir.

O sistema não descobriu necessariamente quem ele é.

Descobriu algo muito mais interessante.

Ele não está se comportando como a pessoa que afirma ser.

☕ Um Café no Bellacosa Mainframe

Onde até Diabolik descobre que enganar um IF é fácil. Difícil é enganar quarenta anos de histórico.



Para ir mais longe

https://eljefemidnightlunch.blogspot.com/2024/10/diabolik-no-mainframe-o-roubo-perfeito.html

segunda-feira, 18 de maio de 2026

O Lobo Roxo da Faria Lima: COBOL, Nubank e o Dia em que uma Startup Entrou no Salão dos Bancos e Descobriu que os Gigantes Tinham um Problema Chamado Fricção

 

Bellacosa Mainframe e o lobo roxo da Faria Lima

☕ Um Café no Bellacosa Mainframe

O Lobo Roxo da Faria Lima: COBOL, Nubank e o Dia em que uma Startup Entrou no Salão dos Bancos e Descobriu que os Gigantes Tinham um Problema Chamado Fricção

💳 Como um cartão roxo, um aplicativo e uma arquitetura digital desafiaram Itaú, Bradesco, Santander, Banco do Brasil, Caixa e companhia — e o que um programador COBOL iniciante pode aprender com essa história antes de tentar reescrever o mundo em microsserviços

Imagine a cena.

Um enorme salão de operações financeiras.

Telas piscando.

Gráficos subindo e descendo.

Telefones tocando.

Executivos engravatados dizendo coisas como:

— Liquida isso antes do fechamento.

— Aumenta o limite da carteira.

— Quero essa posição zerada antes do almoço.

— Quanto temos de exposição?

No fundo da sala existe uma enorme porta de aço.

Nela está escrito:

CORE BANKING
AUTHORIZED PERSONNEL ONLY

Atrás daquela porta existem décadas de tecnologia bancária.

COBOL.

CICS.

Db2.

IMS.

MQ.

JCL.

VSAM.

RACF.

Batch noturno.

Arquivos gigantes.

Processamento de milhões de transações.

Sistemas que funcionavam quando muitos fundadores de fintechs ainda estavam aprendendo a andar.

Na mesa principal estão sentados os gigantes.

Banco do Brasil.

Caixa Econômica Federal.

Bradesco.

Itaú.

Santander.

Cada um com décadas — alguns com séculos — de história, capital, infraestrutura, clientes, agências, funcionários e sistemas.

Então entra alguém segurando um pequeno cartão roxo.

Nenhuma agência.

Nenhum prédio gigantesco.

Nenhuma tradição centenária.

Nenhum gerente esperando atrás de uma mesa de madeira.

Apenas um smartphone.

O pessoal da sala olha.

Um executivo pergunta:

— E você é quem?

A resposta:

— Nubank.

Silêncio.

Outro executivo ri.

— Banco?

— Mais ou menos.

— Quantas agências?

— Nenhuma.

— Quantos caixas?

— Nenhum.

— Então o que você tem?

O cartão roxo sobe lentamente.

— Um aplicativo.

Provavelmente alguém teria mandado o rapaz procurar a recepção.

E esse é justamente o começo da história.

Porque o Nubank não entrou no mercado bancário brasileiro tentando construir um banco tradicional um pouco melhor.

Ele entrou questionando uma premissa muito mais perigosa:

E se várias coisas que nós consideramos parte natural de um banco existirem apenas porque sempre foram feitas daquele jeito?

Para um programador COBOL iniciante, essa pergunta vale ouro.

Não porque COBOL seja velho.

Mas porque sistemas corporativos acumulam, ao longo das décadas, uma enorme quantidade de decisões.

Algumas são brilhantes.

Algumas continuam essenciais.

Algumas existem porque ninguém ousou perguntar por quê.

E algumas continuam ali simplesmente porque alterar aquilo custaria tanto que todo mundo prefere fingir que não percebeu.

Pegue o café.

Hoje vamos falar de bancos.

Mas, principalmente, vamos falar de sistemas.


Capítulo 1 — O mercado impossível

Imagine que você estivesse montando uma startup em 2013.

Alguém apresenta a ideia:

Vamos criar uma instituição financeira no Brasil.

Qualquer pessoa minimamente racional poderia responder:

— Excelente. E depois vamos fabricar aviões para competir com Boeing e Airbus?

O mercado brasileiro já possuía gigantes.

Banco do Brasil.

Caixa.

Bradesco.

Itaú.

Santander.

Bancos regionais.

Bancos médios.

Cooperativas.

Financeiras.

Administradoras de cartão.

Cada um com clientes, capital, tecnologia e décadas de conhecimento regulatório.

Era aparentemente um mercado horrível para entrar.

Só que existe uma diferença importante entre:

mercado competitivo

e:

mercado satisfatório para o consumidor

Essas coisas não são iguais.

Um mercado pode ter muitos concorrentes e, mesmo assim, oferecer experiências muito semelhantes.

Esse era um dos grandes pontos do sistema bancário tradicional.

O consumidor frequentemente encontrava:

tarifa
fila
agência
formulário
assinatura
telefone
gerente
burocracia
espera

O banco podia ser tecnologicamente sofisticadíssimo por trás.

Mas para o cliente?

Às vezes parecia 1987.

E aqui aparece uma primeira lição fundamental para quem está começando em COBOL.

Backend excelente não garante experiência excelente.

Você pode ter:

99,999% disponibilidade

no core.

Pode processar:

10 milhões de transações

durante a madrugada.

Pode ter:

RACF
CICS
DB2
IMS
GDG
SMF
WLM

funcionando perfeitamente.

Mas se o usuário precisar preencher três formulários, telefonar cinco vezes e esperar 40 minutos para resolver alguma coisa, ele não enxerga sua arquitetura maravilhosa.

Ele enxerga sofrimento.

O Nubank encontrou espaço justamente nessa distância.


Capítulo 2 — O inimigo não era o mainframe

Aqui existe um erro que aparece frequentemente quando se fala de fintech.

Alguém diz:

Fintech venceu porque banco tradicional usa mainframe.

Calma.

Não.

Muito pelo contrário.

Os mainframes dos grandes bancos são parte da razão pela qual essas instituições conseguem operar em enorme escala.

Um IBM Z pode processar volumes absurdos de transações com confiabilidade extraordinária.

COBOL continua executando grande parte da economia mundial porque resolve muito bem problemas transacionais.

Portanto:

MAINFRAME != PROBLEMA

O verdadeiro problema era frequentemente:

PROCESSO + ORGANIZAÇÃO + FRICÇÃO + HISTÓRIA

Veja a diferença.

O banco tradicional tinha algo conceitualmente parecido com:

CLIENTE
   |
   v
AGÊNCIA
   |
   v
GERENTE
   |
   v
SISTEMA DE ATENDIMENTO
   |
   v
MIDDLEWARE
   |
   v
CORE BANKING

O Nubank podia imaginar desde o início:

CLIENTE
   |
   v
SMARTPHONE
   |
   v
APLICAÇÃO
   |
   v
SERVIÇOS
   |
   v
PLATAFORMA FINANCEIRA

Não significa que o segundo modelo seja magicamente simples.

Há dezenas de problemas escondidos ali:

  • segurança;

  • KYC;

  • antifraude;

  • crédito;

  • liquidação;

  • bandeiras;

  • compliance;

  • regulação;

  • cobrança;

  • observabilidade;

  • contingência;

  • reconciliação.

Mas existe uma vantagem brutal:

o sistema nasceu pensando no canal digital como canal principal.

Isso é diferente de pegar um sistema construído durante décadas e acrescentar:

IF CHANNEL = MOBILE
    PERFORM DIGITAL-FLOW
END-IF.

Sim, COBOLzeiro.

O mundo inteiro eventualmente vira um IF.


Capítulo 3 — O smartphone virou agência bancária

Um dos fatores decisivos do sucesso do Nubank foi timing.

O smartphone estava deixando de ser luxo.

Estava virando infraestrutura social.

De repente milhões de pessoas carregavam no bolso:

tela
câmera
internet
GPS
autenticação
notificações
aplicativos

Tudo isso em um único dispositivo.

Antes, para construir presença nacional, um banco precisava de prédios.

Agências.

Funcionários.

Terminais.

Caixas eletrônicos.

Segurança.

Transporte de numerário.

Infraestrutura física.

O smartphone alterou radicalmente essa equação.

A agência podia ser:

+-------------------+
|                   |
|      📱           |
|                   |
+-------------------+

O cliente não precisava ir ao banco.

O banco passava a ir com o cliente.

Essa mudança parece óbvia hoje.

Mas quase toda inovação parece óbvia depois que alguém faz.

Easter egg nº 1

Existe uma frase famosa atribuída ao mundo da tecnologia:

A melhor interface é aquela que desaparece.

No caso bancário, ocorreu algo ainda mais estranho.

A agência inteira começou a desaparecer.


Capítulo 4 — O cartão roxo era um cavalo de Troia

Agora chegamos a uma das decisões mais inteligentes.

O Nubank não tentou inicialmente convencer o brasileiro a transferir toda a vida financeira.

Imagine a proposta:

Feche sua conta no banco onde recebe salário há quinze anos, transfira seus investimentos e venha para uma startup desconhecida.

Resposta natural:

RETURN-CODE = 12

Mas:

Quer experimentar um cartão sem anuidade controlado por aplicativo?

Muito mais fácil.

Esse é um princípio importantíssimo de produto.

Reduza o tamanho da primeira decisão.

O Nubank entrou com algo relativamente simples:

CARTÃO

Depois podia expandir.

É praticamente uma estratégia de:

LAND
AND
EXPAND

Primeiro:

cartão

Depois:

conta

Depois:

Pix

Depois:

empréstimos

Depois:

investimentos

Depois:

seguros

E assim sucessivamente.

O cartão foi quase um:

ENTRY PROGRAM

do ecossistema Nubank.

COBOLzeiros entenderão imediatamente.

Você não chama todo o sistema.

Você chama um ponto de entrada.


Capítulo 5 — O Nubank descobriu o poder do segundo banco

Esse detalhe é gigantesco.

O Nubank não precisava inicialmente substituir Itaú, Bradesco ou Banco do Brasil.

Ele podia coexistir.

Um cliente poderia ter:

SALÁRIO ---------> ITAÚ
POUPANÇA --------> CAIXA
FINANCIAMENTO ---> SANTANDER
CARTÃO ----------> NUBANK

Isso eliminava uma barreira enorme:

switching cost.

Trocar completamente de banco pode ser traumático.

Experimentar um segundo cartão não.

Então milhões de pessoas podiam simplesmente testar.

Se gostassem, aumentavam o relacionamento.

É quase como instalar um programa novo sem desinstalar o antigo.

INSTALL NUBANK
WITHOUT DELETE BANCO-ANTERIOR

A estratégia foi brilhante porque reduziu o medo do consumidor.


Capítulo 6 — UX virou arma competitiva

Durante décadas, bancos venderam sobretudo:

segurança
solidez
tradição
patrimônio
confiança

O Nubank adicionou outra palavra:

experiência

Aplicativo bonito.

Informações claras.

Notificações imediatas.

Controle do cartão.

Atendimento pelo próprio aplicativo.

Linguagem menos burocrática.

Parece pouco?

Não é.

Em software corporativo existe um fenômeno curioso.

Às vezes gastamos:

R$ 100 milhões

melhorando sistemas internos.

Mas uma mudança de três telas altera dramaticamente a percepção do usuário.

Isso é uma lição fundamental.

O cliente não interage com arquitetura.

Ele interage com interfaces.

Você pode ter por trás:

COBOL
Assembler
Java
C
DB2
Kafka
MQ
Cloud

O cliente não se importa.

Ele quer apertar:

PAGAR

e receber:

PAGO

Se der erro, aí todo mundo passa a descobrir sua arquitetura.

É como eletricidade.

Ninguém pergunta qual transformador alimenta a geladeira.

Até faltar luz.


Capítulo 7 — O cartão roxo virou símbolo

Branding também importou enormemente.

Bancos tradicionais frequentemente usavam comunicação séria.

Executivos.

Ternos.

Prédios.

Famílias felizes financiando casas.

O Nubank apareceu com:

ROXO

Uma escolha visual extremamente diferenciada.

O cartão virou objeto de conversa.

E isso gerou algo extraordinário:

pessoas começaram a falar voluntariamente sobre uma instituição financeira.

Pense no absurdo.

Imagine uma conversa em 2015:

— Cara, chegou meu cartão!

— Qual?

— Nubank.

— O roxinho?

Marketing perfeito.

O produto carregava a marca fisicamente dentro da carteira do cliente.

Cada vez que alguém pagava uma conta:

DISPLAY "NUBANK"

Capítulo 8 — O convite criou escassez

Nos primeiros tempos havia fila.

Convites.

Expectativa.

E isso cria um mecanismo psicológico curioso.

Se alguma coisa parece difícil de conseguir, ela parece mais desejável.

É o velho truque do mercado financeiro:

DEMANDA > OFERTA

Então acontecia:

— Você já tem Nubank?

— Ainda não.

— Posso te mandar convite.

Pronto.

O cliente virou canal de aquisição.

Hoje chamaríamos isso de:

REFERRAL

Mas na prática era algo ainda melhor:

marketing social.

A propaganda vinha de alguém conhecido.

Não de um comercial de televisão.


Capítulo 9 — O custo de crescimento mudou

Agora vamos para arquitetura e economia.

Banco tradicional cresceu historicamente construindo:

AGÊNCIA
 |
 +-- imóvel
 +-- funcionários
 +-- segurança
 +-- gerente
 +-- caixa
 +-- telecomunicação
 +-- manutenção
 +-- estrutura administrativa

Cada expansão geográfica significava infraestrutura física.

Um banco digital muda parcialmente a equação.

Novo cliente:

DOWNLOAD
   |
   v
CADASTRO
   |
   v
IDENTIFICAÇÃO
   |
   v
ANÁLISE
   |
   v
CONTA

Isso não significa custo zero.

Nunca significa custo zero.

Existem:

cloud
datacenter
fraude
atendimento
bandeira
processamento
compliance
capital
crédito
cobrança
segurança

Mas o custo marginal assume outra forma.

Essa diferença permite crescer muito rapidamente.

Se dez milhões de pessoas baixarem um aplicativo, você não precisa construir dez milhões de agências.

Seu problema muda.

Agora é:

SCALABILITY

E aí começa outra guerra.


Capítulo 10 — Escalar também dói

Startup tem uma palavra favorita:

scale

Todo mundo quer escalar.

Pouca gente fala da parte divertida.

Quando você escala, tudo que era pequeno vira grande.

Um erro de:

0,01%

parece irrelevante.

Até você ter cem milhões de operações.

Então:

100.000.000 * 0,0001 = 10.000

Dez mil problemas.

Bem-vindo ao mundo real.

COBOLzeiro, guarde essa lição:

sistemas financeiros não podem pensar apenas em funcionalidade; precisam pensar em volume.

Um programa que funciona perfeitamente com:

100 registros

pode virar desastre com:

100 milhões

É por isso que bancos adoram:

performance
capacity planning
WLM
SMF
RMF
batch window
index
partition

Escala transforma detalhes em incidentes.


Capítulo 11 — Dados: o combustível secreto

No começo, um banco tradicional possuía enorme vantagem.

Décadas de histórico.

Milhões de clientes.

Modelos de crédito.

Informações de comportamento.

O Nubank começou pequeno.

Mas conforme ganhou clientes passou a acumular dados.

Imagine:

valor da compra
horário
estabelecimento
pagamentos
atrasos
limites
movimentação
renda
comportamento
frequência

Com escala suficiente, isso vira matéria-prima para análise de risco.

E surge um ciclo extremamente poderoso:

MAIS CLIENTES
      |
      v
MAIS DADOS
      |
      v
MELHORES MODELOS
      |
      v
MELHOR RISCO
      |
      v
MAIS CRÉDITO
      |
      v
MAIS CLIENTES

Esse é um flywheel.

Uma roda que alimenta a si própria.

Para um programador COBOL isso pode parecer distante.

Não é.

Porque em algum ponto todos esses modelos precisam conversar com sistemas transacionais.

Pode existir uma IA sofisticadíssima decidindo:

LIMIT = 8500

Mas alguém precisa registrar isso.

Controlar.

Auditar.

Autorizar.

Persistir.

E eventualmente cobrar.

Nesse momento você encontra novamente:

CORE

Capítulo 12 — Pix mudou as regras do tabuleiro

Depois ocorreu outra transformação gigantesca.

Pix.

Antes, movimentar dinheiro entre bancos tinha mais fricção.

TED.

DOC.

Horários.

Tarifas.

Prazo.

O Pix reduziu dramaticamente isso.

De repente:

BANCO A
  |
 PIX
  |
  v
BANCO B

quase instantaneamente.

Isso teve uma consequência econômica importante:

reduziu o aprisionamento do cliente.

Se dinheiro circula facilmente, possuir conta em vários bancos fica muito menos complicado.

Você pode manter:

BANCO TRADICIONAL
+
FINTECH
+
CORRETORA

e movimentar recursos entre eles.

Para challengers como Nubank isso é excelente.

A infraestrutura nacional passa a reduzir parte da vantagem das redes tradicionais.

Easter egg nº 2

Para quem viveu TED e DOC:

Pix parece MOVE CORRESPONDING.

Só que alguém finalmente colocou:

SYNCHRONOUS

na operação.


Capítulo 13 — Open Finance e o fim do castelo fechado

Depois veio Open Finance.

Conceitualmente, a ideia é poderosa:

os dados financeiros pertencem ao cliente.

Com autorização, informações podem transitar entre instituições.

Isso reduz outro moat tradicional.

Antes:

BANCO
 |
 +-- possui histórico
 +-- conhece cliente
 +-- controla relacionamento

Agora potencialmente:

CLIENTE
 |
 +-- autoriza compartilhamento

Isso aumenta competição.

O banco deixa de ser simplesmente o proprietário da informação.

Vira guardião de dados cuja circulação pode ser autorizada.

É uma mudança filosófica enorme.


Capítulo 14 — Por que os gigantes não esmagaram o Nubank?

Chegamos à pergunta mais interessante.

Itaú tinha dinheiro.

Bradesco tinha dinheiro.

Santander tinha dinheiro.

Banco do Brasil tinha dinheiro.

Todos tinham equipes de TI gigantescas.

Então por que simplesmente não copiaram tudo?

Aqui aparece o famoso:

Innovator's Dilemma.

Imagine que você ganha bilhões com:

ANUIDADE
TARIFA
PACOTE
SERVIÇOS

Aparece alguém dizendo:

— Precisamos eliminar tarifas.

Seu diretor financeiro pergunta:

— Quanto isso custa?

— Alguns bilhões.

— E quanto ganhamos?

— Talvez no futuro evitemos perder clientes.

Excelente reunião.

😂

Para uma startup:

receita existente = 0

Ela pode destruir um modelo econômico porque não tem receita antiga para proteger.

Para uma empresa incumbente:

CANIBALIZAR PRODUTO

é uma decisão dolorosa.

Esse é um dos motivos pelos quais empresas pequenas conseguem ameaçar gigantes.

Elas não possuem passado.

O passado é ativo.

Mas também pode ser peso.


Capítulo 15 — Legado tecnológico versus legado organizacional

Outro ponto importantíssimo.

Quando ouvimos:

LEGADO

pensamos:

COBOL
MAINFRAME

Mas existe legado muito mais perigoso:

LEGADO ORGANIZACIONAL

Exemplo:

— Por que precisamos dessa aprovação?

— Porque sempre foi assim.

— Quem aprovava?

— Um departamento extinto em 2004.

— Então por que ainda aprovamos?

— Não sei.

Esse tipo de coisa existe em toda grande organização.

Veja:

legacy code
legacy process
legacy policy
legacy incentive
legacy hierarchy
legacy culture

Às vezes reescrever o sistema é fácil.

Difícil é reescrever a empresa.


Capítulo 16 — O Nubank mudou os concorrentes

Uma das maiores vitórias de uma inovação acontece quando os concorrentes passam a copiá-la.

Hoje bancos tradicionais oferecem:

app excelente
Pix
cartão virtual
controle digital
conta sem tarifa
atendimento digital
investimentos no app
biometria
notificações

Isso significa que o Nubank venceu todos?

Não.

Significa algo mais interessante:

ele alterou a referência do consumidor.

Antes o cliente comparava:

BANCO A vs BANCO B

Depois passou a comparar:

EXPERIÊNCIA DIGITAL A vs EXPERIÊNCIA DIGITAL B

Isso força todo mundo a melhorar.


Capítulo 17 — Os gigantes continuam gigantes

Não caia na narrativa simplista:

Fintech matou bancos tradicionais.

Não matou.

Os grandes bancos continuam tendo vantagens absurdas.

Corporate banking.

Agronegócio.

Financiamento imobiliário.

Crédito estruturado.

Câmbio.

Tesouraria.

Derivativos.

Seguros.

Gestão patrimonial.

Redes empresariais.

Capital.

Conhecimento regulatório.

Relacionamentos institucionais.

Infraestrutura.

Décadas de dados.

O mundo bancário é muito maior do que cartão de crédito.

Então a disputa não é:

NUBANK VS BANCO

É:

QUAL PARTE DA CADEIA FINANCEIRA
CADA UM CONSEGUE DOMINAR?

Muito mais interessante.


Capítulo 18 — O que um COBOLzeiro iniciante aprende com tudo isso?

Agora chegamos ao café.

Você começou COBOL e pensa:

— O que Nubank tem a ver comigo?

Tudo.

Passo 1 — Aprenda o core

Antes de criticar sistema legado, entenda-o.

Estude:

COBOL
JCL
CICS
DB2
VSAM
IMS
MQ
RACF

Entenda por que cada coisa existe.

Passo 2 — Pense em jornada

Não veja apenas:

PROGRAM A

Veja:

CLIENTE
   |
   v
CANAL
   |
   v
API
   |
   v
MIDDLEWARE
   |
   v
COBOL
   |
   v
DB2

O programa faz parte de uma experiência maior.

Passo 3 — Pergunte onde está a fricção

O gargalo pode não ser CPU.

Pode ser processo.

Pode ser autorização.

Pode ser formulário.

Pode ser arquitetura.

Pode ser gente.

Passo 4 — Não confunda modernização com reescrita

Modernizar pode significar:

expor API
automatizar deploy
melhorar observabilidade
integrar cloud
introduzir DevOps
reduzir etapas manuais

sem apagar o COBOL.

Passo 5 — Aprenda economia

Programador financeiro precisa entender:

receita
custo
risco
fraude
crédito
capital
margem
inadimplência

Seu código existe para sustentar negócio.

Passo 6 — Aprenda dados

Banco moderno é cada vez mais:

transação
+
dados
+
modelo
+
automação

Passo 7 — Nunca subestime UX

Um backend perfeito escondido atrás de uma experiência horrível continua sendo um produto ruim.


Capítulo 19 — O pequeno PERFORM que virou império

Existe algo quase poético na história do Nubank.

Ele não começou tentando resolver:

TODO O SISTEMA FINANCEIRO

Começou resolvendo:

UM PROBLEMA

Cartão.

Sem anuidade.

No smartphone.

Depois executou algo parecido com:

PERFORM EXPAND-PRODUCT
    UNTIL CUSTOMER-BASE = HUGE

Isso é uma lição de arquitetura e de carreira.

Quem começa COBOL às vezes tenta aprender tudo ao mesmo tempo:

COBOL
JCL
CICS
DB2
IMS
MQ
Assembler
Java
Python
Cloud
DevOps
AI

Calma.

Comece pelo cartão roxo.

Escolha seu primeiro problema.

Domine.

Depois expanda.


Capítulo 20 — O verdadeiro Lobo Roxo

No fim das contas, o Nubank não venceu simplesmente porque era digital.

Também não venceu porque bancos antigos eram incompetentes.

Muito menos porque COBOL estava ultrapassado.

Ele cresceu porque uma combinação rara aconteceu ao mesmo tempo:

SMARTPHONE
+
UX
+
BAIXA FRICÇÃO
+
MARCA
+
TIMING
+
DISTRIBUIÇÃO DIGITAL
+
DADOS
+
ESCALA
+
MUDANÇAS REGULATÓRIAS

O cartão roxo foi apenas a face visível.

Por trás dele existia uma tese poderosa:

a experiência bancária podia ser reconstruída colocando o cliente digital no centro.

E existe uma ironia deliciosa.

Os bancos tradicionais passaram décadas criando fortalezas tecnológicas incríveis.

Mainframes.

Redes.

Datacenters.

Sistemas de liquidação.

Processamento massivo.

Segurança.

Redundância.

O Nubank não precisou destruir a fortaleza.

Encontrou uma porta lateral.

Essa porta chamava-se:

EXPERIÊNCIA

Entrou por ali.

Depois que entrou, começou a construir sua própria fortaleza.


Epílogo — Wall Street encontra o CPD

Imagine novamente o salão.

Os grandes bancos continuam sentados.

Só que agora existe outra cadeira na mesa.

Roxa.

O veterano do mainframe olha para o jovem programador COBOL.

— Aprendeu alguma coisa?

O rapaz responde:

— Que startup mata legado?

O veterano dá um gole no café.

— Não.

— Que mainframe morreu?

— Também não.

— Então o quê?

Ele aponta para uma tela onde milhões de transações passam por segundo.

— Sistemas não perdem mercado porque são velhos.

Pausa.

— Perdem mercado quando deixam de resolver aquilo que o cliente considera importante.

O novato fica pensando.

Na tela aparece:

TRANSACTION APPROVED

O veterano sorri.

— E outra coisa.

— O quê?

— Nunca confunda uma interface simples com um sistema simples.

Atrás do botão roxo existe um mundo.

Crédito.

Fraude.

Liquidação.

Compliance.

Segurança.

Auditoria.

Dados.

Regulação.

Resiliência.

E, em algum lugar escondido do planeta financeiro, provavelmente um programa escrito décadas atrás ainda está fazendo alguma coisa importantíssima.

Talvez seja COBOL.

Talvez ninguém saiba quem escreveu.

Talvez exista um comentário:

* DO NOT CHANGE THIS ROUTINE.

Sem nenhuma explicação.

O jovem pergunta:

— Posso apagar?

O veterano encara.

— Wall Street tem uma regra.

— Qual?

— Se você não sabe por que existe, não execute DELETE.

☕ Fim do café.

E lembre-se:

na próxima vez que alguém mostrar um aplicativo moderno e disser:

“Isso substituiu o banco antigo.”

Pergunte:

E ONDE LIQUIDA?

Normalmente é aí que a conversa começa a ficar realmente interessante.

quarta-feira, 23 de outubro de 2024

🕶️ DIABOLIK NO MAINFRAME — O Roubo Perfeito e o Risk Score que Percebeu Tudo

 

Bellacosa Mainframe e o Risk Score

☕ Um Café no Bellacosa Mainframe

🕶️ DIABOLIK NO MAINFRAME — O Roubo Perfeito e o Risk Score que Percebeu Tudo

Fraude, AML, comportamento, dispositivos, transações, grafos e Risk Scoring em tempo real — porque o criminoso perfeito não precisa cometer um erro. Basta fazer algo que não combine com a vítima.

Há uma diferença fundamental entre um ladrão comum e Diabolik.

O ladrão comum tenta abrir a porta.

Diabolik já sabe onde está a chave.

O ladrão comum aparece diante da câmera.

Diabolik estudou o ângulo morto.

O ladrão comum rouba o cartão.

Diabolik prefere que o banco continue acreditando que o verdadeiro dono está usando o cartão.

E é justamente por isso que ele é um excelente personagem para entendermos o Risk Scoring moderno.

Imagine uma noite qualquer.

03:17.

Em algum lugar da cidade, um cliente chamado João dorme tranquilamente.

Seu cadastro no banco diz:

CUSTOMER: JOAO
KYC: OK
PEP: NO
SANCTIONS: NO
ACCOUNT AGE: 8 YEARS
RISK: LOW

Tudo parece normal.

O problema é que João não está usando sua conta.

Diabolik está.

E nosso sistema tem poucos milissegundos para perceber isso.

Bem-vindo ao estranho mundo onde conhecer a identidade do cliente já não basta.



🕶️ CAPÍTULO 1 — Diabolik não quer parecer Diabolik

O Risk Scoring tradicional tinha uma visão relativamente confortável do mundo.

O cliente chegava, apresentava seus documentos, passava pelas verificações necessárias e recebia determinada classificação:

LOW
MEDIUM
HIGH

Era quase uma fotografia.

No momento em que João abriu sua conta, o banco verificou identidade, endereço, documentos, profissão, renda e outros elementos necessários ao processo.

Depois disso:

JOAO = LOW RISK

O problema está na palavra é.

João não é necessariamente LOW RISK.

João estava associado a determinado nível de risco naquele contexto e naquele momento.

Meses depois, muita coisa pode ter mudado.

O cliente pode trocar de telefone, viajar, mudar endereço, começar a movimentar valores diferentes, adicionar beneficiários, alterar senhas e utilizar novos dispositivos.

E existe ainda uma possibilidade mais inquietante:

João continua sendo João.

Mas alguém conseguiu assumir sua identidade digital.

Diabolik não precisa modificar o cadastro.

Pelo contrário.

Quanto menos alterar, melhor.



🎭 CAPÍTULO 2 — A melhor máscara é uma identidade verdadeira

Essa é uma das ideias mais interessantes da fraude digital.

Imagine que um criminoso tenha:

CPF correto
nome correto
endereço correto
data de nascimento correta
credenciais corretas

Uma verificação baseada exclusivamente em identidade pode encontrar:

IDENTITY = VALID

E isso pode ser perfeitamente verdadeiro.

A identidade realmente existe.

O problema é outro:

quem está controlando aquela identidade naquele instante?

É uma diferença monumental.

Podemos ter:

IDENTITY RISK = LOW

e simultaneamente:

BEHAVIOR RISK = HIGH
DEVICE RISK   = HIGH
SESSION RISK  = HIGH

Por isso o Risk Scoring moderno deixa de perguntar apenas:

Quem é você?

E começa a perguntar:

O que está acontecendo?



📸 CAPÍTULO 3 — O velho sistema guardava fotografias

Vamos imaginar um sistema fictício chamado BELLABANK.

No cadastro de João encontramos:

CUSTOMER-ID : 00091827364
NAME        : JOAO SILVA
KYC-STATUS  : APPROVED
PEP-FLAG    : N
AML-RISK    : LOW
COUNTRY     : BR

Excelente.

Só que o cadastro não consegue contar sozinho a história seguinte:

03:17 NEW DEVICE

03:19 PASSWORD RESET

03:21 NEW BENEFICIARY

03:22 TRANSFER R$ 9.800

Cada evento isoladamente pode ser legítimo.

Pessoas compram celulares.

Pessoas esquecem senhas.

Pessoas cadastram beneficiários.

Pessoas transferem R$9.800.

Mas a sequência inteira é muito mais interessante.

É aí que começamos a sair da fotografia e entrar no filme.


Bellacosa Mainframe e o risk scoring

🎬 CAPÍTULO 4 — Risk Scoring transforma fotografia em filme

No modelo contínuo, o cliente não recebe apenas uma etiqueta eterna.

Podemos imaginar:

09:00 RISK = 12

Compra café.

09:17 RISK = 11

Usa o mesmo celular.

12:30 RISK = 10

Compra almoço num estabelecimento habitual.

Tudo normal.

Então:

03:17 NEW DEVICE

Score:

10 -> 22

Logo depois:

PASSWORD RESET

Score:

22 -> 39

Novo beneficiário:

39 -> 58

Transferência incomum:

58 -> 84

Diabolik ainda possui usuário e senha corretos.

O cadastro continua correto.

Mas agora o sistema diz:

IDENTITY = OK

BEHAVIOR = NOT OK

Esse é o coração da mudança.



🧮 CAPÍTULO 5 — O Risk Score entra em cena

Para um programador COBOL iniciante, podemos começar pensando em algo simples:

RISK-SCORE = 0

Cada fator acrescenta ou reduz pontos:

IF NEW-DEVICE = 'Y'
   ADD 10 TO RISK-SCORE
END-IF

IF PASSWORD-RESET = 'Y'
   ADD 15 TO RISK-SCORE
END-IF

IF NEW-BENEFICIARY = 'Y'
   ADD 20 TO RISK-SCORE
END-IF

IF UNUSUAL-AMOUNT = 'Y'
   ADD 25 TO RISK-SCORE
END-IF.

Teríamos:

10 + 15 + 20 + 25 = 70

E poderíamos estabelecer:

00-20 LOW
21-40 MEDIUM
41-60 HIGH
61-100 CRITICAL

É apenas um exemplo didático. Um sistema real exigiria muito mais cuidado com pesos, regras, contexto, validação, calibração e governança.

Mas a essência está aqui:

SIGNALS
   ↓
WEIGHTS
   ↓
RULES
   ↓
SCORE
   ↓
DECISION

💎 CAPÍTULO 6 — Nem todo diamante vale os mesmos pontos

Aqui Diabolik começa a rir do nosso programa COBOL.

Porque ele percebeu uma fragilidade.

Se nosso modelo simplesmente somar:

NEW DEVICE        +10
PASSWORD RESET    +10
NEW BENEFICIARY   +10
TRANSFER          +10

teremos:

RISK = 40

Mas talvez essa combinação específica represente risco muito maior.

É a diferença entre observar quatro acontecimentos e observar uma história formada por quatro acontecimentos.

Considere:

A = NEW DEVICE
B = PASSWORD RESET
C = NEW BENEFICIARY
D = LARGE TRANSFER

Não podemos assumir sempre que:

RISK(A+B+C+D)
=
RISK(A)+RISK(B)+RISK(C)+RISK(D)

A sequência pode produzir um risco adicional.

Em segurança, contexto importa.

Em fraude, ordem também importa.


⏱️ CAPÍTULO 7 — Diabolik conhece o relógio

Imagine:

01/08 NEW DEVICE
15/08 PASSWORD RESET
02/09 NEW BENEFICIARY
15/09 TRANSFER

Pode ser perfeitamente normal.

Agora:

03:17 NEW DEVICE
03:18 PASSWORD RESET
03:20 NEW BENEFICIARY
03:22 TRANSFER

Os eventos são praticamente os mesmos.

Mas o significado mudou completamente.

Entrou uma nova dimensão:

velocity.

Não basta perguntar:

WHAT?

Precisamos perguntar:

WHAT?
WHEN?
HOW OFTEN?
IN WHICH ORDER?

Em sistemas transacionais, tempo também é dado.


🧬 CAPÍTULO 8 — O melhor suspeito de João é o próprio João

Agora chegamos ao comportamento.

Imagine que João normalmente faça:

R$ 70
R$ 150
R$ 380
R$ 600
R$ 1.200

Então aparece:

R$ 9.800

Interessante.

Mas Maria administra uma empresa e normalmente movimenta:

R$ 30.000
R$ 70.000
R$ 120.000

Hoje ela movimentou:

R$ 9.800

Se tivermos uma regra burra:

IF AMOUNT > 5000
   HIGH-RISK
END-IF

João e Maria recebem tratamento semelhante.

Mas os comportamentos são completamente diferentes.

O sistema moderno procura estabelecer um baseline.

Ou seja:

como este cliente normalmente se comporta?

Isso permite comparar:

CURRENT BEHAVIOR
       versus
EXPECTED BEHAVIOR

A pergunta deixa de ser:

R$9.800 é muito?

E passa a ser:

R$9.800 é estranho para João?

Isso é muito mais poderoso.


🌍 CAPÍTULO 9 — Diabolik viaja rápido demais

Imagine:

20:00 LOGIN SAO PAULO

Depois:

20:35 LOGIN TOKYO

Talvez João tenha descoberto teletransporte.

Talvez seja VPN.

Talvez seja problema na geolocalização.

Talvez sejam sessões diferentes.

Ou talvez tenhamos uma conta comprometida.

Um bom sistema não deveria automaticamente concluir:

FRAUD!

Ele deveria produzir algo semelhante a:

IMPOSSIBLE_TRAVEL +25
NEW_DEVICE        +15
UNKNOWN_IP        +10

E combinar isso com todo o restante.

Essa é outra diferença fundamental.

Sinal não é sentença.

Sinal é evidência.


🕸️ CAPÍTULO 10 — O Inspetor Ginko descobre o grafo

Diabolik conseguiu ser perfeito.

Nenhuma transferência parece absurda.

Nenhum login parece impossível.

Nenhuma senha foi redefinida.

Individualmente, cada conta parece normal.

Então entra o equivalente digital do Inspetor Ginko.

Ele deixa de olhar apenas indivíduos e começa a observar relações.

              DEVICE-X
             /    |    \
            /     |     \
         JOAO   MARIA   CARLOS
           |      |       |
        ACCOUNT ACCOUNT ACCOUNT

Interessante.

Três pessoas diferentes utilizam o mesmo dispositivo.

Isso é fraude?

Não necessariamente.

Pode ser uma família.

Pode ser uma empresa.

Pode ser um equipamento compartilhado.

Agora descobrimos:

DEVICE-X
   |
   +--- ACCOUNT-A
   |
   +--- ACCOUNT-B
   |
   +--- ACCOUNT-C
   |
   +--- ACCOUNT-D

E duas dessas contas tiveram fraude confirmada.

A relação ficou mais interessante.

Estamos entrando no mundo de graph analytics.

Clientes, contas, cartões, dispositivos, IPs, telefones, endereços, merchants e beneficiários podem ser representados como nós conectados.

O risco pode estar não apenas no indivíduo.

Pode estar na rede à qual ele pertence.


💳 CAPÍTULO 11 — Diabolik entra no BELLACARD

Vamos colocar nosso ladrão dentro de um sistema de cartões.

Diabolik conseguiu utilizar o cartão de João.

Uma autorização chega:

CARD
AMOUNT
MERCHANT
MCC
COUNTRY
TERMINAL
TIMESTAMP

O sistema tradicional verifica:

CARD VALID?
ACCOUNT ACTIVE?
LIMIT AVAILABLE?
CARD BLOCKED?
PIN/CVV VALID?

Mas agora adicionamos:

RISK ENGINE

Arquiteturalmente:

POS / ATM / MOBILE
        |
        v
 TRANSACTION
        |
        v
+----------------+
| AUTHORIZATION  |
+----------------+
        |
   +----+-----+
   |          |
   v          v
ACCOUNT    RISK ENGINE
   |          |
   +----+-----+
        |
        v
 DECISION ENGINE
        |
 +------+------+------+
 |      |      |      |
APPROVE MONITOR VERIFY DECLINE

Agora o Risk Score passa a participar da decisão.


🚦 CAPÍTULO 12 — Nem todo suspeito deve ser preso

Essa talvez seja a parte mais importante do conceito inteiro.

Imagine:

RISK 12

Resposta:

APPROVE

Score:

RISK 32

Talvez:

APPROVE + MONITOR

Score:

RISK 54

Talvez:

STEP-UP AUTHENTICATION

Peça biometria.

Confirmação adicional.

MFA.

Outro fator.

Score:

RISK 72

Talvez:

REVIEW

Score:

RISK 96

Talvez:

DECLINE
BLOCK
INVESTIGATE

Perceba a mudança.

Risk Scoring não serve exclusivamente para dizer:

NÃO.

Ele pode ajudar o sistema a decidir quanto de confiança adicional precisa antes de dizer SIM.


💰 CAPÍTULO 13 — Prender todo mundo também custa dinheiro

Imagine uma instituição aterrorizada com fraude.

Ela cria:

IF TRANSACTION-AMOUNT > 5000
   DECLINE
END-IF

Fraudes diminuem.

O diretor comemora.

Até aparecer outro relatório:

APPROVAL RATE ↓
CUSTOMER SATISFACTION ↓
REVENUE ↓
ABANDONMENT ↑
SUPPORT CALLS ↑

Descobrimos o false positive.

O cliente era legítimo.

Nosso sistema o tratou como criminoso.

Diabolik escapou enquanto prendíamos João.

É quase poeticamente apropriado.


⚖️ CAPÍTULO 14 — O Risk Engine vive entre dois erros

Todo sistema antifraude vive numa tensão.

Se for permissivo demais:

FRAUD ↑
LOSSES ↑

Se for rígido demais:

FALSE POSITIVES ↑
CUSTOMER FRICTION ↑
DECLINES ↑
REVENUE ↓

Então existe uma espécie de equação empresarial:

MAXIMIZE

LEGITIMATE APPROVALS
REVENUE
CUSTOMER EXPERIENCE

MINIMIZE

FRAUD
AML EXPOSURE
CHARGEBACKS
OPERATIONAL COST
REGULATORY RISK

Risk Scoring não elimina essa tensão.

Ele nos permite administrá-la com maior granularidade.


🏦 CAPÍTULO 15 — Fraud e AML moram no mesmo prédio, mas não são irmãos gêmeos

Fraude e AML podem utilizar muitos sinais semelhantes:

IDENTITY
TRANSACTIONS
DEVICES
LOCATION
BENEFICIARIES
BEHAVIOR
NETWORK

Mas não são exatamente o mesmo problema.

Fraude normalmente está preocupada com apropriação indevida, engano, abuso de contas, pagamentos ou recursos.

AML olha para riscos associados à movimentação e possível lavagem de recursos, entre outras tipologias de crime financeiro.

Podemos ter:

FRAUD SCORE
     |
     +------+
            |
            v
      COMPOSITE RISK
            ^
            |
     +------+
     |
AML SCORE

A vantagem está em compartilhar sinais sem destruir as particularidades de cada disciplina.


🤖 CAPÍTULO 16 — Então chega a Inteligência Artificial

Até aqui podemos fazer muita coisa com regras.

Mas temos milhões de eventos.

Centenas de variáveis.

Relações complexas.

Padrões temporais.

Machine Learning pode ajudar a encontrar combinações que seriam extremamente difíceis de escrever manualmente.

O problema aparece quando recebemos:

MODEL OUTPUT = 97

Perguntamos:

WHY?

E o computador responde metaforicamente:

¯\_(ツ)_/¯

Não.

Ginko não aceitaria.

O auditor muito menos.

Um sistema robusto precisa oferecer reason codes, evidências, rastreabilidade e governança.

Por exemplo:

RISK SCORE = 91

REASONS:

R017 NEW DEVICE
R042 IMPOSSIBLE TRAVEL
R071 UNUSUAL AMOUNT
R103 NEW BENEFICIARY
R121 HIGH VELOCITY

Agora o número possui uma história.


🗄️ CAPÍTULO 17 — Ginko entra no Db2

Vamos finalmente entrar no IBM Z.

Podemos imaginar:

CHANNELS
 |
 +-- MOBILE
 +-- WEB
 +-- ATM
 +-- POS
 |
 v
API / MESSAGE LAYER
 |
 v
CICS
 |
 +----------+
 |          |
 v          v
Db2       IBM MQ
 |          |
 |          v
 |       EVENTS
 |          |
 +-----> RISK ENGINE
            |
      +-----+-----+
      |     |     |
    RULES  ML   GRAPH
      |     |     |
      +-----+-----+
            |
            v
        RISK SCORE
            |
            v
      DECISION ENGINE

O detalhe crucial:

o cliente está esperando.

No supermercado, João não quer assistir a uma arquitetura de 47 microsserviços discutindo se deve aprovar seu café.

Ele quer:

BIP!
APROVADO

Portanto latência importa.

Muito.


⚡ CAPÍTULO 18 — O roubo perfeito dura milissegundos

Uma transação online pode precisar executar diversas verificações:

CARD VALIDATION
ACCOUNT LOOKUP
LIMIT CHECK
STATUS CHECK
FRAUD RULES
RISK SCORE
AUTHORIZATION
LOGGING

Tudo dentro de um orçamento de latência.

Essa é uma das razões pelas quais a arquitetura de sistemas críticos é tão fascinante.

Não basta calcular corretamente.

Precisamos calcular corretamente a tempo.

O Risk Engine que responde depois que a transação terminou é como Ginko chegando ao cofre na manhã seguinte.

Interessante para investigação.

Inútil para impedir aquele evento.


🧯 CAPÍTULO 19 — O sistema também precisa investigar a si mesmo

Imagine uma nova regra.

Ela bloqueia 40% das transações de determinado segmento.

Fraude cai 2%.

Parece bom?

Talvez não.

Precisamos observar:

APPROVAL RATE
DECLINE RATE
FRAUD RATE
FALSE POSITIVE RATE
CHARGEBACK RATE
CHALLENGE RATE
MANUAL REVIEW RATE

Também:

RULE HIT RATE
SCORE DISTRIBUTION
REASON CODES

E algo que considero particularmente interessante:

SCORE MIGRATION

Quem passou:

LOW -> MEDIUM

Quem passou:

MEDIUM -> HIGH

E principalmente:

LOW -> CRITICAL

O valor não está somente em descobrir quem está perigoso.

Está em descobrir quem está mudando rapidamente.


⌛ CAPÍTULO 20 — Até suspeitas envelhecem

João viajou.

Usou um novo dispositivo.

Fez uma transação diferente.

Seu score subiu:

RISK = 68

Depois voltou para casa.

Utilizou normalmente sua conta por semanas.

Nada estranho aconteceu.

Deveria continuar em 68 para sempre?

Provavelmente não.

Podemos introduzir o conceito de risk decay.

Conforme o tempo passa sem novos sinais relevantes:

68
 |
 v
55
 |
 v
41
 |
 v
28

Isso impede que eventos antigos se transformem em condenações eternas.

Tempo não serve apenas para aumentar risco.

Também pode ajudar a contextualizá-lo.


🎯 CAPÍTULO 21 — O Risk Score também pode ser atacado

Aqui Diabolik percebe outra coisa.

Se conseguir descobrir as regras, poderá tentar permanecer abaixo dos thresholds.

Suponha:

R$10.000 = HIGH RISK

Então ele tenta:

R$4.800
R$4.700
R$4.900

Uma regra olha para cada evento:

OK
OK
OK

Um sistema contextual observa:

3 TRANSACTIONS
SHORT WINDOW
TOTAL R$14.400
UNUSUAL VELOCITY

E responde:

RISK ↑

Isso nos ensina outra coisa importante:

fraudadores também observam sistemas antifraude.

O Risk Engine não enfrenta um fenômeno estático.

Existe um adversário adaptativo do outro lado.


🧪 CAPÍTULO 22 — Champion contra Challenger

Se alterarmos um modelo de risco diretamente em produção, podemos criar nosso próprio desastre.

Então imagine:

CHAMPION MODEL

É o modelo atualmente utilizado.

Ao lado:

CHALLENGER MODEL

O challenger pode receber os mesmos eventos sem necessariamente controlar a decisão final.

Depois comparamos:

FRAUD DETECTION
FALSE POSITIVES
APPROVAL RATE
LATENCY
STABILITY

Se realmente for melhor, pode tornar-se o novo champion.

Isso transforma Risk Scoring em processo de engenharia, e não numa coleção de palpites.


🧾 CAPÍTULO 23 — Diabolik odeia auditoria

Imagine que seis meses depois alguém pergunte:

Por que a transação 918273 foi recusada?

Não podemos responder:

Porque o score estava alto.

Precisamos conseguir reconstruir:

TRANSACTION
MODEL VERSION
RULE VERSION
INPUT DATA
SCORE
REASON CODES
DECISION
TIMESTAMP

Idealmente:

03:17:01 EVENT RECEIVED
03:17:01 DEVICE RULE HIT
03:17:01 VELOCITY RULE HIT
03:17:01 SCORE 82
03:17:01 STEP-UP REQUESTED
03:17:04 MFA FAILED
03:17:04 DECLINED

Isso é auditabilidade.

E em sistemas financeiros ela não é decoração arquitetural.

É parte do produto.


🕵️ CAPÍTULO 24 — A máquina encontra a pista; Ginko monta o caso

Automação não significa necessariamente remover o investigador.

Significa evitar que ele desperdice seu tempo procurando palha.

Imagine um analista recebendo:

CASE 827364

CUSTOMER: JOAO
RISK: 93

TRIGGERS:
NEW DEVICE
PASSWORD RESET
NEW BENEFICIARY
UNUSUAL TRANSFER
SHARED DEVICE

RELATED:
7 ACCOUNTS

CONFIRMED FRAUD:
2 ACCOUNTS

Agora existe um caso investigável.

A máquina percorreu milhões de eventos.

O humano recebeu uma exceção relevante.

MACHINE
   |
   v
DETECT
   |
   v
CORRELATE
   |
   v
PRIORITIZE
   |
   v
HUMAN INVESTIGATION

Essa parceria é muito mais interessante do que a fantasia de simplesmente substituir todo investigador por IA.


💎 CAPÍTULO 25 — Finalmente Diabolik chega ao cofre

Às 03:17, Diabolik inicia sua operação.

Primeiro:

LOGIN

Nada acontece.

Depois:

NEW DEVICE

Pequena alteração.

Depois:

PASSWORD RESET

Outra alteração.

Depois:

NEW BENEFICIARY

O sistema começa a ficar desconfiado.

Finalmente:

TRANSFER R$ 48.000

O antigo sistema talvez enxergasse:

JOAO
KYC OK
ACCOUNT ACTIVE
BALANCE AVAILABLE

O novo sistema enxerga:

JOAO
+
NEW DEVICE
+
PASSWORD RESET
+
NEW BENEFICIARY
+
UNUSUAL AMOUNT
+
HIGH VELOCITY
+
BEHAVIORAL DEVIATION

Resultado:

RISK SCORE = 94

Decision Engine:

STEP-UP AUTHENTICATION

Diabolik possui usuário.

Possui senha.

Possui dados pessoais.

Mas falta alguma coisa que João possui.

A operação falha.

Não porque o sistema descobriu:

Este homem é Diabolik.

Isso seria impossível.

Ele descobriu algo muito mais útil:

Quem quer que esteja realizando esta operação não está se comportando como João.

Esse é o verdadeiro poder da análise comportamental.


🐣 EASTER EGG — 03:17

Quem já visitou algumas vezes o Bellacosa Mainframe percebeu.

Algo sempre acontece às:

03:17

É o horário em que ninguém deveria estar olhando.

O batch está trabalhando.

O operador tomou café.

O desenvolvedor jurou que não mexeu em produção.

E algum JOB misterioso aparece:

JOBNAME  DIABOLIK
OWNER    UNKNOWN
STATUS   EXECUTING

Ginko abre o SDSF.

Procura o JOB.

Nada.

Só encontra no SYSOUT:

ICH408I
USER(DIABOLIK) ACCESS DENIED

Desta vez, RACF ganhou.

☕


🧠 CAPÍTULO 26 — O que o programador COBOL iniciante precisa guardar

Depois de toda essa perseguição, podemos reduzir o Risk Scoring a uma cadeia bastante compreensível:

RECEIVE EVENT
     |
     v
IDENTIFY CUSTOMER
     |
     v
LOAD CONTEXT
     |
     v
READ HISTORY
     |
     v
CALCULATE SIGNALS
     |
     v
APPLY RULES
     |
     v
CALCULATE SCORE
     |
     v
MAKE DECISION
     |
     v
LOG EVERYTHING

Veja que curioso.

Quando retiramos os nomes modernos, aparecem conceitos conhecidos:

INPUT
VALIDATION
LOOKUP
BUSINESS RULE
CALCULATION
DECISION
AUDIT
COMMIT

O programador COBOL de 1985 reconheceria boa parte da lógica.

O que mudou foi a quantidade de contexto disponível e a velocidade necessária para correlacioná-lo.

Hoje podemos acrescentar:

DEVICE
IP
LOCATION
BEHAVIOR
VELOCITY
GRAPH
ML
REAL-TIME EVENTS

Mas o problema fundamental continua lindamente familiar:

DADOS
  +
REGRAS
  +
CONTEXTO
  =
DECISÃO

☕ EPÍLOGO — Ginko nunca precisou saber quem estava atrás da máscara

Essa talvez seja a grande lição de Risk Scoring.

O modelo antigo queria classificar pessoas:

LOW
MEDIUM
HIGH

O modelo moderno procura compreender situações:

CUSTOMER
+
TRANSACTION
+
DEVICE
+
LOCATION
+
TIME
+
BEHAVIOR
+
HISTORY
+
RELATIONSHIPS

E calcula novamente quando o contexto muda.

Isso muda também a relação entre segurança e negócio.

Um bom cliente realizando uma operação compatível com seu comportamento pode receber menos atrito.

Uma pequena anomalia pode receber monitoramento.

Uma situação intermediária pode receber autenticação adicional.

Uma sequência altamente suspeita pode ser bloqueada ou enviada para investigação.

Portanto:

RISK ≠ BLOCK

Risk é informação para decidir qual controle é proporcional à situação.

É isso que torna o Risk Scoring moderno tão interessante para fintechs, bancos, adquirentes, sistemas de cartões e arquiteturas de pagamentos.

A missão não é bloquear o maior número possível de transações.

É algo muito mais difícil:

bloquear Diabolik sem impedir João de comprar o jantar.

E existe uma ironia maravilhosa nisso.

Diabolik passou décadas aperfeiçoando máscaras, identidades falsas, disfarces e planos perfeitos.

No mundo digital, porém, talvez ele encontre um adversário diferente.

Não uma câmera procurando seu rosto.

Não um policial procurando seu nome.

Não um cadastro perguntando quem ele diz ser.

Mas um Risk Engine silencioso perguntando:

Você possui as credenciais de João.

Você conhece os dados de João.

Você entrou na conta de João.

Mas...

por que não está se comportando como João?

No outro lado da tela, Ginko sorri.

O RISK-SCORE muda:

17
29
46
68
94

Diabolik aperta ENTER.

O mainframe responde:

TRANSACTION DECLINED

REASON:
BEHAVIORAL RISK

RETURN-CODE: 08

E em algum lugar do data center, provavelmente ao lado de um programa COBOL que ninguém ousa recompilar desde 1997, o JOB continua EXECUTING.

Porque no Risk Scoring moderno, o crime perfeito não precisa deixar uma impressão digital.

Basta deixar uma anomalia. ☕🕶️💻



quinta-feira, 25 de julho de 2024

💵 Bud Fox e a Fintech de Wall Street — Quando Vibe Coding encontra Context Engineering

 

Bellacosa Mainframe e a codificação vibe coding e context engineering

☕ Um Café no Bellacosa Mainframe

💵 Bud Fox e a Fintech de Wall Street — Quando Vibe Coding encontra Context Engineering

SDD, DDD, Monólito Modular, Evals, Engineering Loop, agentes de IA e a perigosa diferença entre gerar código que funciona e construir software em que podemos confiar.



Nova York, 1987.

Bud Fox atravessa os corredores da Jackson Steinem & Co. com dois telefones, uma agenda cheia de nomes e uma obsessão: descobrir alguma informação que os outros ainda não possuem.

Em Wall Street, informação significa vantagem.

Quase quarenta anos depois, troque o pregão por uma IDE, os terminais financeiros por agentes de IA e as ações por milhares de classes Java.

A questão continua surpreendentemente parecida:

informação sem contexto pode ser tão perigosa quanto informação nenhuma.

Nossa história começa com uma proposta irresistível.

Vamos construir uma fintech.

E vamos usar IA.



🎬 CAPÍTULO 1 — Bud Fox descobre Vibe Coding

Imagine Bud Fox chegando ao escritório de tecnologia.

Ele abre seu agente de IA e escreve:

Crie uma fintech em Java 21.

Spring Boot
PostgreSQL
Kafka
DDD
Arquitetura Hexagonal
Monólito Modular

Módulos:

Customers
Accounts
Pix
Fraud
Ledger
Notifications

ENTER.

Alguns minutos depois aparecem:

Controllers
Services
Repositories
Entities
DTOs
Migrations
Tests
Dockerfiles
Kafka configuration
REST APIs

Bud olha para a tela.

— Isso costumava levar semanas!

Bem-vindo ao Vibe Coding.

Gerar software tornou-se extraordinariamente barato. O material que analisamos começa justamente com essa constatação: descrevemos algo para um agente e rapidamente aparecem controllers, migrations, testes, Dockerfiles e dezenas de classes.

Bud encontrou sua primeira ação quente.

Só existe um problema.

O programa funcionar hoje não significa que sua arquitetura sobreviverá aos próximos 500 prompts.



📈 CAPÍTULO 2 — O primeiro lucro esconde a primeira dívida

Bud pede:

Implemente Send Pix.

A IA escreve.

Depois:

Adicione limite Pix.

Ela escreve.

Depois:

Adicione análise antifraude.

Mais código.

Prompt número 47:

Implemente estorno.

Prompt número 83:

Adicione Pix agendado.

Então aparece:

account.setBalance(
    account.getBalance().subtract(amount)
);

Excelente Java.

Provavelmente compila.

Talvez passe nos testes.

E está completamente errado.

Por quê?

Porque meses atrás nossa equipe tomou uma decisão arquitetural:

Ledger é a única fonte de verdade financeira.

Accounts conhece conta, estado, bloqueios e limites. Ledger conhece journals, débitos, créditos e posição financeira. Essa divisão de responsabilidade está explicitamente definida no modelo que estamos estudando.

O agente sabia Java.

Sabia Spring.

Sabia PostgreSQL.

Sabia como subtrair amount.

O que ele não sabia era:

como esta empresa decidiu representar dinheiro.

E encontramos nosso primeiro princípio.

Código correto localmente pode estar errado globalmente.



🦈 CAPÍTULO 3 — Gordon Gekko aparece na arquitetura

Se Gordon Gekko estivesse olhando nosso repositório, provavelmente perguntaria:

— Quem é dono de quê?

Excelente pergunta.

Porque software corporativo não é apenas um conjunto de classes.

É uma coleção de responsabilidades.

Nossa fintech possui:

Customers
    │
    │ identidade, cadastro, KYC
    │
Accounts
    │
    │ status, bloqueios, limites
    │
Pix
    │
    │ transferências
    │
    ├────────────► Fraud
    │               risco
    │
    ▼
Events
    │
    ├────────────► Ledger
    │               contabilidade
    │
    └────────────► Notifications
                    mensagens

Essa arquitetura possui uma característica particularmente interessante:

é um monólito modular.

Existe um único grande deployment, mas dentro dele tentamos preservar fronteiras claras.

com.bellacosa.fintech

├── customers
├── accounts
├── pix
├── fraud
├── ledger
└── notifications

Não confunda isso com um monólito desorganizado.

A intenção é praticamente:

uma cidade dentro de uma muralha, mas dividida em bairros com responsabilidades próprias.



🏦 CAPÍTULO 4 — Accounts não é Ledger

Essa distinção merece ficar gravada na parede do pregão.

Imagine:

ACCOUNT

A tentação inicial seria criar:

Account

customer
number
status
balance
limit
riskScore
pixKeys
transactions

Pronto.

Nasceu o God Object.

Em nossa fintech preferimos:

ACCOUNTS

Account
AccountStatus
AccountLimit
AccountRestriction

Enquanto:

LEDGER

Journal
LedgerEntry
Debit
Credit
Balance

E Fraud possui:

RiskAssessment
RiskScore
RiskDecision

Pix:

PixTransfer
PixKey
TransferStatus

Portanto:

ACCOUNT != MONEY

Essa aparentemente pequena decisão arquitetural é enorme.

Accounts responde:

A conta pode operar?

Fraud:

Esta operação apresenta risco aceitável?

Pix:

Qual é o estado da transferência?

Ledger:

O que aconteceu financeiramente?

Agora nossa IA começa a receber uma coisa muito mais importante do que instruções de programação.

Ela recebe semântica.


🧠 CAPÍTULO 5 — Bud Fox descobre Context Engineering

Bud percebe que ficar repetindo tudo em prompts é inviável.

Inicialmente:

Crie uma API Pix.

Depois:

Crie uma API Pix usando DDD.

Logo chegamos ao monstro:

Java 21.
Spring Boot.
PostgreSQL.
Kafka.
DDD.
Hexagonal.
Modular Monolith.
Pix não acessa AccountRepository.
Ledger controla saldo.
Use Outbox.
Use idempotência.
Use double-entry bookkeeping.
...

O próprio material mostra essa evolução e aponta o limite da estratégia: o prompt não deveria funcionar como banco de memória da engenharia do produto.

É quando Bud encontra algo muito mais valioso que uma ação privilegiada.

Context Engineering.

Prompt Engineering pergunta:

Como faço uma boa pergunta ao modelo?

Context Engineering pergunta:

Quais informações o agente precisa ter disponíveis para tomar uma boa decisão?

Parece apenas uma mudança de frase.

Não é.

É uma mudança de arquitetura.


📚 CAPÍTULO 6 — O conhecimento sai do chat

Começamos a construir:

docs/

├── domain/
│   ├── bounded-contexts.md
│   ├── ubiquitous-language.md
│   ├── ownership.md
│   ├── business-rules.md
│   └── context-map.md
│
└── architecture/
    ├── c4.md
    └── adr/

Agora podemos registrar:

OWN-001

Customers é proprietário
da identidade do cliente.
OWN-002

Accounts é proprietário
do estado operacional da conta.
OWN-003

Ledger é proprietário
da posição financeira.

E:

ARCH-007

Pix não acessa diretamente
Accounts Infrastructure.

Agora a IA não precisa “lembrar” dessas decisões.

Elas existem fora dela.

Essa é uma diferença monumental:

ANTES

Chat
 ↓
IA
 ↓
Code

torna-se:

DOMAIN
   +
ARCHITECTURE
   +
DECISIONS
   +
RULES
   ↓
AGENT
   ↓
CODE

A organização começa a possuir uma memória de engenharia.


🗺️ CAPÍTULO 7 — Bud desenha o mapa de Wall Street

Existe outra pergunta.

Se Pix precisa descobrir se uma conta pode transferir, ele pode simplesmente acessar:

AccountRepository

?

Não.

Porque isso atravessa a fronteira do módulo Accounts.

O material sugere algo conceitualmente parecido com:

PIX
 │
 ▼
AccountTransferEligibility
 │
 ▼
ACCOUNTS

Pix pergunta:

Essa conta pode transferir?

Ele não pergunta:

Me entregue sua tabela, repository e estrutura interna que eu resolvo daqui.

A mesma lógica vale para Fraud.

Errado:

PIX
 ↓
FraudRepository
 ↓
FraudRule
 ↓
RiskModel

Melhor:

PIX
 ↓
RiskAssessment
 ↓
FRAUD

Pix quer uma decisão.

Não precisa conhecer a cozinha inteira que produziu essa decisão.


🚨 CAPÍTULO 8 — O maior perigo do monólito modular

Aqui existe uma armadilha deliciosa.

No microservice:

PIX SERVICE

    rede

ACCOUNTS SERVICE

existe uma barreira física.

No monólito:

pix/
accounts/

está tudo no mesmo lugar.

Então alguém pensa:

“Vou pegar só esse repository rapidinho.”

import accounts.infrastructure.AccountRepository;

Funciona.

E exatamente por funcionar é perigoso.

Começamos:

Pix → Accounts

Depois:

Pix → Accounts Infrastructure

Fraud faz igual.

Notifications também.

Logo:

        Customers
       ↙    ↓    ↘
Accounts ↔ Pix ↔ Fraud
  ↕       ↕       ↕
Ledger ↔ Events ↔ Notifications

Parabéns.

Criamos o espaguete modular.

A pasta continua bonita.

A arquitetura morreu.


🎯 CAPÍTULO 9 — SDD entra no pregão

Bud recebe a próxima demanda:

Send Pix.

Antes ele pediria:

Implemente Send Pix.

Agora começa pela intenção.

INTENT
   ↓
SPEC
   ↓
RESEARCH
   ↓
DATA MODEL
   ↓
CONTRACTS
   ↓
PLAN
   ↓
TASKS
   ↓
IMPLEMENTATION

Esse é justamente o fluxo de Spec-Driven Development proposto no material.

Criamos:

specs/
└── 005-send-pix/

    ├── spec.md
    ├── research.md
    ├── data-model.md

    ├── contracts/
    │   ├── api.md
    │   └── events.md

    ├── evals/

    ├── plan.md
    └── tasks.md

Ainda não começamos pelo PixController.

Começamos perguntando:

O que significa transferir dinheiro neste negócio?

Essa pergunta vale mais que cinquenta classes.


📜 CAPÍTULO 10 — A Spec é o prospecto da operação

Nossa spec.md pode declarar:

FEATURE

Send Pix

Objetivo:

Transferir dinheiro entre contas
respeitando elegibilidade,
fundos disponíveis,
limites,
risco,
contabilidade
e idempotência.

E então aparecem as regras:

BR-001
A conta deve existir.

BR-002
A conta deve estar ativa.

BR-003
O valor deve ser maior que zero.

BR-004
Devem existir fundos disponíveis.

BR-005
O limite Pix deve ser respeitado.

BR-006
A análise de risco deve aprovar
a operação.

BR-007
A mesma Idempotency-Key não pode
produzir duas transferências.

São exatamente as classes de regras usadas no exemplo original.

Agora o agente não precisa adivinhar o negócio.

Mas surge outro problema.


🕵️ CAPÍTULO 11 — Gordon Gekko pergunta: “Quem fiscaliza?”

Podemos escrever:

Pix não pode acessar Accounts Infrastructure.

Excelente.

Então um agente escreve:

import accounts.infrastructure.AccountRepository;

A documentação dizia não.

O código disse sim.

Quem ganhou?

O compilador.

Precisamos transformar regras humanas em regras verificáveis.

Entram os:

🧪 EVALS

Podemos pensar:

SPEC
=
o que esperamos

EVAL
=
como demonstramos que continua verdadeiro

Essa relação aparece claramente no material.


🛡️ CAPÍTULO 12 — A SEC da nossa arquitetura

Vamos criar alguns fiscais.

Architecture Eval

PIX não pode importar:

accounts.infrastructure
ledger.infrastructure
fraud.infrastructure

Idempotency Eval

Given

Idempotency-Key = ABC123

When

POST /pix/transfers
é executado duas vezes

Then

existe apenas uma PixTransfer.

Ledger Eval

Pix = R$100

Debit  = R$100
Credit = R$100

sum(debits) == sum(credits)

Esses exemplos aparecem diretamente no modelo estudado.

Evals tornam a arquitetura menos dependente da boa vontade do programador.

Ou da memória da IA.


🧪 CAPÍTULO 13 — Eval não significa apenas JUnit

Essa distinção é essencial.

Podemos ter:

DOMAIN EVALS

Regras de negócio.

ARCHITECTURE EVALS

Fronteiras.

CONTRACT EVALS

APIs e eventos.

INTEGRATION EVALS

Banco, Kafka, Outbox.

SECURITY EVALS

Autorização e exposição de dados.

CONCURRENCY EVALS

Operações simultâneas.

ACCOUNTING EVALS

Integridade contábil.

OBSERVABILITY EVALS

Se conseguiremos descobrir o que aconteceu quando tudo der errado.

O material também trata Evals dessa maneira ampla, indo muito além de testes unitários.


⚔️ CAPÍTULO 14 — Dois traders querem gastar o mesmo dinheiro

Temos:

Saldo disponível = R$1.000

Chegam simultaneamente:

PIX A = R$800
PIX B = R$800

Processo A lê:

saldo = 1000

Processo B:

saldo = 1000

A conclui:

1000 >= 800

B também.

Resultado possível:

R$1.600 transferidos

contra:

R$1.000 disponíveis.

Nosso happy-path:

Given saldo 1000
When Pix 800
Then aprovado

passaria maravilhosamente.

Mas precisamos de:

CONCURRENCY-EVAL-001

Given

availableFunds = 1000

When

Pix A = 800
Pix B = 800

simultaneamente

Then

somente uma operação
pode consumir os fundos.

Agora começamos a testar não apenas exemplos.

Testamos invariantes.


🔁 CAPÍTULO 15 — A mesma ordem chegou duas vezes

Outro clássico do mercado financeiro.

Cliente envia:

POST /pix/transfers
Idempotency-Key: ABC123

A rede fica lenta.

Nenhuma resposta.

O aplicativo tenta novamente.

Sem idempotência:

PIX #1001   R$100
PIX #1002   R$100

Com idempotência:

Request 1 ──┐
            │
            ├── ABC123 ──► PIX #1001
            │
Request 2 ──┘

Mas existe uma segunda armadilha.


📬 CAPÍTULO 16 — Kafka telefona novamente

Nossa arquitetura:

PIX
 │
 ▼
OUTBOX
 │
 ▼
KAFKA
 │
 ▼
LEDGER

Ledger recebe:

PixTransferCompleted #777

Produz:

Debit  R$100
Credit R$100

Depois o evento chega novamente.

Se o consumidor não for idempotente:

Debit 100
Credit 100

Debit 100
Credit 100

O livro continua matematicamente equilibrado!

Mas economicamente duplicamos a operação.

Esse é um detalhe extraordinariamente importante:

consistência matemática não implica correção de negócio.

O próprio exemplo do material usa duplicação de eventos gerando lançamentos repetidos para demonstrar como produção pode revelar uma invariante que faltava.


🔄 CAPÍTULO 17 — Engineering Loop: o fechamento do pregão não encerra a história

Software não termina no merge.

Nem no deploy.

Nosso ciclo passa a ser:

UNDERSTAND
    ↓
IMPLEMENT
    ↓
TEST
    ↓
REVIEW
    ↓
OBSERVE
    ↓
LEARN
    ↺

Understand

O agente consulta:

Spec
Business Rules
Ownership
Context Map
ADRs
Contracts
Evals

Implement

Escreve dentro dessas fronteiras.

Test

Executa:

Unit
Integration
Contract
Architecture
Security
Evals

Review

Perguntamos:

Atendeu à intenção?

Quebrou algum contexto?

Introduziu acoplamento?

Idempotência continua válida?

Há risco concorrente?

Observe

Produção finalmente fala.

Learn

E aqui acontece a mágica.


📊 CAPÍTULO 18 — Produção é o verdadeiro mercado

Nosso Pix entra em produção.

Passamos a observar:

pix_transfer_total

pix_transfer_success_total

pix_transfer_failed_total

pix_transfer_duration_seconds

fraud_analysis_duration_seconds

outbox_pending_events

Esses sinais também aparecem no modelo de Engineering Loop estudado.

Então...

03:17.

O telefone toca.

☕ Easter egg Bellacosa desbloqueado.

Existe lançamento duplicado.

Bud Fox olha para o monitor.

O mercado está aberto.

Só que agora o mercado é produção.


🧯 CAPÍTULO 19 — Não corrija apenas o bug

A abordagem antiga:

INCIDENT
 ↓
BUG
 ↓
FIX
 ↓
DEPLOY

A abordagem que estamos construindo:

INCIDENT
    ↓
ANALYSIS
    ↓
FINDING
    ↓
DECISION
    ↓
 ┌──┴───────────────┐
 ▼                  ▼
CODE              CONTEXT
 ▼                  ▼
TEST               ADR
 ▼                  ▼
EVAL               SPEC
 └────────┬─────────┘
          ▼
       LEARNING

Descobrimos:

Duplicate event delivery
can generate duplicate
ledger postings.

Decidimos:

All financial consumers
must be idempotent.

Criamos:

006-ledger-consumer-idempotency/

Exatamente como no cenário do material.

O incidente não produziu apenas patch.

Produziu conhecimento.


🧠 CAPÍTULO 20 — Aqui está a verdadeira fortuna de Bud Fox

Agora chegamos ao ponto que considero mais importante de toda essa arquitetura.

Um incidente ocorrido hoje não deveria permanecer apenas:

na memória do arquiteto

num ticket

num e-mail

num post-mortem

num canal de chat

num comentário de código

Ele precisa alimentar:

INCIDENT
   ↓
LEARNING
   ↓
CONTEXT

E então:

CONTEXT
   ↓
NEXT AGENT

O material faz exatamente essa inversão: contexto deixa de ser apenas entrada e passa a ser também saída do processo de engenharia.

Isso transforma Context Engineering numa espécie de memória institucional versionada.


🗃️ CAPÍTULO 21 — ADR: o arquivo secreto de Gordon Gekko

Imagine:

ADR-023

Título:

Ledger is the financial
source of truth

Não basta escrever:

Decision:

Ledger owns balance.

Precisamos explicar:

Context:

Accounts represents operational state.

Ledger represents financial state.

Decision:

All financial postings belong to Ledger.

Consequences:

Accounts cannot change balance.

Pix cannot maintain balance.

Cards cannot maintain balance.

Financial position must be derived
from Ledger.

Agora, meses depois, alguém pede:

Implemente cashback.

O agente encontra ADR-023.

Sem ele poderia criar:

account.addBalance(cashback);

Com ele percebe:

Cashback
   ↓
Ledger Posting
   ↓
Debit/Credit

ADR não é apenas documentação histórica.

Para agentes, pode funcionar como memória de decisões e de suas justificativas.


🧭 CAPÍTULO 22 — Mas Context Engineering também pode virar um monstro

Agora Bud encontra outro problema.

Temos:

900 ADRs
3.000 Specs
20.000 testes
500 incidentes
10.000 documentos

Podemos simplesmente colocar tudo no prompt?

Não.

Isso seria trocar:

PROMPT GIGANTE

por:

CONTEXTO GIGANTE

Context Engineering maduro também precisa responder:

Qual contexto é relevante para esta tarefa?

Para:

Implement Pix Scheduled Transfer

talvez precisemos:

Pix Domain Context

Accounts public contract

Fraud public contract

Ledger public contract

Pix business rules

relevant ADRs

current spec

relevant incidents

relevant evals

Não precisamos carregar todo o sistema.

Surge então:

TASK
 │
 ▼
CONTEXT ROUTER
 │
 ├── Domain
 ├── Architecture
 ├── ADR
 ├── Spec
 ├── Contracts
 ├── Evals
 └── Learning
 │
 ▼
AGENT

A próxima evolução não é apenas ter contexto.

É entregar o contexto certo no momento certo.


🤖 CAPÍTULO 23 — Wall Street ganha uma mesa inteira de agentes

Por que usar somente um agente?

Podemos ter:

                  HUMAN
                    │
                    ▼
              PLANNER AGENT
                    │
                    ▼
           IMPLEMENTATION AGENT
                    │
                    ▼
               TEST AGENT
                    │
                    ▼
          ARCHITECTURE AGENT
                    │
                    ▼
            SECURITY AGENT
                    │
                    ▼
              REVIEW AGENT
                    │
                    ▼
                  HUMAN

Implementation Agent produz:

import accounts.infrastructure.AccountRepository;

Architecture Eval responde:

FAILED

ARCH-002

PIX cannot depend on
ACCOUNTS.infrastructure

O agente consulta o contexto.

Encontra:

AccountTransferEligibility

Corrige.

Executa novamente.

PASS

Perceba a mudança.

Evals deixam de servir apenas ao pipeline.

Eles se tornam feedback para o raciocínio iterativo dos agentes.


👨‍💻 CAPÍTULO 24 — E onde ficou o programador?

Essa pergunta inevitavelmente aparece.

Se agentes:

geram código
geram testes
fazem review
analisam contratos
procuram bugs

qual é o papel humano?

Ele sobe de nível.

Antes:

HUMAN
  ↓
CODE

Agora:

                 HUMAN
                   │
       ┌───────────┼───────────┐
       ▼           ▼           ▼
    INTENT       RISK       TRADE-OFF
       │           │           │
       └───────────┼───────────┘
                   ▼
               CONTEXT
                   │
                   ▼
                 AGENT
                   │
                   ▼
                 CODE

O desenvolvedor continua precisando entender código.

Mas passa a dedicar muito mais energia a:

intenção, fronteiras, invariantes, contratos, risco, decisões e evidências.


🏗️ CAPÍTULO 25 — O repositório deixa de guardar somente código

Nossa BellacosaBank pode terminar assim:

bellacosa-fintech/

├── docs/
│
│   ├── domain/
│   │   ├── ubiquitous-language.md
│   │   ├── bounded-contexts.md
│   │   ├── context-map.md
│   │   ├── ownership.md
│   │   └── invariants.md
│   │
│   └── architecture/
│       ├── c4/
│       └── adr/
│
├── specs/
│   ├── 001-create-customer/
│   ├── 002-open-account/
│   ├── 003-create-pix-key/
│   ├── 004-risk-analysis/
│   ├── 005-send-pix/
│   └── 006-ledger-idempotency/
│
├── evals/
│   ├── architecture/
│   ├── domain/
│   ├── contracts/
│   ├── accounting/
│   ├── concurrency/
│   ├── security/
│   └── observability/
│
├── engineering/
│   ├── loops/
│   ├── incidents/
│   ├── feedback/
│   └── learning/
│
└── src/
    ├── customers/
    ├── accounts/
    ├── pix/
    ├── fraud/
    ├── ledger/
    └── notifications/

A estrutura-base de documentação, specs, loops, feedback e implementação é justamente a proposta apresentada no material original.

Agora cada diretório responde a uma pergunta.

docs/domain
→ Como nosso negócio funciona?

docs/architecture
→ Como decidimos estruturá-lo?

specs
→ O que queremos construir?

evals
→ Como provamos?

engineering
→ O que aconteceu enquanto construíamos?

incidents
→ Onde a realidade contrariou nossas hipóteses?

learning
→ O que aprendemos?

src
→ Qual implementação existe atualmente?

Isso é muito mais poderoso que simplesmente armazenar código.


⚡ CAPÍTULO 26 — E o Vibe Coding volta pela porta da frente

Depois de toda essa burocracia arquitetural alguém poderia concluir:

Então Vibe Coding acabou.

Exatamente o contrário.

Agora Bud pode escrever:

Implemente Pix agendado.

Só que por trás dessa frase curta existe:

          "Implemente Pix agendado"
                     │
                     ▼
              CONTEXT ROUTER
                     │
       ┌─────────────┼─────────────┐
       ▼             ▼             ▼
     DOMAIN         ADRs          SPEC
       │             │             │
       ├─────────────┼─────────────┤
       ▼             ▼             ▼
   CONTRACTS       RULES         EVALS
       │             │             │
       └─────────────┼─────────────┘
                     ▼
                   AGENT
                     │
                     ▼
              IMPLEMENTATION
                     │
                     ▼
                   EVALS
                     │
                     ▼
                  REVIEW

O material chama atenção para esse paradoxo:

quanto melhor estruturado o contexto, menos precisamos repetir tudo no prompt.

Portanto Vibe Coding não precisa ser sinônimo de engenharia irresponsável.

Podemos ter:

Vibe Coding sobre trilhos.


🖥️ CAPÍTULO 27 — E onde entra o COBOL?

Agora chegamos ao ponto especialmente interessante para quem vive no mundo mainframe.

Muito antes de alguém dizer Context Engineering, mainframes já conviviam com o problema.

Imagine um programa:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. PGMPX001.

Quarenta anos de história.

Ele usa:

COPYBOOKS
VSAM
Db2
CICS
MQ
JCL
PROCs
RACF
SORT
programas chamados
programas chamadores
arquivos downstream
jobs batch

Alguém pede:

“Altere a regra de limite.”

O programador iniciante pensa:

abrir COBOL
       ↓
achar IF
       ↓
alterar
       ↓
compilar

O veterano pergunta:

Quem chama?

Quem é chamado?

Qual COPYBOOK?

Qual tabela?

Qual transação CICS?

Qual arquivo?

Qual JCL?

Qual janela batch?

Qual downstream?

Qual rollback?

Qual regra histórica?

Por que aquele IF existe?

Isso é Context Engineering antes do nome existir.


🏛️ CAPÍTULO 28 — O mainframe é uma catedral de contexto

Imagine:

               BUSINESS RULE
                     │
                     ▼
                 COPYBOOK
                     │
             ┌───────┼───────┐
             ▼       ▼       ▼
           COBOL    CICS     BATCH
             │       │       │
             ▼       ▼       ▼
            Db2     MQ      VSAM
             │               │
             └───────┬───────┘
                     ▼
                 DOWNSTREAM

Um agente que simplesmente recebe:

“Modernize esse COBOL.”

está quase cego.

Ele precisa saber:

Business Context
Architecture Context
Data Context
Integration Context
Security Context
Operational Context
Historical Context

Ou seja, o desafio não é:

A IA sabe COBOL?

A pergunta muito mais importante é:

A IA sabe o que esse COBOL significa dentro daquela organização?

Aí a conversa sobre Context Engineering deixa de parecer moda de IA.

Ela começa a parecer extremamente familiar para qualquer veterano de mainframe.


💎 CAPÍTULO 29 — A verdadeira informação privilegiada

Bud Fox começou nossa história procurando a próxima informação capaz de lhe dar vantagem.

No desenvolvimento com IA também existe uma informação privilegiada.

Não é:

"Use Spring Boot."

Todo modelo sabe isso.

Não é:

"Use Kafka."

Também sabe.

Não é sequer:

"Use DDD."

A verdadeira vantagem está em conhecimento que só sua organização possui:

Por que Ledger controla saldo?

Por que Pix não acessa AccountsRepository?

Por que determinado consumer precisa ser idempotente?

Por que aquele limite existe?

Por que aquela decisão foi tomada?

Qual incidente revelou aquela regra?

Qual comportamento não pode mudar?

Qual contrato não pode quebrar?

Isso é conhecimento institucional.

E, ao contrário do insider trading de Wall Street, aqui queremos exatamente o contrário:

tornar esse conhecimento acessível, explícito, governado e verificável para quem legitimamente precisa construir o sistema.


🎞️ EPÍLOGO — Bud Fox fecha o terminal

No começo tínhamos:

PROMPT
   ↓
CODE

Parecia revolucionário.

Depois descobrimos:

VIBE CODING
     ↓
VELOCIDADE

Mas velocidade precisava de direção.

Então:

SDD
 ↓
INTENÇÃO

A intenção precisava respeitar fronteiras.

DDD
+
MODULAR MONOLITH
 ↓
OWNERSHIP
+
BOUNDARIES

As fronteiras precisavam estar disponíveis aos agentes.

CONTEXT ENGINEERING
 ↓
MEMÓRIA DE ENGENHARIA

A memória precisava ser verificável.

EVALS
 ↓
EVIDÊNCIA

E nenhuma especificação conhece completamente a realidade.

Então:

ENGINEERING LOOP
 ↓
OBSERVAR
 ↓
APRENDER

Finalmente fechamos o círculo:

                  INTENT
                    │
                    ▼
                 CONTEXT
                    │
                    ▼
                   SDD
                    │
                    ▼
                  EVALS
                    │
                    ▼
                  AGENT
                    │
                    ▼
             IMPLEMENTATION
                    │
                    ▼
             ENGINEERING LOOP
                    │
                    ▼
               PRODUCTION
                    │
                    ▼
                 SIGNALS
                    │
                    ▼
                FEEDBACK
                    │
                    ▼
                LEARNING
                    │
                    └────────────► CONTEXT
                                   ↺

É exatamente a síntese alcançada pelo material: Vibe Coding acelera; SDD dá direção; DDD protege fronteiras; Evals tornam intenção verificável; Engineering Loop converte execução em aprendizado; Context Engineering conecta o conjunto.

Bud olha para Gordon Gekko.

Gekko talvez dissesse:

informação é o ativo mais valioso da sala.

Mas no desenvolvimento de software com agentes existe uma versão melhor dessa máxima:

Código está ficando barato. Contexto confiável está ficando valioso.

Porque não será particularmente impressionante uma IA produzir dez mil linhas de Java, COBOL ou Python em uma tarde.

O verdadeiro feito será ela chegar ao prompt número 500, depois de quarenta features, dez desenvolvedores, cinco agentes, três mudanças arquiteturais e aquele inevitável incidente das 03:17, e ainda compreender que:

Accounts
≠
Ledger

que:

Pix
NÃO acessa
Accounts Infrastructure

que:

Debit == Credit

não é suficiente se o mesmo evento financeiro tiver sido processado duas vezes;

e, sobretudo, compreender por que cada uma dessas decisões existe.

Quando conseguirmos isso, teremos ido muito além de Vibe Coding.

Teremos construído algo que empresas perseguem desde muito antes da IA:

software capaz de preservar o conhecimento acumulado por quem o construiu.

E talvez aí esteja a maior ironia desta história.

O futuro dos agentes de IA pode acabar redescobrindo uma das grandes lições do mainframe:

sistemas críticos sobrevivem durante décadas não porque alguém escreveu código perfeito, mas porque sucessivas gerações conseguiram preservar contratos, regras, interfaces, decisões e conhecimento suficientes para continuar mudando sem destruir aquilo que já funcionava.

Bud Fox queria descobrir qual seria a próxima grande operação.

No nosso pregão tecnológico, talvez já tenhamos encontrado uma:

Vibe Coding gera código. Context Engineering preserva engenharia.

E em sistemas que movimentam dinheiro — seja uma fintech Java de 2026 ou um COBOL processando milhões de transações num IBM Z — essa diferença vale muito mais do que algumas linhas de código produzidas em segundos.



Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...