JetBrains AI Assistant design rules — keeping IntelliJ and WebStorm generations on-brand.

JetBrains AI Assistant ships in IntelliJ, WebStorm, PyCharm, GoLand, RubyMine, and the rest of the suite. It is excellent at refactoring and code completion. On design tasks, it reverts to the same model defaults every other AI surface produces — Inter as display, the canonical purple-to-blue gradient, three identical cards. ux-skill wires into JetBrains AI through the custom instructions surface and a CLI-driven linter that runs in the integrated terminal.

By the ux-skill team · 8 min read · MIT-licensed open source

Why JetBrains projects hit the design problem

A typical JetBrains project is backend-led: a Spring Boot API in IntelliJ, a Kotlin service, a Python data pipeline in PyCharm, a Go service in GoLand. The frontend often sits adjacent as a small Next.js or Vue app generated quickly to expose the API. That frontend is where AI Assistant lands its defaults — because it is treated as the boilerplate part of the job.

The result is consistent across teams: a backend whose architecture took weeks of design thinking and a frontend whose visual choices took ten minutes. The frontend ends up looking like every other AI-generated frontend, because no one budgeted the cognition for the brief.

ux-skill is the forcing function for that brief. The 10-field discovery takes 90 seconds. The recommender returns a design system. The linter catches drift on the way back. JetBrains AI generates the code; ux-skill enforces the rails.

Where JetBrains AI reads instructions from

JetBrains AI Assistant reads project context from a few sources. The most useful for design rules is the workspace AI Rules file at .junie/guidelines.md (the convention shared with JetBrains' Junie agent) or a project-level AI_ASSISTANT_GUIDELINES.md in the repo root. JetBrains AI also reads .cursorrules when present, for cross-IDE compatibility.

ux-skill generates a JetBrains-flavored rules file with uxskill init --target jetbrains. The generator writes a 30-line guidelines file plus a reference to .ux/design-system/MASTER.md for deeper context.

$ uxskill init --target jetbrains

[OK] Wrote .junie/guidelines.md
[OK] Wrote .ux/design-system/MASTER.md
[OK] Wrote .ux/design-system/tokens.css
[OK] Wrote .ux/design-system/manifest.json

The .ux state directory is the source of truth

Every ux-skill install writes into one directory: .ux/ at the project root. JetBrains AI reads files in this directory the same way it reads src/ — through the workspace context window.

Commit .ux/ and .junie/. The next JetBrains AI session reads them on startup. The state is repo-local, version-controlled, and deterministic — same brief, same files.

The tokens.css that lands in a Spring project

A concrete example. Run discovery for a Spring Boot admin dashboard, audience is internal ops at a logistics company, tone is precise and technical, reference brands are Linear and Stripe, region is MENA, dark mode required. The recommender returns editorial-precise + cool-neutral + Fraunces-Inter + restrained motion. The persist save step writes this tokens.css:

/* .ux/design-system/tokens.css */
/* Generated by ux-skill v2.0.0-alpha.1 — 2026-05-28 */

:root {
  /* Surface */
  --surface: #f5f3ee;
  --surface-2: #ece8df;
  --ink: #1c1a17;
  --body: #3f3d39;
  --muted: #6e6c66;

  /* Accent (single, restrained) */
  --accent: #b5703f;
  --accent-active: #945a30;

  /* Type ramp */
  --font-display: "Fraunces", "Cormorant Garamond", serif;
  --font-body: "Inter", system-ui, sans-serif;
  --font-mono: "JetBrains Mono", ui-monospace, monospace;

  /* Spacing (4px base) */
  --space-2: 8px;
  --space-3: 12px;
  --space-4: 16px;
  --space-6: 24px;
  --space-8: 32px;

  /* Motion */
  --ease-out: cubic-bezier(0.16, 1, 0.3, 1);
  --duration-fast: 160ms;
  --duration-normal: 220ms;
}

@media (prefers-color-scheme: dark) {
  :root {
    --surface: #1a1816;
    --surface-2: #252320;
    --ink: #f0ede5;
    --body: #c8c4ba;
    --muted: #807d75;
  }
}

Note the choice of mono: JetBrains Mono. The recommender knows that a JetBrains-targeted project pairs well with the family. Import this file from your app.css or tailwind.config.js and every component built from there inherits the system.

The recommender output for a JetBrains project brief

Here is what ux recommend returns for the brief above, running in IntelliJ's integrated terminal:

$ ux recommend

[OK] Loaded brief from .ux/last-discovery.json
[OK] 5 parallel searches complete · 156ms

industry      logistics-saas-internal-ops    (score 0.89 / 184 entries)
style         editorial-precise              (score 0.86 / 84 entries)
palette       cool-neutral-warm-accent       (score 0.81 / 176 entries)
type_pair     fraunces-inter-jetbrains-mono  (score 0.83 / 70 entries)
motion        restrained-supportive          (score 0.78 / 57 entries)

components    nav, kpi-strip, data-table, drawer, command-palette, toast
brand_refs    Linear, Stripe, Vercel
guardrails    35 anti-patterns at threshold high

Recommendation saved to .ux/last-recommendation.json

Two-hundred milliseconds, no LLM call. The components list reflects an internal admin dashboard (data-table, drawer, command-palette) rather than a marketing landing page (hero, social-proof, feature-strip). The recommender scores against the brief's project_type field, which was "app-dashboard."

The Kotlin angle — Compose Multiplatform projects

Kotlin projects in IntelliJ that target Compose for Web or Compose Multiplatform consume tokens differently. Instead of CSS, ux-skill emits a Kotlin-friendly token object. The same recommendation translates to:

// build/generated/uxskill/Tokens.kt
object Tokens {
  val surface = Color(0xFFF5F3EE)
  val surfaceAlt = Color(0xFFECE8DF)
  val ink = Color(0xFF1C1A17)
  val accent = Color(0xFFB5703F)

  val fontDisplay = FontFamily(Font(R.font.fraunces_variable))
  val fontBody = FontFamily(Font(R.font.inter_variable))

  val space2 = 8.dp
  val space4 = 16.dp
  val space6 = 24.dp

  val durationFast = 160
  val durationNormal = 220
}

Generated by uxskill generate --target compose. The same recommendation can emit CSS, Tailwind config, or Kotlin tokens. The system is the contract; the emitted format adapts to the stack.

Three install paths in JetBrains

Path A — pip install plus integrated terminal

Open IntelliJ's terminal pane. Install ux-skill globally:

$ pipx install uxskill
$ ux discover                 # 10-field brief
$ ux recommend                # 5-parallel-search
$ ux init --target jetbrains  # writes .junie/guidelines.md
$ ux persist save --project-root .

JetBrains AI reads .junie/guidelines.md on the next session. The linter runs from the same terminal whenever you want to gate a generation.

Path B — pre-commit hook

If your JetBrains project uses pre-commit (most modern Kotlin or Spring repos do), register ux-skill as a hook so the linter runs before any commit:

# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: uxskill-lint
        entry: uxskill lint --threshold high
        language: python
        additional_dependencies: [uxskill]
        files: \.(tsx|jsx|vue|css|scss|html)$

Path C — MCP server for the agent

JetBrains AI Assistant gained MCP support in 2025. Wire ux-skill as a stdio MCP server through the AI Assistant settings:

// Settings > Tools > AI Assistant > MCP Servers
{
  "uxskill": {
    "command": "ux-mcp",
    "args": []
  }
}

After restart, the 14 ux-skill MCP tools are reachable from any AI Assistant prompt. Same engine as Claude Desktop and Zed, different host. Documented in the MCP post.

IntelliJ is the IDE that already understood "treat your project as a domain model." ux-skill brings that mindset to the design surface.

Compose, Spring, or pure frontend — same engine

ux-skill ships 25 tech-stack entries in data/tech-stacks.json. The relevant subset for JetBrains projects:

The recommender picks the appropriate target automatically from the stack field in the discovery brief. The persist step writes the right file format for that stack.

What ux-skill ships for JetBrains users

• 68 deterministic regex rules in the anti-slop linter.
• Custom guidelines generator via uxskill init --target jetbrains, writes .junie/guidelines.md.
• 959 structured entries across 11 JSON manifests.
• 131 brand DESIGN.md specs.
• 25 tech stack entries with token emit targets for Spring, Kotlin, Compose, Django, Rails, Ktor.
• 14 MCP tools reachable from AI Assistant's MCP client.

What it does not do

• No JetBrains plugin. ux-skill is a CLI plus an MCP server. It does not ship as a Marketplace plugin today. The integration surface is the terminal, the rules file, and MCP.
• No live preview. Use JetBrains' built-in browser preview or pair with a dev server.
• Not branded. ux-skill is 14 stars on GitHub. ui-ux-pro-max-skill is 84,005. The case for installing is architecture, not awareness.

Five minutes to working

End to end in IntelliJ, from a fresh checkout:

1. pipx install uxskill in IntelliJ's integrated terminal.
2. uxskill init --target jetbrains — writes .junie/guidelines.md.
3. uxskill discover — 10-field interactive brief.
4. uxskill recommend — 5-parallel-search merge, about 200 ms.
5. uxskill persist save --project-root . — writes MASTER.md, tokens.css, manifest.json.
6. Restart AI Assistant. It reads the guidelines and the MASTER.md on the next prompt.
7. Generate visual code. Run uxskill lint src/ to catch drift.

Total wall-clock: under five minutes. Total cost: zero. License: MIT.