speckit-implement

Execute Speckit project plans from tasks.md with prerequisite checks and hooks.

Updated Apr 6, 2026
One-click install
npx skills add https://github.com/Congtrinhh/sholy-be --skill speckit-implement-congtrinhh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: speckit-implement
Source: https://github.com/Congtrinhh/sholy-be/tree/main/.agents/skills/speckit-implement
Command: npx skills add https://github.com/Congtrinhh/sholy-be --skill speckit-implement-congtrinhh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Speckit implementation workflows can stall when teams lack a reliable, repeatable way to execute a planned set of tasks, validate prerequisites, and apply optional project hooks before and after implementation.

Core Features & Use Cases

  • Pre-implementation guardrails: Checks prerequisites via the repo script, verifies checklist completion status, and optionally runs configured pre-implement extension hooks.
  • Plan-driven execution: Loads tasks.md and plan.md to execute phases in order, respects parallel task markers, and coordinates execution using file-based sequencing rules.
  • Post-validation and hook support: Validates completion, ensures tasks are marked complete, and optionally runs configured after_implement extension hooks.

Quick Start

Run the speckit-implement skill in your repo root to execute tasks from tasks.md and apply hooks defined in .specify/extensions.yml.

Frequently Asked Questions about speckit-implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I execute a planned set of implementation tasks from a markdown file?

To execute implementation tasks from a markdown file, run the skill in your repo root to load tasks.md, validate prerequisite checklists, and coordinate phased execution. It reads the plan definitions and enforces dependency- and parallel-aware sequencing rules automatically.

Can I run custom pre-implementation and post-implementation hooks during project bootstrapping?

Yes, you can run custom hooks during project bootstrapping by defining them in your .specify/extensions.yml file. The execution flow optionally triggers configured pre-implement and after_implement extension hooks before and after running the core task phases.

What is the best way to coordinate parallel task execution and dependency-aware sequencing?

The best way to coordinate parallel task execution is to use a plan-driven skill that reads parallel task markers directly from tasks.md. It applies file-based sequencing rules to manage dependencies and reports progress as each phase completes.

How do I validate checklist completion status before starting an implementation phase?

You validate checklist completion status by running pre-implementation guardrails that check prerequisites via the repository script. This ensures all required checklist items are verified before executing the planned task phases from tasks.md.

Does this implementation planning approach work for repository modernization and feature buildouts?

Yes, this implementation planning approach works for repository modernization, feature buildouts, integration work, and polish completion scenarios. It executes the project plan by coordinating task phases and marking tasks complete as they finish.

Why are my implementation workflows stalling during task orchestration?

Implementation workflows stall during task orchestration when lacking a reliable way to execute planned tasks and validate prerequisites. Using a plan-driven execution skill resolves this by enforcing dependency-aware sequencing, validating checklists, and applying project hooks.