home / skills / beshkenadze / claude-skills-marketplace / ios-design-workflow

ios-design-workflow skill

safe

This skill orchestrates end-to-end iOS design workflow from idea to implementation, aligning with Apple HIG and generating actionable specs and tasks.

npx playbooks add skill beshkenadze/claude-skills-marketplace --skill ios-design-workflow

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.7 KB

---
name: ios-design-workflow
description: Orchestrates complete iOS app design workflow from idea to implementation. Use when starting a new iOS feature, planning iOS app architecture, or need end-to-end iOS design process.
version: 1.0.0
---

# iOS Design Workflow

End-to-end orchestrator for iOS app design, from initial idea to GitHub/Gitea issues.

## When to Use

- Starting a new iOS app or feature
- Planning iOS UI/UX from scratch
- Need structured approach to iOS design
- Want to follow Apple HIG throughout the process

## Workflow Phases

### Phase 1: Requirements Gathering
**Invoke:** `superpowers:brainstorming`

Explore the idea through collaborative dialogue:
- Clarify app purpose and target users
- Identify core features and user flows
- Define success criteria
- Understand constraints (iOS versions, devices)

### Phase 2: Research
**Invoke:** `sc:research`

Deep research on:
- Similar iOS apps and patterns
- Apple HIG requirements for the feature type
- SwiftUI/UIKit capabilities needed
- Third-party libraries if applicable

### Phase 3: Business Specification
**Invoke:** `sc:business-panel` then `sc:spec-panel`

Create comprehensive specification:
- User stories with acceptance criteria
- Feature requirements document
- UI/UX flow diagrams
- Success metrics

Save to: `docs/specs/{feature-name}-spec.md`

### Phase 4: Task Decomposition
**Invoke:** `sc:workflow` or `sc:spawn`

Break specification into actionable tasks:
- Identify independent work streams
- Define task dependencies
- Estimate complexity (S/M/L)
- Create parallelization strategy

### Phase 5: Architecture Planning
**Invoke:** `sc:design` + `ios-swiftui-generator`

For each task:
- Design component architecture
- Generate SwiftUI code scaffolding
- Plan data flow and state management
- Document API contracts

Validate with: `ios-design-review`

### Phase 6: Documentation & Issues
**Actions:**
1. Save all specs to `docs/` directory
2. Create issues via Gitea MCP or GitHub CLI
3. Link issues to specification documents
4. Set up project board if needed

## Example Usage

```
User: I want to build an iOS expense tracker app

Claude: [Invokes superpowers:brainstorming]
- What's the primary use case?
- Target audience?
- Key features needed?
...continues through all phases...
```

## Output Artifacts

| Phase | Output |
|-------|--------|
| 1 | `docs/plans/YYYY-MM-DD-{feature}-requirements.md` |
| 2 | Research findings in conversation |
| 3 | `docs/specs/{feature}-spec.md` |
| 4 | Task breakdown with estimates |
| 5 | Architecture docs + code scaffolding |
| 6 | GitHub/Gitea issues created |

## Related Skills

- `ios-swiftui-generator` — Generate SwiftUI components
- `ios-design-review` — Validate HIG compliance
- `ios-hig-reference` — Apple HIG quick reference

Overview

This skill orchestrates a complete iOS app design workflow from idea to implementation, guiding teams through requirements, research, specification, architecture, and issue creation. It enforces Apple HIG and produces concrete artifacts like spec files, task breakdowns, architecture docs, and code scaffolding. Use it to move quickly from concept to tracked engineering work.

How this skill works

The skill walks through six phases: requirements gathering, research, business specification, task decomposition, architecture planning, and documentation/issues. For each phase it produces artifacts (markdown specs, task lists, SwiftUI scaffolds) and can invoke related tools or skills to generate code or run design reviews. Final outputs are saved under docs/, and issues are created in GitHub or Gitea and linked to specs.

When to use it

Starting a new iOS app or feature from scratch
Planning UI/UX and component architecture aligned with Apple HIG
Breaking a feature into implementation-ready tasks and estimates
Generating SwiftUI scaffolding and API contracts for engineers
Preparing deliverables and tracked issues for handoff to development

Best practices

Run the brainstorming phase with product, design, and engineering present to align on success criteria
Keep specs in docs/specs/{feature}-spec.md and link issues back to the single source of truth
Estimate tasks using S/M/L and mark dependencies to enable parallel work streams
Use the ios-swiftui-generator for scaffolding, then review with ios-design-review for HIG compliance
Automate issue creation (GitHub/Gitea CLI) and maintain a project board for visibility

Example use cases

Design and implement a new iOS expense tracker feature from idea to deployable tasks
Plan and document a complex onboarding flow with acceptance criteria and success metrics
Generate SwiftUI component scaffolds for a reusable design system and document API contracts
Break a monolithic feature into parallelizable tasks with estimates and a project board for sprints

FAQ

What artifacts does the workflow produce?

It outputs requirements and spec markdown files, task lists with estimates, architecture docs, SwiftUI scaffolding, and created GitHub/Gitea issues linked to specs.

How does it enforce Apple HIG?

It integrates research and a design review phase (ios-design-review) to validate components and flows against HIG guidance before finalizing architecture and code scaffolds.

Can it create issues automatically?

Yes — the workflow can create issues via GitHub or Gitea CLI and link them to the spec files, plus set up a project board if needed.