lx: ferramenta de vibe coding sob controle total do desenvolvedor

Introdução

Olá. Sou um estudante interessado em engenharia da computação. Desta vez, desenvolvi um programa chamado lx e quis fazer minha primeira postagem no GeekNews, onde até então eu só lia os textos.

Recentemente, o vibe coding, em que você dá instruções em linguagem natural para a IA e ela escreve todo o código sozinha, virou tendência.
Eu tenho medo desse tipo de vibe coding.
Não é simplesmente um medo de perder o emprego, mas uma sensação de perda da programação por estarem nos tirando a "alegria de escrever código (Wrangling code) (fonte: Kent Beck - Augmented Coding: Beyond the Vibes)" e o "controle do desenvolvedor".

Algumas pessoas dizem que essa mudança é uma evolução natural da programação, como a transição dos cartões perfurados para linguagem de máquina, assembly e C. Mas eu acho que essa analogia está errada.
As abstrações do passado foram um processo de colocar um “martelo melhor” nas mãos do desenvolvedor.
As ferramentas continuaram evoluindo, mas quem empunhava o martelo ainda era o ser humano, e o resultado permanecia inteiramente sob controle do desenvolvedor.
Mas o coding com IA de agora é diferente.
Agora o robô empunha o martelo no nosso lugar, e o desenvolvedor fica apenas olhando, ou no máximo tentando persuadir um pouco o robô.
Se não pudermos empunhar o martelo, acho que isso já não pode mais ser chamado de programação.
Porque não está totalmente sob nosso controle.

Por isso eu criei o lx.
O lx é uma ferramenta que tira o martelo das mãos do robô e o coloca de volta nas mãos do desenvolvedor.
O lx permite tratar a IA como uma ferramenta rigidamente controlável.

Desenvolvimento

O lx segue a filosofia de "a interface é do humano, a lógica é da IA".
O desenvolvedor define as entradas, saídas e o que a função faz, firmando um “contrato”, e a IA cuida apenas da implementação interna dessa função.

Essa abordagem garante a continuidade do desenvolvimento.
No momento em que se escreve a entrada e a saída da função, aquela lógica já é considerada concluída.
O programador não fica preso aos detalhes da implementação e pode escrever imediatamente a lógica de nível superior, mantendo o fluxo de desenvolvimento sem interrupções.

Além disso, o lx não faz uma simples substituição de texto. Ele usa o pacote github.com/tree-sitter/go-tree-sitter para fazer o parsing do código-fonte com base em AST (árvore sintática abstrata). Assim, não polui outros trechos do arquivo, comentários ou indentação, e substitui com segurança apenas a lógica do escopo especificado.

Uso básico

A forma básica de usar o lx é a seguinte.

package main  
  
import (  
	"fmt"  
  
	lx "github.com/chebread/lxgo"  
)  
  
func main() {  
	var year string = "2025-01-02"  
    // O desenvolvedor controla as chamadas de função e o fluxo.  
	result1 := LX_GetYear(year)  
  
	var age = 30  
	result2 := LX_GetAge(age)  
  
	fmt.Println(result1, result2)  
}  
  
func LX_GetYear(year string) (result string) {  
	// Prompt a ser enviado para a IA  
	lx.Generate("converter o formato yyyy-dd-mm para data no formato coreano")  
	return  
}  
  
func LX_GetAge(year int) (result string) {  
	// Caso seja incômodo instalar separadamente a biblioteca lx correspondente à linguagem de programação, também há suporte ao marcador de comentário lx() como abaixo.  
    // lx("converter a idade coreana para idade internacional")  
	return  
}  

No código acima, a função LX_GetYear é um contrato definido pelo desenvolvedor.
Quando a ferramenta lx é executada, ela reconhece lx.Generate(...) ou o marcador // lx(...), envia o prompt ao LLM e sobrescreve o corpo dessa função com código realmente funcional.

Nesse processo, é aplicada otimização de tokens. Em vez de enviar o arquivo inteiro, apenas a assinatura da função e o prompt são enviados ao LLM, reduzindo custos e reforçando a segurança.

2. Controle do desenvolvedor

A lógica dentro da função lx é escrita pela IA, mas quem usa essa função precisa ser o desenvolvedor.
No entanto, como qualquer lógica personalizada misturada dentro da função lx será ignorada, é possível manter o controle por meio de uma função wrapper, como abaixo.

package test  
  
import (  
	"fmt"  
	lx "github.com/chebread/lxgo"  
)  
  
func main() {  
	var year string = "2025-01-02"  
	result1 := ParseYear(year) // Chamada da função wrapper  
  
	fmt.Println(result1)  
}  
  
// Lógica de negócio controlada pelo desenvolvedor  
func ParseYear(year string) string {  
    // Usa a lógica gerada pela IA como se fosse um componente  
	res := LX_GetYear(year)  
    
    // Processamento adicional do resultado fica por conta do desenvolvedor  
	foo := fmt.Sprintf("Hoje é %v!", res)  
	return foo  
}  
  
func LX_GetYear(year string) (result string) {  
	lx.Generate("converter o formato yyyy-dd-mm para data no formato coreano")  
	return  
}  

3. Gerenciamento seguro de dependências e transparência

O lx busca seguir o princípio da responsabilidade única (SRP).
Ele apenas gera código; não compila nem executa o programa.
Além disso, se o código gerado pela IA precisar de bibliotecas externas, o lx não instala pacotes por conta própria.

1. Code: explicita um comentário // lx-dep: ... no topo do código gerado

2. Output: informa pela saída padrão do CLI a lista do que precisa ser instalado

Em vez disso, ele reporta isso ao desenvolvedor dessas duas formas.
O desenvolvedor verifica e decide pessoalmente se quer instalar as dependências.

4. Configuração

Para usar o lx, é necessária uma configuração de LLM. Basta criar um lx-config.yaml no diretório home (~/) ou na raiz do projeto (./). Se o arquivo existir nos dois caminhos, a configuração local terá prioridade, permitindo gerenciar configurações diferentes do lx para cada projeto.

# lx-config.yaml  
provider: "gemini"  
api_key: "foo"  
model: "bar"  

5. Instalação e execução

Usuários de Mac podem instalar via Homebrew, e em outros sistemas operacionais é possível baixar o binário em lx's GitHub Releases para instalar.

brew tap chebread/lx  
brew install lx  

Após a instalação, execute o comando lx no caminho do projeto para gerar o código real.
O lx tem um recurso de geração inteligente: funções cujo código já foi gerado não chamam o LLM novamente, então você pode executar o comando lx repetidamente com tranquilidade.

Observação: o lx usa ferramentas específicas de cada linguagem para formatar o código gerado (Go: goimports, Python: ruff, JS: prettier). Essas ferramentas precisam estar instaladas previamente.

6. Licença

O lx é distribuído sob a licença AGPL-3.0 License.
O objetivo é contribuir para o ecossistema open source e, ao mesmo tempo, evitar que essa ferramenta seja apropriada de forma fechada.

Conclusão

Software é o resultado cristalizado do esforço constante da humanidade. Mesmo na era da IA, o programador deve continuar sendo o dono do código.
O lx permite deixar para a IA as “implementações entediantes”, como regexs incômodas ou parsing de dados, enquanto a estrutura e o fluxo do programa permanecem inteiramente nas mãos do humano.
Recomendo esta ferramenta para desenvolvedores que não querem perder a alegria de escrever código (Wrangling code) nem o controle!

[moderator]

De acordo com a política operacional, comentários inadequados foram removidos, e o uso da conta em questão foi restringido.

[callakrsos]

Acho que, mesmo a programação de agora, no fim das contas, também é baseada em padrões humanos.
No futuro, provavelmente vamos desenvolver de uma forma que não dependa de linguagens ineficientes moldadas para humanos.
Vamos aproveitar bastante os frameworks centrados em humanos de hoje.

[galadbran]

Acho muito interessante porque é uma abordagem completamente oposta à tendência atual de que, para fazer direito, você nem deveria olhar o código.
Dependendo de como for escolhido, talvez dê para usar só com a sensação de definir com clareza exatamente qual área a IA pode tocar.
Também pode ser uma boa tentar criar isso com as skills dos agentes de codificação, não?

[chebread]

Vou analisar isso ativamente. Se tiver interesse, agradecemos muitos PRs!

[narubrown]

Parece um projeto interessante!

Escreve-se a especificação do lx -> substituem-se as funções lx por funções reais com a ferramenta lx -> depois compila em Go, pelo visto.
Como uma camada que usa lx passa a existir no projeto,
parece que dá para separar a camada escrita com LLM, o que pode facilitar bastante a manutenção depois.

Parece uma tentativa interessante usando LLM!

[chebread]

Obrigado. O lx também oferece suporte a linguagens além de Go, então agradecemos muito pelo uso e pelos comentários!

[iknowca]

O objetivo é interessante, mas ao longo de todo o texto dá para sentir fortemente aquele estilo típico de IA,
o que torna difícil confiar nele.

[chebread]

Boa observação. Como ainda estou no ensino médio, não tenho muito tempo, então, ao usar inteligência artificial para escrever, o texto acabou se tornando bem menos confiável. Mesmo que isso seja um pouco incômodo, peço a sua compreensão.

[wegaia]

Uau, é impressionante que um estudante do ensino médio tenha idealizado algo assim.
Com mais experiência, parece que vai criar coisas ainda mais incríveis.

[siabard]

Então, o correto seria que, quando o código que chama lx.Generate recebe um comando pela linha de comando, ele seja substituído por um código escrito pelo LLM, certo?
Acho uma boa ideia que a parte que faz a chamada possa funcionar como uma espécie de restrição de tipo. Também fiquei curioso se vocês estão considerando um modo em que o comando lx seja executado automaticamente em editores e afins para substituir o código de implementação. (Além disso, seria ótimo se houvesse alguma forma de regenerar o código quando o resultado gerado não agradar.)
Gostei bastante do projeto.

[chebread]

Então o código que chama lx.Generate funciona de modo que, quando um comando é dado pela linha de comando, ele é substituído por um código escrito pelo LLM, certo? -> Sim, isso mesmo!

Acho que é uma boa ideia que a parte da chamada possa servir como uma espécie de restrição de tipos. Também fiquei curioso se vocês estão considerando um modo em que o comando lx seja executado automaticamente no editor etc., substituindo o código de implementação. -> Acho que é realmente uma ótima ideia. Vamos levar isso em consideração ativamente.

Além disso, seria bom se houvesse alguma forma de regenerar quando o código gerado não agrada. -> Como a filosofia do projeto é uma IA sob o controle do desenvolvedor, projetamos de forma que, se for necessária uma regeneração, seja preciso criar novamente o marcador lx.

[maneuling]

O nível dos comentários que aparecem aqui, se esforçando para entrar depois de ver algo feito por um estudante do ensino médio, já mostra bem o nível de inteligência.

Olhe no espelho e vá se tratar.

killdong | 9 meses atrás | parent | on: Eu uso bombas ZIP para proteger meu servidor (idiallo.com)
Acho que, se a pessoa não assume responsabilidade nem pelo que despeja na internet, deveria ser proibida de usar a internet. Limpe o que você despejou.