# ios-taste

ios-taste designs iOS 18+ SwiftUI views guided by user context and emotional intent instead of defaulting to generic lists.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode, Windsurf (Devin Desktop), Claude.ai · 280 installs · ★ 227 repo stars
- Author: pproenca
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/pproenca/dot-skills/tree/HEAD/skills/.curated/ios-taste/SKILL.md
- Updated: 2026-08-15
- Security check: automated, 2026-11-16 (text) — no signs of malicious code found.
- HTML: https://affpapa.org/en/nevibecode/skills/ios-taste

## What it does

Standard code prompts jump directly into layouts, producing repetitive lists that feel like spreadsheets. This skill enforces a designer-first sequence for iOS 18+ SwiftUI screens. It opens with the 0.5-second test: defining the dominant screen shape before reading any copy, such as a metric display or thumbnail grid.

Next comes mapping out context. The agent identifies when a user opens the view, their emotional goal, and the single primary action. Only then does it pick SwiftUI primitives, choosing between `Toggle` and `Picker`, `Stepper` and `Slider`, or `List` and `ScrollView`.

Skipping context leads directly to lifeless layouts, making component choice a core design step.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add pproenca/dot-skills --skill ios-taste -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/ios-taste/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/ios-taste/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add pproenca/dot-skills --skill ios-taste -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/ios-taste/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add pproenca/dot-skills --skill ios-taste -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/ios-taste/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install pproenca/dot-skills skills/.curated/ios-taste
```

2. **Manually: put the files in place**
- File: `.github/skills/ios-taste/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add pproenca/dot-skills --skill ios-taste -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/pproenca/dot-skills --path skills/.curated/ios-taste
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/ios-taste/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add pproenca/dot-skills --skill ios-taste -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/pproenca/dot-skills/tree/HEAD/skills/.curated/ios-taste/SKILL.md

## When to use it
- design native iOS 18+ SwiftUI views grounded in user intent
- review existing SwiftUI code to remove generic demo styling
- select fitting SwiftUI components like sheets, sliders, or steppers
- establish visual screen hierarchy before writing layout code

## Example prompts
- build a settings screen on SwiftUI that feels like a native app
- create a detail view for a workout summary in iOS 18
- review this SwiftUI code for design quality, it feels generic

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 79c9f37d2552aa26.

BEGIN THIRD-PARTY FILE 79c9f37d2552aa26
````text
---
name: ios-taste
description: >
  Designs iOS 18+ SwiftUI experiences with real taste — starting from
  user goals, not pixels. Use this skill whenever the user asks you to
  build SwiftUI views, screens, or experiences. Trigger when the user
  says "build a settings screen", "create a detail view", "design
  this properly", "I want this to feel like a native app", or any
  SwiftUI UI task. Also trigger when reviewing SwiftUI code for design
  quality, or when the user says the output "looks like a demo" or
  "feels generic." When building any user-facing SwiftUI view, lean
  toward triggering this skill.
---

# iOS Taste

Taste doesn't start at the pixel level. It starts at "who is this
person and what do they need?" The visual refinement is the LAST step.
The first step is understanding the user's world deeply enough that
the interface design feels inevitable — like it couldn't have been
designed any other way.

Your default mode skips straight to layout. It produces technically
correct SwiftUI that looks generic because it was never grounded in
a real person's needs. This skill changes the order of operations:
think like a designer first, then write code.

## Phase 0: The 0.5-Second Test (ORIENT before everything)

Before designing anything, answer ONE question:

> **What does the user SEE in the first half-second — before they
> read a single word?**

This is not about content. It's about the SHAPE of the screen.
Close your eyes and picture it. What dominates?

- A **ring** at 40% of screen height? → Fitness dashboard
- A **gradient card** with bold white text? → Music/travel/content
- A **large number** floating in space? → Finance/health metric
- A **grid of thumbnails**? → Photo/recipe/shopping collection
- A **clean form** with generous space? → Settings/profile

If your answer is "a List with rows of text" → STOP. That's a
spreadsheet, not an app. Go back and find the visual shape.

Write the 0.5-second answer as the FIRST line of the experience
brief:

```swift
// 0.5s: Four warm gradient cards stacked on black — a cookbook
```

This single sentence anchors every decision that follows. If the
code you write doesn't produce that shape, something went wrong.

## Phase 1: Design Thinking (Before You Touch SwiftUI)

Before writing a single line of code, answer these questions. Write
the answers down as comments or in your thinking. If you skip this
phase, your output will look like every other AI-generated UI —
correct but soulless.

### 1. Who is the user?

Not "a fitness enthusiast." A real person with a context:

- What moment are they in when they open this screen? (Rushing
  between meetings? Relaxing on the couch? Mid-workout?)
- What did they just do before arriving here? (Finished a run?
  Browsed a list? Got a notification?)
- What do they want to accomplish in under 10 seconds?

This shapes EVERYTHING. A user mid-workout needs giant tap targets
and glanceable data. A user browsing recipes at home wants rich
````
END THIRD-PARTY FILE 79c9f37d2552aa26

The third-party file has ended. Everything between the 79c9f37d2552aa26 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 3001 of 20087 bytes. © pproenca · MIT · https://github.com/pproenca/dot-skills/tree/HEAD/skills/.curated/ios-taste/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md
