OverviewHistoryStatsSecurity
npx skills add ...
Documentation
SKILL.md
npx skills add athola/claude-night-market --skill project-execution
Executes implementation plans with progress tracking, checkpoint validation, and quality gates. Use after planning is complete and tasks are ready to implement.
npx skills add athola/claude-night-market --skill project-execution
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 workflowWith imbue:
Skill(imbue:graduated-implementation) at the ramp gate so
each increment's ambition is earned by demonstrated understanding
of the prior one, not ramped on completion aloneWithout superpowers:
Actions:
Validation:
For each task in dependency order:
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:
Implementation is where the honest lessons appear: the approach that had to be
reworked, the blocker that cost a day, the assumption from planning that did
not hold. Capture these in docs/lessons-learned.md now, blamelessly, instead
of letting them vanish into "done." Draft and confirm one entry per
substantive lesson:
Skill(leyline:decision-journal) and follow
it to append a lesson entry: what_happened, what_didnt_work,
root_cause, and a concrete action. Set phase to execute. Show the
draft; append on confirmation (status starts open).docs/lessons-learned.md by hand using
the in-file ENTRY TEMPLATE; assign the next LL-NNN id.Trigger this whenever execution involved rework, a failed approach, or a blocker that exhausted the two-challenge / 3-attempt limit. A clean run with no surprises needs no entry.
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.
Before implementing a task, delegate it.
Skill(conjure:delegation-core) is on by default, so the decision to
make is whether a Keep Local clause holds, not whether to bother.
Keep the task local when it is design or trade-off work, when its context carries a secret, when it needs turn-by-turn iteration, or when its output cannot be validated afterward. Otherwise hand it to the delegator and validate what comes back through the same TDD workflow below. The tests are the validation: a delegated implementation that fails the RED test is rejected exactly like a local one.
If the result carries a fallback_reason, no external model ran.
Report which providers were tried, then implement the task here.
An exhausted chain is not a blocked task and does not belong in
docs/lessons-learned.md.
RED Phase:
Verification: Run pytest -v to verify tests pass.
GREEN Phase:
Verification: Run pytest -v to verify tests pass.
REFACTOR Phase:
Verification: Run pytest -v to verify tests pass.
Quality Gates:
Verification: Run pytest -v to verify tests pass.
Automated Checks:
Verification: Run pytest -v to verify tests pass.
Save to .attune/execution-state.json:
Verification: Run pytest -v to verify tests pass.
Daily Standup:
Verification: Run the command with --help flag to verify availability.
Sprint Report:
Verification: Run the command with --help flag to verify availability.
Common Blockers:
When blocked, apply debugging framework:
When to escalate:
Escalation format:
Verification: Run the command with --help flag to verify availability.
Task is complete when:
Test Pyramid:
Verification: Run the command with --help flag to verify availability.
Per Task:
Track daily:
Formulas:
Verification: Run the command with --help flag to verify availability.
If ahead of schedule:
If behind schedule:
docs/lessons-learned.md as an open entry (a clean run needs none).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(conjure:delegation-core) - Default-on delegation of task executionSkill(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 checkpointAt mission completion, produce a Mission Report using the
template from references/mission-report.md. The report documents:
See references/mission-report.md for the full template and
example reports for successful, partial, and failed missions.
See /attune:execute command documentation for complete examples.
# Write test that fails
def test_user_authentication():
user = authenticate("user@example.com", "password")
assert user.is_authenticated
# Run test → FAILS (feature not implemented)# 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# 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- [ ] 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# Run quality gates
make lint # Linting passes
make typecheck # Type checking passes
make test # All tests pass
uv run pytest --cov # Coverage threshold met{
"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": []
}# 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]# 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## 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 `pytest -v` to verify tests pass.
/\
/E2E\ Few, slow, expensive
/------\
/ INT \ Some, moderate speed
/----------\
/ UNIT \ Many, fast, cheap**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