openspec-apply-change

Apply OpenSpec change tasks by reading context files and updating task artifacts.

6|Updated Feb 5, 2026
One-click install
npx skills add https://github.com/jacobcy/vibe-coding-control-center --skill openspec-apply-change-jacobcy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: openspec-apply-change
Source: https://github.com/jacobcy/vibe-coding-control-center/tree/main/.github/skills/openspec-apply-change
Command: npx skills add https://github.com/jacobcy/vibe-coding-control-center --skill openspec-apply-change-jacobcy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill removes friction when moving from OpenSpec change definitions to concrete implementation by automating the selection, context discovery, and task-by-task application workflow so developers can focus on minimal, scoped code changes rather than orchestration details.

Core Features & Use Cases

  • Change selection and discovery: Infer or prompt for the change name, list active changes, and announce the selected change and override mechanism.
  • Schema-aware instructions: Query openspec for status and apply instructions, read context files based on schema, and surface dynamic guidance.
  • Task-driven implementation loop: Iterate through pending tasks, apply minimal focused code changes, mark tasks complete, handle blocked/ambiguous tasks by pausing and prompting the user.
  • Use Case: When picking up work on an OpenSpec change, use this skill to fetch the apply instructions, read specs and tasks, implement the next pending items, and update task checkboxes as you go.

Quick Start

Apply the next pending OpenSpec task for the given change, read the context files listed by the CLI, implement the minimal scoped code change, and mark the task complete.

Frequently Asked Questions about openspec-apply-change

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

FAQPage Schema
How do I automate OpenSpec task implementation for a specific code change?

To automate OpenSpec task implementation, apply the named change to iterate through pending tasks, read context files, write minimal scoped code, and update the task artifacts automatically. The workflow queries the openspec CLI for status and schema-specific instructions to drive the loop.

How does task-driven code implementation handle blocked or ambiguous tasks?

Task-driven code implementation handles blocked or ambiguous tasks by pausing the workflow and prompting the user for clarification. It processes pending tasks iteratively but stops automatically marking progress when a task lacks clear instructions or context.

Do I need the openspec CLI to apply changes and update task artifacts?

Yes, you need the openspec CLI to fetch status and apply instructions for the change. The implementation workflow requires querying the CLI to read context files, follow schema-specific guidance, and update the tasks file to mark progress.

What is the best way to move from an OpenSpec change definition to concrete code?

The best way to move from an OpenSpec change definition to concrete code is using an automated apply workflow that discovers context, selects the change, and implements pending tasks one by one. This removes orchestration friction so developers can focus on minimal code changes.

Can I infer the active OpenSpec change name automatically without manual prompts?

Yes, the change selection and discovery mechanism can infer the active OpenSpec change name automatically or prompt you to select from a list. It announces the selected change and any override mechanism before fetching apply instructions.

Why does my OpenSpec apply workflow pause before completing all pending tasks?

Your OpenSpec apply workflow pauses before completing all pending tasks when it encounters blocked or ambiguous items requiring user input. It stops the task-driven implementation loop to prevent incorrect code changes and waits for your guidance.