Planning Ios Implementation Skill for Claude

Plan implementation, design an approach, or create an architecture plan for a Bitwarden iOS feature. Use when asked to "plan implementation", "design approach", "architecture plan", "how should I implement", "what files do I need", or to create a design doc before writing code.

1k tokens

context cost

the whole folder, loaded on every use

files

instructions only

copies elsewhere

how many repositories repackaged it

653

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/bitwarden/ios --skill planning-ios-implementation

The instruction itself

9 sections, as written by the author

Planning iOS Implementation

Use this skill to design a complete implementation plan before writing code. Output is saved as a design document.

Prerequisites

Requirements must be clear. If not, invoke refining-ios-requirements first.
Read Docs/Architecture.md before proceeding — it is the authoritative source for all patterns.

Step 1: Classify the Change

Determine the change type to guide scope and planning depth:

| Type | Description | Typical Scope |

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

| New Feature | Entirely new functionality, screens, or flows | New files + modifications, multi-phase |

| Enhancement | Extending existing feature with new capabilities | Mostly modifications, 1-2 phases |

| Bug Fix | Correcting incorrect behavior | Targeted modifications, single phase |

| Refactoring | Restructuring without behavior change | Modifications only, migration-aware |

| Infrastructure | Build, CI, tooling, or dependency changes | Config files, minimal code changes |

State the classification and rationale before proceeding.

Step 2: Explore Existing Patterns

Search the codebase for similar existing implementations to follow:

Find a similar existing feature in the same domain
Identify which services/repositories it uses
Note how its Coordinator, Processor, and View are structured
Check if BitwardenKit/UI/ has reusable components for the new UI

Step 3: List Files to Create/Modify

For each file, specify path, action (create/modify), domain placement, and purpose. Group by layer:

### New Files (Create)

#### Core Layer
- `BitwardenShared/Core/<Domain>/<Feature>/Services/<Feature>Service.swift`
  - Protocol + Default<Feature>Service + Has<Feature>Service

#### UI Layer
- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Coordinator.swift`
- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Processor.swift`
- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>State.swift`
- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Action.swift`
- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Effect.swift`
- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>View.swift`

#### Tests (co-located with implementation)
- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>ProcessorTests.swift`
- `BitwardenShared/Core/<Domain>/<Feature>/Services/<Feature>ServiceTests.swift`

### Modified Files
- `BitwardenShared/Core/Platform/Services/ServiceContainer.swift` — Add new service
- `<Existing>Coordinator.swift` — Add new route

Step 4: Dependency-Ordered Implementation Phases

Order phases so each builds on the previous:

### Phase 1: Data / Core Layer
Models, CoreData entities (if needed), service protocols, repository protocols

### Phase 2: Service/Repository Implementations
Default<Name>Service/Repository — business logic, SDK calls, network

### Phase 3: DI Wiring
ServiceContainer extensions, Has* protocol additions

### Phase 4: Processor + State
StateProcessor subclass, State struct, Action enum, Effect enum

### Phase 5: View + Coordinator
SwiftUI View with store.binding, Coordinator with routes, navigation wiring

### Phase 6: Tests
ProcessorTests (action/effect paths), ServiceTests (business logic), ViewTests (snapshots if UI)

Step 5: Risk Assessment

Identify risks and mitigations:

Security: Does this touch vault data, auth tokens, or Keychain? → Security review required
Extensions: Does this affect AutoFill/Action/Share extensions? → Memory limit check needed
Multi-account: Does this need per-account isolation? → CoreData userId scoping
SDK dependency: Does this require BitwardenSdk changes? → Coordinate with SDK team

Step 6: Save Design Document

Save the plan to .claude/outputs/plans/<ticket-id>.md.

Confirm Before Proceeding

Present the plan to the user and ask: "Here is the implementation plan. Should I proceed with implementation?"

Other skills for the same job

different authors, same section of the catalogue

Doc Coauthoring

by anthropics

vendor ×10

Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.

Structured manuscript/grant review with checklist-based evaluation. Use when writing formal peer reviews with specific criteria methodology assessment, statistical validity, reporting standards compliance (CONSORT/STROBE), and constructive feedback. Best for actual review writing, manuscript revision. For evaluating claims/evidence quality use scientific-critical-thinking; for quantitative scoring frameworks use scholar-evaluation.

Agile product ownership toolkit for Senior Product Owner including INVEST-compliant user story generation, sprint planning, backlog management, and velocity tracking. Use for story writing, sprint planning, stakeholder communication, and agile ceremonies.

Expert guidance for writing secure, reliable, and performant Claude Code hooks - validates design decisions, enforces best practices, and prevents common pitfalls. Use when creating, reviewing, or debugging Claude Code hooks.

Use when creating or developing anything, before writing code or implementation plans - refines rough ideas into fully-formed designs through structured Socratic questioning, alternative exploration, and incremental validation

Conducts structured requirements workshops to produce feature specifications, user stories, EARS-format functional requirements, acceptance criteria, and implementation checklists. Use when defining new features, gathering requirements, or writing specifications. Invoke for feature definition, requirements gathering, user stories, EARS format specs, PRDs, acceptance criteria, or requirement matrices.

Use markdown formatting when drafting content intended for external systems (GitHub issues/PRs, Jira tickets, wiki pages, design docs, etc.) so formatting is preserved when the user copies it. Load this skill before producing any draft the user will paste elsewhere.

889 tokens

How to use it

Copy the folder

Take bitwarden/planning-ios-implementation 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.