new-task

name	new-task
description	Use when the user gives a vague or high-level feature request that needs decomposition into implementable work — new ideas, '~만들어줘' with implicit requirements, features with multiple possible approaches. NOT for specific 1-2 file changes, obvious bug fixes, quick questions, or when spec/trace already exist (use stv:do-work).

Desc: Transform vague user requirements into STV-structured feature specs with traced scenarios. Orchestrates stv:spec and stv:trace to produce implementable work.

New Task — STV Feature Decomposition

Overview

new-task transforms vague user requirements into structured STV artifacts (spec.md + trace.md) with traced scenarios as the task list.

Core principle: Understand intent deeply → Create spec via stv:spec → Create trace via stv:trace → trace.md scenarios = task list.

When to Use

Use when:

• User describes feature/idea in vague or high-level terms
• Need to decompose work into implementable scenarios
• Architectural decisions required before implementation
• Multiple implementation approaches possible
• Work requires structured spec + trace before coding

Do NOT use when:

• User request is already specific (1-2 file changes)
• Fixing obvious bug with clear solution
• Quick clarification or simple question
• Spec and trace already exist (use stv:do-work directly)

Decision Gate (MANDATORY)

Read ${CLAUDE_PLUGIN_ROOT}/prompts/decision-gate.md and apply it to every decision in this workflow.

Sizing Rubric: read ${CLAUDE_PLUGIN_ROOT}/prompts/decision-gate.md (single source — do not duplicate the table here). Sizes below (tiny/small/medium/large/xlarge) refer to expected code change (added + deleted).

Workflow Phases

Phase 1: Intent Understanding
    ↓
Phase 2: Spec Creation (→ stv:spec)
    ↓
Phase 3: Trace Creation (→ stv:trace)
    ↓
Phase 4: Summary & Next Steps

Phase 1: Intent Understanding (~5min)

Goal: Ground the vague request in actual project context.

1. Analyze user request

   • Identify core intent
   • Extract implicit requirements
   • Estimate scope

2. Explore codebase (Agent:Explore)

   • Identify related existing code
   • Understand existing patterns, conventions, architecture
   • Check if similar features already exist
   • Map affected areas

3. Summarize context

   • Organize discovered code/patterns
   • Identify integration points with existing architecture
   • Prepare information for spec interview in Phase 2

Phase 2: Spec Creation → Invoke stv:spec

Goal: Generate a structured spec.md.

Skill(skill="stv:spec") invoked

• Conduct spec interview based on context collected in Phase 1
• Apply Decision Gate: switching cost < small → autonomous judgment, >= medium → ask user
• Output: docs/{feature}/spec.md

Phase 3: Trace Creation → Invoke stv:trace

Goal: Decompose spec into per-scenario vertical traces + RED contract tests.

Skill(skill="stv:trace") invoked

• Trace per-scenario call stacks using spec.md as input
• Derive contract tests for each scenario
• Output: docs/{feature}/trace.md + RED tests

Phase 4: Summary & Next Steps (~2min)

Goal: Present overall results to the user + execution guidance.

1. trace.md scenario list = task list

   • Each scenario in the Implementation Status table is one work unit

2. Present summary to user

## Feature Ready: {feature-name}

### Artifacts Created
- `docs/{feature}/spec.md` — PRD + Architecture
- `docs/{feature}/trace.md` — {N} scenarios traced
- {N} RED contract tests created

### Scenario Task List
| # | Scenario | Size | Status |
|---|----------|------|--------|
| 1 | {title} | {tier} | Ready |
| 2 | {title} | {tier} | Ready |
| ... | ... | ... | ... |

### Auto-Decisions Made
{Summary of items autonomously decided via Decision Gate}

### Next Step
→ Start per-scenario implementation with `stv:do-work`
→ Or implement directly with `stv:work docs/{feature}/trace.md`

Integration with Other Skills

INVOKES:

• stv:spec — Spec creation in Phase 2
• stv:trace — Trace creation in Phase 3

SEQUENTIAL: After new-task completes → Use stv:do-work for execution If the request is ambiguous rather than merely high-level (contradictory goals, unclear scope owner), run stv:clarify first and feed its Context Brief into Phase 1.

CALLED BY:

• stv:plan-new-task — Called after proposing a new feature and user selects an idea

Common Mistakes

Mistake	Fix
Skipping Phase 1	Always explore codebase first — plans grounded in reality
Starting trace without spec	Must follow stv:spec → stv:trace order
Not treating trace scenarios as tasks	trace.md Implementation Status = task list
Asking user about trivial things	Apply Decision Gate: switching cost < small → autonomous judgment

NEVER

• Skip or abbreviate stv:spec or stv:trace workflows
• Guide implementation without a trace
• Declare "complete" without a scenario list