# Speckit Implement

> Speckit Implement

- Skill: `majiayu000/speckit-implement-2` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/speckit-implement-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/speckit-implement-2/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/speckit-implement-2

---


# Spec-Kit Implement

Execute the implementation by processing tasks from tasks.md in phases. Fourth step in spec-kit workflow.

## When to Use

- After creating tasks.md with `speckit-tasks`
- Ready to start implementation
- Want to execute tasks systematically

## Execution Workflow

1. **Setup**: Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` to get FEATURE_DIR and AVAILABLE_DOCS
2. **Check checklists status** (if FEATURE_DIR/checklists/ exists):
   - **VALIDATION GATE**: Scan all checklist files and count total, completed, incomplete items
   - Create status table showing pass/fail for each checklist
   - **If any checklist incomplete**: STOP and ask user if they want to proceed anyway
     - User must explicitly approve to continue
   - **If all complete**: Automatically proceed to implementation
3. **Load implementation context**:
   - **REQUIRED**: tasks.md (complete task list), plan.md (tech stack, architecture)
   - **IF EXISTS**: data-model.md, contracts/, research.md, quickstart.md
4. **Project setup verification**:
   - Create/verify ignore files based on actual project setup (gitignore, dockerignore, eslintignore, etc.)
   - Detect technology from plan.md and add appropriate patterns
   - Only append missing critical patterns to existing ignore files
5. **Parse tasks.md structure**:
   - Extract task phases, dependencies, details (ID, description, file paths)
   - Identify parallel markers `[P]` and sequential vs parallel execution rules
6. **Execute implementation** following task plan:
   - Phase-by-phase execution (complete each phase before next)
   - Respect dependencies (sequential tasks in order, parallel tasks `[P]` can run together)
   - Follow TDD approach if tests exist (execute test tasks before implementation)
   - File-based coordination (tasks on same files run sequentially)
   - Validation checkpoints after each phase
7. **Implementation execution order**:
   - Setup first (initialize structure, dependencies, configuration)
   - Tests before code (if test tasks exist)
   - Core development (models, services, CLI commands, endpoints)
   - Integration work (database, middleware, logging, external services)
   - Polish and validation (unit tests, optimization, documentation)
8. **Progress tracking and task completion**:
   - Report progress after each completed task
   - Halt execution if non-parallel task fails
   - For parallel tasks, continue with successful ones, report failures
   - **CRITICAL**: Mark completed tasks **immediately** with `[X]` in tasks.md
     - Change `- [ ] T001` to `- [X] T001` after completion
     - Do NOT batch task updates - mark each one as you complete it

## Key Points

- **Load only required context** - Don't read every artifact, only what's needed
- **Respect task dependencies** - Sequential vs parallel execution
- **Mark tasks complete** immediately with `[X]` in tasks.md
- **Create ignore files** based on detected technology (from plan.md)
- **Phase-by-phase execution** - Complete each phase before moving to next
- **Error handling** - Halt on critical failures, report parallel task failures
- **Checklist validation** - Warn if checklists incomplete before starting

## Next Steps

After implementation:

- Manual testing and QA
- Code review
- Deployment planning

## See Also

- `speckit-tasks` - Break plan into actionable tasks
- `speckit-checklist` - Generate custom validation checklists
- `speckit-analyze` - Validate cross-artifact consistency