android-to-ios

Files (1)

• SKILL.md

SKILL.md (first lines)

# Android to iOS: Feature Parity Implementation

Use Android code as the reference to implement the equivalent iOS feature. Not a literal translation - understand what the Android code does, then implement it idiomatically for iOS.

**Use this when:**
- Porting a feature from Android to iOS
- Android is the "source of truth" for a feature
- Ensuring feature parity between platforms

## Key Principle

```
Android Code → Understand Feature → Match iOS Codebase Patterns → Implement
                  (what)                  (how it's done here)
```

**Preserved:** Feature behavior, data structure shapes, business logic, user flows
**Adapted:** Language idioms, frameworks, patterns to match the iOS codebase

---

## Workflow

### Step 0: Gather Context

**Ask the user for both pieces of information:**

```
To port a feature from Android to iOS, I need:

1. PATH TO ANDROID CODEBASE (source of truth)
   Where is the Android project located?
   Example: /path/to/android-app or ../android-app

2. FEATURE TO IMPLEMENT
   What feature or component should I port?
   Example: "UserProfile screen" or "the authentication flow" or "app/src/main/java/features/checkout"
```

**Assumptions:**
- Current working directory = iOS codebase (target)
- User provides path to Android codebase (source)

If the user already provided this info, proceed. Otherwise, ask.

### Step 1: Locate the Android Feature

Navigate to the Android codebase path and find the relevant files:

1. Go to the Android path provided
2. Find files related to the feature
3. Read and understand the implementation

### Step 2: Analyze the Android Code

Thoroughly understand:

| Aspect | What to Extract |
|--------|-----------------|
| **Feature Behavior** | What does this feature do? User-facing functionality |
| **Data Structures** | Models, types, sealed classes - their shapes and relationships |
| **Business Logic** | Core logic, validations, transformations |
| **State Management** | What state exists, how it flows |
| **API Contracts** | Network calls, request/response shapes |
| **UI Flow** | Screens, navigation, user interactions |
| **Edge Cases** | Error handling, loading states, empty states |

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
                  ANDROID FEATURE ANALYSIS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

## Feature: [Name]

### What It Does
[User-facing description]

### Data Structures
[Key models and their relationships]

### Business Logic
[Core logic summary]

### State
[What state is managed, how it changes]

### API Calls
[Endpoints, request/response shapes]

### UI Flow
[Screens, navigation]

### Edge Cases Handled
- [Case 1]
- [Case 2]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

### Step 3: Analyze iOS Codebase Patterns

**Before implementing, understand how THIS iOS codebase does things:**

1. **Check if `.claude/codebase-style.md` exists** - If yes, use it and skip manual analysis
2. Find similar features in the codebase
3. Note the patterns used:
   - Architecture pattern
   - UI framework and patterns
   - State management approach
   - Networking approach
   - Dependency injection
   - File/folder organization
   - Naming conventions

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
                 iOS CODEBASE PATTERNS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

From michaelboeding/skills, MIT.

More from michaelboeding/skills