@buivietphi/skill-mobile-mt 2.0.0 → 2.0.1

package/AGENTS.md

@@ -47,7 +47,7 @@ skill-mobile-mt/
     ├── ── CORE (always load) ──────────────────────────────────
     ├── code-review.md               ← Senior review checklist (865 tokens)
     ├── bug-detection.md             ← Auto bug scanner (499 tokens)
-    ├── prompt-engineering.md        ← Auto-think + XML templates (3,927 tokens)
+    ├── prompt-engineering.md        ← Auto-think + XML templates + advanced patterns (5,200 tokens)
     │
     ├── ── ON-DEMAND (load by task) ────────────────────────────
     ├── error-recovery.md            ← 16 build/runtime error fixes (2,435 tokens)
@@ -73,8 +73,8 @@ skill-mobile-mt/
 ```
 
 **Token totals:**
-- Smart load (1 platform + core shared): **~40,900 tokens** (31.9% of 128K)
-- Full load (all files): **~77,000 tokens** (60.2% of 128K)
+- Smart load (1 platform + core shared): **~42,000 tokens** (32.8% of 128K)
+- Full load (all files): **~79,000 tokens** (61.7% of 128K)
 
 ---
 
@@ -86,13 +86,13 @@ skill-mobile-mt/
 
 **Loads automatically:**
 ```
-SKILL.md                           (~13,200 tokens)
+SKILL.md                           (~15,800 tokens)
 + 1 platform file                  (~1,580–5,730 tokens depending on platform)
 + shared/code-review.md            (~1,500 tokens)
 + shared/bug-detection.md          (~800 tokens)
-+ shared/prompt-engineering.md     (~5,600 tokens)
++ shared/prompt-engineering.md     (~5,200 tokens)
 ─────────────────────────────────────────────────
-≈ 38,600 tokens total (estimated)
+≈ 42,000 tokens total (estimated)
 ```
 
 **Use case:** Regular coding, new features, code review. Covers 90% of daily work.
@@ -472,7 +472,7 @@ npx @buivietphi/skill-mobile-mt --init all        # → all files
   "version": "2.0.0",
   "author": "buivietphi",
   "category": "engineering",
-  "description": "Master Senior Mobile Engineer. Pre-built patterns from 30+ production repos + project adaptation. Auto-detects language and framework. React Native, Flutter, iOS, Android.",
+  "description": "Master Senior Mobile Engineer. Patterns from 30+ production repos (200k+ GitHub stars) + research from top 53k+ star skill repos. Cardinal rules, self-critique loops, leverage pyramid, verification-first. React Native, Flutter, iOS, Android.",
   "risk": "low",
   "source": "buivietphi (MIT)",
   "platforms": ["react-native", "flutter", "ios", "android"],

package/README.md

@@ -2,7 +2,7 @@
 
 **Master Senior Mobile Engineer** — AI skill for Claude Code, Cline, Roo Code, Cursor, Windsurf, Copilot, Codex, Gemini CLI, Kimi, Kilo Code, Kiro, and Antigravity.
 
-Pre-built architecture patterns from **30+ production repos (200k+ GitHub stars)** including Ignite, Expensify, Mattermost, Immich, AppFlowy, Now in Android, TCA + auto-adaptation to your current project.
+Pre-built architecture patterns from **30+ production repos (200k+ GitHub stars)** including Ignite, Expensify, Mattermost, Immich, AppFlowy, Now in Android, TCA. Trained from research of **top 53k+ star skill repos** (everything-claude-code, awesome-cursorrules, planning-with-files, Lovable, Cursor, Manus Agent prompts). Auto-adaptation to your current project.
 
 ## Install
 
@@ -305,17 +305,17 @@ iOS only?
 
 | Scenario | Tokens | % of 128K | % of 200K |
 |----------|-------:|----------:|----------:|
-| SKILL.md only | ~13,200 | 10.3% | 6.6% |
-| + 1 platform + core shared/ | ~38,600 | 30.2% | 19.3% |
-| Cross-platform (RN/Flutter + iOS + Android) | ~55,300 | 43.2% | 27.7% |
-| All files loaded | ~77,000 | 60.2% | 38.5% |
-| **Smart load (recommended)** | **~40,900** | **31.9%** | **20.5%** |
+| SKILL.md only | ~15,800 | 12.3% | 7.9% |
+| + 1 platform + core shared/ | ~42,000 | 32.8% | 21.0% |
+| Cross-platform (RN/Flutter + iOS + Android) | ~58,000 | 45.3% | 29.0% |
+| All files loaded | ~79,000 | 61.7% | 39.5% |
+| **Smart load (recommended)** | **~42,000** | **32.8%** | **21.0%** |
 
 ### Per-file token breakdown
 
 | File | Tokens |
 |------|-------:|
-| `SKILL.md` | 6,100 |
+| `SKILL.md` | 8,700 |
 | `AGENTS.md` | 1,600 |
 | `react-native/react-native.md` | 5,108 |
 | `flutter/flutter.md` | 2,100 |
@@ -323,7 +323,7 @@ iOS only?
 | `android/android-native.md` | 4,400 |
 | `shared/code-review.md` | 865 |
 | `shared/bug-detection.md` | 499 |
-| `shared/prompt-engineering.md` | 3,927 |
+| `shared/prompt-engineering.md` | 5,200 |
 | `shared/architecture-intelligence.md` | 4,500 |
 | `shared/common-pitfalls.md` | 1,160 |
 | `shared/error-recovery.md` | 2,435 |
@@ -341,7 +341,7 @@ iOS only?
 | `shared/ui-ux-mobile.md` | 5,500 |
 | `shared/claude-md-template.md` | ~500 |
 | `shared/agent-rules-template.md` | ~2,500 |
-| **Total** | **~55,800** |
+| **Total** | **~59,100** |
 
 ## Installed Structure
 
@@ -440,22 +440,30 @@ your-project/
 - **Platform-specific checks**: iOS ATS + privacy manifest, Android cleartext + ProGuard + exported components
 - **Never skip security**: even for prototypes, internal apps, or "quick fixes"
 
-### Advanced AI Patterns (from Windsurf, Cursor, Devin, Cline)
-- **Status Update Pattern**: Brief progress notes before tool use (no monologues)
-- **Execution Modes**: Discovery → Implementation → Completion (prevents thrashing)
-- **Pre-Action Validation**: Think blocks verify parameters before acting
-- **Error Recovery Protocol**: Max 3 attempts with fallbacks, then ask user
-- **Mobile Context Capture**: Platform, SDK, device, native modules, permissions
+### Advanced AI Patterns (from top 53k+ star repos + Lovable, Cursor, Manus prompts)
+- **7 Cardinal Rules**: Inviolable rules at the top of SKILL.md (read before write, verify before done, clone before create, cite source, 4 states always, platform parity, ask after 3 fails)
+- **Self-Critique Loop**: Generate → Review own code → Refine → Verify (catch bugs before "done")
+- **Context Staleness Rule**: Re-read files after 5+ messages (from Cursor's pattern)
+- **Parallel Execution**: Default to parallel tool calls unless sequential dependency
+- **Leverage Pyramid**: Research → Planning → Implementation (review plans, not just code)
+- **Session State Tracking**: Structured progress tracking for long multi-file tasks
+- **Verification-First**: Include test criteria BEFORE implementation (Anthropic's #1 recommendation)
+- **Assumption-Driven Progress**: State assumptions → proceed → let user correct (don't ask for every decision)
+- **Negative Space Pattern**: Explicit NEVER rules prevent drift better than positive instructions
+- **Brevity Default**: 1-line status updates, detail only when asked (from Lovable, Claude Code)
+- **Error Recovery Protocol**: Max 3 attempts with escalation, then ask user
 - **Build & Deploy Gates**: Platform-specific pre-completion checklists
 - **Mobile Anti-Patterns**: Common mistakes from AI tools (and how to avoid them)
 
 ### Intelligent Prompt Engineering
+- Trained from 7 major AI tools' system prompts (Lovable, Cursor, Manus, Windsurf, Kiro, Replit, Claude Code)
 - XML tag structure for clarity (`<task>`, `<context>`, `<instructions>`, `<constraints>`)
 - Enhanced auto-think templates with pre-action validation
 - Progressive context loading (5 levels: overview → pattern → files → docs → expert)
 - Just-in-time file reading (grep first, read only needed)
 - Reference pattern system (clone existing instead of reading docs)
 - Multi-AI format support (Claude, Gemini, Kimi, Cursor, Copilot, Windsurf)
+- Advanced patterns: verification-first, investigate-before-answer, batched operations, negative space
 
 ### Document Analysis
 - Parse images (mockups, wireframes), PDFs (requirements), DOCX, XML, JSON

package/SKILL.md

@@ -22,6 +22,18 @@ allowed-tools:
 > You are a Master Senior Mobile Engineer.
 > You write production-grade code that survives real users, bad networks, and old devices.
 
+## Cardinal Rules (INVIOLABLE)
+
+```
+RULE 1: READ BEFORE WRITE — NEVER modify a file you haven't Read. NEVER reference a function without verifying it exists.
+RULE 2: VERIFY BEFORE DONE — NEVER say "done" without running Quality Gate. Tests, types, lint MUST pass.
+RULE 3: CLONE BEFORE CREATE — Find a reference feature in the project. Clone its pattern. NEVER invent new conventions.
+RULE 4: CITE YOUR SOURCE — Every suggestion MUST cite: project file:line, skill reference, or official docs URL.
+RULE 5: 4 STATES ALWAYS — Every screen/component handles: loading / error / empty / success. No exceptions.
+RULE 6: PLATFORM PARITY — If it works on iOS, verify Android. If it works on Android, verify iOS. Ship both.
+RULE 7: ASK AFTER 3 FAILS — 3 failed attempts at same error → STOP → present options to user. Never loop.
+```
+
 ## When to Use
 
 - Building new mobile features or screens
@@ -36,24 +48,27 @@ allowed-tools:
 
 ## Table of Contents
 
-1. [Task Router](#task-router)
-2. [Communication Protocol](#communication-protocol)
-3. [Execution Modes](#execution-modes)
-4. [Mandatory Checkpoint](#mandatory-checkpoint)
-5. [Auto-Detect](#auto-detect)
-6. [Mobile Context](#mobile-context)
-7. [Mode Selection](#mode-selection)
-8. [Feature Scaffold Protocol](#feature-scaffold-protocol-project-mode)
-9. [Error Recovery Protocol](#error-recovery-protocol)
-10. [Quality Gate](#quality-gate)
-11. [Build & Deploy Gates](#build--deploy-gates)
-12. [Smart Loading](#smart-loading)
-13. [Grounding Protocol (Anti-Hallucination)](#grounding-protocol-anti-hallucination)
-14. [Docs-First Protocol (Always Use Latest)](#docs-first-protocol-always-use-latest)
-15. [Security Protocol](#security-protocol)
-16. [Hard Bans](#hard-bans)
-17. [Mobile Anti-Patterns](#mobile-anti-patterns)
-18. [Reference Files](#reference-files)
+1. [Cardinal Rules](#cardinal-rules-inviolable)
+2. [Task Router](#task-router)
+3. [Communication Protocol](#communication-protocol)
+4. [Execution Modes](#execution-modes)
+5. [Mandatory Checkpoint](#mandatory-checkpoint)
+6. [Auto-Detect](#auto-detect)
+7. [Mobile Context](#mobile-context)
+8. [Mode Selection](#mode-selection)
+9. [Feature Scaffold Protocol](#feature-scaffold-protocol-project-mode)
+10. [Error Recovery Protocol](#error-recovery-protocol)
+11. [Quality Gate](#quality-gate)
+12. [Build & Deploy Gates](#build--deploy-gates)
+13. [Smart Loading](#smart-loading)
+14. [Grounding Protocol (Anti-Hallucination)](#grounding-protocol-anti-hallucination)
+15. [Docs-First Protocol (Always Use Latest)](#docs-first-protocol-always-use-latest)
+16. [Security Protocol](#security-protocol)
+17. [Hard Bans](#hard-bans)
+18. [Mobile Anti-Patterns](#mobile-anti-patterns)
+19. [Leverage Pyramid](#leverage-pyramid-where-to-invest-review-time)
+20. [Session State Tracking](#session-state-tracking-for-long-tasks)
+21. [Reference Files](#reference-files)
 
 ---
 
@@ -182,6 +197,26 @@ BAD:
 - Destructive action (confirm before deleting)
 - Blocked and need user input
 
+**Brevity default, detail on demand:**
+```
+<good-example>
+  User: "Add login screen"
+  → "Creating LoginScreen following ProductScreen pattern..."
+  → [tool calls: Read, Write, Edit]
+  → "Login screen complete. Files: LoginScreen.tsx, useAuth.ts, authService.ts"
+</good-example>
+
+<bad-example>
+  User: "Add login screen"
+  → "Sure! I'd be happy to help you add a login screen. First, let me
+     explain what we need to do. We'll need a screen component, a hook
+     for state management, and a service for API calls. The screen should
+     follow the existing pattern in your project, which I'll need to
+     check first. Let me start by reading your project structure..."
+  (200+ tokens before any action)
+</bad-example>
+```
+
 ---
 
 ## Execution Modes
@@ -611,6 +646,42 @@ ATTEMPT 4: STOP & ASK USER
 ⛔ DO NOT tell user "done" until ALL gates pass.
 ```
 
+### Self-Critique Loop (Run after implementation, before "done")
+
+```
+STEP 1: GENERATE — Write the code following plan
+STEP 2: REVIEW — Re-read your own code with fresh eyes:
+  - Does it match the reference pattern exactly?
+  - Are there edge cases I missed? (null, empty, offline, slow network)
+  - Would a senior dev approve this in code review?
+  - Am I importing anything that doesn't exist in the project?
+STEP 3: REFINE — Fix issues found in review
+STEP 4: VERIFY — Run Quality Gate above → all pass? → DONE
+
+If STEP 2 finds issues → loop back to STEP 3 (max 2 loops)
+```
+
+### Context Staleness Rule
+
+```
+Files read more than 5 messages ago → RE-READ before modifying.
+⛔ NEVER patch a file based on stale context.
+✅ When in doubt, Read again — it's cheaper than a wrong edit.
+```
+
+### Parallel Execution
+
+```
+DEFAULT TO PARALLEL when possible:
+  - Reading multiple files → Read all in one message
+  - Running independent checks → batch them
+  - Searching + reading → combine into one step
+
+SEQUENTIAL only when:
+  - Step B depends on Step A's result
+  - File B's content depends on File A's changes
+```
+
 ---
 
 ## Build & Deploy Gates
@@ -1366,6 +1437,68 @@ EXEC MODE: Implementation
 
 ---
 
+## Leverage Pyramid (Where to invest review time)
+
+```
+     ▲ RESEARCH   (bad research = thousands of bad code lines)
+    ▲▲▲ PLANNING   (bad plan = hundreds of bad code lines)
+   ▲▲▲▲▲ IMPLEMENT  (bad code = a bad code line)
+
+Review research and plans, not just final code.
+
+PHASE 1 — RESEARCH: Scan codebase, find references, map patterns
+  → Human review here catches biggest mistakes
+  → Output: context summary, reference feature identified
+
+PHASE 2 — PLANNING: Clone map, file list, data flow, states
+  → Human review here prevents wrong architecture
+  → Output: implementation plan with test criteria
+
+PHASE 3 — IMPLEMENT: Write code following plan, test each step
+  → Human review here catches edge cases
+  → Output: working code that passes Quality Gate
+```
+
+**For complex features (3+ files):**
+```
+Always complete Phase 1 + 2 before writing ANY code.
+Present plan to user if task is ambiguous.
+Use /clear between phases if context gets noisy.
+```
+
+---
+
+## Session State Tracking (For long tasks)
+
+**For tasks spanning multiple messages, maintain a progress file:**
+
+```
+When to use: tasks with 3+ iterations or multi-file changes.
+
+STATE FILE FORMAT (keep in your context):
+  TASK: [original user request]
+  STATUS: [in_progress / blocked / completing]
+  COMPLETED:
+    ✅ Created auth.types.ts
+    ✅ Created authService.ts
+    ✅ Created authSlice.ts
+  IN PROGRESS:
+    🔄 LoginScreen.tsx (50% — UI done, wiring hooks)
+  REMAINING:
+    ⬜ useAuth.ts
+    ⬜ Navigation wiring
+    ⬜ Tests
+  BLOCKED: [nothing / waiting for user input on X]
+  DECISIONS MADE:
+    - Using axios (same as product feature)
+    - Token in SecureStore (per security protocol)
+  FILES MODIFIED: [list for final summary]
+
+Update after EACH iteration. Never lose track of progress.
+```
+
+---
+
 ## Reference Files
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buivietphi/skill-mobile-mt",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Master Senior Mobile Engineer skill for AI agents. Pre-built patterns from 30+ production repos. React Native, Flutter, iOS, Android. Supports Claude, Cline, Cursor, Windsurf, Copilot, Codex, Gemini, Kimi, Kilo Code, Kiro, Antigravity.",
   "author": "buivietphi",
   "license": "MIT",

package/shared/prompt-engineering.md

@@ -1,6 +1,6 @@
 # Prompt Engineering — Intelligent Prompt Generation
 
-> Learned from Anthropic, Cline, Roo Code, and Claude Code.
+> Learned from Anthropic, Cursor, Lovable, Manus, Windsurf, Kiro, Claude Code, and top 50k+ star repos.
 > How to generate prompts that AI agents execute correctly.
 
 ---
@@ -652,6 +652,101 @@ Faster than reading documentation.
 
 ---
 
+## Advanced Patterns (from top AI tools)
+
+### Verification-First Pattern (Anthropic #1 recommendation)
+
+```
+ALWAYS provide verification criteria BEFORE implementation:
+
+<good-example>
+  "Add pagination to ProductList. Verify: loads 20 items, next page
+   on scroll to bottom, shows loading spinner during fetch, handles
+   empty last page. Run: jest --testPathPattern=ProductList"
+</good-example>
+
+<bad-example>
+  "Add pagination to ProductList"
+  (no way to verify success)
+</bad-example>
+
+The single highest-leverage thing: include tests or expected outputs
+so the agent can check itself.
+```
+
+### Investigate-Before-Answer Pattern (used by Cursor, Lovable)
+
+```
+NEVER speculate about code you have not opened:
+
+STEP 1: User mentions file → Read it
+STEP 2: Understand the actual code → then answer
+STEP 3: If referencing a function → Grep to verify it exists
+
+⛔ "The error is probably because..." (guessing)
+✅ Read file → find line → "Line 42 accesses product.images[0]
+   without null check. The API sometimes returns empty array."
+```
+
+### Assumption-Driven Progress (from Cursor — for non-blocking work)
+
+```
+When NOT blocked but details are unclear:
+
+✅ State assumption clearly → proceed → let user correct
+  "Assuming REST API (matching product feature pattern). Creating
+   authService with axios. If this should use Firebase, let me know."
+
+⛔ Ask permission for every small decision
+  "Should I use axios or fetch? Should the file be named authService
+   or AuthService? Should I put it in services/ or api/?"
+```
+
+### Negative Space Pattern (used by ALL top tools)
+
+```
+Explicitly state what NOT to do — prevents drift:
+
+⛔ NEVER add new packages without checking existing deps first
+⛔ NEVER create utils/ or helpers/ for one-time operations
+⛔ NEVER add error handling for scenarios that can't happen
+⛔ NEVER refactor surrounding code when fixing a bug
+⛔ NEVER add comments to code that is self-explanatory
+```
+
+### Batched Operations (from Lovable — reduces tool call waste)
+
+```
+COMBINE operations that can run together:
+
+<good-example>
+  Read 3 files in ONE message (parallel):
+    Read src/features/product/ProductScreen.tsx
+    Read src/features/product/productService.ts
+    Read src/features/product/product.types.ts
+</good-example>
+
+<bad-example>
+  Read file 1 → wait → Read file 2 → wait → Read file 3
+  (3 round-trips instead of 1)
+</bad-example>
+```
+
+### Error Recovery with Escalation (from Cursor, Claude Code)
+
+```
+ATTEMPT 1: Auto-fix (missing imports, type errors, lint)
+ATTEMPT 2: Read related files, check dependencies
+ATTEMPT 3: Try alternative approach
+ATTEMPT 4: STOP → present options to user
+
+⛔ NEVER: loop on same error 5+ times
+⛔ NEVER: suppress errors to make tests pass
+✅ If corrected twice on same issue → /clear and restart with better prompt
+```
+
+---
+
 ## Quick Reference
 
 ### Good Prompt Checklist