CopilotHub
SearchPromptsInstructionsAgentsToolsMCPs
  1. Home
  2. Instructions
  3. quarkus.instructions
Back to Instructions

quarkus.instructions

Coding standards for quarkus.instructions

java
0 downloads
51 views
0

Tags

testing
security
performance
best-practices
documentation
error-handling
api
database

Related Instructions

View all →

Spring Boot 2 → 3 Migration Guide (Jakarta EE)

**/*.java

Production-safe step-by-step playbook to migrate Spring Boot 2.x to 3.x with Jakarta EE, Java 17, Spring Security 6, and Hibernate 6

java
spring-boot
spring-boot
java
+5
1
299

Python Docstring Standards

*.py

Write clear and consistent Python docstrings

python
python
documentation
+1
0
61

API Route Security

app/api/**/*.ts

Security best practices for Next.js API routes

typescript
nextjs
security
api
+2
0
57

TypeScript Error Handling

*.ts

Comprehensive error handling patterns for TypeScript applications

typescript
typescript
error-handling
+1
0
57

React Component Best Practices

*.tsx

Guidelines for creating maintainable and performant React components

typescript
react
react
typescript
+2
0
62

WordPress Development — Copilot Instructions

Coding standards for wordpress.instructions

typescript
testing
security
+5
1
116
Browse More Instructions

CopilotHub

A curated collection of prompts, instructions, agents, and tools for AI-powered development.

Quick Links

  • Prompts
  • Instructions
  • Agents
  • Tools
  • MCPs
  • Search

Browse by Category

  • Code Generation
  • Debugging
  • Documentation
  • Refactoring
  • Testing
  • Security

Legal

  • Guidelines
  • About
  • Privacy Policy
  • Terms of Service

Community

GitHub

© 2026 CopilotHub.

  • Instructions for high-quality Quarkus applications with Java 17 or later.

Project Context

  • Latest Quarkus version: 3.x
  • Java version: 17 or later
  • Use Maven or Gradle for build management.
  • Focus on clean architecture, maintainability, and performance.

Development Standards

  • Write clear and concise comments for each class, method, and complex logic.
  • Use Javadoc for public APIs and methods to ensure clarity for consumers.
  • Maintain a consistent coding style across the project, adhering to Java conventions.
  • Adhere to the Quarkus coding standards and best practices for optimal performance and maintainability.
  • Follow Jarkarta EE and MicroProfile conventions, ensuring clarity in package organization.
  • Use Java 17 or later features where appropriate, such as records and sealed classes.

Naming Conventions

  • Use PascalCase for class names (e.g., ProductService, ProductResource).
  • Use camelCase for method and variable names (e.g., findProductById, isProductAvailable).
  • Use ALL_CAPS for constants (e.g., DEFAULT_PAGE_SIZE).

Quarkus

  • Leverage Quarkus Dev Mode for faster development cycles.
  • Implement build-time optimizations using Quarkus extensions and best practices.
  • Configure native builds with GraalVM for optimal performance (e.g., use the quarkus-maven-plugin).
  • Use quarkus logging capabilities (JBoss, SL4J or JUL) for consistent logging practices.

Quarkus-Specific Patterns

  • Use @ApplicationScoped for singleton beans instead of @Singleton
  • Use @Inject for dependency injection
  • Prefer Panache repositories over traditional JPA repositories
  • Use @Transactional on service methods that modify data
  • Apply @Path with descriptive REST endpoint paths
  • Use @Consumes(MediaType.APPLICATION_JSON) and @Produces(MediaType.APPLICATION_JSON) for REST resources

REST Resources

  • Always use JAX-RS annotations (@Path, @GET, @POST, etc.)
  • Return proper HTTP status codes (200, 201, 400, 404, 500)
  • Use Response class for complex responses
  • Include proper error handling with try-catch blocks
  • Validate input parameters using Bean Validation annotations
  • Implement rate limiting for public endpoints

Data Access

  • Prefer Panache entities (extend PanacheEntity) over traditional JPA
  • Use Panache repositories (PanacheRepository<T>) for complex queries
  • Always use @Transactional for data modifications
  • Use named queries for complex database operations
  • Implement proper pagination for list endpoints

Configuration

  • Use application.properties or application.yaml for simple configuration
  • Use @ConfigProperty for type-safe configuration classes
  • Prefer environment variables for sensitive data
  • Use profiles for different environments (dev, test, prod)

Testing

  • Use @QuarkusTest for integration tests
  • Use JUnit 5 for unit tests
  • Use @QuarkusIntegrationTest for native build tests
  • Mock external dependencies using @QuarkusTestResource
  • Use RestAssured for REST endpoint testing (@QuarkusTestResource)
  • Use @Transactional for tests that modify the database
  • Use test-containers for database integration tests

Don't use these patterns:

  • Don't use field injection in tests (use constructor injection)
  • Don't hardcode configuration values
  • Don't ignore exceptions

Development Workflow

When creating new features:

  1. Create entity with proper validation
  2. Create repository with custom queries
  3. Create service with business logic
  4. Create REST resource with proper endpoints
  5. Write comprehensive tests
  6. Add proper error handling
  7. Update documentation

Security Considerations

When implementing security:

  • Use Quarkus Security extensions (e.g., quarkus-smallrye-jwt, quarkus-oidc).
  • Implement role-based access control (RBAC) using MicroProfile JWT or OIDC.
  • Validate all input parameters