Skip to main content
kata-execute-quick-task Execute small ad-hoc tasks with Kata guarantees, running quick tasks without full planning, or handling one-off work outside the roadmap. Triggers include "quick task", "quick mode", "quick fix", "ad-hoc task", "small task", and "one-off task".
Zur Installation springen Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/gannonh/kata-marketplace --skill kata-execute-quick-taskDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... Mehr aus diesem Repository Capture an idea, task, or issue that surfaces during a Kata session as a structured issue for later work. This skill creates markdown issue files in the .planning/issues/open directory with relevant metadata and content extracted from the conversation. Triggers include "add issue", "capture issue", "new issue", "create issue", "log issue", "file issue", "add todo" (deprecated), "capture todo" (deprecated), "new todo" (deprecated).
Add a milestone to an existing project, starting a new milestone cycle, creating the first milestone after project init, or defining what's next after completing work. Triggers include "add milestone", "new milestone", "start milestone", "create milestone", "first milestone", "next milestone", and "milestone cycle".
Add planned work discovered during execution to the end of the current milestone in the roadmap. This skill appends sequential phases to the current milestone's phase list, automatically calculating the next phase number. Triggers include "add phase", "append phase", "new phase", and "create phase". This skill updates ROADMAP.md and STATE.md accordingly.
Basierend auf der SOC-Berufsklassifikation
name kata-execute-quick-task description Execute small ad-hoc tasks with Kata guarantees, running quick tasks without full planning, or handling one-off work outside the roadmap. Triggers include "quick task", "quick mode", "quick fix", "ad-hoc task", "small task", and "one-off task". metadata {"version":"0.1.0"}
Execute small, ad-hoc tasks with Kata guarantees (atomic commits, STATE.md tracking) while skipping optional agents (research, plan-checker, verifier).
Quick mode is the same system with a shorter path:
Spawns kata-planner (quick mode) + kata-executor(s)
Skips kata-phase-researcher, kata-plan-checker, kata-verifier
Quick tasks live in .planning/quick/ separate from planned phases
Updates STATE.md "Quick Tasks Completed" table (NOT ROADMAP.md)
Use when: You know exactly what to do and the task is small enough to not need research or verification.
<execution_context>
Orchestration is inline - no separate workflow file. Quick mode is deliberately simpler than full Kata.
</execution_context>
@.planning/STATE.md
**Step 0: Resolve Model Profile**
Read model profile for agent spawning:
MODEL_PROFILE=$(node "${CLAUDE_PLUGIN_ROOT} /skills/kata-execute-quick-task/scripts/kata-lib.cjs" read-config "model_profile" "balanced" )
Default to "balanced" if not set.
Model lookup table:
Agent quality balanced budget
kata-planner opus opus sonnet kata-executor opus sonnet sonnet
Store resolved models for use in Task calls below.
Step 1: Pre-flight validation
Check that an active Kata project exists:
if [ ! -f .planning/ROADMAP.md ]; then
echo "Quick mode requires an active project with ROADMAP.md."
echo "Run /kata-new-project first."
exit 1
fi
If validation fails, stop immediately with the error message.
Quick tasks can run mid-phase - validation only checks ROADMAP.md exists, not phase status.
Step 1.5: Parse issue argument (optional)
Check for issue file path argument:
ISSUE_FILE=""
ISSUE_NUMBER=""
ISSUE_TITLE=""
ISSUE_PROBLEM=""
if echo "$ARGUMENTS " | grep -q -- "--issue" ; then
ISSUE_FILE=$(echo "$ARGUMENTS " | grep -oE '\-\-issue [^ ]+' | cut -d' ' -f2)
if [ -f "$ISSUE_FILE " ]; then
ISSUE_TITLE=$(grep "^title:" "$ISSUE_FILE " | cut -d':' -f2- | xargs)
PROVENANCE=$(grep "^provenance:" "$ISSUE_FILE " | cut -d' ' -f2)
if echo "$PROVENANCE " | grep -q "^github:" ; then
ISSUE_NUMBER=$(echo "$PROVENANCE " | grep -oE '#[0-9]+' | tr -d '#' )
fi
ISSUE_PROBLEM=$(sed -n '/^## Problem/,/^## /p' "$ISSUE_FILE " | tail -n +2 | head -n -1)
fi
fi
If ISSUE_FILE provided but file not found: error and exit.
If ISSUE_FILE provided and valid: Use issue title as description (skip Step 2 prompt).
Step 2: Get task description
If $ISSUE_FILE is set (issue-driven quick task):
DESCRIPTION="$ISSUE_TITLE "
echo "Using issue title: $DESCRIPTION "
Skip the AskUserQuestion prompt — use the issue title as the description.
If no issue context (standard quick task):
Prompt user interactively for the task description:
AskUserQuestion(
header: "Quick Task",
question: "What do you want to do?",
followUp: null
)
Store response as $DESCRIPTION.
If empty, re-prompt: "Please provide a task description."
Generate slug from description (both paths):
Generate slug from description:
slug=$(echo "$DESCRIPTION " | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//' | cut -c1-40)
Step 3: Calculate next quick task number
Ensure .planning/quick/ directory exists and find the next sequential number:
mkdir -p .planning/quick
last=$(ls -1d .planning/quick/[0-9][0-9][0-9]-* 2>/dev/null | sort -r | head -1 | xargs -I{} basename {} | grep -oE '^[0-9]+' )
if [ -z "$last " ]; then
next_num="001"
else
next_num=$(printf "%03d" $((10 #$last + 1 )))
fi
Step 4: Create quick task directory
Create the directory for this quick task:
QUICK_DIR=".planning/quick/${next_num} -${slug} "
mkdir -p "$QUICK_DIR "
Creating quick task ${next_num}: ${DESCRIPTION}
Directory: ${QUICK_DIR}
Store $QUICK_DIR for use in orchestration.
Step 4.5: Read context files
Read files before spawning agents using the Read tool. The @ syntax does not work across Task() boundaries - content must be inlined.
.planning/STATE.md (required) — store as STATE_CONTENTskills/kata-plan-phase/references/planner-instructions.md (cross-skill reference) — store as planner_instructions_contentskills/kata-execute-phase/references/executor-instructions.md (cross-skill reference) — store as executor_instructions_content Store content for use in Task prompts below.
Step 5: Spawn planner (quick mode)
Spawn kata-planner with quick mode context:
Task(
prompt="<agent-instructions>\n{planner_instructions_content}\n</agent-instructions>\n\n" +
"<planning_context>
**Mode:** quick
**Directory:** ${QUICK_DIR}
**Description:** ${DESCRIPTION}
**Project State:**
${STATE_CONTENT}
**Issue Context (if from issue):**
${ISSUE_FILE:+Issue File: $ISSUE_FILE}
${ISSUE_NUMBER:+GitHub Issue: #$ISSUE_NUMBER}
${ISSUE_PROBLEM:+
Problem:
$ISSUE_PROBLEM}
</planning_context>
<constraints>
- Create a SINGLE plan with 1-3 focused tasks
- Quick tasks should be atomic and self-contained
- No research phase, no checker phase
- Target ~30% context usage (simple, focused)
</constraints>
<output>
Write plan to: ${QUICK_DIR}/${next_num}-PLAN.md
Return: ## PLANNING COMPLETE with plan path
</output>
",
subagent_type="general-purpose",
model="{planner_model}",
description="Quick plan: ${DESCRIPTION}"
)
Verify plan exists at ${QUICK_DIR}/${next_num}-PLAN.md
Extract plan count (typically 1 for quick tasks)
Report: "Plan created: ${QUICK_DIR}/${next_num}-PLAN.md"
If plan not found, error: "Planner failed to create ${next_num}-PLAN.md"
Read the plan content before spawning using the Read tool:
${QUICK_DIR}/${next_num}-PLAN.md Spawn kata-executor with inlined plan (use the STATE_CONTENT from step 4.5):
Task(
prompt="<agent-instructions>\n{executor_instructions_content}\n</agent-instructions>\n\n" +
"Execute quick task ${next_num}.
<plan>
${PLAN_CONTENT}
</plan>
<project_state>
${STATE_CONTENT}
</project_state>
<constraints>
- Execute all tasks in the plan
- Commit each task atomically
- Create summary at: ${QUICK_DIR}/${next_num}-SUMMARY.md
- Do NOT update ROADMAP.md (quick tasks are separate from planned phases)
</constraints>
",
subagent_type="general-purpose",
model="{executor_model}",
description="Execute: ${DESCRIPTION}"
)
Verify summary exists at ${QUICK_DIR}/${next_num}-SUMMARY.md
Extract commit hash from executor output
Report completion status
If summary not found, error: "Executor failed to create ${next_num}-SUMMARY.md"
Note: For quick tasks producing multiple plans (rare), spawn executors in parallel waves per phase-execute patterns.
Update STATE.md with quick task completion record.
7a. Check if "Quick Tasks Completed" section exists:
Read STATE.md and check for ### Quick Tasks Completed section.
7b. If section doesn't exist, create it:
Insert after ### Blockers/Concerns section:
### Quick Tasks Completed
| # | Description | Date | Commit | Directory |
| --- | ----------- | ---- | ------ | --------- |
7c. Append new row to table:
| ${next_num} | ${DESCRIPTION} | $(date +%Y-%m-%d) | ${commit_ hash} | [${next_num}-${slug} ](./quick/${next_num}-${slug}/ ) |
7d. Update "Last activity" line:
Find and update the line:
Last activity: $(date +%Y-%m-%d) - Completed quick task ${next_num}: ${DESCRIPTION}
Use Edit tool to make these changes atomically
Step 7.5: Create PR with issue closure (if issue-driven)
Check pr_workflow config:
PR_WORKFLOW=$(node "${CLAUDE_PLUGIN_ROOT} /skills/kata-execute-quick-task/scripts/kata-lib.cjs" read-config "pr_workflow" "false" )
If $ISSUE_NUMBER is set (issue-driven quick task):
BRANCH="fix/quick-${next_num} -${slug} "
git checkout -b "$BRANCH "
git push -u origin "$BRANCH "
cat > /tmp/quick-pr-body.md << PR_EOF
## Summary
Completes issue #${ISSUE_NUMBER}: ${ISSUE_TITLE}
## Changes
Quick task ${next_num}: ${DESCRIPTION}
See: ${QUICK_DIR}/${next_num}-SUMMARY.md
Closes #${ISSUE_NUMBER}
PR_EOF
gh pr create \
--title "fix: ${ISSUE_TITLE} " \
--body-file /tmp/quick-pr-body.md
echo "PR created with Closes #${ISSUE_NUMBER} "
gh issue close "$ISSUE_NUMBER " --comment "Completed via quick task ${next_num} "
echo "Issue #${ISSUE_NUMBER} closed directly (pr_workflow=false)"
If no $ISSUE_NUMBER:
Skip PR creation (standard quick task, not issue-driven).
Step 8: Final commit and completion
Stage and commit quick task artifacts:
git add ${QUICK_DIR} /${next_num} -PLAN.md
git add ${QUICK_DIR} /${next_num} -SUMMARY.md
git add .planning/STATE.md
git commit -m "$(cat <<'EOF'
docs(quick-${next_num}) : ${DESCRIPTION}
Quick task completed.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
EOF
)"
commit_hash=$(git rev-parse --short HEAD)
Display completion output:
---
Kata > QUICK TASK COMPLETE
Quick Task ${next_num}: ${DESCRIPTION}
Summary: ${QUICK_DIR}/${next_num}-SUMMARY.md
Commit: ${commit_hash}
---
Ready for next task: /kata-execute-quick-task
