guicedee-creator

Create new GuicedEE-ready Maven modules with enforced Maven 4 and JDK 25+ baselines, GuicedEE BOM import, and JPMS main/test module boundaries. Use when scaffolding a new module, generating initial `pom.xml` and `module-info.java` files, or validating that module/test packages are separated (`.test` suffix in tests).

5 stars

Best use case

guicedee-creator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Create new GuicedEE-ready Maven modules with enforced Maven 4 and JDK 25+ baselines, GuicedEE BOM import, and JPMS main/test module boundaries. Use when scaffolding a new module, generating initial `pom.xml` and `module-info.java` files, or validating that module/test packages are separated (`.test` suffix in tests).

Teams using guicedee-creator should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/guicedee-creator/SKILL.md --create-dirs "https://raw.githubusercontent.com/GuicedEE/ai-rules/main/skills/.system/guicedee-creator/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/guicedee-creator/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How guicedee-creator Compares

Feature / Agentguicedee-creatorStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Create new GuicedEE-ready Maven modules with enforced Maven 4 and JDK 25+ baselines, GuicedEE BOM import, and JPMS main/test module boundaries. Use when scaffolding a new module, generating initial `pom.xml` and `module-info.java` files, or validating that module/test packages are separated (`.test` suffix in tests).

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# GuicedEE Creator

Create a new module with GuicedEE baseline constraints and validate them deterministically.

## Required Flow
1. Collect inputs: `groupId`, `artifactId`, `moduleName`, and base package.
2. Create Maven project structure with `src/main/java` and `src/test/java`.
3. Apply the baseline POM constraints from `references/guicedee-baseline.md`:
   - Maven wrapper pinned to Maven 4
   - Java release/source/target at 25 or higher
   - GuicedEE BOM import in `dependencyManagement`
   - Testing stack includes `org.junit.jupiter:junit-jupiter` (`test` scope), JUnit Jupiter `6.0.3+`, and Mockito
4. Create `module-info.java` for both main and test roots with explicit `requires`/`opens` directives:
   - Test module must `requires` JUnit Jupiter module(s) for the `junit-jupiter` dependency
   - Every test package must be opened to `org.junit.platform.commons`
   - Any package requiring injection must open to `com.google.guice`
   - Any DTO/JSON deserialization package must open to `com.fasterxml.jackson.databind`
   - Any package using Vert.x features must open to `com.guicedee.vertx`
   - Safe default: open each used package to all required runtime targets
5. Ensure package separation:
   - Test module defaults to `<moduleName>.test`
   - Test package names end in `.test`
   - No package is shared between main and test source sets
6. Create a bootstrap main class with:
   - `LogUtils.addHighlightedConsoleLogger(Level.DEBUG)`
   - `IGuiceContext.registerModule("<moduleName>")`
   - `IGuiceContext.instance().inject()`
7. If lifecycle/injection sequence customization is needed, implement lifecycle SPI classes:
   - `com.guicedee.client.services.lifecycle.IGuicePreStartup`
   - `com.guicedee.client.services.lifecycle.IGuiceModule`
   - `com.guicedee.client.services.lifecycle.IGuicePostStartup`
   - All lifecycle hooks extend `IDefaultService<J>` (CRTP); override `sortOrder()` to control execution order and `enabled()` to conditionally skip
8. Register every SPI implementation in both:
   - `src/main/java/module-info.java` (`provides ... with ...`)
   - `src/main/resources/META-INF/services/<spi-interface-fqcn>`
9. Run `scripts/verify_guicedee_baseline.py` before finishing.

## Non-Negotiable Constraints
- Maven 4 is required (enforce via wrapper + enforcer rule).
- JDK 25 minimum is required.
- BOM import must exist exactly as:
  - `<groupId>com.guicedee</groupId>`
  - `<artifactId>guicedee-bom</artifactId>`
  - `<type>pom</type>`
  - `<scope>import</scope>`
- `module-info.java` must exist in both:
  - `src/main/java/module-info.java`
  - `src/test/java/module-info.java`
- `pom.xml` must include:
  - `<groupId>org.junit.jupiter</groupId>`
  - `<artifactId>junit-jupiter</artifactId>`
  - `<scope>test</scope>`
- Test module must declare `requires` for JUnit Jupiter (for example `requires org.junit.jupiter.api;`).
- Every test package must include an `opens <package> to org.junit.platform.commons;` directive.
- Injection packages must `opens` to `com.google.guice`.
- DTO/JSON deserialization packages must `opens` to `com.fasterxml.jackson.databind`.
- Vert.x packages must `opens` to `com.guicedee.vertx`.
- Safe default for main module packages: open used packages to all required targets (`com.google.guice`, `com.fasterxml.jackson.databind`, `com.guicedee.vertx`).
- Safe default for test module packages: also include `org.junit.platform.commons`.
- A bootstrap `main()` class must exist in `src/main/java` and register the current module name.
- Lifecycle SPI implementations must be registered in both `module-info.java` and `META-INF/services`.
- Lifecycle SPI implementations must override `sortOrder()` (from `IDefaultService<J>`).
- Testing baseline must include JUnit Jupiter `6.0.3+` and Mockito.
- Playwright is optional and should be added for browser/E2E automation use cases.
- Package names cannot be duplicated between main and test modules.
- Test packages must use `.test` suffix.

## Validation Command
```bash
python3 scripts/verify_guicedee_baseline.py --project-root .
```

## References
- `references/guicedee-baseline.md` - baseline snippets for `pom.xml`, wrapper, and module templates.

Related Skills

skill-creator

5
from GuicedEE/ai-rules

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Codex's capabilities with specialized knowledge, workflows, or tool integrations.

guicedee-websockets

5
from GuicedEE/ai-rules

RFC 6455 WebSocket support for GuicedEE using Vert.x 5: call-scoped connections, action-based message routing via IWebSocketMessageReceiver SPI, group management and broadcasting, WebSocketServerOptions, and lifecycle hooks. Use when adding WebSocket messaging, implementing real-time communication, managing WebSocket groups, or creating message receivers.

guicedee-webservices

5
from GuicedEE/ai-rules

SOAP web services for GuicedEE using Apache CXF conventions: JAX-WS annotations (@WebService, @WebMethod, @WebParam, @WebResult), code-first and WSDL-first approaches, endpoint publishing, CXF interceptors and logging, MTOM, WS-Security (WSS4J), SOAP 1.1/1.2 bindings, and Guice DI integration. Use when creating SOAP services, publishing JAX-WS endpoints, configuring CXF bindings, or adding WS-Security.

guicedee-web

5
from GuicedEE/ai-rules

Bootstrap reactive HTTP/HTTPS servers with Vert.x 5 inside GuicedEE: Router setup, BodyHandler configuration, TLS/HTTPS, SPI extension points (VertxRouterConfigurator, VertxHttpServerOptionsConfigurator, VertxHttpServerConfigurator), per-verticle sub-routers, and environment-driven configuration. Use when setting up the Vert.x web server, configuring HTTP/HTTPS, adding custom routes or middleware, or managing server options.

guicedee-vertx

5
from GuicedEE/ai-rules

Build reactive services using Vert.x 5 inside the GuicedEE DI lifecycle: event-bus consumers, publishers, verticle deployment, codecs, throttling, clustering, SPI hooks, and JPMS module setup. Use when adding Vert.x event-bus messaging, deploying verticles, wiring reactive endpoints with Guice injection, configuring Vert.x runtime options, or implementing custom codecs and cluster managers.

guicedee-service-registry

5
from GuicedEE/ai-rules

Named service registry with health-aware resolution for GuicedEE. Register services by simple name, auto-construct URLs from cloud DNS suffix, monitor health status, resolve services via registry:name prefix or bare name in rest-client @Endpoint. Supports aliases, multiple external URLs, Kubernetes internal URLs, and per-service health paths. Use when registering named services, checking service health, resolving service URLs by name, or integrating with rest-client for service-to-service calls.

guicedee-rest

5
from GuicedEE/ai-rules

Build Jakarta REST (JAX-RS) services on Vert.x 5 inside GuicedEE: @Path/@GET/@POST route registration, parameter binding (@PathParam, @QueryParam, @HeaderParam, etc.), Guice-managed resource classes, response handling, content negotiation, and JPMS module setup. Use when creating REST endpoints, configuring Jakarta REST resources, or wiring JAX-RS services with Guice injection.

guicedee-rest-client

5
from GuicedEE/ai-rules

Annotation-driven REST client for GuicedEE using Vert.x 5 WebClient: @Endpoint declarations, RestClient<Send, Receive> injection, authentication strategies (Bearer, Basic, API Key, OAuth2, mTLS), path parameters, environment variable overrides, package-level endpoints, service registry integration (bare name or registry: prefix), and RestClientConfigurator SPI. Use when making outbound REST calls, configuring REST client endpoints, or wiring reactive HTTP clients with Guice injection.

guicedee-rabbitmq

5
from GuicedEE/ai-rules

Annotation-driven RabbitMQ integration for GuicedEE with Vert.x 5: @RabbitConnectionOptions, @QueueExchange, @QueueDefinition, QueueConsumer/QueuePublisher injection, exchange management, queue options (priority, TTL, prefetch), publisher confirms, environment variable overrides, and verticle-scoped connections. Use when adding RabbitMQ messaging, declaring exchanges and queues, creating consumers and publishers, or configuring AMQP topology.

guicedee-persistence

5
from GuicedEE/ai-rules

Reactive JPA persistence with Hibernate Reactive 7, Vert.x 5 SQL clients, and Mutiny sessions inside GuicedEE: DatabaseModule setup, persistence.xml configuration, multi-database support, @EntityManager scoping, and environment variable resolution. Use when adding database persistence, configuring Hibernate Reactive, creating DatabaseModule subclasses, wiring Mutiny.SessionFactory, or managing multiple persistence units.

guicedee-openapi

5
from GuicedEE/ai-rules

Automatic OpenAPI 3.1 spec generation and serving for GuicedEE with Vert.x 5: scans Jakarta REST resources at startup, serves /openapi.json and /openapi.yaml endpoints, Swagger annotations support, @OpenAPIDefinition configuration, and companion Swagger UI module. Use when generating API documentation, serving OpenAPI specs, or configuring Swagger annotations on REST resources.

guicedee-metrics

5
from GuicedEE/ai-rules

Application metrics for GuicedEE using Vert.x 5 Dropwizard Metrics and MicroProfile Metrics 5.1: @Counted, @Timed, @MetricMethod annotations, Guice AOP interceptors, Prometheus scrape endpoint, Graphite reporting, JMX exposure, @MetricsOptions configuration, environment variable overrides, and Vert.x built-in metrics (event bus, HTTP, pools). Use when adding application metrics, configuring Prometheus endpoints, creating custom counters/timers, or monitoring Vert.x internals.