feature-builder
/feature-builder
End-to-end workflow to take a mobile feature from idea to verified code through six phases — plan, implement by layer, test, build-fix, review, verify. Use when building a non-trivial Android/iOS/KMP feature and you want a structured, repeatable path. Sequences the real skills and agents available here; it does not invoke an external pipeline.
- Author
- TalissonVitorino ↗
- Repository
- kmp-ios-skills ↗
- Licence
- MIT
- Last repository change
- 25.08.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 25.08.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
End-to-end workflow to take a mobile feature from idea to verified code through six phases — plan, implement by layer, test, build-fix, review, verify. Use when building a non-trivial Android/iOS/KMP feature and you want a structured, repeatable path. Sequences the real skills and agents available here; it does not invoke an external pipeline.
Original author description
End-to-end workflow to take a mobile feature from idea to verified code through six phases — plan, implement by layer, test, build-fix, review, verify. Use when building a non-trivial Android/iOS/KMP feature and you want a structured, repeatable path. Sequences the real skills and agents available here; it does not invoke an external pipeline.
How it works
- The six phases
- Phase 2 — implementation order (layer by layer)
- Per-platform layer map
- Build & verify commands
- Acceptance criteria
SKILL.md preview
--- name: feature-builder description: End-to-end workflow to take a mobile feature from idea to verified code through six phases — plan, implement by layer, test, build-fix, review, verify. Use when building a non-trivial Android/iOS/KMP feature and you want a structured, repeatable path. Sequences the real skills and agents available here; it does not invoke an external pipeline. --- # Feature Builder (workflow) A structured 6-phase path for building a mobile feature end to end. This is a **workflow guide** — it sequences the real skills/agents you already have; it does **not** call external `/feature-*` pipeline commands. > **Platform auto-detect:** `shared/src/commonMain/` → **KMP** · `*.xcodeproj` / `*.xcworkspace` → **iOS** · a module `build.gradle(.kts)` applying `com.android.application` → **Android**. Ambiguous → ask. ## The six phases | # | Phase | Do it with | |---|---|---| | 1 | **Plan** | `superpowers:brainstorming` → `superpowers:writing-plans` (or the `Plan` agent). Output: module breakdown, file list, task order. | | 2 | **Implement (by layer)** | Build in dependency order, pulling the matching library skill per layer (below). Drive with `superpowers:test-driven-development`. | | 3 | **Test** | Unit + UI + E2E. `mobile-testing` (Android/JVM) · `ios-testing` (iOS) · depth: `android-skills:android-testing`. | | 4 | **Build & fix** | Compile + run tests, fix in a loop (cap ~5 iterations, then escalate). Debug via `android-skills:android-debugging`. | | 5 | **Review** | `superpowers:requesting-code-review`, or the `feature-dev:code-reviewer` / `pr-review-toolkit` agents. Block on security & correctness. | | 6 | **Verify** | Run the tests for real, confirm coverage/behaviour, re-run to catch flakiness. `superpowers:verification-before-completion`. | ## Phase 2 — implementation order (layer by layer) ``` domain → (network ∥ ui) → data → wiring ``` - **domain** — models, repository interfaces, use cases returning a typed result (`error-handling-result`). - **network** — API + DTOs (`kmp-networking` / `ktor-patterns`). **ui** — screens, ViewModels, state (`jetpack-compose`, `swiftui-patterns`, `swiftui-observation`, `mvi-architecture`). No mutual dependency → do them together. - **data** — repository impl, mappers, local cache (`kmp-repositories`, `sqldelight-patterns` / `room-patterns` / `swiftdata`). - **wiring** — DI (`kmp-di` / `android-di-koin`), navigation (`navigation`), manifest/permissions. ## Per-platform layer map | Layer | Android | iOS | KMP | |---|---|---|---| | Domain | Kotlin data classes | Swift structs | commonMain models (`shared-models`) | | Network | Retrofit / Ktor | URLSession | Ktor shared (`kmp-networking`) | | UI | Compose + ViewModel | SwiftUI + `@Observable` | Compose MP / SwiftUI | | Data | Room / DataStore | SwiftData / Core Data | SQLDelight, or Room KMP (2.8.x: Android/iOS/JVM/native from `commonMain`, needs `androidx.sqlite:sqlite-bundled`) | | Wiring | Koin/Hilt + Navigation | container + NavigationStack | Koin + shared nav | ## Build & verify commands | | Compile | Unit | UI / Instrumented | |---|---|---|---| | Android | `./gradlew assembleDebug` | `./gradlew test` | `./gradlew connectedAndroidTest` | | iOS | `xcodebuild build -scheme App` | `xcodebuild test -scheme App -destination 'platform=iOS Simulator,name=iPhone 17'` | same, `-testPlan UITests` | | KMP | `./gradlew assemble` | `./gradlew check` | platform-specific | - **KMP:** `allTests` aggregates common/native/JVM tests but **not** the Android unit tests — AGP owns those (`testDebugUnitTest`), and its reports are not merged into the `allTests` report. Use `check` (or `allTests` + `testDebugUnitTest`) to cover both. `build` = `assemble` + `check`, so it compiles *and* tests. - **iOS:** pass `-workspace App.xcworkspace` (or `-project App.xcodeproj`) — `xcodebuild` only auto-resolves a lone `.xcodeproj` in the working directory. ## Acceptance criteria - Builds clean on the target platform(s). - Unit ≥ ~80% on new code · UI covers each screen + key interactions · E2E covers happy path + top error paths. - Code review: no unresolved critical/high findings. - Tests pass reliably (re-run) before you call it done. --- *This is the lean, working version. The original marketplace skill specified an automated `/feature-build` pipeline (named sub-agents, `.omc/` state files, and an instinct / mobile-memory learning layer). That orchestration isn't installed here, and its learning/memory layer is the meta-system you opted out of — so it was removed. Restore the original from the `everything-claude-code-mobile` marketplace if you ever wire that pipeline up.*
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · TalissonVitorino/kmp-ios-skills | 100 | MIT |
| usibuilds/claude-context-zones | 100 | MIT |
Database snapshot: 13.11.2026 · package version 464412ba4642 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100implement-feature
End-to-end feature implementation workflow. Use when the user says "implement", "build feature", "work on task", "start implementation", or any feature development work. Covers plan review, test writing, implementation, verification, and delivery. - 100ship
Full-cycle development workflow for any non-trivial feature or fix. Runs up to 10 phases (explore+interview loop, plan, implement, verify, edge cases, e2e tests, code review, security review, final verify) using the strongest available model for planning and autonomous goal… - 100david-workflow
End-to-end workflow for a feature, fix or change. Plan in phases with a verification plan up front, implement, verify for real and review with sub agents, open a PR (or a gh stack) with evidence attached, drive CI and review comments to green, test on a preview deploy with a… - 100workflow-build-feature
Build a feature end to end: spec and TDD, implement, unit tests, Playwright check, PR. Use when "build a feature" or "implement this end-to-end". Spec/TDD loop only → workflow-spec-tdd. One bug → workflow-fix-and-ship. - 90autonomous-delivery-pipeline
Use when the user wants end-to-end autonomous execution from a brief idea to working, verified code -- multi-phase work spanning requirements, planning, implementation, QA, and validation. Not for brainstorming, single focused changes, or quick fixes. - 100feature-implement
[Implementation] Use when the user asks to build a feature from an idea or description with no plan file yet: research and trace the code, create and get the plan approved, build each phase with its tests, review, verify once, sync specs and docs. Existing plan: plan --mode=execute.