# beautify-site

Adopt this skill: https://proskills.md/skills/other/beautify-site-beautify-site-skills-beautify-site

Page: https://proskills.md/skills/other/beautify-site-beautify-site-skills-beautify-site
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/beautify-site/SKILL.md
size: 8087
upstream: https://github.com/beautify-site/beautify-site/blob/main/skills/beautify-site/SKILL.md

````text
---
name: beautify-site
description: Use when the user wants a website, page, or UI to look better — "make this site look better", "beautify my landing page", "redesign this UI", "make it look professional", "this page looks bland/generic/cheap", "polish the design", "make it look expensive", "make it extravagant". Runs one ordered pipeline — pin a design direction, fit components to it, layer motion, then strip every AI tell in a mandatory final pass. Bold and extravagant by default. Fully self-contained — every helper tool is optional with a documented fallback. Produces a persisted design-system MASTER.md plus implemented, accessibility-checked, AI-tell-free UI.
---

# Beautify Site

Turn a bland or generic interface into a deliberate, coherent one — by deciding the design direction FIRST, then choosing components that fit it, adding motion, and finally stripping every AI tell.

## Ambition — bold by default

**Design extravagantly unless the user asked for restraint.** Safe and tasteful is the failure mode. Commit hard to one direction and execute it with precision — canvas/WebGL, scroll-linked motion, sticky-pinned sequences, cursor-reactive surfaces, staggered orchestration, custom cursors, live counters, grain, parallax depth. Vary the direction every single time; converging on a house style is its own AI tell.

Dial back ONLY when the user explicitly asks for minimal/quiet, or the project's own documented design system says so and the user has not overridden it. When a project's rules conflict with this default, **surface the conflict and let the user choose** — never silently pick restraint.

Bold is an aesthetic budget, not an accessibility one. Reduced motion, focus rings, touch targets, contrast, and no-horizontal-overflow are never traded away.

## When to use

- "Make this site/page/app look better" · "beautify my landing page" · "redesign this UI"
- "This looks generic / bland / cheap / AI-generated" · "make it look professional"
- Any request to improve the visual quality of an existing or new interface.

**Not for:** a single isolated tweak ("make this button blue"), a pure copy/wording fix, or a performance problem. Those are one-off edits — just do them.

## The order is the whole point

```
1.  DIRECTION   →  design-system/<slug>/MASTER.md  (ui-ux-pro-max if present, else by hand)
1.5 DENSITY     →  name >= 6 visual devices BEFORE building  (references/visual-density.md)
2.  COMPONENTS  →  chosen to FIT MASTER.md         (21st.dev if signed in, else hand-built)
3.  MOTION      →  layered on, honoring MASTER.md  (motion.dev docs — free, no auth)
4.  IMPECCABLE  →  every AI tell stripped from the BUILT artifact  (blocklist is inline)
```

**Never reorder these.** Picking a component before the design system exists is the exact failure this skill prevents: you get a page assembled from good-looking parts that do not belong together. MASTER.md is the contract — steps 2 and 3 both read it and conform to it.

Each step gates the next. If step 1 produces nothing usable, do not proceed to step 2.

## The failure this skill will most likely hand you

Not ugliness. **Emptiness.** A page where every individual choice is defensible — considered
palette, correct type scale, disciplined spacing, a clean impeccable pass — and the whole thing
still reads as a beautifully set README rather than a product page.

It happens because *taste* is what this pipeline optimises for, and taste is not density. The
user will not say "insufficient visual device count". They will say **"too basic"**, "too
clean", "too simplistic" — and they will be right, and no amount of re-tuning the palette will
answer it.

**Step 1.5 exists to stop that and it is mandatory.** Read
[references/visual-density.md](references/visual-density.md), count your devices, and name them
in the run *before* you build. Six is the floor. A direction called minimal, editorial, Swiss or
"exaggerated minimalism" does not lower it — those words describe restraint in *composition*,
never absence of *things*.

**Also learn the distinction it draws.** "Too bare" means either thin content or thin visuals,
and they have opposite fixes. Answering thin visuals with more paragraphs is the single most
reliable way to be told the same thing twice.

**Step 4 is not optional and never skipped** — not because the work "already looks good", not because time is short, not because the user seemed happy. A design that has not been through the impeccable pass is not finished.

## Preflight — check before you start, degrade with a clear next action

Run these checks first and tell the user what you found. Never die mid-run on a missing dependency.

**Nothing here is a hard dependency.** Every helper below is an accelerator with a documented fallback,
so this skill runs standalone on a fresh machine with no other skill installed.

| Check | How | If missing |
|---|---|---|
| `ui-ux-pro-max` (optional) | `ls ~/.claude/skills/ui-ux-pro-max/SKILL.md` | Author MASTER.md yourself — [step 1 "Author it yourself"](references/step-1-design-direction.md). Same deliverable, no blocker. Offer the install (`npx ui-ux-pro-max-cli@latest init --ai claude --global`) but do not wait on it. |
| `impeccable` (optional) | `ls ~/.claude/skills/impeccable/SKILL.md` | Step 4's own blocklist is the complete standard — [step 4](references/step-4-impeccable.md). The pass runs at full strength either way. |
| Python (only for ui-ux-pro-max) | `python --version` (**not** `python3` on Windows — that hits the Store stub) | Use the step 1 fallback. Never install Python yourself. |
| 21st CLI installed + signed in | `21st whoami` | `npm i -g @21st-dev/cli`, then ask the user to run `21st login` (interactive browser sign-in — never run it unattended). Step 2 degrades to hand-building — see [references/step-2-components.md](references/step-2-components.md). |
| Target stack | Read `package.json` / config | React + Tailwind = full support. Otherwise see "Non-React stacks". |
| Existing design system | Look for `design-system/*/MASTER.md` | Reuse it instead of regenerating — a project has ONE direction. |

State plainly which steps will run at full strength and which will degrade, then proceed with what works.
**A missing helper never stops the run** — it only changes how a step is performed.

## Step 1 — Design direction (required)

Establish the visual direction and persist it. This is the only step that is never optional.

→ [references/step-1-design-direction.md](references/step-1-design-direction.md)

## Step 1.5 — Visual density (required, and the one most often skipped)

Count the made things your page will contain, before you build any of them. Under six it will
read as basic however good the typography is.

→ [references/visual-density.md](references/visual-density.md)

## Step 2 — Components and templates (free-first)

Find the best-fitting **free** component or template and adapt it to MASTER.md. Search is free; installs are rate-limited; AI generation costs money — never spend without asking.

→ [references/step-2-components.md](references/step-2-components.md)

## Step 3 — Motion (last)

Add purposeful animation using Motion, pulling current docs from `https://motion.dev/llms.txt`. Free, no auth.

→ [references/step-3-motion.md](references/step-3-motion.md)

## Step 4 — Impeccable pass (MANDATORY — strip every AI tell)

The design is built. Now prove it does not read as machine-made. Audit the **built artifact** against the `impeccable` skill's bans and remove every hit by restructuring — never by softening.

The two hard bans that fail the pass outright: **gradient text** (`background-clip: text` over any gradient) and **side-stripe accents** (`border-left`/`border-right` > 1px on a card, list item, callout, or alert).

→ [references/step-4-impeccable.md](references/step-4-impeccable.md)

## Non-React stacks

Say this plainly rather than half-delivering:

- **React + Tailwind** — all three steps at full strength.
- **Vue / Svelte /
````

## File: README.md
upstream: https://github.com/beautify-site/beautify-site/blob/main/README.md

````text
<div align="center">

# Beautify Site

### Made in [Omniscio](https://omniscio.com)

**Make any website look professionally designed: bold, coherent, and free of the tell-tale signs of AI-generated design.**

A skill for [Claude Code](https://code.claude.com/docs/en/skills) that redesigns a page the way a designer would. It picks a direction first, fits components to it, adds motion, then audits the result. It comes built into [Omniscio](https://omniscio.com), a desktop app for managing many AI coding sessions from one place.

[![Made in Omniscio](https://img.shields.io/badge/made_in-Omniscio-06070B.svg)](https://omniscio.com)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![Claude Code skill](https://img.shields.io/badge/Claude_Code-skill-D97757.svg)](https://code.claude.com/docs/en/skills)
[![Claude Code plugin](https://img.shields.io/badge/Claude_Code-plugin-D97757.svg)](https://code.claude.com/docs/en/plugins)
[![React + Tailwind](https://img.shields.io/badge/React_%2B_Tailwind-full_support-38B2AC.svg)](#works-with)

</div>

---

## Use it in Omniscio

Beautify Site is built into Omniscio 0.1.105 and later, so there's nothing extra to install.

1. **Get Omniscio.** Download it from [omniscio.com](https://omniscio.com).
2. **Turn the skill on.** Open **Settings → Features** and switch on **Enable Beautify Site skill**. It's off by default.
3. **Restart Omniscio.** The skill is added the next time the app starts.
4. **Ask for it.** In any session, ask for a better-looking page in plain words, like *"make this landing page look better"*. There's no button to press. The skill starts on its own.

Not using Omniscio? [Install it in Claude Code](#getting-started) instead.

## Overview

Ask an AI to make a page look better and you usually get one of two results. Either the page is stitched together from nice-looking parts that don't belong together, or it's tasteful but empty and still reads as generic.

Beautify Site prevents both by enforcing the order a designer works in. It settles the design direction first and saves it as a design system. Components and motion then have to follow that system. The run ends with a mandatory audit that removes the patterns people now recognize as machine-made.

Once it's installed, just ask Claude Code for a better-looking page:

- "Make this landing page look better"
- "This site looks generic. Make it look expensive."
- "Redesign this UI"

## Features

- **Direction before components.** Settles one visual direction and saves it as `design-system/<slug>/MASTER.md`, the contract every later step follows.
- **A visual-density gate.** Names at least six visual devices before building anything, so the page never reads as "too basic".
- **Components that fit.** Searches [21st.dev](https://21st.dev) for free components and templates, then restyles them to the design system, or builds them by hand.
- **Purposeful motion.** Adds animation with [Motion](https://motion.dev), within a scroll budget and with full reduced-motion support.
- **A mandatory AI-tell pass.** Audits the built page and removes giveaways such as gradient text, side-stripe accents, eyebrow labels and fake terminal mockups.
- **Bold by default.** Designs extravagantly unless you ask for something minimal, and never trades away accessibility to do it.
- **Verified before it's called done.** Checks contrast, keyboard access, reduced motion and mobile overflow, then screenshots the rendered page.
- **Runs anywhere.** Every helper tool is optional and has a built-in fallback, so it works on a fresh machine.
- **Never spends money silently.** Paid AI generation always needs your explicit approval.

## How it works

| Step | What happens | Result |
|---|---|---|
| **1. Direction** | Settles on one bold visual direction | `design-system/<slug>/MASTER.md` |
| **1.5 Density** | Names at least six visual devices before building | A device list the build must deliver |
| **2. Components** | Finds free components that fit the direction and adapts them | Components restyled to the design system |
| **3. Motion** | Adds purposeful animation and prices every pinned section in scroll distance | Motion that follows the design system |
| **4. Impeccable pass** | Audits the built page and strips every AI tell | A clean, verified page |

The steps never run out of order. Choosing components before the design system exists is exactly the failure this skill is built to prevent.

## Works with

| Stack | Support |
|---|---|
| React + Tailwind | Every step at full strength |
| Vue, Svelte, Astro, plain JS | Direction and motion at full strength. Components are hand-built, using 21st.dev as a reference. |
| SwiftUI, Flutter, Compose | Design direction only. Use the platform's own animation system. |

## Optional helpers

Nothing here is required. If a helper is missing, the skill tells you and uses its fallback.

| Helper | Speeds up | Fallback |
|---|---|---|
| [ui-ux-pro-max](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill) skill (needs Python) | Choosing the design direction | Writes the design system itself |
| [Impeccable](https://github.com/pbakaus/impeccable) skill | The final AI-tell audit | Uses its own built-in blocklist |
| [21st.dev](https://21st.dev) CLI, signed in | Finding components | Builds components by hand |

Motion's documentation is free and needs no account.

## Getting started

These steps are for Claude Code on its own. In Omniscio, just [switch it on](#use-it-in-omniscio).

### Prerequisites

- [Claude Code](https://code.claude.com/docs/en/skills)
- A website or app to improve, or a new one to design

### Install as a plugin (recommended)

In Claude Code, run:

```text
/plugin marketplace add beautify-site/beautify-site
/plugin install beautify-site@beautify-site
```

Or from your terminal:

```bash
claude plugin marketplace add beautify-site/beautify-site
claude plugin install beautify-site@beautify-site
```

### Install manually

Copy the skill folder into your personal skills folder.

**macOS / Linux**

```bash
git clone https://github.com/beautify-site/beautify-site.git
mkdir -p ~/.claude/skills
cp -r beautify-site/skills/beautify-site ~/.claude/skills/
```

**Windows (PowerShell)**

```powershell
git clone https://github.com/beautify-site/beautify-site.git
New-Item -ItemType Directory -Force "$HOME\.claude\skills" | Out-Null
Copy-Item -Recurse beautify-site\skills\beautify-site "$HOME\.claude\skills\"
```

Start a new Claude Code session and the skill is ready.

### Use it

Open your project in Claude Code and ask for a better-looking page. The skill will:

1. Tell you which steps will run at full strength and which will use a fallback.
2. Ask what you're going for, then write the design system.
3. Build, animate, audit and verify the page, then report what it checked.

## Project structure

```text
beautify-site/
├── .claude-plugin/
│   ├── marketplace.json          # lets Claude Code install this repo as a plugin
│   └── plugin.json               # plugin details
├── skills/
│   └── beautify-site/
│       ├── SKILL.md              # the pipeline, preflight checks, verification and rules
│       └── references/
│           ├── step-1-design-direction.md
│           ├── visual-density.md
│           ├── step-2-components.md
│           ├── step-3-motion.md
│           └── step-4-impeccable.md
├── LICENSE
└── README.md
```

## License

[MIT](LICENSE) © 2026 Beautify Site contributors
````
