Introdução

A JetBrains, a famosa empresa por trás de editores como IntelliJ IDEA ou Android Studio, não quis ficar para trás na corrida da inteligência artificial. Embora já tenha tentado com o seu próprio modelo “Copilot” que, na minha opinião, foi um fracasso, desta vez nos surpreende com algo novo, algo que pode fazer o Cursor, o editor de código semiautônomo, tremer com o tempo.

E é que a JetBrains nos apresenta o Junie, um agente a quem podemos delegar tarefas e, como já faz o nosso bom amigo Cursor, pega o contexto do código do seu projeto e a partir disso edita ou cria as classes que você precisa.

Neste post estaremos vendo o que o Junie nos oferece, vamos compará-lo nas mesmas condições com o Cursor e tentaremos chegar à conclusão se vale a pena.

O problema de se manter atualizado

É isso mesmo, a cada semana aparece uma nova IA com mais capacidades que a anterior. É quase impossível estar em dia com tudo o que vai saindo, desta vez nos deparamos com o Junie, que em vez de ser um editor diferente é um plugin que pode ser incorporado POR ENQUANTO aos IDEs IntelliJ Idea, PyCharm e WebStorm.

O que é Junie AI?

A graça do Junie é esquecer os chats “rudimentares” onde a IA só tem de contexto o que você fala com ela. Aqui ela aprende com o seu projeto completo e te ajuda a fazer as tarefas mais repetitivas.

Não só revisa os arquivos, mas é capaz de executar comandos, e portanto testes. É isso mesmo, ela executa os testes e sabe se foram bem ou mal e pode consertá-los. A ideia principal que nos apresentam é que o desenvolvedor deve deixar de se ocupar das tarefas repetitivas e focar nas decisões críticas do produto.

Características principais

• Aprendizado contextual: Aprende com o seu projeto completo, não apenas com os chats
• Execução de comandos: Pode executar testes e consertá-los se falharem
• Automação de tarefas repetitivas: Permite ao desenvolvedor focar em decisões críticas
• Integração com IDEs existentes: Não requer mudar de editor

Estado atual e acesso

No momento, o Junie só pode ser acessado com beta fechado inscrevendo-se na lista de espera, mas a mim concederam há algumas semanas, então não se preocupem, não é algo impossível.

👉 https://www.jetbrains.com/junie/

Tecnologia por trás do Junie

Caso estejam se perguntando, utilizam LLMs da OpenAI e Anthropic, vamos lá, como todo mundo. Não é nada novo, mas o que me surpreendeu é que em nenhum momento deixa escolher qual modelo você quer que utilize.

Como veem esta é a interface e não tem nenhum seletor. Entendo que dependendo do contexto usará um modelo ou outro.

Funcionalidades adicionais e limitações

Outra coisa que tem assim como o Cursor são os Guidelines, um arquivo .md que você pode especificar para cada projeto para que siga essas instruções. Recomendo a página cursor.directory que compila muitas instruções deste tipo, e neste post vamos usá-lo para compará-lo.

Também não parece ter uma seção de index project, funcionalidade que o Cursor tem para poder acessar arquivos do projeto com muito mais velocidade. Isto é um problema e nota-se, vocês verão que o JUNIE vai ser muito mais lento para nós.

Outra coisa a destacar é que segundo as suas políticas e o que tenho visto, parece que não há limite de uso. Assim como todos os editores deste estilo estabelecem limites mesmo que pague o premium, aqui não nos indica em nenhum momento. Imagino que estará limitado de alguma maneira mas nada que se possa ver à primeira vista.

Por último, outra coisa que devem saber é que só podem acessar o beta se tiverem a licença paga. Se usam a versão gratuita não vão poder. Talvez por isso não haja limite de requisições.

Comparação com Cursor

Vamos testá-lo em igualdade de condições com o Cursor.

Para testar as suas capacidades, não vou apenas me basear na experiência de uso que tive programando meus próprios projetos, mas fiz um teste básico para compará-lo bem com o Cursor.

Baixei um artefato base do Spring Initializer, coloquei alguns plugins como H2 e Lombok e mais algum, e dupliquei o projeto para abri-lo em cada editor de código.

O prompt de teste

O prompt que preparei foi o seguinte:

Crie um projeto Spring Boot com Java 21 utilizando Maven. A aplicação deve gerenciar uma loja simples com os seguintes requisitos:

Entidades:
	•	Product: com campos id, name, description, price, stock
	•	Customer: com campos id, name, email, address
	•	Order: com campos id, customer (relação ManyToOne), products (relação ManyToMany), totalAmount, orderDate

Banco de dados:
	•	Use H2 embarcado, configuração em application.properties
	•	Crie as tabelas automaticamente usando JPA (ddl-auto=update)

Repositórios:
	•	Use interfaces JpaRepository para cada entidade

Endpoints REST:
	•	Implemente um CRUD completo para Product e Customer
	•	Para Order, implemente:
	•	Criar um pedido atribuindo produtos existentes a um cliente
	•	Obter todos os pedidos de um cliente por ID
	•	Consultar o total de um pedido

Controladores:
	•	Use @RestController e @RequestMapping("/api/…") para organizar os endpoints
	•	Valide a entrada com @Valid onde aplicável
	•	Retorne respostas usando ResponseEntity

Extras:
	•	Use Lombok para evitar boilerplate
	•	Configure o acesso ao console do H2
	•	Siga boas práticas (nomes claros, divisão por camadas: controller, service, repository)
	•	Se possível, implemente DTOs para a entrada/saída de Order para não expor diretamente as entidades

Saída esperada: código completo pronto para compilar, incluindo:
	•	pom.xml com dependências necessárias
	•	Classes Entity
	•	Interfaces Repository
	•	Classes Service se aplicável
	•	Controladores REST
	•	Configuração em application.properties

Instruções personalizadas

E à parte, tanto no Cursor com as rules personalizadas e no Junie com seus guidelines (que vêm a ser o mesmo) indiquei isto aqui para que levem em conta:

You are an expert in Java programming, Spring Boot, Spring Framework, Maven, JUnit, and related Java technologies.

Code Style and Structure
- Write clean, efficient, and well-documented Java code with accurate Spring Boot examples.
- Use Spring Boot best practices and conventions throughout your code.
- Implement RESTful API design patterns when creating web services.
- Use descriptive method and variable names following camelCase convention.
- Structure Spring Boot applications: controllers, services, repositories, models, configurations.

Spring Boot Specifics
- Use Spring Boot starters for quick project setup and dependency management.
- Implement proper use of annotations (e.g., @SpringBootApplication, @RestController, @Service).
- Utilize Spring Boot's auto-configuration features effectively.
- Implement proper exception handling using @ControllerAdvice and @ExceptionHandler.

Naming Conventions
- Use PascalCase for class names (e.g., UserController, OrderService).
- Use camelCase for method and variable names (e.g., findUserById, isOrderValid).
- Use ALL_CAPS for constants (e.g., MAX_RETRY_ATTEMPTS, DEFAULT_PAGE_SIZE).

Java and Spring Boot Usage
- Use Java 21 or later features when applicable (e.g., records, sealed classes, pattern matching).
- Leverage Spring Boot 3.x features and best practices.
- Use Spring Data JPA for database operations when applicable.
- Implement proper validation using Bean Validation (e.g., @Valid, custom validators).

Configuration and Properties
- Use application.properties or application.yml for configuration.
- Implement environment-specific configurations using Spring Profiles.
- Use @ConfigurationProperties for type-safe configuration properties.

Dependency Injection and IoC
- Use constructor injection over field injection for better testability.
- Leverage Spring's IoC container for managing bean lifecycles.

Testing
- Write unit tests using JUnit 5 and Spring Boot Test.
- Use MockMvc for testing web layers.
- Implement integration tests using @SpringBootTest.
- Use @DataJpaTest for repository layer tests.

Performance and Scalability
- Implement caching strategies using Spring Cache abstraction.
- Use async processing with @Async for non-blocking operations.
- Implement proper database indexing and query optimization.

Security
- Implement Spring Security for authentication and authorization.
- Use proper password encoding (e.g., BCrypt).
- Implement CORS configuration when necessary.

Logging and Monitoring
- Use SLF4J with Logback for logging.
- Implement proper log levels (ERROR, WARN, INFO, DEBUG).
- Use Spring Boot Actuator for application monitoring and metrics.

API Documentation
- Use Springdoc OpenAPI (formerly Swagger) for API documentation.

Data Access and ORM
- Use Spring Data JPA for database operations.
- Implement proper entity relationships and cascading.
- Use database migrations with tools like Flyway or Liquibase.

Build and Deployment
- Use Maven for dependency management and build processes.
- Implement proper profiles for different environments (dev, test, prod).
- Use Docker for containerization if applicable.

Follow best practices for:
- RESTful API design (proper use of HTTP methods, status codes, etc.).
- Microservices architecture (if applicable).
- Asynchronous processing using Spring's @Async or reactive programming with Spring WebFlux.

Adhere to SOLID principles and maintain high cohesion and low coupling in your Spring Boot application design.

O processo de execução

Chega a hora da verdade, executo ambos IDEs e deixo que processem. No Cursor, para não fazer uma concorrência desleal, ativei a opção de LLM automático, já que no fim das contas o JUNIE também o faz automático e não te deixa escolher. Poderia ter escolhido Claude 3.7 Sonnet MAX Thinking mas, além de me custar um rim, não seria justo.

Depois de um tempo esperando, para ser sinceros, o Cursor termina muito antes. O Junie geralmente tem mais dificuldade para realizar as operações.

Resultados do teste

Executo ambos códigos e os dois compilam e executam sem problemas, isso é um bom sinal.

Junie AI

• Vantagens:

  • Código mais limpo e estruturado
  • Implementação de DTOs
  • Error handlers incluídos
  • Configuração CSRF básica
  • Testes mais eficientes e contextuais

• Desvantagens:

  • Maior tempo de resposta
  • Sem seletor de modelos
  • Sem indexação de projeto

Começo a revisar o código do Junie e no geral fez um bom código. Obviamente tem uma arquitetura muito muito básica, e lembremos que é um prompt super simples, mas a estrutura não me desagrada e nos criou DTOs, ErrorHandlers e até uma config de CSRF básica. Não está nada mal para estar em beta.

Cursor

• Vantagens:

  • Resposta mais rápida
  • Seletor de modelos disponível
  • Melhor indexação de projeto

• Desvantagens:

  • Estrutura de pastas em espanhol (inconsistente)
  • Falta de error handlers
  • Uso direto de entidades em controladores (sem DTOs)

Revisando o código do Cursor, vejo que me fez parte da estrutura de pastas em espanhol. Curioso, sim é verdade que o prompt estava em espanhol, mas vamos lá, aqui vejo uma red flag. Depois levo mais surpresas: não encontro nenhum error handler e, uau, o que é isto? O coleguinha do Cursor está usando nos controladores não só o mesmo objeto de entrada e saída, mas entramos no objeto e não é nem um DTO, é diretamente o entity.

A verdade é que uma surpresa para mal, não esperava esta gambiarra, coisa que o Junie não falhou e graças a deus.

Como último apontamento a favor do Junie, devo dizer que estive testando que me faça testes e me suba o coverage e é muito mais eficiente que o Copilot ou similar, já que ao ter contexto de todo o projeto sabe exatamente como mockar os objetos e pode ir executando os testes. Coisa que me dei conta que também faz se você pede para editar código existente que já tem testes: edita e executa seus testes, que se falharem ele os conserta. Algo muito curioso.

Tabela comparativa

Conclusão

Em definitiva e colocando todos os dados sobre a mesa, o Junie vale a pena testar, mas se não tem licença de IntelliJ então não vale a pena comprar só por isto. Vejo que é uma ferramenta bastante útil em aplicações mais robustas que o Cursor (o qual funciona melhor para aplicações leves com frameworks como Next.js), mas também não acho que seja a panaceia.

Tem que ter muito cuidado com estas ferramentas, já que mesmo que especifique muito, me deparei que faz coisas no código de maneira pouco ótima e recomendável. Além disso, sem falar do perigo que tem que os desenvolvedores dependam constantemente dos LLM, embora isso seja um tema à parte que tratarei em outro post.

Por agora, minha recomendação é:

• Se já usa JetBrains: Teste o Junie
• Se não tem licença JetBrains: Não vale a pena comprar só pelo Junie
• Para projetos leves (Next.js, etc.): Cursor continua sendo uma melhor opção

💡Talvez também te interesse

24 Sep 2025

Crea tu VPN al país que quieras de la forma más barata

27 Ene 2026

Protege tus aplicaciones web GRATIS con SafeLine WAF

14 Jun 2025

Coolify, La alternativa gratuita a Vercel que debes conocer