Java com Spring Boot, e o mesmo princípio em todo stack

Comece com uma arquitetura pronta para produção

Descreva o sistema e receba a aplicação inteira gerada com Clean Architecture: domínio, aplicação e infraestrutura separados, casos de uso, DTO distinto da entidade, repositório e testes. Não é um README prometendo padrão: é o código que sai, com o seu domínio dentro.

Gerar com Clean Architecture → Ver as camadas

7 dias com tudo liberado. Sem cartão de crédito. Projeto padrão, sem runtime da plataforma.

1.600+ Modelos de aplicações reais
100% Código compilável, sem alucinação
3 Camadas de teste geradas
PacienteService.java
// injeção por construtor, sem campo mágico
public PacienteService(
    PacienteRepository repository,
    AuditContext audit) { ... }
 
// o DTO é o contrato, a entidade fica dentro
public PacienteResponse criar(
    PacienteCreateRequest request) {
  Paciente entidade = mapear(request);
  return PacienteResponse.de(
    repository.save(entidade));
}
✓ mesmo padrão em cada módulo gerado

O que está dentro de cada projeto gerado

Clean Architecture DDD Casos de uso DTO Repository Services Controllers Injeção por construtor Papéis e permissões Multi-tenant Auditoria Migrations versionadas OpenAPI Três camadas de teste

Como funciona

Você descreve o sistema. A arquitetura vem junto.

A ordem importa: primeiro a IA entende o negócio e escolhe o modelo, depois o gerador escreve o código. A arquitetura é o motivo pelo qual o resultado se sustenta, não um formulário que você preenche na entrada.

1

Descreva o sistema

A IA conduz um levantamento de requisitos: o que é controlado, quem usa, o que cada perfil pode fazer.

2

O modelo é escolhido

Entre mais de 1.600 modelos de aplicações empresariais reais, o mais próximo do seu caso, adaptado ao seu domínio.

3

O gerador escreve o código

A partir de templates determinísticos. Cada módulo nasce com a mesma separação de camadas do anterior.

4

Compila, testa e confere

Compilação, lint, três camadas de teste e conferência contra o contrato de API, antes de você baixar.

Modelo de dados de um projeto no ClickMVP, com tabelas, campos e tipos

É deste modelo que saem entidade, DTOs, repositório, service, controller, migration, permissões e telas de cada cadastro.

O objetivo do ClickMVP não é apenas gerar código. É gerar software organizado, sustentável e preparado para continuar evoluindo depois que o time assume.

As camadas

Separação que sobrevive ao segundo mês

Não é organização de pasta. É dependência apontando para dentro, com o domínio sem saber que existe HTTP ou banco.

Domínio

As entidades e as invariantes do seu negócio. Sem anotação de framework web, sem conhecer o transporte, sem depender de quem chama.

Aplicação

Os casos de uso: o service que orquestra, valida, aplica permissão e devolve DTO. É aqui que a sua regra específica entra, com teste ao lado.

Infraestrutura

Persistência, e-mail, storage, gateway de pagamento e o controller REST. Trocável, porque nada do domínio depende de detalhe daqui.

Regras que o gerador não deixa quebrar

A parte chata é a que mais custa depois

Toda equipe começa com a arquitetura certa. O que corrói é o atalho de terça-feira. Como aqui o código é gerado a partir de templates, o atalho não tem por onde entrar: cada módulo novo nasce igual ao anterior.

  • ✓ A rota responde pelo DTO, nunca pela linha de persistência
  • ✓ Entrada validada no limite, com erro previsível e traduzido
  • ✓ Permissão checada no servidor, não só escondendo o botão
  • ✓ Token em cookie HttpOnly, nada guardado no navegador
  • ✓ Consulta de outro dono responde 404, não 403 que confirma existência
  • ✓ Schema versionado em migration desde o primeiro commit
  • ✓ Contrato de API único, conferido a cada geração
o que roda antes de você baixar
✓ compilação do backend
✓ lint e checagem de estilo
✓ testes unitários dos services
✓ testes de rota com o app de pé
✓ testes ponta a ponta no navegador
✓ conferência contra o contrato de API
✓ schema do banco igual ao modelo
# código de template determinístico:
# nenhuma linha escrita por adivinhação
147 arquivos Java, um pacote por módulo de domínio
115 endpoints REST conferidos contra o contrato canônico
30 testes de service e de rota, com Mockito e MockMvc
9 migrations Flyway versionadas desde o primeiro commit

Medido num projeto real de 14 cadastros, gerado em Java com Spring Boot e React: 26.400 linhas no backend, 54.800 no total, com DTO separado da entidade em cada módulo.

No frontend também

SOLID não para na fronteira do backend

React, Next.js e Angular seguem a mesma divisão de responsabilidade, traduzida para o idioma de cada framework.

Componente de apresentação puro

A tabela e o formulário não sabem quem é o usuário nem o que ele pode. Recebem dados e ações, e só. Testar é trivial.

A página orquestra

Estado, carregamento e permissão vivem na página. A ação que a pessoa não pode fazer não chega ao componente, então nem existe na tela.

HTTP isolado em service

Nenhuma tela chama a API direto. O acesso fica num service tipado, alinhado com o contrato OpenAPI do backend.

Perguntas frequentes

O que um time técnico pergunta primeiro

No service do módulo, que é onde a camada de aplicação já vive. O gerador entrega o CRUD, as validações do modelo e toda a base de acesso, auditoria e cobrança funcionando. A sua regra específica entra num lugar que já existe, com teste ao lado, em vez de você criar a estrutura antes de escrever a primeira linha do que interessa.
O princípio é o mesmo, traduzido para o idioma de cada framework e nunca diluído. No backend: domínio, aplicação e infraestrutura separados, DTO distinto da entidade de persistência e injeção por construtor. No frontend: componente de apresentação puro, a página orquestra estado e permissão, e o acesso HTTP fica isolado num service.
O código sai de templates determinísticos, não de um modelo de linguagem escrevendo linha a linha, então não existe alucinação no caminho do código. Cada geração passa por compilação, lint, testes de unidade, de rota e ponta a ponta, e por uma conferência do resultado contra o contrato de API canônico do gerador.
É o passo seguinte. Um template te dá a estrutura vazia e você programa cada CRUD, cada tela e cada permissão do seu domínio. Aqui o ponto de partida são mais de 1.600 modelos de aplicações empresariais reais: a IA escolhe o mais próximo do seu caso, adapta ao seu negócio, e o seu domínio sai gerado com tabelas, telas, papéis, auditoria e cobrança funcionando. O código é um projeto padrão que abre em qualquer IDE.

Abra o código e julgue você mesmo

Mais de 1.600 modelos de aplicações reais como ponto de partida. 7 dias com tudo liberado, sem cartão de crédito.

Gerar aplicação com Clean Architecture →