pac-openspec-apply-change

Coordinate OpenSpec change tasks with atomic commits and status updates.

2|1|Updated Mar 4, 2026
One-click install
npx skills add https://github.com/ladislas/mypac --skill pac-openspec-apply-change
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pac-openspec-apply-change
Source: https://github.com/ladislas/mypac/tree/main/skills/pac-openspec-apply-change
Command: npx skills add https://github.com/ladislas/mypac --skill pac-openspec-apply-change

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Orchestrates the end-to-end application of OpenSpec changes by guiding task execution, status tracking, and artifact updates within a repository.

Core Features & Use Cases

  • Orchestrates change application: selects a change, reads status, and fetches actionable instructions from the OpenSpec workflow.
  • Handles progress and blockers: announces the active change, shows progress, and suggests remediation when tasks are blocked or ambiguous.
  • Performs scoped implementation: applies tasks in small, verifiable slices, commits changes atomically, and updates the task tracking to reflect completion.

Quick Start

Provide a change name or use context to apply an OpenSpec change step by step.

Frequently Asked Questions about pac-openspec-apply-change

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

FAQPage Schema
How do I automate OpenSpec change management and task execution in a repository?

OpenSpec change management is automated by coordinating task execution, reading CLI outputs for status, and applying changes in small, verifiable slices. The workflow handles iterative commits and updates task tracking to reflect completion.

What is the best way to handle blocked states or partial progress during an OpenSpec change?

Handling blocked states during an OpenSpec change involves reading context files to determine status and suggesting remediation for ambiguous tasks. The workflow manages partial progress by announcing the active change and showing actionable instructions.

How do I commit code changes atomically when applying an OpenSpec change?

Committing code changes atomically during an OpenSpec change requires applying tasks in scoped, verifiable slices. The workflow performs scoped implementation and commits changes as atomic units while updating the task checklist.

Can I use this OpenSpec workflow to track iterative task progress across multiple sessions?

Tracking iterative OpenSpec task progress across sessions is supported by reading CLI outputs and context files at the start, continuation, or completion of a change. The workflow announces the active change and shows progress to maintain state.

Why do I need a workflow to apply OpenSpec changes instead of manual code commits?

Applying OpenSpec changes manually risks misaligned task tracking and incomplete status updates. This workflow orchestrates end-to-end application by fetching actionable instructions, handling blockers, and ensuring artifact updates are committed atomically.

Does this workflow support continuing an OpenSpec change that was interrupted midway?

Continuing an interrupted OpenSpec change is fully supported by reading current status from CLI outputs and context files. The workflow determines the exact progress state and fetches actionable instructions to resume task execution seamlessly.