build-like-iphone-team

Applies Apple's Project Purple design philosophy for radical innovation. This skill should be used when the user wants to challenge industry conventions, approach open-ended problems requiring disruptive thinking, or when standard brainstorming needs a breakthrough approach.

523 stars

Best use case

build-like-iphone-team is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Applies Apple's Project Purple design philosophy for radical innovation. This skill should be used when the user wants to challenge industry conventions, approach open-ended problems requiring disruptive thinking, or when standard brainstorming needs a breakthrough approach.

Teams using build-like-iphone-team should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/build-like-iphone-team/SKILL.md --create-dirs "https://raw.githubusercontent.com/FradSer/dotclaude/main/superpowers/skills/build-like-iphone-team/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/build-like-iphone-team/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How build-like-iphone-team Compares

Feature / Agentbuild-like-iphone-teamStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Applies Apple's Project Purple design philosophy for radical innovation. This skill should be used when the user wants to challenge industry conventions, approach open-ended problems requiring disruptive thinking, or when standard brainstorming needs a breakthrough approach.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Build Like the Original iPhone Team

Knowledge reference for applying Apple's Project Purple design philosophy. Based on the original iPhone (2004-2007) development that created the revolutionary device.

## Project Purple Context

**Timeline**: 2003-2007, $150 million investment, 2.5 years in complete isolation
**Team**: 200 of Apple's top engineers, sworn to secrecy
**Code names**: Project Purple (overall), P1 (iPod phone), P2 (multi-touch tablet), Purple Dorm (isolation building)
**Origin**: Started as tablet project (Model 035), pivoted to phone after multi-touch breakthrough

**The pivot**: In 2003, Jony's team experimented with multi-touch to get rid of mouse and keyboard. Duncan Kerr demonstrated multi-touch in a brainstorming meeting - first time the team had seen it. Within a week, Input Engineering built a working prototype with a 12-inch MacBook display. When Jobs saw this - zoom in/out on Apple campus with finger gestures - he said "My God, we can build a phone with this." Tablet aside, phone began.

## The Five iPhone Principles

### 1. First-Principles Thinking: Slash All Redundancy
Strip away all assumptions. Ask "What is the absolute minimum needed to deliver core value?"

**iPhone example**:
- When industry said "phones need physical keyboards," Apple asked "If the screen can become anything, why do we need fixed buttons?"
- Jony Ive's first iPhone sketch showed the entire front face as one big, unbroken expanse of glass
- The screen wasn't a display - it was the interface. Hardware and software designed together

**Application**: Identify fundamental truth, question every industry assumption, rebuild from basics.

**See `./references/first-principles.md`** for detailed patterns and templates.

### 2. Force "Impossible" Technology into Reality
Never accept "no" as an answer. Find or create breakthrough technology.

**iPhone examples**:
- **Multi-touch**: Only existed in labs. Apple's Input Engineering team built a ping-pong-table-sized capacitive display for testing. Within a week, they had a working prototype.
- **Gorilla Glass**: Jobs called Corning CEO 6 months before launch. Gorilla Glass existed as lab curiosity. Jobs said "You're afraid." Corning transformed their facility.
- **Capacitive display**: Scaling laboratory technology to mobile required inventing new manufacturing processes.

**Application**: Identify barriers, research breakthroughs, find partners, confront fear.

**See `./references/breakthrough-research.md`** for breakthrough stories and research methodology.

### 3. Experience-Driven Specifications
Define in human moments, not technical metrics.

**iPhone example**: "A device Steve can use in the bathroom to check email" translated to 60fps scrolling with fluid inertia. Greg Christie's team got a two-week ultimatum from Jobs in 2005: bigger ideas or project goes elsewhere. Under pressure, they developed features like swipe to unlock - designed to feel intuitive and natural.

**Application**: Describe the moment, extract the feeling, derive technical constraints.

**See `./references/experience-specs.md`** for writing experience-driven specifications.

### 4. Internal Competition: Survival of the Fittest
Let best ideas win through fierce competition. No compromise hybrids.

**iPhone example**: Apple hedged its bets by developing two phones in parallel. P1 (iPod nano with phone features, led by Tony Fadell) vs P2 (multi-touch device based on Model 035 tablet, led by Jony). After six months, Fadell's team produced a working prototype, but the multi-touch approach won. P1 team's insights enhanced P2, but final product was pure P2 vision.

**Application**: Spawn competing teams, compare head-to-head, winner takes all.

**See `./references/internal-competition.md`** for competition patterns and selection criteria.

### 5. Purple Dorm Isolation
Build in secret. Eliminate all outside noise.

**iPhone example**: Scott Forstall couldn't tell recruits what they'd work on. Team locked down a building with badge readers, cameras, Fight Club poster. Jobs spread teams across campus. Presentations to Jobs happened in windowless rooms to avoid leaks. Employees had to sign NDAs for their NDAs. Only 30 people saw complete iPhone before announcement. The "soup of misery" - pressure cooker with impossible deadline, impossible mission, company's future resting on it.

**Application**: Isolate teams from trends, competitors, conventions. Focus on perfect.

**See `./references/purple-dorm.md`** for isolation principles and team setup.

## The iPhone Formula: Key Lessons

1. **Tablet before phone** - The multi-touch display was invented for a tablet, then pivoted to phone. Technology readiness meets opportunity.
2. **Pressure creates breakthroughs** - Jobs' two-week ultimatum to Greg Christie's team forced creative solutions like swipe to unlock.
3. **Hardware-software together** - The screen wasn't just a display. It was the interface. Capacitive touchscreen and software designed in tandem.
4. **Rapid prototyping** - Within a week of seeing multi-touch demo, engineers had working 12-inch display prototype.
5. **Ultimatum-driven innovation** - When Christie ran out of time, Jobs gave him two weeks for bigger ideas or project moves to another group.
6. **No compromise on interface** - The entire front was one big, unbroken expanse of glass. No buttons, no distractions.
7. **Swipe to unlock** - Designed to feel intuitive and natural with the new touch input paradigm.
8. **Full web, not "baby web"** - Competitors used WAP giving dumbed-down web. iPhone delivered full internet experience.
9. **Windowless secrecy** - Presentations to Jobs in windowless rooms to avoid leaks.
10. **Pressure cooker culture** - Round-the-clock work through weekends, holidays, vacations, honeymoons. The future of the company was at stake.

## When to Apply iPhone Philosophy

Use this knowledge when:
- Creating new product categories, not improving existing ones
- Industry conventions are blocking innovation
- Need to challenge fundamental assumptions
- "Everyone does it this way" is the primary obstacle
- Willing to invest in radical innovation
- Facing pressure that could drive breakthrough solutions

Don't apply when:
- Making incremental improvements
- Problem is straightforward and well-understood
- Quick delivery matters more than breakthrough
- Stakeholders demand proven, conservative approaches

## Quick Reference

| Situation | Apply Which Principle |
|-----------|---------------------|
| Industry says "can't" | First-Principles + Breakthrough |
| Technology doesn't exist | Breakthrough + Rapid Prototyping |
| Need to define requirements | Experience-Driven Specs |
| Facing deadline pressure | Ultimatum-Driven Innovation |
| Multiple viable approaches | Internal Competition |
| Outside influence | Purple Dorm Isolation |
| Hardware-software mismatch | Integration: Design Together |
| Need commitment to vision | All principles together |

## Reference Files

Detailed guidance for each principle:

- `./references/first-principles.md` - Questioning assumptions, zero-based approach
- `./references/breakthrough-research.md` - Multi-touch, Gorilla Glass, iOS, Capacitive Display
- `./references/experience-specs.md` - Writing specs in human moments
- `./references/internal-competition.md` - P1 vs P2, winner-takes-all selection
- `./references/purple-dorm.md` - Extreme isolation, Fight Club poster, pressure cooker culture

Remember: iPhone wasn't better because of more features. It was better because it rejected all assumptions and built something from first principles. The multi-touch display was invented for a tablet, then pivoted to phone when Jobs realized "My God, we can build a phone with this."

Related Skills

agent-team-driven-development

523
from FradSer/dotclaude

Provides guidance on coordinating multiple specialized teammates working in parallel. This skill should be used when the user needs to execute complex implementation plans, resolve cross-cutting concerns, or coordinate independent work streams requiring communication.

update-readme

523
from FradSer/dotclaude

Updates README.md and README.zh-CN.md to reflect the project's current state. Use this skill whenever the user asks to "update the README", "sync the docs", "update documentation", "reflect latest changes in README", or wants both the English and Chinese READMEs to match the current project. Always triggers when the user mentions updating or regenerating README files, especially for bilingual (EN/ZH) projects.

swiftui-review

523
from FradSer/dotclaude

Reviews SwiftUI code for best practices on modern APIs, maintainability, and performance. This skill should be used when the user asks to review SwiftUI code, check for deprecated iOS/macOS APIs, validate data flow patterns, or audit accessibility compliance in Swift projects.

writing-plans

523
from FradSer/dotclaude

Creates executable implementation plans that break down designs into detailed tasks. This skill should be used when the user has completed a brainstorming design and asks to "write an implementation plan" or "create step-by-step tasks" for execution.

systematic-debugging

523
from FradSer/dotclaude

Provides a systematic debugging methodology with a 4-phase root cause analysis process. This skill should be used when the user reports a bug, error, test failure, or unexpected behavior, ensuring thorough investigation precedes any code changes.

need-vet

523
from FradSer/dotclaude

This skill should be used when the user invokes /need-vet to enable work verification for the current task. Claude must verify completion and append the verified tag before the session can end.

executing-plans

523
from FradSer/dotclaude

Executes written implementation plans efficiently using agent teams or subagents. This skill should be used when the user has a completed plan.md, asks to "execute the plan", or is ready to run batches of independent tasks in parallel following BDD principles.

brainstorming

523
from FradSer/dotclaude

Structures collaborative dialogue to turn rough ideas into implementation-ready designs. This skill should be used when the user has a new idea, feature request, ambiguous requirement, or asks to "brainstorm a solution" before implementation begins.

behavior-driven-development

523
from FradSer/dotclaude

Applies behavior-driven development principles including Gherkin scenarios and test-driven development. This skill should be used when the user asks to implement features, fix bugs, or when writing executable specifications and tests before writing production code.

shadcn

523
from FradSer/dotclaude

Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI. Provides project context, component docs, and usage examples. Applies when working with shadcn/ui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for "shadcn init", "create an app with --preset", or "switch to --preset".

refactor

523
from FradSer/dotclaude

Executes automated refactoring for specific files, directories, or semantic queries. This skill should be used when the user asks to refactor specific files or directories, simplify recently changed code, clean up dead code in a limited scope, or invokes "/refactor".

refactor-project

523
from FradSer/dotclaude

Executes automated project-wide refactoring with a focus on cross-file optimization. This skill should be used when the user asks for project-wide refactoring, cross-file simplification, consistency standardization across the codebase, duplication reduction, or invokes "/refactor-project".