Skip to content
Skills Library
Programming · Building & coding

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.

Licence
MIT
Last repository change
25.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.08.2026, without references to retired models or APIs.

Licence

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

  1. The six phases
  2. Phase 2 — implementation order (layer by layer)
  3. Per-platform layer map
  4. Build & verify commands
  5. Acceptance criteria
Original SKILL.md headings · 61 lines, 614 words
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

RepositoryScoreLicence
This page · TalissonVitorino/kmp-ios-skills100MIT
usibuilds/claude-context-zones100MIT

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.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.