taipt1504
UserA Claude Code plugin for Java & Spring Boot backend engineers that turns one task into a gate-enforced 7-phase agentic workflow — Discover → Brainstorm → Spec → Plan → Implement → Review → Learn. Native hooks, 11 subagents, path-scoped rules, project memory & strict test-first TDD.
Categories
Indexed Skills (30)
systematic-debug
Structured debugging protocol — reproduce → isolate (bisect) → root cause → test → fix. Used on-demand when a bug appears outside Phase Loop (e.g., user reports a failing test, prod incident). Slash-invoke /claudehut:debug <symptom>. Does not auto-trigger; user-controlled.
brainstorm
Phase 1 of ClaudeHut workflow — scan codebase + reuse-detection, draft a design document, run main-thread AskUserQuestion exchanges for any open decisions, converge on an approved design. Use when the user requests new functionality AND no task is active (phase=none), OR when explicitly invoked via /claudehut:brainstorm. Triggers on natural-language "add|implement|build|design|refactor|fix bug" with a noun (feature/endpoint/service/class/module/api).
build
Phase 4 of ClaudeHut workflow — execute the approved plan by dispatching each parallel group of tasks as concurrent builder subagents (each in its own git worktree), then merging results. Tasks within the same Parallel group run simultaneously; groups run in order. Strict TDD enforced per task. Use after Plan phase approval. Triggers when phase=build.
init
Scaffold the .claudehut/ directory in the current Java project (creates memory/, specs/, plans/, state/, rules/ subdirs and seeds template configs). Run via /claudehut:init when first enabling ClaudeHut on a project. One-time per project; refuses if directory already exists.
kafka-consumer
Spring Kafka consumer conventions — @KafkaListener, manual ack modes, DLT pattern, retry topic, idempotency via dedup store, JSON/Avro deserialization. Auto-loads when editing `**/*Listener*.java`, `**/*Consumer*.java` in projects with messaging=kafka.
learn
Phase 6 of ClaudeHut workflow — extract patterns, anti-patterns, decisions, and reusable snippets from the completed task, persist as memory in `.claudehut/memory/learnings.jsonl`, update `index.md`, optionally promote to global tier when threshold met. Use after Verify-Review passes. Triggers when phase=learn.
lombok
Project Lombok conventions for Java/Spring Boot 3.x. Auto-loads when a file uses Lombok annotations (@Data, @Value, @Builder, @SuperBuilder, @Slf4j, @RequiredArgsConstructor, etc.) or matches `**/*.java` in projects with lombok on the build classpath. Covers the safe-annotation matrix, the JPA-entity / Jackson / MapStruct interop traps, builder patterns with inheritance and defaults, and the recommended lombok.config. Invoke whenever Java source uses any `lombok.*` import or carries a Lombok annotation — even a one-line @Slf4j edit triggers this skill per the plugin's 1% rule.
plan
Phase 3 of ClaudeHut workflow — break an approved contract into a file-level task list with 2–5 minute chunks, exact paths, RED test commands, GREEN implementation steps, DAG dependencies, and risk callouts. Use immediately after Spec phase approval. Produces `.claudehut/plans/<id>-plan.md`. Triggers when phase=plan.
redis-cache
Spring Data Redis conventions — caching with @Cacheable, key strategy, TTL/eviction policies, Redisson distributed lock patterns. Auto-loads when editing `**/*Cache*.java` or files using @Cacheable. Covers RedisTemplate config + serialization.
reuse-scan
Quét codebase tìm impl tái sử dụng được trước khi tạo mới (Java backend). Detect plugin reuse ngoài đã cài (Understand-Anything, Graphify) rồi invoke trực tiếp slash command native + normalize output. Fallback grep + heuristic khi không plugin nào khả dụng. Auto-trigger Phase Brainstorm step 2 + `PreToolUse(Write)` cho file Java mới. Slash `/claudehut:reuse-scan <topic>`. Always invoke before allowing new class creation.
spec
Phase 2 of ClaudeHut workflow — convert an approved design document into a binary behavioral contract (Given/When/Then, API shape, edge cases, NFRs). Use immediately after Brainstorm phase approval. Produces `.claudehut/specs/<id>-contract.md`. Triggers when phase=spec.
spring-webflux
Spring WebFlux conventions for Java Spring Boot 3.x reactive stack. Auto-loads when editing `**/*Handler.java` or `**/*Controller.java` in projects with web_stack=webflux. Covers RouterFunctions + Handler pattern, schedulers, context propagation, StepVerifier testing, backpressure.
using-claudehut
ClaudeHut workflow + plugin-skill discovery contract for subagents. Preloaded into every dispatch-eligible agent via `skills:` frontmatter so the subagent receives, at startup, (a) the non-negotiable skill-invocation discipline and (b) the catalog of all plugin skills with trigger excerpts. Lets the subagent decide — natively, no hook injection — which skill(s) to invoke when its task touches a domain its preloaded skills do not cover (e.g. builder hitting Kafka, mapping, JPA, WebFlux, ...).
verify-review
Phase 5 of ClaudeHut workflow — run verify pipeline (build/tests/coverage/lint/static/security) via a gate-runner subagent, then the orchestrator fans out reviewer subagents in parallel, aggregates shards, and decides pass-or-refactor; bounded retry (max 3) then escalate. Use after Build phase completes. Triggers when phase=loop.
wiremock-stub
WireMock stub conventions for HTTP integration tests. Stub mapping JSON format, scenario-based stateful stubs, request matching strategies, fault injection. Auto-loads when editing `src/test/**/*Wiremock*.java` or `**/__stubs/*.json`.
arch-unit-check
Run ArchUnit tests if present in project to enforce package-layout/hexagonal/DDD rules. Used in Phase 5 verify stage. Optional — skips if ArchUnit not on classpath. Slash-invoke /claudehut:arch-unit-check for ad-hoc verification.
discover
Show ClaudeHut plugin status — active task, current phase, detected stack, loaded skills/agents/rules/hooks, integration backends (Understand-Anything, Graphify), and MCP server status. Run via /claudehut:discover when you need to know what the plugin is doing right now.
flyway-migration
Flyway migration conventions for PostgreSQL/MySQL — naming, online-safe DDL (CREATE INDEX CONCURRENTLY, expand-contract for renames), idempotency, backfill patterns. Auto-loads when editing `**/db/migration/V*.sql` or `R*.sql`.
jackson
Jackson serialization/deserialization conventions for Spring Boot 3.x. Auto-loads when editing `**/*Dto.java`, `**/*Request.java`, `**/*Response.java`, `**/ObjectMapper*.java`, `**/JsonConfig*.java`. Covers ObjectMapper config, polymorphic deserialization (subtype whitelist), JavaTimeModule, mixins, mass-assignment prevention.
jpa-hibernate
JPA + Hibernate conventions for Spring Boot 3.x servlet stack. Auto-loads when editing `**/*Repository.java`, `**/*Entity.java` in projects with orm=jpa. Covers @Entity mapping, fetch strategies (N+1 prevention), @Transactional semantics, JPQL/Criteria, projection patterns.
kafka-producer
Spring Kafka producer conventions — idempotent producer config, transactional outbox pattern, Schema Registry integration, JSON/Avro serialization, retry + backoff. Auto-loads when editing `**/*Producer*.java`, `**/*Publisher*.java` in projects with messaging=kafka.
mapstruct
MapStruct mapper conventions for Java. Auto-loads when editing `**/*Mapper.java` files with @Mapper annotation. Covers @Mapping/@MappingTarget/@BeanMapping config, null strategies, Lombok interop, before/after mapping hooks, generated impl review.
nats
NATS / JetStream consumer + publisher conventions for Java (jnats). Auto-loads when editing `**/*NatsListener*.java`, `**/*NatsClient*.java` in projects with messaging=nats. Covers durable consumers, ack policies, JetStream streams + consumers, replay.
owasp-scan
Run OWASP dependency-check + custom Spring Security misconfig regex scans. Used in Phase 5 verify stage. Slash-invoke /claudehut:owasp-scan for on-demand scans. Outputs structured findings list; fails build on High/Critical.
r2dbc
Reactive R2DBC conventions for Spring Boot 3.x WebFlux stack. Auto-loads when editing `**/*Repository.java` in projects with orm=r2dbc. Covers ReactiveCrudRepository, R2dbcEntityTemplate, reactive transactions, converter setup, Testcontainers integration.
rabbitmq
Spring AMQP (RabbitMQ) conventions — exchange/queue/binding topology, manual ack, DLX (dead-letter exchange) pattern, retry policy, message TTL. Auto-loads when editing `**/*RabbitListener*.java` in projects with messaging=rabbitmq.
spring-mvc
Spring MVC REST controller conventions for Java Spring Boot 3.x. Auto-loads when editing `**/*Controller.java` files in projects with web_stack=mvc. Covers @RestController, validation, ResponseEntity, @ControllerAdvice exception handling, RFC 7807 ProblemDetail, JWT auth integration.
tdd-cycle
Enforce strict RED → GREEN → REFACTOR test-driven cycle for Java/Spring code. Required for every Build phase task. Detects and rejects common anti-patterns (prod-before-test, test-after, manual-test rationalization). Use during Phase 4 Build or whenever writing new logic. Auto-loads when test files in scope.
testcontainers
Testcontainers for Java integration tests — singleton vs per-class lifecycle, reuse flag, network sharing, Postgres/Kafka/Redis containers, dynamic Spring properties. Auto-loads when editing `**/*IT.java`, `src/integrationTest/**/*.java`.
write-skill
Scaffold a new ClaudeHut skill using the 3-bucket layout (SKILL.md + references/ + scripts/ + assets/). Validates frontmatter contract, applies naming conventions, generates skeleton with placeholders. Run via /claudehut:write-skill <skill-name>. Use when extending ClaudeHut with new domain expertise.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.