What is the primary function of the Task Execution Engine?

The Task Execution Engine automates the execution of implementation tasks directly from design documents formatted with markdown checkboxes.

How do I mark tasks as completed or failed?

You can mark tasks as completed or failed using the task manager script with specific commands to update the status in your design document.

Can I resume work on interrupted tasks?

Yes, you can resume interrupted work by running the task manager with the same design file, which will automatically find the first uncompleted task.

What format do tasks need to be in?

Tasks must be written as markdown checkboxes within the design document, following the specified format for details and dependencies.

Is this skill suitable for all types of projects?

This skill is best suited for projects that use markdown for task management and where automation is preferred. It may not fit projects requiring more interactive task management.

Task Execution Engine

Name: Task Execution Engine
Availability: InStock
Author: davila7

Free

Automate implementation tasks from design documents.

by davila730.2k stars on davila7/claude-code-templates

2 views

Updated Aug 10, 2026

Get this skill

Free · Opens the source repo

What Task Execution Engine does

The Task Execution Engine skill allows developers to execute implementation tasks directly from design documents formatted in markdown. By utilizing markdown checkboxes, it eliminates the need for separate session files, streamlining the workflow for feature implementation. This skill is particularly beneficial for teams that rely on design documents generated from feature-analysis outputs, enabling a seamless transition from design to implementation.

With this skill, users can easily manage tasks by marking them as completed or failed, providing a clear status update within the design document itself. The task manager script supports various commands to interact with the design file, such as retrieving the next task, updating task status, and resuming interrupted work. This functionality is especially useful for developers who need to pick up where they left off or execute tasks in batches without losing context.

The execution loop of the Task Execution Engine is designed to automate the task management process. It continuously fetches the next task, reads its details, implements the task, verifies acceptance criteria, and updates the status accordingly. This autonomous approach minimizes interruptions and allows developers to focus on coding rather than managing task lists manually. The unattended mode further enhances this by ensuring that the execution continues without halting for clarifications, making it ideal for environments where efficiency is critical.

Overall, the Task Execution Engine is a practical tool for developers looking to enhance their productivity and streamline their implementation processes. It is particularly suited for teams working on complex projects that require a clear and organized approach to task management, ensuring that all tasks are tracked and completed systematically.

When to use it

Use this skill when implementing features from design documents, especially after generating tasks with a feature-analysis tool.

When not to use it

This skill may not be suitable for projects that do not utilize markdown for task management or for teams that prefer interactive task management over automated execution.

What you can build with it

Implementing Features from Design Documents

Use the Task Execution Engine to execute tasks directly from design documents, ensuring a smooth transition from planning to coding.

Resuming Interrupted Work

If your work is interrupted, simply rerun the task manager with the same design file to continue from where you left off.

Batch Executing Tasks

Leverage the automation capabilities to execute multiple tasks in one go, improving efficiency in your development workflow.

How to install Task Execution Engine

View source

1. Install with the skills CLI

npx skills add davila7/claude-code-templates/task-execution-engine --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by davila7

Feature Pipeline

Execute implementation tasks directly from design documents. Tasks are managed as markdown checkboxes - no separate session files needed.

Quick Reference

# Get next task
python3 scripts/task_manager.py next --file <design.md>

# Mark task completed
python3 scripts/task_manager.py done --file <design.md> --task "Task Title"

# Mark task failed
python3 scripts/task_manager.py fail --file <design.md> --task "Task Title" --reason "..."

# Show status
python3 scripts/task_manager.py status --file <design.md>

Task Format

Tasks are written as markdown checkboxes in the design document:

## Implementation Tasks

- [ ] **Create User model** `priority:1` `phase:model`
  - files: src/models/user.py, tests/models/test_user.py
  - [ ] User model has email and password_hash fields
  - [ ] Email validation implemented
  - [ ] Password hashing uses bcrypt

- [ ] **Implement JWT utils** `priority:2` `phase:model`
  - files: src/utils/jwt.py
  - [ ] generate_token() creates valid JWT
  - [ ] verify_token() validates JWT

- [ ] **Create auth API** `priority:3` `phase:api` `deps:Create User model,Implement JWT utils`
  - files: src/api/auth.py
  - [ ] POST /register endpoint
  - [ ] POST /login endpoint

See references/task-format.md for full format specification.

Execution Loop

LOOP until no tasks remain:
  1. GET next task (task_manager.py next)
  2. READ task details (files, criteria)
  3. IMPLEMENT the task
  4. VERIFY acceptance criteria
  5. UPDATE status (task_manager.py done/fail)
  6. CONTINUE

Unattended Mode Rules

NO stopping for questions
NO asking for clarification
Make autonomous decisions based on codebase patterns
If blocked, mark as failed and continue

Status Updates

Completed task:

- [x] **Create User model** `priority:1` `phase:model` ✅
  - files: src/models/user.py
  - [x] User model has email field
  - [x] Password hashing implemented

Failed task:

- [x] **Create User model** `priority:1` `phase:model` ❌
  - files: src/models/user.py
  - [ ] User model has email field
  - reason: Missing database configuration

Resume / Recovery

To resume interrupted work, simply run again with the same design file:

/feature-pipeline docs/designs/xxx.md

The task manager will find the first uncompleted task and continue from there.

Integration

This skill is typically triggered after /feature-analyzer completes:

User: /feature-analyzer implement user auth

Claude: [designs feature, generates task list]
        Design saved to docs/designs/2026-01-02-user-auth.md
        Ready to start implementation?

User: Yes / 开始实现

Claude: [executes tasks via task-execution-engine]

Frequently asked questions about Task Execution Engine

Similar skills

Spring Boot Testing

Master testing techniques for Spring Boot 4 applications.

GitHub Issues

Manage GitHub issues efficiently with MCP tools.

Geofeed Tuner

Optimize your IP geolocation feeds in CSV format.

Batch Files

Master Windows batch scripting for automation and task management.

Adobe Illustrator Scripting

Automate your Illustrator workflows with ExtendScript.

Plugin Structure

Create and organize Claude Code plugins effectively.