Execute implementation plans with checkpoint validation, progress tracking, and quality gates. Use for task implementation, plan execution, progress tracking. Skip if no plan exists.
Executes implementation plans with checkpoint validation, progress tracking, and quality gates.
/plugin marketplace add athola/claude-night-market/plugin install attune@claude-night-marketThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Execute implementation plan systematically with checkpoints, validation, and progress tracking.
Skill(attune:project-planning) first)With superpowers:
Skill(superpowers:executing-plans) for systematic executionSkill(superpowers:systematic-debugging) for issue resolutionSkill(superpowers:verification-before-completion) for validationSkill(superpowers:test-driven-development) for TDD workflowWithout superpowers:
Actions:
Validation:
For each task in dependency order:
1. PRE-TASK
- Verify dependencies complete
- Review acceptance criteria
- Create feature branch (optional)
- Set up task context
2. IMPLEMENT (TDD Cycle)
- Write failing test (RED)
- Implement minimal code (GREEN)
- Refactor for quality (REFACTOR)
- Repeat until all criteria met
3. VALIDATE
- All tests passing?
- All acceptance criteria met?
- Code quality checks pass?
- Documentation updated?
4. CHECKPOINT
- Mark task complete IMMEDIATELY (do NOT batch)
- Update execution state
- Report progress
- Identify blockers
Task Completion Discipline: Always call TaskUpdate(taskId: "X", status: "completed") right after finishing each task—never defer completions to end of session.
Verification: Run pytest -v to verify tests pass.
Actions:
This is the final phase of the attune workflow. No auto-continuation occurs after execution completes. The workflow terminates here. Unlike brainstorming, specification, and planning phases, execution does NOT auto-invoke any subsequent phase.
RED Phase:
# Write test that fails
def test_user_authentication():
user = authenticate("user@example.com", "password")
assert user.is_authenticated
# Run test → FAILS (feature not implemented)
Verification: Run pytest -v to verify tests pass.
GREEN Phase:
# Implement minimal code to pass
def authenticate(email, password):
# Simplest implementation
user = User.find_by_email(email)
if user and user.check_password(password):
user.is_authenticated = True
return user
return None
# Run test → PASSES
Verification: Run pytest -v to verify tests pass.
REFACTOR Phase:
# Improve code quality
def authenticate(email: str, password: str) -> Optional[User]:
"""Authenticate user with email and password."""
user = User.find_by_email(email)
if user is None:
return None
if not user.check_password(password):
return None
user.mark_authenticated()
return user
# Run test → STILL PASSES
Verification: Run pytest -v to verify tests pass.
Quality Gates:
- [ ] All acceptance criteria met
- [ ] All tests passing (unit + integration)
- [ ] Code linted (no warnings)
- [ ] Type checking passes (if applicable)
- [ ] Documentation updated
- [ ] No regression in other components
Verification: Run pytest -v to verify tests pass.
Automated Checks:
# Run quality gates
make lint # Linting passes
make typecheck # Type checking passes
make test # All tests pass
make coverage # Coverage threshold met
Verification: Run pytest -v to verify tests pass.
Save to .attune/execution-state.json:
{
"plan_file": "docs/implementation-plan.md",
"started_at": "2026-01-02T10:00:00Z",
"last_checkpoint": "2026-01-02T14:30:22Z",
"current_sprint": "Sprint 1",
"current_phase": "Phase 1",
"tasks": {
"TASK-001": {
"status": "complete",
"started_at": "2026-01-02T10:05:00Z",
"completed_at": "2026-01-02T10:50:00Z",
"duration_minutes": 45,
"acceptance_criteria_met": true,
"tests_passing": true
},
"TASK-002": {
"status": "in_progress",
"started_at": "2026-01-02T14:00:00Z",
"progress_percent": 60,
"blocker": null
}
},
"metrics": {
"tasks_complete": 15,
"tasks_total": 40,
"completion_percent": 37.5,
"velocity_tasks_per_day": 3.2,
"estimated_completion_date": "2026-02-15"
},
"blockers": []
}
Verification: Run pytest -v to verify tests pass.
Daily Standup:
# Daily Standup - [Date]
## Yesterday
- ✅ [Task] ([duration])
- ✅ [Task] ([duration])
## Today
- 🔄 [Task] ([progress]%)
- 📋 [Task] (planned)
## Blockers
- [Blocker] or None
## Metrics
- Sprint progress: [X/Y] tasks ([%]%)
- [Status message]
Verification: Run the command with --help flag to verify availability.
Sprint Report:
# Sprint [N] Progress Report
**Dates**: [Start] - [End]
**Goal**: [Sprint objective]
## Completed ([X] tasks)
- [Task list]
## In Progress ([Y] tasks)
- [Task] ([progress]%)
## Blocked ([Z] tasks)
- [Task]: [Blocker description]
## Burndown
- Day 1: [N] tasks remaining
- Day 5: [M] tasks remaining ([status])
- Estimated completion: [Date] ([delta])
## Risks
- [Risk] or None identified
Verification: Run the command with --help flag to verify availability.
Common Blockers:
When blocked, apply debugging framework:
When to escalate:
Escalation format:
## Blocker: [TASK-XXX] - [Issue]
**Symptom**: [What's happening]
**Impact**: [Which tasks/timeline affected]
**Attempted Solutions**:
1. [Solution 1] - [Result]
2. [Solution 2] - [Result]
**Recommendation**: [Proposed path forward]
**Decision Needed**: [What needs to be decided]
Verification: Run the command with --help flag to verify availability.
Task is complete when:
Test Pyramid:
**Verification:** Run `pytest -v` to verify tests pass.
/\
/E2E\ Few, slow, expensive
/------\
/ INT \ Some, moderate speed
/----------\
/ UNIT \ Many, fast, cheap
Verification: Run the command with --help flag to verify availability.
Per Task:
Track daily:
Formulas:
**Verification:** Run `pytest -v` to verify tests pass.
Velocity = Tasks completed / Days elapsed
Estimated completion = Tasks remaining / Velocity
On track? = Estimated completion <= Sprint end date
Verification: Run the command with --help flag to verify availability.
If ahead of schedule:
If behind schedule:
Skill(superpowers:executing-plans) - Execution framework (if available)Skill(superpowers:systematic-debugging) - Debugging (if available)Skill(superpowers:test-driven-development) - TDD (if available)Skill(superpowers:verification-before-completion) - Validation (if available)Skill(attune:mission-orchestrator) - Full lifecycle orchestrationAgent(attune:project-implementer) - Task execution agent/attune:execute - Invoke this skill/attune:execute --task [ID] - Execute specific task/attune:execute --resume - Resume from checkpointSee /attune:execute command documentation for complete examples.
Command not found Ensure all dependencies are installed and in PATH
Permission errors Check file permissions and run with appropriate privileges
Unexpected behavior
Enable verbose logging with --verbose flag
Activates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use for discovering, retrieving, and improving prompts.