When a methodology is described only in a PDF document, it gets ignored. Not deliberately — there's just no time to read it, and it's forgotten under deadline pressure. Use Case Pattern handles this differently: the rules are baked into Claude Code skills, and the model applies them automatically on every call.
This article covers how to install all the components and make sure they work.
What the stack consists of
Four independent components, each useful on its own:
| Component | What it does |
|---|---|
| usecase-pattern-skills | 44 methodology skills: "design a UseCase", "check a Handler", "write a spec from a business description" |
| superpowers | An orchestrator plugin for large tasks: brainstorm → plan → execution → verification |
| context7 | An MCP server that pulls in up-to-date library documentation (Spring Boot, FastAPI, TypeORM, etc.) |
| mcp-language-server + jdtls | A Java LSP via MCP — semantic search in the code instead of grep: find_references, definition, rename |
An important clarification: only one skill out of 44 (ucp-spec-design) optionally uses superpowers and context7. The other 43 work without them. That is, components 2–4 are an improvement, not a prerequisite.
Skills catalog
The skills are organized in "design ↔ review" pairs along the lifecycle of a task.
Specification
ucp-spec-design — write a Use Case spec from a business description. It determines the required maturity level (1 — layered architecture, 2 — UCP with CQRS, 3 — DDD + Hexagonal) and fills in the sections with the right depth. The output is docs/spec/: a context root file and a separate file for each domain unit.
ucp-spec-tier-0 — reverse-engineer a spec from existing code. The input is the repo (sources, migrations, configs, tests); the output is the same docs/spec/ structure with level: 0. Fields for which there's no data are filled with not-declared — a signal that it needs clarifying.
Design
ucp-pattern-design — UseCase + Handler + controller + mapper. The most frequently used skill for a specific task.
ucp-api-design — a REST API from the "Commands" section in the spec: OpenAPI YAML, controller signatures, DTOs, error format per RFC 9457.
ucp-ddd-tactical-design — an aggregate, Value Objects, events, and a repository from the "Domain Model" section. Used at Level 3.
ucp-auth-design — Spring Security + OAuth2 Resource Server + JWT + ABAC + an audit aspect.
ucp-bootstrap-design — Spring Boot from scratch: three profiles (production / local / integration-test), Liquibase, jOOQ codegen, security configuration.
ucp-test-design — integration and unit tests from the Use Cases and business rules in the spec. Uses Testcontainers PostgreSQL + WireMock.
Review
ucp-pattern-review — the service's code against the methodology: UseCase as an immutable record, Handler with transactionality, controller via UseCaseDispatcher.
ucp-api-review — the REST contract: URLs in kebab-case, HTTP methods and codes, JSON field names, OpenAPI metadata.
ucp-ddd-tactical-review — the domain code against tactical DDD patterns: Entity, Value Object, Aggregate Root, Domain Event, Repository.
ucp-java-style-review — code style that checkstyle doesn't catch: abbreviations, test names, large lambdas, guard expressions.
ucp-auth-review — authorization: JWT, RBAC, ABAC, S2S, audit, handling of personal data and secrets. Each violation is cited with a rule code.
The idea of design ↔ review pairs
For every methodology rule there are two skills: one creates code according to the rule, the other checks existing code against that rule. This turns a "PDF document with rules" into an executable standard — you don't need to read it separately, it's applied automatically.
Installation
Step 1. Claude Code
If it's not installed yet — claude.com/code. Check that the CLI works:
claude --version
Step 2. usecase-pattern-skills
The skills live in a single repo. Connecting them means cloning and running install.sh:
git clone git@github.com:remodov/usecase-pattern-skills.git ~/projects/usecase-pattern-skills
cd ~/projects/usecase-pattern-skills
# connect to a specific project (recommended):
./install.sh ~/my-project
# or globally for all projects:
./install.sh ~/.claude
install.sh creates symlinks in .claude/skills/* and docs/*.md. Symlinks mean that updates in the repo automatically flow into the project without manual copying.
After installation, the project will have:
.claude/skills/ucp-*/— 44 skillsdocs/*.md— style-guide files that the skills read as input
Check: open Claude Code in the project and type /ucp- — autocompletion should appear with a list of the skills.
Step 3. superpowers (optional)
A plugin from the Claude Code marketplace:
claude plugins install superpowers
If the command is unavailable — check claude help or the Claude Code documentation.
After installation, orchestrator skills will appear:
superpowers:brainstorming— for vague requirementssuperpowers:writing-plans— an implementation plan from a specsuperpowers:executing-plans— step-by-step plan executionsuperpowers:test-driven-development— TDD disciplinesuperpowers:verification-before-completion— a check before committing
Without superpowers, the ucp-* skills are independent operations, and you have to remember the order of steps yourself. With it — a coherent pipeline in which the plan is held between steps.
Step 4. context7 (optional)
context7 is an MCP server that pulls in up-to-date library documentation. Connecting it:
claude mcp add context7
Or manually in ~/.claude/settings.json:
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@context7/mcp-server"]
}
}
}
It's especially useful when working with the ucp-spec-design skill — it won't write an outdated library version into the spec. Without context7, versions in the spec have to be checked manually.
Step 5. LSP via MCP (recommended for large services)
By default, Claude works with code by reading files and searching text. That's enough for small tasks, but on large services the semantics are lost. "Find all callers of Repository.save()" via text search yields spurious matches with Map.save, List.save, and overloads. With LSP (find_references, definition, diagnostics, rename_symbol) — the accuracy is like in an IDE.
When it's worth setting up: a service of 30+ files or 5+ modules. On small ones, the setup overhead outweighs the benefit.
Installation for Java (macOS, about 10 minutes):
brew install jdtls go
go install github.com/isaacphi/mcp-language-server@latest
Connect it to Claude Code as an MCP server for a specific workspace:
claude mcp add --scope user java-lsp-<service> \
$HOME/go/bin/mcp-language-server \
-- -workspace /Users/<you>/IdeaProjects/<service> \
-lsp /opt/homebrew/bin/jdtls
Replace <service> with the project name (for example, orders). The server name determines the tool names: mcp__java-lsp-<service>__find_references and so on.
Check:
claude mcp list
There should be a line java-lsp-<service>: ... ✓ Connected.
First run: after adding it, you need to restart Claude Code — MCP servers load at the start of a session. The first LSP tool call takes 1–3 minutes: jdtls imports the Gradle project in the background, downloads dependencies, and builds an index. Subsequent calls are instant.
Multiple projects: add a separate server for each repo (java-lsp-orders, java-lsp-catalog, and so on). Each consumes 1–2 GB of RAM — it's not worth connecting all projects at once, only the active ones.
Linux and WSL: instead of brew install jdtls, download a release from github.com/eclipse-jdtls/eclipse.jdt.ls/releases and unpack it. Everything else is the same.
Step 6. Verifying the installation
UCP skills — open Claude Code in the project and type:
/ucp-pattern-review
The skill with its description should appear. If not — check the symlinks:
ls -la .claude/skills/
Superpowers (if you installed it):
/superpowers:writing-plans
The skill with its description should appear.
Context7 (if you installed it):
Try asking Claude Code in the chat to find the latest version of any of your project's libraries — Claude should reach for the mcp__context7__* tools.
Java LSP (if you installed it):
Ask Claude to find all callers of a specific method in the project. LSP will give fewer spurious matches than a text search.
If something doesn't work
The /ucp-* skills aren't visible:
ls -la .claude/skills/
There should be symlinks to directories in ~/projects/usecase-pattern-skills/.claude/skills/. If not — rerun install.sh.
Superpowers isn't installed:
claude plugins list
If superpowers isn't in the list — reinstall it. The exact command depends on the Claude Code version; start with claude help plugins.
Context7 isn't responding:
claude mcp list
If the status is down or error — make sure npx is available in PATH and there's internet access (on the first run npx downloads the package). You may need write permission to ~/.npm/.
The ucp-spec-design skill warns about missing dependencies:
Without superpowers, the skill works without TodoWrite planning. Without context7, library versions have to be checked manually. This is graceful degradation, not a blocker — the other 43 skills don't depend on external plugins at all.
In short
- A stack of four components: 44 UCP skills +
superpowers(orchestrator) +context7(up-to-date documentation) + LSP via MCP (semantic search in the code). - The components are independent: the skills work without
superpowersandcontext7; onlyucp-spec-designoptionally uses them. - Installing the skills:
git clone+./install.sh <project>, which creates symlinks — updates flow in automatically. - LSP is worth setting up for services of ~30+ files; on small ones the overhead isn't justified.
- The skills are organized in "design ↔ review" pairs: the design skill creates code according to a rule, the review skill checks existing code against that rule.
- The first Java LSP run takes 1–3 minutes to index; subsequent ones are instant.
Further reading
- Use Case Pattern: a step-by-step application guide — how to apply the methodology from the first UseCase.
- UCP maturity levels — how Level 1, 2, and 3 differ.
- AI writes code. So why a methodology? — why the speed of code generation doesn't remove the need for standards.