vp-k/flutter-craft/flutter-executing

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