Desafios na Geração de Código Assistida por IA

Ao utilizar assistentes de programação baseados em inteligência artificial, é comum encontrar situações onde o código gerado não se alinha completamente com os padrões do projeto ou requer ajustes manuais signifiactivos. Isso ocorre frequentemente devido a ambiguidades no prompt ou à falta de contexto específico sobre as convenções da equipe, levando o modelo a produzir soluções genéricas, um fenômeno conhecido como alucinação de modelo.

Para mitigar esse problema, ferramentas modernas de IDE permitem a definição de Regras de Projeto (Project Rules). Essa funcionalidade possibilita impor restrições rígidas ao modelo, garantindo que o código gerado respeite estilos específicos, arquiteturas definidas e boas práticas de segurança.

Cenário Prático: Integração de API Externa

Considere a necessidade de integrar um serviço de geração de texto em uma aplicação Java. Inicialmente, sem regras definidas, ao fornecer um comando curl para a IA, o resultado tende ser funcional, mas carece de tratamentos de erro robustos e comentários adequados.

Exemplo de requisição base:

curl -X POST "https://api.exemplo.com/v1/chat" \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-max",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "Olá, mundo"
            }
        ]
    },
    "parameters": {
        "result_format": "json"
    }
}'

Sem diretrizes específicas, a classe Java resultante pode funcionar, mas geralmente ignora padrões de nomenclatura da empresa ou não implementa logging adequado.

Configuração do Ambiente

Para ativar o controle rigoroso sobre a geração de código, verifique se o plugin de IA instalado na sua IDE está na versão mais recente (v2.1.5 ou superior). A configuração é realizada diretamente nas preferências do desenvolvedor.

Navegue até as configurações do plugin, localize a seção de Regras de Projeto e habilite a edição personalizada. O conteúdo deve ser estruturado em Markdown, definindo claramente as expectativas técnicas.

Definição das Regras de Engenharia

Abaixo está um exemplo de configuração focada em aplicações Spring Boot, enfatizando segurança, arquitetura limpa e manutenibiliddae.

Princípios Gerais

• Aplicar rigorosamente os princípios SOLID e DRY.
• Garantir segurança contra vulnerabilidades comuns (OWASP Top 10).
• Manter separação de responsabilidades através de arquitetura em camadas.
• Exigir cobertura de testes unitários superior a 80% para novas funcionalidades.

Stack Tecnológico

• Core: Java 17 + Spring Boot 3.x
• Persistência: Spring Data JPA com PostgreSQL
• Utilitários: Lombok, Spring Validation, SpringDoc OpenAPI

Padrões de Implementação

1. Entidades de Domínio

Utilize anotações do JPA explicitamente e evite exposição direta de dados sensíveis.

@Entity
@Table(name = "products")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long productId;

    @Column(nullable = false, unique = true)
    @NotBlank
    private String sku;

    @Column(precision = 10, scale = 2)
    @DecimalMin("0.01")
    private BigDecimal price;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "category_id")
    private Category category;
}

2. Camada de Repositório

Prefera consultas nomeadas e evite N+1 queries utilizando EntityGraph.

public interface ProductRepository extends JpaRepository<Product, Long> {
    Optional<Product> findBySku(String sku);

    @Query("SELECT p FROM Product p JOIN FETCH p.category WHERE p.productId = :id")
    @EntityGraph(attributePaths = {"category"})
    Optional<Product> findDetailsById(@Param("id") Long id);
}

3. Lógica de Negócio (Service)

Transações devem ser gerenciadas exclusivamente nesta camada.

@Service
public class ProductServiceImpl implements ProductService {
    private final ProductRepository repository;

    public ProductServiceImpl(ProductRepository repository) {
        this.repository = repository;
    }

    @Transactional
    public ResponseDTO<ProductVO> registerProduct(ProductDTO dto) {
        Product entity = new Product();
        entity.setSku(dto.getSku());
        entity.setPrice(dto.getPrice());
        
        Product saved = repository.save(entity);
        return ResponseDTO.ok(ProductVO.fromEntity(saved));
    }
}

4. Controladores REST

Validação de entrada deve ocorrer no controller usando @Valid.

@RestController
@RequestMapping("/api/inventory")
public class ProductController {
    private final ProductService service;

    @PostMapping
    public ResponseEntity<ResponseDTO<ProductVO>> add(@Valid @RequestBody ProductDTO dto) {
        try {
            return ResponseEntity.ok(service.registerProduct(dto));
        } catch (BusinessRuleException ex) {
            return ResponseEntity.badRequest().body(ResponseDTO.error(ex.getMessage()));
        }
    }
}

5. Objetos de Transferência (DTO/VO)

Utilize records para imutabilidade quando possível.

public record ProductDTO(
    @NotBlank String sku,
    @NotNull BigDecimal price
) {}

6. Tratamento de Erros Global

Centralize a resposta de erros para manter consistência na API.

@RestControllerAdvice
public class GlobalErrorHandler {
    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<ResponseDTO<Void>> handleNotFound(ProductNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(ResponseDTO.error(ex.getMessage()));
    }
}

Segurança e Performance

• Validação: Nunca confie em entrada do usuário; use Bean Validation.
• SQL: Utilize sempre Prepared Statements via JPA.
• Logs: Utilize SLF4J; evite System.out.
• Prod: Externalize configurações sensíveis via variáveis de ambiente.

Impacto das Regras na Geração

Após aplicar essas diretrizes no arquivo de configuração do plugin, ao solicitar novamente a implementação da integração baseada no curl inicial, o código gerado reflete imediatamente as normas estabelecidas. A classe resultante inclui tratamentos de exceção padronizados, nomenclatura consistente e estrutura de pacotes organizada.

O arquivo de regras fica persistido no diretório do projeto, permitindo versionamento junto com o código fonte. Isso garante que todos os desenvolvedores, humanos ou agentes de IA, sigam o mesmo padrão de qualidade.