Construo software há duas décadas e nunca parei. A responsabilidade foi se acumulando pelo caminho: arquitetura, operação, produto, pessoas e, mais recentemente, inteligência artificial. Essa última camada se apoia em todas as anteriores. Trago para ela a disciplina que a engenharia de software levou décadas para aprender, e hoje é ela que ocupa os papéis do ciclo e faz valer o que cada um deve cumprir.
Quase tudo é privado, porque é produto em operação.
| Agentes que operam | Agentes conversacionais que vendem, atendem, recuperam e agendam em canal de mensagens, com estado, intenção, limites e passagem para humano tratados como engenharia, não como prompt. |
| Plataformas que sustentam | Sistemas de operação de empresa, recrutamento, relacionamento com cliente e identidade única: o que o time usa todo dia e não pode cair. |
| Infraestrutura que aguenta | Mensageria com contingência, filas, integrações entre sistemas corporativos e produtos, e publicação com verificação e retorno em um comando. |
Documento antes de código. Requisitos, arquitetura e stories com critérios de aceite são a fonte do que vai ser feito. Nada entra na esteira sem responder por que existe.
Papéis com autoridade. Cada etapa do ciclo pertence a um agente especializado, com autoridade própria e passagem registrada. Quem cria não implementa; quem implementa não publica. Um hook bloqueia quem tenta pular a fila.
Verificação em tudo. Gates automáticos em cada transição, testes de unidade, de ponta a ponta, de conteúdo e até de movimento, prova visual por viewport e idioma, e regras de projeto que a máquina recusa quebrar.
O humano decide. Aprova o que vale entrar, olha a prévia antes de qualquer mudança ir ao ar, escolhe com prova na mão e diz não. Triar, verificar e juntar evidência é trabalho de máquina.
Começou como um assistente que completava código. Virou um sistema que atravessa o ciclo inteiro, da ideia à publicação, com verificação proporcional ao risco. Esse ciclo roda sobre um sistema de orquestração de agentes para engenharia de software, que define os papéis, a autoridade de cada um, os gates e a memória de projeto. O método vale com qualquer stack.
Software precisa funcionar fora da demo.
Nada entra na esteira sem responder "por que existe?".
Quem cria não implementa; quem implementa não publica.
Automação precisa de limites: autonomia se conquista por risco e verificabilidade.
Execução abundante pede mais verificação, não menos.
Duas décadas atravessando sistemas corporativos, integrações, produtos web e mobile, nuvem e dados, com responsabilidade crescente de arquitetura, operação e liderança. TypeScript e Node no dia a dia, Python quando o problema pede; Postgres, filas, containers e automação de entrega para tudo que vai ao ar. Modelos de linguagem dentro de produto com contexto, custo, latência e falha como requisito: RAG e engenharia de contexto, MCP para ferramentas e dados com contrato, fine-tuning quando prompt não basta.
Também estou escrevendo Depois do Código, um livro sobre engenharia de software na era da inteligência artificial: quando a execução fica abundante, contexto, arquitetura, decisões e verificação passam a importar ainda mais.
In English
I have been building software for two decades and never stopped. Responsibility accumulated along the way: architecture, operations, product, people and, more recently, artificial intelligence. That last layer rests on all the others. I bring to it the discipline software engineering took decades to learn, and today it is the one holding the roles in the cycle and enforcing what each of them must deliver.
What I build. Almost all of it is private, because it is product in operation. Conversational agents that sell, support, recover and schedule on messaging channels, with state, intent, limits and hand-off to a human treated as engineering, not as prompting. Platforms that sustain a company's operation, recruiting, customer relationships and single sign-on. Infrastructure that holds: messaging with contingency, queues, integrations between enterprise systems and products, and releases with verification and one-command rollback.
How I build. Documents before code: requirements, architecture and stories with acceptance criteria are the source of what gets built; nothing enters the pipeline without answering why it exists. Roles with authority: each step of the cycle belongs to a specialised agent with its own authority and a recorded hand-off; whoever writes does not implement, whoever implements does not release, and a hook blocks anyone who skips the queue. Verification everywhere: automatic gates at every transition, unit, end-to-end, content and even motion tests, visual proof per viewport and language, and project rules the machine refuses to break. The human decides: what is worth building, whether the preview ships, which alternative wins, when to say no. It started as an assistant that completed code and became a system that runs the whole cycle, from idea to release, with verification proportional to risk. The cycle runs on an agent orchestration system for software engineering, which defines the roles, each one's authority, the gates and the project memory. The method works with any stack.
What I know. Two decades across enterprise systems, integrations, web and mobile products, cloud and data, with growing responsibility for architecture, operations and leadership. TypeScript and Node day to day, Python when the problem calls for it; Postgres, queues, containers and delivery automation for everything that ships. Language models inside products with context, cost, latency and failure as requirements: RAG and context engineering, MCP for tools and data under a contract, fine-tuning when a prompt is not enough. I am also writing After the Code, a book on software engineering in the age of artificial intelligence: when execution becomes abundant, context, architecture, decisions and verification matter even more.