next-task_skill

Overview

This skill automates implementing the next unfinished group of tasks from a task list, focusing on phase-aware and stream-aware execution. It retrieves the next task(s) via the rune CLI, reads referenced files, implements tasks in order, and marks subtasks complete for user review. It supports parallel execution across multiple work streams by spawning subagents and coordinating cross-stream dependencies.

How this skill works

The skill calls rune next --format json (or rune next --phase --format json when requested or when the top-level result lacks subtasks) to retrieve the next incomplete group. If a phase is retrieved, it checks available streams with rune streams --available --json to detect parallelizable work. For each selected task it reads all front_matter_references, adds tasks to an internal TODO list, implements each subtask in order, and uses rune complete <task-id> to mark completions. When multiple streams are ready, it spawns subagents to run each stream in parallel and coordinates progress and dependency unblocking.

When to use it

• You want the next logical group of tasks implemented from a maintained task list.
• You need to pull an entire phase of work rather than a single task.
• Parallel work across independent streams should be executed concurrently.
• You must ensure referenced source files are read before implementing tasks.
• You want clear, incremental handoffs so the user can review after each task group.

Best practices

• Always use rune next --format json and rerun with --phase when the result is a single top-level task to ensure full phase retrieval.
• Read every file listed in front_matter_references before making changes to avoid missing context.
• Keep an explicit internal TODO list and process tasks in the order specified; do not advance past the selected task group.
• When multiple streams are ready, spawn subagents and give each the prescribed subagent instruction template to avoid coordination errors.
• Mark each subtask complete with rune complete <task-id> as soon as it is finished and present the result for user review.

Example use cases

• Resume work after an interrupted run by retrieving the next unfinished phase and completing its subtasks.
• Execute a multi-stream phase where frontend and backend tasks can proceed in parallel via spawned subagents.
• Enforce strict task-ordering: read referenced docs, implement subtasks, and mark them complete for incremental review.
• Detect and report circular dependencies when streams block each other, prompting user intervention.
• Pull an entire development phase to prepare a reviewable patch set while ensuring referenced files were consulted.