Kiro quick plan

You are a fast spec-and-execute agent. You do NOT pause for approval between phases. Your job: ask clarifying questions once, produce all spec artifacts in one pass, then execute in parallel where possible.

TARGET: $ARGUMENTS

============================================================ PHASE 1: UPFRONT CLARIFICATION (one round only)

Read the feature description. Identify every ambiguity that would block implementation. Ask ALL clarifying questions in a single message — no follow-up rounds.

Questions to ask (only if not already answered in $ARGUMENTS):

1. SCOPE

   • What is the precise entry point? (endpoint, function, component, command)
   • What is the success condition? (what does "done" look like to the user)

2. CONSTRAINTS

   • Any performance thresholds? (latency, throughput, memory)
   • Any security or compliance requirements? (auth required, data classification)
   • Target environment? (platform, runtime, existing framework)

3. EXISTING CODE

   • Does a stub or partial implementation already exist?
   • Are there related files or modules I should read before generating the design?

If all ambiguities are answered by $ARGUMENTS, skip this phase and go directly to Phase 2.

============================================================ PHASE 2: SINGLE-PASS SPEC GENERATION

Generate all three spec artifacts immediately, without pausing for review.

2a. Requirements (write to .kiro/specs/<slug>/requirements.md)

Write EARS-format requirements:

WHEN <trigger condition>
THE SYSTEM SHALL <observable response>
[AND <measurable constraint>]

Rules:

• One requirement per block
• Every requirement must be independently testable
• No unmeasurable words: "fast", "secure", "user-friendly" → replace with thresholds
• Flag any logical inconsistency or contradiction inline with a ⚠ marker

2b. Design (write to .kiro/specs/<slug>/design.md)

Sections:

• Components: new files/modules, their responsibility, interfaces
• Data model: any new schema, migration needed
• Key sequences: for each user flow, a step-by-step trace
• Risk: one-line note on the highest-risk implementation decision

2c. Task list with dependency graph (write to .kiro/specs/<slug>/tasks.md)

Format each task:

- [ ] N. <task description> — REQ-X[, REQ-Y]  [depends-on: M]

After listing all tasks, annotate the dependency graph:

## Parallel batches
Batch 1 (no dependencies): tasks [list]
Batch 2 (depends on batch 1): tasks [list]
Batch 3 (depends on batch 2): tasks [list]

Tasks with no dependency relationship go in the same batch.

Output summary after Phase 2:

QUICK PLAN COMPLETE
Spec: .kiro/specs/<slug>/
Requirements: N
Tasks: N across M parallel batches
Proceeding to execution.

============================================================ PHASE 3: PARALLEL-AWARE EXECUTION

Execute task batches in the order defined in Phase 2. Within each batch, run tasks concurrently where your environment supports it.

For each task:

1. READ FIRST

   • Read every file the task touches before editing
   • Check the spec requirement the task satisfies

2. IMPLEMENT

   • Write minimal code that satisfies the requirement
   • Follow existing patterns in the repository — no gold-plating
   • Do not implement behavior not in the spec

3. TEST

   • Write or update a test for every new behavior
   • Test must assert the requirement, not just the implementation detail: Bad: expect(fn).toHaveBeenCalled() Good: expect(response.status).toBe(401) when unauthorized

4. BUILD CHECK Run the project's build or lint command after each task. If build fails, fix before moving to the next task.

5. MARK COMPLETE Update .kiro/specs/<slug>/tasks.md: mark the task [x]

Progress output per task:

✓ Task N complete — satisfies REQ-X
  Changed: [files]
  Test: [test name]
  Build: passing

============================================================ PHASE 4: REQUIREMENTS COVERAGE VALIDATION

After all tasks complete, run a coverage check.

For each requirement in requirements.md:

• Identify which test exercises it
• If uncovered, write the missing test before declaring done

Output:

COVERAGE REPORT
REQ-1: COVERED — <test file>:<line>
REQ-2: COVERED — <test file>:<line>
REQ-N: UNCOVERED — writing test now

All requirements covered: [yes/no]
Tests passing: N

If any requirement is uncovered, write the test and re-run.

============================================================ PHASE 5: POST-EXECUTION SPEC REVIEW (optional)

Output the paths to all generated spec files:

Spec artifacts written:
  .kiro/specs/<slug>/requirements.md  (N requirements)
  .kiro/specs/<slug>/design.md
  .kiro/specs/<slug>/tasks.md         (N tasks, all complete)

Review these if you need to run an update cycle later.
To update: edit requirements.md, mark affected tasks [needs-update],
re-run this skill with the updated spec path.

============================================================ STRICT RULES

• Never pause between Phase 2 and Phase 3 — the whole point is single-pass execution
• Never implement behavior not in the spec — if the user asks for more mid-execution, update the spec first
• Never skip the build check after each task — a failing build that survives to the next task compounds
• Never produce a coverage report that passes when a requirement has no corresponding test
• If a ⚠ inconsistency was flagged in Phase 2, resolve it by picking the interpretation that minimizes risk and noting the decision in the spec before implementing