Determinismo + IA: a estratégia do Lino para gerar código sem alucinações
Imagine rodar um único comando e receber páginas, APIs, handlers, traduções (i18n) e toda a estrutura organizada do projeto, tudo no lugar certo, sem alucinações e sem erros inesperados.
Fala, pessoal! Tudo bem?
Hoje quero compartilhar a história e a engenharia por trás do Lino, uma ferramenta que venho desenvolvendo nos últimos meses.
Diferente de abordagens baseadas apenas em inteligência artificial, que muitas vezes geram código irregular e produzem estruturas imprevisíveis, o Lino foi pensado para garantir consistência e determinismo, sempre respeitando arquitetura, camadas e convenções.
Mas o que é o Lino?
Lino é uma CLI para criar projetos multilíngues (i18n) do zero, desde APIs, Use Cases, infraestrutura e páginas web integradas.
Spoiler: a próxima fase trará integração com IA para transformar linguagem natural em comandos Lino.
O incômodo que não passava
Quanto custa a inconsistência de código ao longo de um projeto?
Começar um projeto do zero é desafiador. Mas o verdadeiro problema é manter tudo organizado e consistente à medida que o projeto cresce.
Cada novo artefato, seja uma entidade, um novo módulo, um caso de uso ou até mesmo uma API, exige pastas, requests, responses, endpoints, handlers… Esse processo repetitivo gera fadiga mental e abre espaço para atalhos que corroem padrões e qualidade.
Arquiteturas como Clean, Hexagonal e Vertical Slices ajudam a mapear o caminho, mas não removem o esforço repetitivo de criar artefatos alinhados à arquitetura.
- Boilerplates ajudam no início, mas não acompanham o projeto.
- Scaffolding gera código pontual, mas não garante consistência ao longo do tempo.
Eu precisava de algo que assegurasse precisão determinística em cada artefato, desde o início até o fim do projeto.
Foi assim que nasceu a primeira faísca do Lino.
Por que uma CLI?
Eu precisava de uma ferramenta que pudesse ser chamada direto do editor ou da IDE, com comandos realmente simples e intuitivos.
Algo como:
Criar página de produtos
E tudo seria gerado no lugar certo, de forma consistente. Tudo integrado e pronto para uso.
Eu queria poder digitar:
lino page new --name Product
E ter como resultado:
API/
└── Endpoints/
└── Products/
├── CreateProduct/
│ ├── CreateProductEndpoint.cs
│ ├── CreateProductExtensions.cs
│ ├── CreateProductRequest.cs
│ └── CreateProductResponse.cs
├── UpdateProduct/
│ └── ...arquivos
├── DeleteProduct/
│ └── ...arquivos
├── GetProductById/
│ └── ...arquivos
└── ListProducts/
└── ...arquivos
Application/
└── UseCases/
└── Products/
├── Commands/
│ ├── CreateProduct/
│ │ ├── CreateProductCommand.cs
│ │ ├── CreateProductCommandHandler.cs
│ │ ├── CreateProductCommandResult.cs
│ │ └── CreateProductCommandValidator.cs
│ ├── UpdateProduct/
│ │ └── ...arquivos
│ └── DeleteProduct/
│ └── ...arquivos
└── Queries/
├── GetProductById/
│ └── ...arquivos
└── ListProducts/
├── ListProductsQuery.cs
├── ListProductsQueryHandler.cs
├── ListProductsQueryResult.cs
└── ListProductsQueryValidator.cs
Templates simples ou scaffolding tradicional não seriam suficientes.
Eu precisava de algo organizado e consistente desde o primeiro comando.
Eu precisava do Lino.
O nome: uma saga à parte
Antes de chegar em Lino, eu passei por:
- centenas de pesquisas
- domínios já ocupados
- frustração atrás de frustração
Depois de semanas procurando o “nome perfeito”, algo que remetesse a código, qualidade, velocidade, eu me perguntei:
Por que não Lino?
É curto.
É simples.
Carrega parte do meu sobrenome.
E com uma inspiração:
Linus → Linux
E assim nasceu o Lino.
O propósito
Lino veio para eliminar trabalho repetitivo e garantir que cada parte do sistema siga padrões sólidos, mantendo consistência arquitetural e rigor técnico desde o primeiro comando.
Embora o motor do Lino tenha sido projetado para gerar códigos em diversas linguagens e tecnologias, esta primeira versão está focada exclusivamente no ecossistema .NET (C#/Aspire/Blazor). Isso não impede que, no futuro, a geração seja expandida para stacks como Java/Go no backend ou Angular/React no frontend.
Atualmente, o Lino oferece:
- Estrutura completa e configurada: Cria a solução do zero (selecionando stack, bancos, cache, mensageria e i18n), com todas as camadas (Domain, Application, Infrastructure, Persistence, API, IntegrationEvents) já organizadas e prontas para rodar.
- WebApps e CRUDs: Gera páginas full-stack totalmente funcionais, incluindo o scaffolding completo de APIs, Commands, Queries (CQRS) e validações.
- Aceleração de domínio: Cria entidades, value objects, enums e eventos, garantindo que o modelo de domínio esteja integrado de forma consistente com as camadas de aplicação e persistência.
- Infraestrutura por container: Provisiona e configura serviços essenciais (bancos, Redis, RabbitMQ) em containers, permitindo ter uma solução escalável e pronta para rodar em minutos.
- Recursos críticos: Adiciona funcionalidades complexas como Autenticação/Autorização, Background Jobs e Mensageria, sempre mantendo a arquitetura limpa e os padrões sólidos (por exemplo, utilizando Outbox Pattern).
O resultado prático: com um único comando, você obtém uma página completa com backend, frontend e estruturas internas, tudo integrado, validado e aderente a padrões de mercado, sem escrever uma linha de código.
✅Em resumo: O Lino não apenas gera código. Ele padroniza a arquitetura, organiza o sistema e acelera o desenvolvimento enterprise, garantindo previsibilidade e consistência em todo o ciclo de vida do projeto.
Fase 1: geração determinística
A fase atual do Lino é totalmente determinística.
Isso significa que o Lino:
- não toma decisões por conta própria
- não inventa estruturas
- não escreve código imprevisível
Ele constrói o sistema com base em:
- opções selecionadas pelo usuário
- inputs fornecidos
- padrões arquiteturais consolidados
- decisões técnicas explícitas
O resultado: ele gera exatamente o que se espera, sempre da mesma forma.
Fase 2 (futura): prompts generativos
Com a base determinística da Fase 1 consolidada, a Fase 2 traz a evolução natural do Lino: aceitar comandos em linguagem natural, convertidos por IA em instruções formais.
Exemplo:
Crie uma entidade Customer com Name, Email e Address. Gere API, comando CreateCustomer, evento CustomerCreated e faça a migration correspondente.
A IA interpreta o pedido.
O Lino executa deterministicamente.
Isso assegura que:
- não haja designs aleatórios
- não ocorram violações de camadas
- não surjam quebras arquiteturais ou inconsistências estruturais
Decisões Arquiteturais
O Lino adota padrões que garantem um desenvolvimento seguro, performático e consistente.
- Result Pattern: código mais expressivo, previsível e fácil de testar.
- Strongly Typed IDs: segurança contra trocas acidentais e bugs silenciosos.
- Logging de alta performance: rastreabilidade sem custo desnecessário.
Para manter coerência entre banco e mensageria, o Lino combina Unit of Work + Outbox, assegurando integridade transacional e registro confiável de eventos.
E mais:
- Source Generators substituem reflection e elevam desempenho.
- Central Package Management mantém dependências organizadas e atualizações simples.
O resultado: uma base enxuta, robusta e pronta para escalar.
O momento em que o Lino passou a gerar… o próprio Lino
Chegou um momento em que muitos comandos da CLI já funcionavam, mas ainda havia muito a construir.
Então pensei:
Que tal começar de novo, só que agora utilizando o próprio Lino?
Decisão tomada: o Lino passou a gerar a própria estrutura.
Novos módulos, APIs, Commands e Queries agora surgem automaticamente no lugar certo, seguindo arquitetura, convenções e padrões, sem esforço manual.
O obstáculo invisível
No fim das contas, a pergunta que mais pesava era simples:
E se isso só fizer sentido para mim?
Foram anos de estudo, reescritas e decisões difíceis. E, claro, surgiram as dúvidas inevitáveis: estou simplificando demais? Complicando demais? Há espaço para mais uma ferramenta? Alguém além de mim verá valor nisso?
Com o tempo, uma coisa ficou evidente:
O único cenário realmente frustrante seria não lançá-lo.
Hoje, mesmo com adoção inicial pequena, o Lino já transformou meu fluxo de trabalho.
E é por isso que estou aqui: compartilhando, testando e descobrindo até onde essa ideia pode chegar.
Acesso e Sustentabilidade
Para garantir o suporte e a evolução contínua do Lino, ele é disponibilizado através de modelos de assinatura que ajudam a sustentar o desenvolvimento da ferramenta.
Mas existe um plano gratuito, totalmente funcional, ideal para você explorar a ferramenta, validar conceitos e modelar o domínio da sua aplicação sem qualquer custo.
Como começar
Instalação:
dotnet tool install --global Tolitech.Lino
Listar comandos:
lino
Convite à Comunidade
Se você chegou até aqui, meu obrigado de verdade.
A primeira versão deste texto era cinco vezes maior, cheia de detalhes, telas e trechos de código. Provavelmente poucos chegariam ao final.
Então tentei ser mais direto e objetivo.
Espero ter encontrado o equilíbrio certo.
Ferramentas nascem de código, mas evoluem com pessoas. É o seu olhar que vai orientar os próximos passos do Lino.
Se puder, me ajude dando sinais de direção para o futuro da ferramenta:
- Assista ao vídeo de demonstração
- Visite o site
- E, principalmente, compartilhe sua opinião sincera
👉 Site: https://lino.dev
👉 Vídeo de demonstração: Assistir
E antes que eu esqueça:
Aos poucos, vou publicar vídeos destrinchando o código gerado pelo Lino, explicando suas decisões arquiteturais e mostrando cenários reais de desenvolvimento. Vamos juntos do projeto inicial até a aplicação rodando em produção, seja na AWS, Azure ou em um VPS Linux.
Lino 🤝 .NET 🤝 Linux
Conclusão
O Lino nasceu da combinação de:
- compromisso com arquitetura limpa
- busca por código de alta qualidade
- necessidade real de acelerar desenvolvimento enterprise
- dores que vivenciei no dia a dia
- e, claro, uma boa dose de teimosia
É um projeto em constante evolução.
Com o seu feedback, podemos construir, ajustar e aprimorar ainda mais.