Task & Skill Execution Engine
Relevant source files
The following files were used as context for generating this wiki page:- skills/spec-driven-development/SKILL.md
- spec-process-guide/execution/implementation-guide.md
- skills/task-breakdown/SKILL.md
- skills/quality-assurance/SKILL.md
- spec-process-guide/templates/tasks-template.md
- spec-process-guide/process/design-phase.md
- spec-process-guide/resources/standards.md
- skills/design-documentation/SKILL.md
- commands/create-steering-documents-standalone.md
The Task & Skill Execution Engine is a systematic methodology for software feature development, designed to transform vague ideas into well-defined, implementable solutions. It is not a software application but a structured process, referred to as Spec-Driven Development, that leverages a series of "skills" and "steering documents" to guide developers and AI assistants through a three-phase workflow: Requirements, Design, and Tasks. This process ensures quality, reduces ambiguity, and enables effective collaboration, particularly in AI-assisted development environments.
The engine's primary output is a detailed implementation plan, broken down into discrete, actionable coding tasks. This structured approach is ideal for complex features, high-stakes projects, and team collaboration where a shared understanding is critical. It is designed to be used with tools like Claude Code, Cursor, and VS Code.
Sources: skills/spec-driven-development/SKILL.md:1-19, README.md:3-4
Core Architecture: The Three-Phase Workflow
The engine's architecture is defined by the Spec-Driven Development process, which consists of three sequential phases. Each phase builds upon the previous one and includes a quality gate to ensure alignment and completeness before proceeding.
This diagram illustrates the high-level flow of the Spec-Driven Development process.
Phase 1: Requirements Gathering
The goal of this phase is to convert abstract feature ideas into clear, testable requirements. This involves capturing user stories, defining acceptance criteria using the EARS (Easy Approach to Requirements Syntax) format, and identifying edge cases.
EARS Format Patterns:
WHEN [event] THEN [system] SHALL [response]
IF [precondition] THEN [system] SHALL [response]
WHILE [condition] [system] SHALL [continuous behavior]
WHERE [location/context] [system] SHALL [behavior]
Sources: skills/spec-driven-development/SKILL.md:24-31, spec-process-guide/resources/standards.md:15-50
Phase 2: Design Documentation
This phase translates the approved requirements into a comprehensive technical blueprint. It involves researching technical approaches, defining system architecture, specifying data models, and planning error handling and testing strategies. A key output is the Design Document, which serves as the foundation for implementation.
The following diagram shows the relationship between key design artifacts.
A critical part of this phase is documenting key decisions with clear rationale.
### Decision: [Title]
**Context:** [Situation requiring decision]
**Options Considered:**
1. [Option 1] - Pros: [benefits] / Cons: [drawbacks]
2. [Option 2] - Pros: [benefits] / Cons: [drawbacks]
**Decision:** [Chosen option]
**Rationale:** [Why this was selected]
Sources: skills/spec-driven-development/SKILL.md:70-77
Phase 3: Task Planning & Breakdown
The final phase breaks the technical design into a sequence of actionable implementation steps. This is achieved using the task-breakdown skill, which converts design components into specific, small coding tasks (estimated at 2-4 hours each).
Task Hierarchy:
A two-level hierarchy is used to structure tasks, ensuring clarity and traceability.
- [ ] 1. [Epic/Major Component]
- [ ] 1.1 [Specific implementation task]
- [Implementation details]
- [Files/components to create]
- _Requirements: [Requirement references]_
Sources: skills/task-breakdown/SKILL.md:20-26
Task Sequencing Strategies:
The engine supports multiple strategies for ordering tasks to enable incremental progress and manage risk.
| Strategy | Description | Best For |
|---|---|---|
| Foundation-First | Build core infrastructure before features. | New projects, complex systems |
| Feature-Slice | Build complete features end-to-end. | MVP development, early validation |
| Risk-First | Tackle uncertain or complex areas early. | High uncertainty, proof-of-concepts |
| Hybrid | Combine approaches pragmatically. | Recommended for most projects |
| Sources: skills/task-breakdown/SKILL.md:58-86 |
Task Execution Strategy
Once the task plan is generated, the implementation-guide provides a systematic approach for execution, emphasizing a "Single Task Focus Approach".
This flowchart outlines the process for executing a single task.
Blocker Resolution
The execution process includes a defined workflow for handling impediments.
This sequence diagram shows the steps for resolving a blocker.
Quality Assurance & Validation
Quality is enforced through a series of checklists and quality gates at the end of each phase. These gates ensure that the outputs of one phase are sufficient to begin the next.
| Phase | Exit Criteria |
|---|---|
| Requirements | All user stories have testable acceptance criteria in EARS format; no conflicts; stakeholder approval. |
| Design | Architecture addresses all requirements; non-functional requirements are handled; security is considered; technical review is complete. |
| Tasks | All design elements are covered by actionable tasks; tasks are sequenced logically; requirements are referenced. |
| Sources: skills/quality-assurance/SKILL.md:78-103, spec-process-guide/templates/checklists.md:1-160 |
During implementation, each task has its own quality gates before, during, and after coding.
- Before Starting: Requirements understood, test strategy defined.
- During Implementation: Code follows standards, tests are written, coverage meets thresholds.
- Before Completion: All tests pass, code review is completed, requirements are validated.
Sources: skills/quality-assurance/SKILL.md:105-121, spec-process-guide/templates/tasks-template.md:162-181
Steering Documents
A key component of the engine is the use of "Steering Documents". These are contextual guidelines stored in the .kiro/steering/ directory that influence how AI assistants approach development tasks. They contain project-specific standards, conventions, and best practices.
Inclusion Mechanisms:
always: Included in every interaction (default).fileMatch: Included when specific files are in context, based onfileMatchPattern.manual: Included only when explicitly referenced.
Example File Structure:
.kiro/steering/
├── project-standards.md (inclusion: always)
├── git-workflow.md (inclusion: always)
├── frontend-standards.md (inclusion: fileMatch, fileMatchPattern: '*.tsx|*.jsx')
└── api-design.md (inclusion: manual)
Sources: commands/create-steering-documents-standalone.md:1-20, 300-313
Conclusion
The Task & Skill Execution Engine provides a robust, structured framework for developing software, especially in collaboration with AI. By formalizing the process into distinct Requirements, Design, and Task phases, it ensures that development is systematic, traceable, and quality-driven. The use of skills, templates, quality gates, and steering documents creates a predictable and efficient workflow that transforms high-level concepts into well-defined, executable code, minimizing ambiguity and rework.