execute

Execute backlog tasks via scoped plans, worktrees, tests, and commits.

218|11|Updated Feb 22, 2026
One-click install
npx skills add https://github.com/poteto/noodle --skill execute-poteto
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: execute
Source: https://github.com/poteto/noodle/tree/main/.agents/skills/execute
Command: npx skills add https://github.com/poteto/noodle --skill execute-poteto

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This section standardizes and automates the end-to-end execution of backlog items, ensuring scoped work, consistent decomposition, and rigorous commit discipline to avoid drifting work and merge conflicts.

Core Features & Use Cases

  • Scope and plan alignment: reads plans from brain/plans and backlog descriptions to bound work.
  • Decomposition and isolation: breaks work into discrete changes that can be implemented independently in dedicated worktrees.
  • Verification and governance: enforces unit tests, static analysis, and lint checks before merging changes.
  • Use case: autonomously execute a feature or fix by following a plan, creating a worktree, implementing changes, verifying quality, and merging to main with a clear commit per change.

Quick Start

Create a plan-driven worktree, decompose the scope into individual changes, implement, verify, and merge back to main.

Frequently Asked Questions about execute

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate backlog-driven development with scoped worktrees and controlled commits?

Automated backlog-driven development requires reading plans and breaking work into discrete changes. You scope tasks from existing plans, implement changes independently in dedicated worktrees, verify quality with tests and lint, then merge to main with a clear commit per change.

What is the best way to decompose development tasks for isolated implementation?

Task decomposition involves breaking down scope from plans and backlog descriptions into discrete, independently implementable changes. This mechanism bounds work to prevent drifting, ensures each change gets a dedicated worktree, and maintains strict commit discipline to avoid merge conflicts.

Can I execute ad-hoc development prompts without pre-existing plans?

Yes, you can execute ad-hoc prompts alongside linked plans. The workflow reads plans from the brain/plans directory and backlog descriptions to bound work, but also applies structured execution rules—scope, decompose, implement, verify, and merge—to ad-hoc development requests.

How does worktree isolation prevent merge conflicts during automated task execution?

Worktree isolation prevents merge conflicts by implementing each decomposed change in a dedicated, separated worktree. This scoped approach ensures independent development streams do not overlap, enforcing clean merges back to main with a single commit per verified change.

What verification checks are enforced before merging automated code changes?

Verification governance enforces unit tests, static analysis, and lint checks before merging changes. This rigorous quality gate ensures all decomposed work implemented in isolated worktrees passes required testing barriers before it merges to main with a controlled commit.

Why should I use structured workflow execution for backlog items instead of manual coding?

Structured workflow execution standardizes end-to-end backlog item processing to avoid drifting work and merge conflicts. Manual coding lacks enforced scope alignment, decomposition, worktree isolation, and commit discipline, leading to unbounded work and inconsistent quality verification.