# Accelint Qrspi Apply > Implement QRSPI-planned OpenSpec changes with intelligent parallelization. Use when the user wants to apply a QRSPI change, implement tasks with parallelization, or says "apply this QRSPI change", "implement with parallelization", "run the parallel slices". This skill is specifically designed for changes created via accelint-qrspi that include "Parallelization Strategy" sections in tasks.md. It o… - **Type:** Skill - **Install:** `agentstack add skill-gohypergiant-agent-skills-accelint-qrspi-apply` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [gohypergiant](https://agentstack.voostack.com/s/gohypergiant) - **Installs:** 0 - **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills) - **Latest version:** 0.1.0 - **License:** Apache-2.0 - **Upstream author:** [gohypergiant](https://github.com/gohypergiant) - **Source:** https://github.com/gohypergiant/agent-skills/tree/main/skills/accelint-qrspi-apply ## Install ```sh agentstack add skill-gohypergiant-agent-skills-accelint-qrspi-apply ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Accelint QRSPI Apply Implement OpenSpec changes with intelligent parallelization. This skill orchestrates parallel sub-agent execution based on dependency analysis in the OpenSpec task file, validates implementation, and manages the complete apply workflow. ## What This Skill Does **Automates**: The implementation phase of spec-driven development with parallel execution **Scope**: Task implementation → Validation → Archive readiness **Output**: Fully implemented change ready for archival **Does NOT**: Create plans, modify specs, or automatically archive (suggests archival when ready) ## Prerequisites - OpenSpec CLI installed and initialized - OpenSpec change created via `accelint-qrspi` skill (includes "Parallelization Strategy" in tasks.md) - Sub-agent support (for parallel execution) - The expanded OpenSpec workflows (`explore`, `new`, `continue`) enabled **Important**: This skill is specifically designed for QRSPI-planned changes. Standard OpenSpec changes without parallelization strategies should use the regular `/opsx:apply` command directly. ## Workflow Overview ``` ┌─────────────────────────────────────────────────────────────────┐ │ Phase Action Output │ ├─────────────────────────────────────────────────────────────────┤ │ Parse Extract parallelization Dependency graph │ │ Dependencies Identify blocking tasks Execution plan │ │ Load Context Read config.yaml context Project context │ │ Execute Run slices (parallel/serial) Implemented code │ │ Update Docs Sync living documents Updated docs │ │ Verify Run opsx:verify Verification rpt │ └─────────────────────────────────────────────────────────────────┘ ``` ## Phase Breakdown ### Phase 0: Preflight and Change Selection **Steps**: 1. If a change name is provided in the skill arguments, use it 2. Otherwise, try to infer from conversation context (recent mentions of change names) 3. If ambiguous or missing: ```bash openspec list --json ``` Parse the JSON and use **AskUserQuestion** to let the user select the change 4. Announce: "Applying change: ``" and how to override (e.g., re-invoke with different name) 5. Check that tasks.md exists: ```bash openspec status --change "" --json ``` If `state: "blocked"` (missing tasks), exit with: "Tasks artifact is missing. Run `/opsx:continue` to generate tasks before applying." ### Phase 1: Parse Tasks and Parallelization Strategy **Goal**: Extract task structure and identify parallel vs sequential execution opportunities. Detect if work has already started and resume from the correct level. **Steps**: 1. Read the tasks.md file from `openspec/changes//tasks.md` 2. **Validate checklist format** (CRITICAL for progress tracking): - Check that tasks use markdown checklist format: `- [ ] task` or `- [x] task` - If tasks use numbered lists (1. 2. 3.) or plain bullets (- without [ ]): ``` ❌ Invalid tasks.md format This skill requires tasks in markdown checklist format (`- [ ] task`) for progress tracking and resumption detection. Found format: [numbered lists / plain bullets / other] Please regenerate tasks.md using the accelint-qrspi-propose skill or convert manually to checklist format before applying. ``` - Exit if format is invalid — do not proceed with invalid task format 3. **Check for partial completion** (resumption detection): - Count completed tasks (marked `- [x]`) vs total tasks - Parse which slices have all their tasks marked complete - If any slices are complete, announce: "Detected partial completion. Resuming from Slice N." - Adjust the execution plan to skip completed slices 4. Look for the "Parallelization Strategy" section (usually at the end of the file) 5. Parse the strategy to build a dependency graph: **Example strategy:** ```md ## Parallelization Strategy - **Slice 1** must complete first (establishes infrastructure) - **Slice 2** and **Slice 3** can run in parallel after Slice 1 - **Slice 2** (implementation cleanup) is independent of **Slice 3** (docs/verification) - Final integration: merge both slices, run full pre-commit checklist ``` **Parsed dependency graph:** ``` Level 0 (must run first): - Slice 1 Level 1 (can run in parallel after Level 0): - Slice 2 - Slice 3 Level 2 (after all previous): - Final integration ``` 6. If no "Parallelization Strategy" section exists: - Assume all tasks must run sequentially (safe default) - Inform user: "No parallelization strategy found. Running tasks sequentially." 7. Build an execution plan showing: - Which slices run in which order - Which slices can run in parallel (and which are already complete) - Total estimated parallelization speedup - Starting point (Level 0 or resuming from Level N) **Output**: Dependency graph, execution plan, and resumption point if applicable ### Phase 2: Load Project Context **Goal**: Load project context from `openspec/config.yaml` to inject into sub-agent prompts. This compensates for OpenSpec CLI's limitation where the `apply` command doesn't automatically load project context (unlike artifact creation commands). **Background**: OpenSpec's `openspec instructions apply` command does NOT inject the `context` field from `config.yaml` (confirmed via code inspection and testing). This means sub-agents implementing tasks don't receive Stack Facts, coding patterns, testing conventions, or anti-patterns that should guide implementation. We work around this limitation by manually loading and injecting the context. **Steps**: 1. Check if `openspec/config.yaml` exists: ```bash test -f openspec/config.yaml && echo "exists" || echo "missing" ``` 2. If the file exists, read it: ```bash cat openspec/config.yaml ``` 3. Parse and extract the `context` section (YAML block under `context: |`): - The context starts after the line `context: |` - The context continues until the next top-level YAML key (e.g., `rules:`, `schema:`) - Lines in the context block are indented (usually 2 spaces) - Preserve all whitespace and newlines in the context block - You MUST inform the user that you found and loaded the config. 4. Store the extracted context for injection into sub-agent prompts in Phase 3 5. If no `context` field exists or the file is missing: - Set context to empty string - Proceed without context injection (sub-agents will rely on OpenSpec's default behavior) - You MUST inform the user that you could NOT find and load the config. **Example config.yaml structure**: ```yaml schema: spec-driven context: | # STACK FACTS ## Project Identity auditkit-cli: TypeScript-based code quality audit CLI ## Dependencies - @fission-ai/openspec: ^1.2.0 - vitest: ^2.1.8 # CODING PATTERNS - Use Result for fallible operations (never throw) - Data-last parameter ordering for currying - No `any` types — use `unknown` with type guards # TESTING CONVENTIONS - AAA pattern (Arrange/Act/Assert) - One assertion per test - Use descriptive test names rules: proposal: [...] design: [...] ``` **Output**: Extracted project context string (may be empty if not present) ### Phase 3: Execute Tasks (Sequential + Parallel) **Goal**: Implement tasks following the dependency graph, spawning parallel sub-agents where possible. **Sequential execution** (when tasks have dependencies): For each level in the dependency graph (starting from level 0): 1. If the level has only one slice: - Spawn a single sub-agent with this prompt (inject project context from Phase 2): ``` {INJECTED_CONFIG_CONTEXT} /opsx:apply CRITICAL: You MUST use the /opsx:apply command to implement tasks. DO NOT implement tasks directly yourself. The /opsx:apply workflow will load context and guide implementation. IMPORTANT: This is Slice N of a parallelized QRSPI implementation. Context: This slice must complete before other slices can proceed. Other slices will start after you finish. Instructions: - Work ONLY on tasks in Slice N: [list slice N tasks/sections] - Do NOT implement tasks from other slices (Slices X, Y, Z will be handled separately) - Apply the code patterns, conventions, and constraints from - Follow the normal OpenSpec apply workflow: * OpenSpec will load context files (proposal, design, specs, tasks) * Implement the tasks assigned to Slice N * Mark tasks complete as you go: `- [ ]` → `- [x]` * Test your changes if tests are specified in the tasks - Report completion with summary of changes made - The provides Stack Facts, coding patterns, testing conventions, and anti-patterns to avoid. These are constraints for YOU, not content to include in files. Focus exclusively on Slice N. Leave other slice tasks unchecked. ``` Note: If no project context was loaded in Phase 2, omit the `` block entirely 2. Wait for completion before proceeding to the next level **Parallel execution** (when multiple slices are independent): For each level with multiple independent slices: 1. Spawn all sub-agents in parallel in a single turn (one per slice, inject project context from Phase 2): ``` {INJECTED_CONFIG_CONTEXT} /opsx:apply CRITICAL: You MUST use the /opsx:apply command to implement tasks. DO NOT implement tasks directly yourself. The /opsx:apply workflow will load context and guide implementation. IMPORTANT: This is Slice N of a parallelized QRSPI implementation. Context: This slice is independent and runs in parallel with Slices X, Y. Other agents are working on those slices simultaneously. Instructions: - Work ONLY on tasks in Slice N: [list slice N tasks/sections] - Do NOT implement tasks from other slices - they are being handled in parallel - Apply the code patterns, conventions, and constraints from - Follow the normal OpenSpec apply workflow: * OpenSpec will load context files (proposal, design, specs, tasks) * Implement the tasks assigned to Slice N * Mark tasks complete as you go: `- [ ]` → `- [x]` * Test your changes if tests are specified in the tasks - Report completion with summary of changes made - The provides Stack Facts, coding patterns, testing conventions, and anti-patterns to avoid. These are constraints for YOU, not content to include in files. Focus exclusively on Slice N. Leave other slice tasks unchecked. Your work is independent and should not block or depend on other slices. ``` Note: If no project context was loaded in Phase 2, omit the `` block entirely 2. Track completion as each sub-agent finishes 3. When all slices in the level are done, **pause and offer context management**: ``` ✅ Level N complete Completed slices: - Slice X: [summary] - Slice Y: [summary] Next: Level N+1 has M slice(s) to run [list slices] Options: (a) Continue to next level (b) Clear context and resume — I'll pick up from Level N+1 (c) Pause here — you can resume later with this skill ``` 4. If user chooses (b), instruct them: ``` Run `/clear` to reset context, then re-invoke this skill. I'll detect that Level N is complete and resume from Level N+1. ``` 5. If user chooses (c), exit and remind them how to resume: ``` Paused at Level N+1. To resume, re-invoke this skill. Progress is tracked in tasks.md checkboxes. ``` **Slice targeting approach**: OpenSpec's `/opsx:apply` command does not have native "slice targeting" (no `--slice N` flag). This skill achieves parallelization by: 1. **Using the full OpenSpec CLI workflow**: Each sub-agent invokes `/opsx:apply `, which: - Runs `openspec instructions apply --change "" --json` to get context - Loads all context files (proposal, design, specs, tasks) - Provides dynamic instructions based on current state - Handles task progress tracking and status checks 2. **Slice isolation via instructions**: The orchestrating skill: - Parses the parallelization strategy to identify independent slices - Spawns sub-agents with explicit instructions to work ONLY on their assigned slice - Relies on QRSPI's vertical slicing to ensure slices are truly independent - Each sub-agent marks only its slice's tasks as complete 3. **Why this works**: QRSPI's vertical slicing methodology ensures each slice is: - A complete end-to-end feature increment - Independent with minimal file overlap - Testable in isolation - Safe to implement in parallel The slice boundaries are clearly marked in tasks.md (e.g., "## Slice 1: Remove CLI Surface", "## Slice 2: Remove Implementation"), making it straightforward for sub-agents to identify their scope. ### Phase 4: Update Living Documents **Goal**: Update project documentation to reflect the implemented changes before running verification. **Why this matters**: OpenSpec changes represent significant architectural decisions and feature additions. Living documents (ARCHITECTURE.md, AGENTS.md, openspec/config.yaml) provide context for agents working in the codebase, while README.md serves human users. Keeping them synchronized prevents documentation drift and ensures future agents and developers have accurate, up-to-date context about the system's current state. **IMPORTANT**: Run this phase BEFORE verification so the verification step can check documentation completeness. **Steps**: 1. Check if the change is in a repository or package root by looking for `.git/` or `package.json` 2. Determine the repo/package root (may be current directory or a parent) 3. **Process ALL living documents** in this order (do not stop after the first one): - OpenSpec config (`openspec/config.yaml`) - ARCHITECTURE.md (if exists) - AGENTS.md (if exists) - README.md (if exists) For each document in the list above, follow these steps: **Step 3a: Check if update is needed first** - Read the change artifacts to understand what was implemented: * `openspec/changes//proposal.md` * `openspec/changes//design.md` - Assess whether this change introduces content that would affect the document - If the change is trivial (typos, comments) or doesn't touch the document's scope, skip to the next document **Step 3b: Update the document if needed** **For OpenSpec config** (`/openspec/config.yaml`): - Check if `accelint-onboard-openspec` skill is installed - If skill is available: ``` /accelint-onboard-openspec We have just completed the change spec openspec/changes/. Given this change, we need to make sure that the openspec/config.yaml is current and up to date. ``` The skill will read the proposal and design from the change directory to understand what was implemented and update the config accordingly. - If skill is NOT available, read the change artifacts: - `openspec/changes//proposal.md` - `openspec/changes//design.md` Then read `openspec/config.yaml` and update manually focusing on **project DNA (WHAT the project is)**: - **Tech Stack section**: Add new dependencies, frameworks, or libraries introduced by this change with versions - **Domain Concepts section**: Add new entities or domain terms if this change introduces them - **Code Patterns section**: Update if this change establishes new patterns (exports, error handling, validation approaches) - **Architecture Patterns section**: Add new design patterns if introduced (factory, repository, observer, etc.) - **Patterns to Avoid section**: Add any anti-patterns this change deprecates or makes explicit - **Per-artifact rules** (`rules:` section): Update if this change affects proposal/design/tasks/spec requiremen … ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [gohypergiant](https://github.com/gohypergiant) - **Source:** [gohypergiant/agent-skills](https://github.com/gohypergiant/agent-skills) - **License:** Apache-2.0 Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-gohypergiant-agent-skills-accelint-qrspi-apply - Seller: https://agentstack.voostack.com/s/gohypergiant - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.