uxskill
Star on GitHub
Language
English 简体中文 繁體中文 日本語 한국어 हिन्दी Bahasa Indonesia Tiếng Việt ไทย العربية Español Français Deutsch Português Русский Türkçe Italiano
Blog · JetBrains · 2026-05-28

# 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.

File | Purpose | Read by
--- | --- | ---
`.ux/last-discovery.json` | 10-field brief, the human input | Recommender, regenerator
`.ux/last-recommendation.json` | Recommender output, structured | persist save, MCP server
`.ux/design-system/MASTER.md` | Readable design system source of truth | JetBrains AI, humans, Claude Code
`.ux/design-system/tokens.css` | CSS custom properties | Your app.css, Tailwind config
`.ux/design-system/manifest.json` | Structured form of the recommendation | lint, generate, MCP server
`.junie/guidelines.md` | JetBrains-flavored rules summary | JetBrains AI Assistant

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:

Stack | Token emit target | Best for
--- | --- | ---
Spring Boot + Thymeleaf | CSS custom properties | Server-rendered Java/Kotlin frontend
Spring Boot + Next.js | CSS + Tailwind config | API + adjacent SPA
Kotlin + Compose Web | Kotlin object | Compose Multiplatform shared UI
Ktor + Vue | CSS + Vue plugin | Lightweight Kotlin API + Vue SPA
Django + HTMX | CSS + Alpine config | PyCharm full-stack
Rails + Hotwire | CSS + Stimulus values | RubyMine full-stack

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 12 JSON manifests.
- 160 brand DESIGN.md specs.
- 25 tech stack entries with token emit targets for Spring, Kotlin, Compose, Django, Rails, Ktor.
- 18 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.

Honesty card

#### A JetBrains plugin is on the roadmap.

The current integration is CLI plus MCP. A native JetBrains Marketplace plugin would let us surface the recommender inside the AI Assistant chat without leaving the IDE. That is on the roadmap for v2.3 but not shipped yet.

The CLI plus MCP approach covers the full functionality today, you just live in the integrated terminal more than you might in a plugin-first world. That terminal is fast and right there.

## 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.

Install for JetBrains

## One CLI install. All twelve IDEs.

ux-skill works in IntelliJ, WebStorm, PyCharm, GoLand, RubyMine, RustRover, CLion, PhpStorm, DataGrip, RubyMine, Rider, and Android Studio. Same Python engine, same integrated terminal, same files.

$ pipx install uxskill
$ uxskill init --target jetbrains
$ uxskill lint src/ --threshold high
or via npx if Python is not installed
$ npx uxskill@alpha init --target jetbrains
or as a Claude Code plugin alongside JetBrains
$ /plugin install ux@ux-skill

## Related reads

- Cursor design plugin
- AI design system CLI
- Monorepo design system for AI coding
- Python design system generator