Native App Designer Agent Skill

Creates breathtaking iOS/Mac and web apps with organic, non-AI aesthetic. Expert in SwiftUI, React animations, physics-based motion, and human-crafted design. Use for iOS/Mac app UI, React/Vue animations, native-feel web apps, physics-based motion design. Activate on "SwiftUI", "iOS app", "native app", "React animation", "motion design", "UIKit", "physics animation". NOT for backend logic, API design (use backend-architect), simple static sites (use web-design-expert), or pure graphic design (use design-system-creator).

7k tokens

context cost

the whole folder, loaded on every use

files

instructions only

copies elsewhere

how many repositories repackaged it

177

stars on the repo

on the repository, not the skill itself

Install

one command, takes just this skill from the repository

npx skills add https://github.com/curiositech/some_claude_skills --skill native-app-designer

The instruction itself

26 sections, as written by the author

Native App Designer

Elite native app designer specializing in breathtaking, human-centered applications that feel organic and alive—never generic or AI-generated.

When to Use This Skill

✅ Use for:

iOS/Mac app UI design with SwiftUI or UIKit
React/Vue/Svelte apps with delightful animations
Physics-based motion design and micro-interactions
Native-feel Progressive Web Apps (PWAs)
App onboarding flows with personality
Custom shader effects (Metal/WebGL)
Component library design with character

❌ Do NOT use for:

Backend API logic → use backend-architect
Simple static websites → use web-design-expert
Design system tokens only → use design-system-creator
Graphic design/brand identity → use design-system-creator
Accessibility-first ADHD apps → use adhd-design-expert
Retro/vaporwave aesthetics → use vaporwave-glassomorphic-ui-designer

MCP Integrations

Available MCPs

| MCP | Purpose |

|-----|---------|

| 21st Century Dev | Component inspiration and building |

| Stability AI | Generate design assets and mockups |

| Firecrawl | Research design patterns |

| Figma MCP (if configured) | Import designs from Figma |

| Apple Developer Docs MCP (community) | Access SwiftUI/UIKit documentation |

Component Inspiration Workflow

1. Search 21st.dev for modern patterns
2. Analyze animation timing, color usage, hierarchy
3. Adapt (don't copy) - add your personality
4. Use mcp__magic__21st_magic_component_builder to scaffold
5. Refine with mcp__magic__21st_magic_component_refiner

Common Anti-Patterns

Anti-Pattern: Generic Card Syndrome

What it looks like: Every component is a white card with shadow

Why it's wrong: Creates monotonous, AI-generated aesthetic

What to do instead: Mix layouts—cards, lists, grids, overlays, inline elements

Anti-Pattern: Linear Animation Death

What it looks like: .animation(.linear(duration: 0.3))

Why it's wrong: Feels robotic, lifeless, unnatural

What to do instead: Use spring physics with response/damping parameters

Anti-Pattern: Rainbow Vomit

What it looks like: Using every color in the palette everywhere

Why it's wrong: No visual hierarchy, overwhelming

What to do instead: Restrained palette with purposeful color usage

Anti-Pattern: Animation Overload

What it looks like: Everything bounces, slides, and fades constantly

Why it's wrong: Distracting, overwhelming, hides content

What to do instead: Animate intentionally—guide attention, provide feedback

Anti-Pattern: Inconsistent Spacing

What it looks like: Random margins (8px, 14px, 23px...)

Why it's wrong: Feels unpolished, chaotic

What to do instead: 4pt or 8pt grid system with consistent rhythm

Design Philosophy: Beyond Generic

What Makes Apps Look "AI-Generated" (AVOID)

❌ Perfectly centered everything with no visual rhythm
❌ Generic gradients (linear purple-to-blue everywhere)
❌ Oversized, ultra-rounded corners on everything
❌ Stock illustrations with same flat art style
❌ Over-reliance on cards with identical spacing
❌ Soulless animations (generic slide-in-from-bottom)

What Makes Apps Feel Human-Crafted (DO THIS)

✅ Asymmetry with purpose: Break the grid intentionally
✅ Unexpected details: Easter eggs, playful copy, personality
✅ Organic motion: Physics-based animations, spring dynamics
✅ Textural elements: Subtle noise, gradients with character
✅ Thoughtful hierarchy: Visual weight that guides naturally
✅ Emotional color: Palettes that evoke feeling
✅ Contextual adaptation: UI that responds to content and state

App Personality Types

Choose a personality and commit to it:

|------------|-----------|-------|------------|

Motion Design Principles

Spring Physics Cheat Sheet

// Snappy, responsive
.spring(response: 0.3, dampingFraction: 0.7)

// Bouncy, playful
.spring(response: 0.5, dampingFraction: 0.5)

// Smooth, elegant
.spring(response: 0.6, dampingFraction: 0.8)

// Dramatic, slow
.spring(response: 0.8, dampingFraction: 0.6)

Animation Timing

Immediate feedback: 0-100ms (button press)
Quick transitions: 150-300ms (page change)
Deliberate animations: 300-500ms (onboarding)
Dramatic moments: 500-1000ms (celebrations)

Details That Delight

Small touches that make users smile:

Pull-to-refresh with personality (not just a spinner)
Empty states with character and guidance
Loading states that entertain
Success states that celebrate
Error states that empathize
Haptic feedback on key interactions

Platform-Specific Best Practices

iOS Native

Use system materials (.ultraThinMaterial, .regularMaterial)
Respect safe areas and Dynamic Island
Support Dynamic Type (accessibility)
Implement haptic feedback strategically
Use SF Symbols with weight matching
Support dark mode with semantic colors

Web Native Feel

60fps animations using transform/opacity
CSS containment for performance
Pull-to-refresh implementation
PWA install prompt
Reduced motion support
Touch-friendly targets (44px minimum)

Tools & Libraries

iOS

SwiftUI: Declarative UI framework
UIKit: When SwiftUI isn't enough
Lottie: After Effects animations
SF Symbols: Apple's icon system

Web

Framer Motion: React animation library
GSAP: JavaScript animation powerhouse
react-spring: Physics-based React animations
Lottie Web: Cross-platform animations

Design

Figma: Primary design tool
Principle: Advanced prototyping
21st.dev: Component inspiration

Technical references for deep dives:

/references/swiftui-patterns.md - SwiftUI components, animations, color palettes
/references/react-patterns.md - React/Vue patterns, Framer Motion, responsive design
/references/custom-shaders.md - Metal and WebGL shaders for unique effects

Philosophy: The difference between good and breathtaking is soul. Every pixel should have purpose. Every animation should feel inevitable. Every interaction should delight.

Other skills for the same job

different authors, same section of the catalogue

Use Dom

by openai

vendor ×3

Use Expo DOM components to run web code in a webview on native and as-is on web. Migrate web code to native incrementally.

3k tokens

Frontend Dev Guidelines

by mrgoonie

×2

Frontend development guidelines for React/TypeScript applications. Modern patterns including Suspense, lazy loading, useSuspenseQuery, file organization with features directory, MUI v7 styling, TanStack Router, performance optimization, and TypeScript best practices. Use when creating components, pages, features, fetching data, styling, routing, or working with frontend code.

33k tokens

Next Cache Components

by vercel-labs

vendor ×2

Next.js 16 Cache Components - PPR, use cache directive, cacheLife, cacheTag, updateTag

| Build Shopify apps, extensions, themes using GraphQL Admin API, Shopify CLI, Polaris UI, and Liquid. "shopify theme", "liquid template", "polaris", "shopify graphql", "shopify webhook", "shopify billing", "app subscription", "metafields", "shopify functions"

Build Gradio web UIs and demos in Python. Use when creating or editing Gradio apps, components, event listeners, layouts, or chatbots.

10k tokens

Figma Generate Diagram

by openai

vendor ×1

MANDATORY prerequisite — load this skill BEFORE every `generate_diagram` tool call. NEVER call `generate_diagram` directly without loading this skill first. Trigger whenever the user asks to create, generate, draw, render, sketch, or build a diagram — flowchart, architecture diagram, sequence diagram, ERD or entity-relationship diagram, state diagram or state machine, gantt chart, or timeline. Also trigger when the user mentions Mermaid syntax or wants a system architecture, decision tree, dependency graph, API call flow, auth handshake, schema, or pipeline visualized in FigJam. Routes to type-specific guidance, sets universal Mermaid constraints, and tells you when to use a different diagram type or skip the tool entirely (mindmaps, pie charts, class diagrams, etc.).

Analyzes web performance using Chrome DevTools MCP. Measures Core Web Vitals (LCP, INP, CLS) and supplementary metrics (FCP, TBT, Speed Index), identifies render-blocking resources, network dependency chains, layout shifts, caching issues, and accessibility gaps. Use when asked to audit, profile, debug, or optimize page load performance, Lighthouse scores, or site speed. Biases towards retrieval from current documentation over pre-trained knowledge.

Algorithmic philosophies are computational aesthetic movements that are then expressed through code. Output .md files (philosophy), .html files (interactive viewer), and .js files (generative algorithms).

15k tokens scripts

How to use it

Copy the folder

Take curiositech/native-app-designer from the repository into ~/.claude/skills for personal use, or into .claude/skills inside a project.

Check the name does not clash

The agent identifies a skill by the name field in its header. Two skills with the same name cannot sit side by side — one of them will be ignored.