version: "1.0.1" name: flutter-executing description: Use when you have a written implementation plan to execute with review checkpoints

Executing Flutter Implementation Plans

Overview

Load plan, review critically, execute tasks in batches, run Flutter verifications, report for review between batches.

Core principle: Batch execution with checkpoints for review.

Announce at start: "I'm using the flutter-executing skill to implement this plan."

The Process

Step 1: Load and Review Plan

1. Read plan file

``bash cat docs/plans/YYYY-MM-DD-<feature>-plan.md ``

1. Check dependencies first

``bash cat pubspec.yaml ``

1. Install new dependencies if needed

``bash flutter pub get ``

1. Review critically:

• Are file paths correct?
• Is layer order followed (Domain → Data → Presentation)?
• Are there any gaps in the plan?

1. If concerns: Raise them before starting
2. If no concerns: Create todo entries (task tracking tool) and proceed

Step 2: Execute Batch

Default: First 3 tasks

For each task:

1. Mark as in_progress in the task tracker
2. Create/modify files as specified
3. Write complete code (from plan)
4. Run verification:

``bash flutter analyze lib/features/<feature>/ ``

1. Commit:

``bash git add <files> git commit -m "<conventional commit message>" ``

1. Mark as completed in the task tracker

Step 3: Verify Batch

After completing 3 tasks, run full verification:

# Static analysis
flutter analyze
# Expected: No issues found!
 
# Run tests (if test files exist)
flutter test test/features/<feature>/
# Expected: All tests passed!
 
# Quick build check (optional — full build runs once in flutter-finishing)
flutter build <target> --debug   # apk / ios / web / windows … per project platform
# Expected: Built successfully

Step 4: Report

When batch complete, report:

## Batch N Complete
 
**Tasks completed:**
1.✅ Task 1: [description]
2.✅ Task 2: [description]
3.✅ Task 3: [description]
 
**Verification:**
-flutter analyze: No issues found
-flutter test: X/X passed
 
**Files created/modified:**
-lib/features/.../entity.dart
-lib/features/.../repository.dart
-...
 
**Ready for feedback.**

Step 5: Continue

Based on feedback:

• Apply changes if needed
• Execute next batch of 3 tasks
• Repeat until all tasks complete

Step 6: Complete Development

After all tasks complete and verified:

1. Run final verification:

``bash flutter analyze flutter test flutter build <target> --debug # per project platform (apk/ios/web/…) ``

1. Announce: "I'm using the flutter-finishing skill to complete this work."

1. REQUIRED SUB-SKILL: Use flutter-craft:flutter-finishing

• Verify tests
• Present 4 options (merge/PR/keep/discard)
• Execute choice
• Cleanup worktree if applicable

Flutter-Specific Verification Commands

When to Stop and Ask for Help

STOP executing immediately when:

• flutter analyze shows errors (not just warnings)
• Tests fail with unclear cause
• Missing dependency not in pubspec.yaml
• Plan has unclear instructions
• File path in plan doesn't match project structure
• State management pattern unclear

Ask for clarification rather than guessing.

Layer Order Verification

Before executing, verify plan follows this order:

1. Domain Layer tasks first
   ├── Entities
   ├── Repository interfaces
   └── UseCases
 
2. Data Layer tasks second
   ├── Models
   ├── DataSources
   └── Repository implementations
 
3. Presentation Layer tasks third
   ├── State Management
   ├── Widgets
   └── Screens
 
4. Test tasks after implementation
   ├── Repository tests (priority 1)
   ├── State tests (priority 2)
   ├── Widget tests (priority 3, optional)
   └── Golden tests (priority 4, optional, visual regression)

If plan doesn't follow this order, raise concern before starting.

REQUIRED SUB-SKILL

During Execution

After EACH batch, you MUST invoke: → flutter-craft:flutter-verification (verify before continuing)

After All Tasks Complete

You MUST invoke: → flutter-craft:flutter-finishing (present completion options)

Remember

• Review plan critically first - Don't blindly execute
• Follow layer order - Domain → Data → Presentation
• Run flutter analyze per batch - Catch errors early
• Commit after each task - Atomic commits
• Report and wait - Don't continue without feedback
• Stop when blocked - Don't guess, ask