| name | executing-plans-quickly |
| description | Use when you have a written implementation plan file to execute quickly - does implementation and reviews inline in main context without subagent dispatch |
Executing Plans Quickly
Overview
Execute implementation plans inline in the main context. Same task triplet structure and review discipline as executing-plans, but without subagent dispatch for faster execution.
Core principle: Inline execution trades isolation for speed - best for simple plans where context pollution isn't a concern.
Announce at start: "I'm using the executing-plans-quickly skill to implement this plan inline."
When to Use This Skill
Use this skill when:
- Simple plans with 1-3 tasks
- Well-understood changes where context pollution isn't a concern
- Interactive sessions where speed matters more than isolation
Use full executing-plans when:
- Complex plans with many tasks
- Long-running autonomous work
- When you want independent review perspectives
The Process
For each task triplet (Implement → Spec Review → Code Review):
1. Mark "Implement" in_progress
2. Implement the task inline (TDD, commit)
3. Mark "Implement" complete
4. Mark "Spec Review" in_progress
5. Self-review against spec (inline checklist)
6. If issues → fix inline, amend commit
7. Mark "Spec Review" complete
8. Mark "Code Review" in_progress
9. Self-review for code quality (inline checklist)
10. If issues → fix inline, amend commit
11. Mark "Code Review" complete
12. Proceed to next triplet
After all triplets:
Use verifying-work
Step 1: Load Plan and Initialize Tasks
- Read plan file
- Review critically - identify any questions or concerns
- If concerns: Raise them before starting
- If no concerns: Initialize task tracking
Initialize task tracking:
TaskList
- If tasks exist for this plan: Use
AskUserQuestion to ask:
AskUserQuestion(
questions: [{
question: "Found existing tasks for this plan. How would you like to proceed?",
header: "Resume",
multiSelect: false,
options: [
{ label: "Continue (Recommended)", description: "Resume from first incomplete task" },
{ label: "Start fresh", description: "Start new session for clean execution" }
]
}]
)
- Continue: Use existing tasks, resume from first non-completed triplet
- Start fresh: Advise user to start a new session for clean execution (tasks are session-scoped and cannot be deleted)
- If no tasks exist: Create all task triplets from the plan (see "Creating Tasks from Plan" below)
Creating Tasks from Plan
Parse the plan document and create a task triplet for each task:
For each Task N in the plan:
-
Create Implementation task:
TaskCreate:
subject: "Task N: Implement [Component Name]"
description: |
[Copy task content from plan: Files, Steps, Acceptance Criteria]
activeForm: "Implementing [Component Name]"
-
Create Spec Review task:
TaskCreate:
subject: "Task N: Spec Review"
description: |
Review implementation of Task N for spec compliance.
Verify all requirements are met, nothing extra added.
activeForm: "Reviewing spec compliance for [Component Name]"
-
Create Code Review task:
TaskCreate:
subject: "Task N: Code Review"
description: |
Review implementation of Task N for code quality.
Check tests, error handling, maintainability.
activeForm: "Reviewing code quality for [Component Name]"
After all tasks created, set blocking relationships:
# Within each triplet:
TaskUpdate:
taskId: [spec-review-id]
addBlockedBy: [implement-id]
TaskUpdate:
taskId: [code-review-id]
addBlockedBy: [spec-review-id]
# Between triplets (Task N+1 blocked by Task N's code review):
TaskUpdate:
taskId: [task-N+1-implement-id]
addBlockedBy: [task-N-code-review-id]
Step 2: Execute Each Task Triplet
For each task triplet in order:
2a. Implementation Phase
Mark in progress:
TaskUpdate:
taskId: [implement-task-id]
status: in_progress
Implement inline:
- Follow the task steps exactly as written in the plan
- Use TDD: write failing test, make it pass, refactor
- Commit when complete
Mark complete:
TaskUpdate:
taskId: [implement-task-id]
status: completed
2b. Spec Review Phase
Mark in progress:
TaskUpdate:
taskId: [spec-review-task-id]
status: in_progress
Review against spec checklist:
□ All requirements from task spec implemented
□ No extra features added beyond spec
□ No requirements misinterpreted
□ Tests cover the specified behavior
If issues found:
- Fix the issues inline
- Amend the commit:
git add -A && git commit --amend --no-edit
- Re-check the checklist
Mark complete (only after all checks pass):
TaskUpdate:
taskId: [spec-review-task-id]
status: completed
2c. Code Quality Review Phase
Mark in progress:
TaskUpdate:
taskId: [code-review-task-id]
status: in_progress
Review for code quality checklist:
□ Tests actually test behavior (not implementation details)
□ Error handling appropriate for the context
□ Follows existing codebase patterns
□ No obvious bugs or edge cases missed
If issues found:
- Fix the issues inline
- Amend the commit:
git add -A && git commit --amend --no-edit
- Re-check the checklist
Mark complete:
TaskUpdate:
taskId: [code-review-task-id]
status: completed
Proceed to next triplet.
Step 3: Verify and Complete
After all tasks complete:
REQUIRED SUB-SKILL: Use Skill(verifying-work)
When to Stop and Ask
STOP executing immediately when:
- Hit a blocker (missing dependency, unclear instruction)
- Test fails and fix is not obvious
- Discover fundamental misunderstanding of requirements
Ask for clarification rather than guessing.
Red Flags
Never:
- Skip either review phase
- Proceed to code quality before spec compliance passes
- Ignore issues found in review
- Guess when blocked
Always:
- Follow plan steps exactly
- Use TDD for implementation
- Fix issues before proceeding to next task
- Commit after each implementation task
Integration
Required skills:
- test-driven-development - Implementation discipline
- verifying-work - Holistic review after all tasks complete
Used by:
- writing-plans - Creates plans this skill executes
