Accelint Qrspi Propose

Accelint QRSPI

Automate the QRSPI + OpenSpec planning workflow, implementing the methodology from "We Got RPI Wrong" with OpenSpec's artifact system. This skill orchestrates the Question generation → Research → Design → Structure phases, with mandatory human checkpoints before code is written.

What This Skill Does

Automates: The planning phase of spec-driven development using QRSPI methodology Scope: Questions → Research → Design → Structure/Plan (stops before implementation) Output: A complete OpenSpec change ready for /opsx:apply

Does NOT: Implement code, run tests, create PRs, or archive changes

Prerequisites

This skill requires the expanded OpenSpec workflows (explore, new, continue) to access the step-by-step artifact generation.

To verify these workflows are enabled:

openspec config list

Check that the workflows: section includes: explore, new, and continue.

If any are missing, enable the expanded profile:

openspec config profile
# Select "expanded" from the list
openspec update

Workflow Overview

┌─────────────────────────────────────────────────────────────────┐
│  Phase          Context              Output          Checkpoint │
├─────────────────────────────────────────────────────────────────┤
│  Questions      Ticket only          Questions       —          │
│  Research       Questions only       Research doc    —          │
│  Design         Q+R (NO ticket)      proposal.md     —          │
│                                      design.md       —          │
│                                      [STOP HERE]                │
│  ⚠️  CHECKPOINT 1: Review design.md - MUST approve to continue  │
│                                                                 │
│  Specs/Tasks    Q+R+design           specs/*         —          │
│                                      tasks.md        —          │
│  ⚠️  CHECKPOINT 2: Review tasks.md - MUST approve to continue   │
│                                                                 │
│  Done           —                    Exit            —          │
└─────────────────────────────────────────────────────────────────┘

Note: Ticket is kept OUT of context after Phase 1 to prevent completion bleed.

Critical: Phase 3 generates ONLY proposal.md and design.md, then STOPS for review.
Phase 5 generates specs/* and tasks.md separately after design approval.

⚠️  MANDATORY CHECKPOINTS: The agent MUST pause and wait for explicit user approval
at both checkpoints. Proceeding without approval bypasses QRSPI's core value.

Phase Breakdown

Phase 0: Preflight Checks

Before starting, verify the user provided input and OpenSpec has the required workflows enabled.

Steps:

1. Validate user input: Check if the user provided a ticket, feature request, or idea in their prompt (either as skill arguments or in their message). If the prompt is empty or contains only the skill invocation with no actual content:

   I need a ticket or feature description to plan. Please provide:

   - A ticket ID and description (e.g., "ATI-123: Add user authentication...")
   - A feature request ("I want to add dark mode support...")
   - An idea or problem statement ("Users complain about slow search...")

   Then I'll use QRSPI to break it down into a structured plan.

Exit the skill and wait for the user to provide input. Do NOT proceed with internal examples or placeholder content.

2. Tell the user: "Checking OpenSpec configuration..." 3. Run openspec config list and parse the output 4. Check if the workflows: section contains all three required workflows: explore, new, and continue 5. If any are missing:

   This skill requires the expanded OpenSpec workflows (explore, new, continue).

   Your current workflows: [list what's enabled]
   Missing: [list what's missing]

   To enable the expanded workflows, run:

   openspec config profile
   # Select "expanded" from the list
   openspec update

   Then re-run this skill.

6. Exit the skill if required workflows are not enabled 7. If validation passes and all workflows are present, proceed to Phase 1

Phase 1: Questions (Ticket Context → Questions)

Goal: Generate research questions from the ticket, without proposing solutions.

Context isolation: The agent generating questions should see ONLY the ticket, not prior codebase knowledge or research. This prevents solution-first thinking.

Steps:

1. Accept the ticket description from the user (passed as the skill argument or prompted if missing) 2. Spawn a sub-agent with this exact prompt:

   /opsx:explore

   I have this ticket:

   [paste full ticket description here]

   Generate a list of research questions that will tell us everything we need
   to know before building this. Do not propose any solutions. Questions only.

3. Wait for the sub-agent to complete and return the questions 4. Extract and store the questions — they will be passed to the next phase

Output: A structured list of research questions (no answers yet)

Phase 2: Research (Questions Only → Research Doc)

Goal: Answer the questions with objective facts from the codebase, without the ticket bleeding into research.

Context isolation: The agent answering questions should see ONLY the questions, not the original ticket. This is the core QRSPI insight — research is objective, ticket-agnostic.

Steps:

1. Spawn a NEW sub-agent (fresh context) with this exact prompt:

   /opsx:explore

   [paste ONLY the research questions from Phase 1]

   Answer each question with facts only. Observe what the codebase does today.
   Do not suggest changes or implementation approaches.

2. Wait for the sub-agent to complete and return the research document 3. Store the research answers — they will inform the design phase

Output: A research document with objective answers to all questions

Phase 3: Design Scaffolding

Goal: Create the OpenSpec change and generate proposal.md and design.md artifacts.

Context isolation: The ticket should NOT be in context during artifact generation to prevent "completion bleed". Spawn a sub-agent with only questions + research.

Steps:

1. Read openspec/config.yaml to extract the rules.design section 2. Read CLAUDE.md or AGENTS.md to extract agent behavior context 3. Spawn a sub-agent with this exact prompt:

   You are generating OpenSpec artifacts based on QRSPI research. You have access
   to the research questions and answers, but NOT the original ticket text. This
   prevents solution bias.

   Research Questions and Answers:
   [paste questions from Phase 1]

   Research Findings:
   [paste research doc from Phase 2]

   OpenSpec Design Rules (from config.yaml):
   [paste the rules.design section verbatim]

   Agent Behavior Context:
   [paste relevant sections from CLAUDE.md/AGENTS.md]

   CRITICAL: You MUST use /opsx commands to create and generate artifacts.
   DO NOT create files or write artifact content yourself. The /opsx commands
   will handle artifact generation following OpenSpec's configured rules.

   Now create the OpenSpec change with proposal and design artifacts:

   1. Run /opsx:new to create the change (OpenSpec will prompt for a slug)
   2. CRITICAL: Capture the change name/slug from the output and use it in all subsequent commands
   3. Run /opsx:continue <change-name> ONCE to generate proposal.md ONLY
   4. Run /opsx:continue <change-name> ONCE to generate design.md ONLY
   5. STOP after design.md - do NOT generate specs or tasks yet

   IMPORTANT: Let /opsx:continue generate proposal.md and design.md using the
   OpenSpec workflow. DO NOT write these files yourself. The /opsx:continue
   command handles artifact generation based on config.yaml rules.

   After design.md is generated (and ONLY proposal.md and design.md exist),
   report completion, the CHANGE NAME, and the path to the design file.

   IMPORTANT: You MUST report the change name explicitly at the end like:
   "Change name: <slug>"

   CRITICAL: STOP AFTER GENERATING DESIGN.MD. DO NOT CONTINUE TO SPECS OR TASKS.
   Your job ends here. The parent agent will handle the checkpoint and Phase 5.
   If you generate specs/* or tasks.md, you will bypass the mandatory design review.

4. Wait for the sub-agent to complete 5. Extract the change name/slug from the sub-agent output (look for "Change name:" or parse from the file path) 6. Store the change name — it will be passed to Phase 5 7. Verify the design.md file exists at the reported path 8. CRITICAL: DO NOT continue to Phase 5 yet. You MUST proceed to Phase 4 checkpoint. 9. Proceed to Phase 4 (mandatory checkpoint)

Output: Generated proposal.md and design.md in openspec/changes/<slug>/

Phase 4: Design Review Checkpoint ⚠️ MANDATORY

Goal: Get human approval before proceeding to task breakdown.

This is the "brain surgery" moment from the QRSPI talk — a correction here costs minutes; the same correction after implementation costs a code review cycle.

CRITICAL: You MUST pause here and wait for user input. DO NOT proceed to Phase 5 without explicit user approval. If you skip this checkpoint, you defeat the entire purpose of QRSPI's separation of design from implementation planning.

Steps:

1. Read the generated design.md file 2. Present it to the user with this framing:

   Design artifact generated. Please review for:

   - Wrong pattern references (did I find the legacy way instead of the current way?)
   - Unresolved assumptions presented as decisions
   - Missing affected systems (any service boundaries not mentioned?)
   - Scope creep (does the design cover more than the ticket?)

   Options:
   (a) Approve — continue to task breakdown
   (b) Request edits — tell me what to change, I'll modify in place
   (c) Manual edit — edit the file yourself, then tell me when ready

3. Wait for user input:

• (a) Approve: Proceed to Phase 5
• (b) Request edits:
• User describes changes
• Make edits to design.md in place
• Show diff of changes
• Re-present for review (repeat until approved)
• (c) Manual edit:
• Wait for user confirmation that edits are complete
• Re-read design.md
• Proceed to Phase 5

CRITICAL: DO NOT PROCEED TO PHASE 5 WITHOUT EXPLICIT USER APPROVAL.

If the user does not explicitly approve (says "looks good", "approve", "continue", etc.), DO NOT move forward. This checkpoint is mandatory - skipping it bypasses the core value of QRSPI methodology.

Phase 5: Specs & Tasks Generation

Goal: Generate delta specs and task breakdown with vertical slicing.

Context isolation: Continue to keep ticket out of context. Spawn a sub-agent with questions + research + approved design.md.

Steps:

1. Read the (possibly user-edited) design.md file from Phase 4 2. Read openspec/config.yaml to extract the rules.spec and rules.tasks sections 3. Read CLAUDE.md or AGENTS.md for agent behavior context 4. Spawn a sub-agent with this exact prompt:

   You are generating OpenSpec specs and tasks based on QRSPI research and an
   approved design. You have access to research and design, but NOT the original
   ticket text.

   CHANGE NAME: <change-name-from-phase-3>

   Research Questions and Answers:
   [paste questions from Phase 1]

   Research Findings:
   [paste research doc from Phase 2]

   Approved Design:
   [paste design.md content]

   OpenSpec Spec Rules (from config.yaml):
   [paste the rules.spec section verbatim]

   OpenSpec Tasks Rules (from config.yaml):
   [paste the rules.tasks section verbatim]

   Agent Behavior Context:
   [paste relevant sections from CLAUDE.md/AGENTS.md]

   CRITICAL: You MUST use /opsx:continue commands to generate artifacts.
   DO NOT generate specs or tasks.md content yourself. The /opsx:continue command
   will handle artifact generation following OpenSpec's configured rules.

   Now generate the remaining OpenSpec artifacts:

   1. Run /opsx:continue <change-name> to generate specs/* (delta specs)
   2. Run /opsx:continue <change-name> to generate tasks.md

   IMPORTANT: Let /opsx:continue generate tasks.md using the OpenSpec workflow.
   DO NOT write tasks.md yourself. The /opsx:continue command handles this.

   After tasks.md is generated, the parent agent will validate vertical slicing
   and add a "## Parallelization Strategy" section if needed.

   After tasks.md is generated, report completion and the path to the tasks file.

5. Wait for the sub-agent to complete 6. Verify specs/* and tasks.md exist at the reported paths 7. Read the generated tasks.md file 8. Validate vertical slicing structure:

VERTICAL SLICING (required for qrspi-apply):

Each slice must deliver an end-to-end testable feature path, NOT a horizontal layer. Structure the work so that after completing Slice 1, you have something demonstrable and testable.

✓ CORRECT - Vertical (end-to-end feature slices):

   Slice 1: Mock API + working frontend (user can see and click, no real data)
   Slice 2: Wire real service layer (now pulls actual data)
   Slice 3: Add database integration (data persists)

✗ WRONG - Horizontal (architectural layers):

   Phase 1: All database migrations
   Phase 2: All service layer changes
   Phase 3: All API endpoints
   Phase 4: All frontend components

Indicators of VERTICAL slicing (correct):

• Each slice has a "Deliverable:" that describes a working, testable feature
• Slices cross architectural boundaries (e.g., a slice touches both CLI and implementation)
• Each slice ends with something demonstrable to a user or stakeholder
• Parallelization is possible with minimal dependencies between slices

Indicators of HORIZONTAL slicing (incorrect):

• Slices are organized by layer: "Database changes", "Service layer", "API routes", "Frontend"
• Deliverables are architectural components, not user-facing features
• Early slices cannot be tested end-to-end without later slices
• Slices have sequential dependencies (must finish layer 1 before layer 2)

Requirements for each slice:

• Deliverable: A working, testable increment (e.g., "CLI with security removed from public API")
• Test: Explicit verification steps showing the slice works end-to-end
• Parallelization: Slices should be independent enough to implement concurrently with minimal blocking
• Checkpoints: Each subtask has a "Test:" line describing verification
• Size: Prefer 3-5 major slices; more than 5 suggests scope is too large
• Duration: Max 2 hours per subtask; break larger work into smaller subtasks

9. If horizontal or mixed slicing detected, automatically convert to vertical slices:

CRITICAL: The qrspi-apply skill requires vertical slicing. If /opsx:continue generated horizontal slices, you MUST restructure them before presenting to the user.

Conversion process:

a) Identify end-to-end feature paths: Look for the smallest complete user-facing feature that touches all relevant architectural layers. For example:

• Instead of: "Slice 1: All API changes" + "Slice 2: All CLI changes"
• Convert to: "Slice 1: CLI help command (CLI + API)" + "Slice 2: CLI list command (CLI + API)"

b) Restructure each slice with these required elements:

• Deliverable: - A working, demonstrable feature (not just "API endpoint exists")
• Test: - Explicit verification showing the end-to-end path works
• Subtasks in markdown checklist format: Each subtask MUST use - [ ] instruction format
• Subtasks that cross layers (e.g., "- [ ] Update API handler" + "- [ ] Wire CLI command" + "- [ ] Add help text")

CRITICAL: Preserve the markdown checklist format (- [ ] ...) for all subtasks. Do NOT use numbered lists (1. 2. 3.) or plain bullets (- without [ ]). The qrspi-apply skill depends on this format to track task completion.

c) Preserve parallelization opportunities: Structure slices to be independent

• Good: "Slice 1: auth flow" and "Slice 2: data export flow" are independent
• Bad: "Slice 1: database schema" must complete before "Slice 2: service layer"

d) Update Parallelization Strategy (if it exists): If the tasks.md already has a "## Parallelization Strategy" section, revise it to reflect the new slice structure (which slices can run in parallel, which have dependencies). Note: If the section doesn't exist, the parent agent will add it in step 10.

e) Write changes to tasks.md: Edit the file in place using the Edit tool

f) Show diff to user: Display what changed and explain why (e.g., "Converted from layer-based to feature-based slices for better parallelization")

10. CRITICAL: Check for and add Parallelization Strategy section:

After vertical slicing is validated/corrected, check if tasks.md contains a "## Parallelization Strategy" section.

If the section is missing or incomplete, add it NOW using the Edit tool to append to the end of tasks.md (after all slices):

   ## Parallelization Strategy

   ### Dependencies (Must Complete First)

   - **Slice X** must wait until Slices Y-Z complete (reason)

   **Independent tasks (can run in parallel):**
   - Slice A and Slice B are independent → can implement simultaneously
   - Slice A and Slice C are independent → can implement simultaneously

   **Sequential dependencies:**
   - Slice D must complete before Slice E because (reason)

   **Critical path:**
   Slice X → Slice Y (reason for dependency)

   **Recommended implementation order:**
   1. Implement Slices A, B, C in parallel (description)
   2. Implement Slice D (description)
   3. Implement Slice E (description)

Keep it simple and focused on:

• Which slices can run in parallel (and why they're independent)
• Which slices must be sequential (and the dependency reason)
• Recommended order for implementation

DO NOT overcomplicate with excessive detail or edge cases.

If the section exists but was part of a horizontal-to-vertical conversion (step 9d), verify it accurately reflects the new vertical slice structure and update if needed.

11. Present tasks.md to the user for final approval:

   Specs and tasks generated.

   [If auto-converted:]
   ✓ Converted task structure to vertical slices for better parallelization
   and incremental delivery. Each phase now delivers an end-to-end testable feature.

   [If already vertical:]
   ✓ Task structure follows vertical slicing

   Options:
   (a) Approve — planning complete, ready for implementation
   (b) Request changes — tell me what to adjust
   (c) Manual edit — edit tasks.md yourself, then confirm

12. Handle user input (same flow as Phase 4: approve, request edits, or manual edit)

CRITICAL: DO NOT PROCEED TO PHASE 6 WITHOUT EXPLICIT USER APPROVAL.

Wait for the user to explicitly approve the tasks.md structure. If they don't respond or the conversation ends, stop here - do not auto-proceed to completion.

Output: Generated specs/* and tasks.md in openspec/changes/<slug>/

Phase 6: Completion

After tasks.md is approved:

1. Announce completion:

   ✅ QRSPI planning phase complete.

   Change name: <change-name-from-phase-3>

   Generated artifacts:
   - openspec/changes/<change-slug>/proposal.md
   - openspec/changes/<change-slug>/design.md
   - openspec/changes/<change-slug>/specs/*
   - openspec/changes/<change-slug>/tasks.md

   Next steps:
   1. Review the artifacts one more time if needed
   2. Run `/clear` to start fresh context for implementation
   3. Run `/opsx:apply <change-name>` to begin implementation

   This allows you to create multiple specs before implementation and
   maintains proper context management.

2. Exit the skill — do NOT automatically invoke /opsx:apply

Key Principles

Context Isolation (QRSPI Core)

The two-context-window pattern is essential:

• Questions generation: Ticket is IN context → generates questions
• Research answers: Ticket is OUT of context, only questions IN context → objective facts

This prevents "solution-first thinking" where the agent jumps to implementation ideas during research.

Human Checkpoints

Two mandatory review gates:

1. After design.md: Catch wrong patterns, missing systems, scope issues 2. After tasks.md: Verify vertical slicing, phase ordering

These are the highest-leverage moments for corrections — before any code is written.

Vertical Slicing Enforcement

The skill should actively check for and discourage horizontal (layer-by-layer) slicing. Each phase should deliver a testable end-to-end slice.

No Automatic Implementation

The skill stops after planning. The user explicitly runs /opsx:apply when ready. This allows:

• Multiple specs to be created before any implementation starts
• Context clearing between planning and implementation
• User control over when implementation begins

Error Handling

If OpenSpec commands fail:

• Surface the error to the user
• Ask if they want to retry or abort
• Do not continue to next phase on failure

If sub-agent fails:

• Show the error from the sub-agent
• Ask user if they want to retry that phase or provide manual input
• Allow manual fallback (user provides questions/research directly)

If design.md or tasks.md is missing after generation:

• Check if the file exists at expected path
• If missing, ask user to verify OpenSpec configuration
• Provide the expected path for manual inspection

Configuration Requirements

This skill assumes the project has:

1. OpenSpec installed and initialized (openspec/ directory exists) 2. openspec/config.yaml configured (ideally via accelint-onboard-openspec skill) 3. Expanded OpenSpec profile enabled 4. AGENTS.md or CLAUDE.md defining agent behavior (ideally via accelint-onboard-agent skill)

If any of these are missing, guide the user to set them up before running this skill.

NEVER Do This

NEVER generate artifacts yourself — Always use /opsx commands (new, continue) to create proposal.md, design.md, specs/*, and tasks.md. The /opsx workflow handles artifact generation following OpenSpec's configured rules. If you write artifacts directly, you bypass the project's design/spec/task rules and create inconsistent outputs.

NEVER generate tasks.md from scratch — Always use /opsx:continue to create the initial tasks.md. However, you MUST restructure it if the generated output uses horizontal slicing instead of vertical slicing. The qrspi-apply skill requires vertical slicing. If /opsx:continue generates horizontal slices (organized by architectural layer), convert them to vertical slices (end-to-end feature deliverables) following the validation guidance in Phase 5 Step 10. When restructuring, preserve the markdown checklist format (- [ ] task) — do NOT convert to numbered lists or plain bullets.

NEVER use numbered lists or plain bullets in tasks.md — All subtasks must use markdown checklist format: - [ ] instruction. The qrspi-apply skill tracks completion by checking/unchecking these boxes. If you see numbered lists (1. 2. 3.) or plain bullets (- without [ ]), convert them to - [ ] ... format.

NEVER overcomplicate Parallelization Strategy — Keep it simple: list which slices can run in parallel, which have sequential dependencies, and recommended implementation order. Don't add excessive detail about every possible edge case or coordination mechanism. The example in this skill shows the right level of detail.

NEVER continue to specs/tasks without design approval — Phase 4 checkpoint is mandatory. If you skip the design review and generate tasks immediately, you miss the "brain surgery" moment where corrections are cheap. Fixing design issues after code is written costs review cycles and rework.

NEVER let the ticket leak into research/design context — Questions are generated WITH ticket context, but research and design must see ONLY questions + research answers. If the ticket stays in context during research, the agent will propose solutions instead of gathering objective facts about the current codebase.

NEVER skip the mandatory checkpoints — Phase 4 (after design.md) and Phase 5 Step 12 (after tasks.md) require explicit user approval before continuing. If you proceed without waiting for user confirmation ("looks good", "approve", "continue"), you bypass the core value of QRSPI: cheap corrections at the design stage. The "brain surgery" moment is when design is reviewed BEFORE specs/tasks are generated. Skipping checkpoints defeats the entire methodology.

Example Usage

User: I want to plan this ticket using QRSPI:

## ATI-12: smart-ls CLI tool
Create a CLI tool that returns structured directory listings as JSON...

Changelog

[1.2.1] - 2026-05-07

Fixed

• CRITICAL: Input validation in Phase 0 — skill now checks if user provided a ticket or idea before proceeding
• Issue: When invoked with no arguments/content, skill attempted to use internal examples to generate artifacts
• Fix: Added validation step in Phase 0 that checks for user-provided input and exits with helpful prompt if missing
• Rationale: Prevents skill from hallucinating requirements or using unrelated example data
• User experience: Clear error message explaining what input is needed (ticket ID, feature request, or problem statement)

Version

• Bumped from 1.2.0 → 1.2.1

[1.2.0] - 2026-05-05

Fixed

• CRITICAL: Agents bypassing /opsx commands — Added explicit CRITICAL/IMPORTANT notes to prevent agents from generating artifacts directly
• Issue: Sub-agents were sometimes writing tasks.md, proposal.md, or design.md content themselves instead of delegating to /opsx:continue commands
• Impact: When agents generate artifacts directly, they bypass OpenSpec's configured rules and create inconsistent outputs (e.g., tasks.md missing checklist format)
• Fix: Added CRITICAL blocks in Phase 3 and Phase 5 prompts stating "DO NOT generate content yourself. The /opsx:continue command handles artifact generation."
• Rationale: /opsx commands follow project-specific rules in config.yaml; direct generation ignores these rules

• CRITICAL: Markdown checklist format enforcement — Added explicit validation for - [ ] task format in tasks.md
• Issue: When restructuring tasks.md from horizontal to vertical slicing, agents might lose the markdown checklist format and use numbered lists or plain bullets
• Impact: qrspi-apply skill depends on - [ ] ... format to track task completion; other formats break the workflow
• Fix: Added CRITICAL note in Step 10b requiring markdown checklist format preservation during restructuring
• Added anti-pattern: "NEVER use numbered lists or plain bullets in tasks.md"

• CRITICAL: Agents skipping mandatory checkpoints — Strengthened enforcement of Phase 4 and Phase 5 checkpoints
• Issue: Agents were sometimes not pausing after design.md generation and proceeding directly to specs/tasks, bypassing the design review checkpoint
• Impact: Defeats the "brain surgery" moment where design corrections are cheap; skipping review means fixing issues after code is written (expensive)
• Fix: Added multiple CRITICAL blocks enforcing stops:
• Phase 3 sub-agent prompt: "STOP AFTER GENERATING DESIGN.MD. Your job ends here."
• Phase 3 Step 8: "DO NOT continue to Phase 5 yet. You MUST proceed to Phase 4 checkpoint."
• Phase 4 header: "You MUST pause here and wait for user input."
• Phase 4 end: "DO NOT PROCEED TO PHASE 5 WITHOUT EXPLICIT USER APPROVAL."
• Phase 5 Step 12: "DO NOT PROCEED TO PHASE 6 WITHOUT EXPLICIT USER APPROVAL."
• Updated workflow diagram with visual ⚠️ checkpoint markers
• Added anti-pattern: "NEVER skip the mandatory checkpoints"

• Parallelization Strategy overcomplicated — Simplified guidance with concrete template and "DO NOT overcomplicate" warning
• Issue: Agents were sometimes generating overly detailed parallelization sections with excessive edge cases
• Fix: Added simple template format showing the right level of detail: dependencies, parallel opportunities, recommended order
• Added explicit checkpoint (Step 9) to verify Parallelization Strategy exists and follows the simple format
• Example template now matches the format from actual working changes

Added

• NEVER Do This section — Added anti-pattern list reinforcing key principles
• NEVER generate artifacts yourself (always use /opsx commands)
• NEVER write tasks.md content directly (breaks checklist format)
• NEVER overcomplicate Parallelization Strategy (keep it simple)
• NEVER continue to specs/tasks without design approval (skips "brain surgery" checkpoint)
• NEVER let ticket leak into research/design context (causes solution-first thinking)
• Rationale: Explicit anti-patterns help agents avoid common failure modes

Changed

• Phase 5 vertical slicing guidance — Moved detailed vertical slicing guidance from sub-agent prompt to validation step
• Issue: Long guidance in sub-agent prompt wasn't preventing agents from generating artifacts directly, and removing it entirely lost important context for validation
• Fix: Added brief CRITICAL notes in sub-agent prompt delegating to /opsx:continue; restored full vertical slicing guidance to Step 8 (validation phase)
• Rationale: Validation step needs detailed criteria to restructure horizontal slices; sub-agent prompt just needs to delegate to /opsx:continue
• Validation logic (Steps 8-10) now includes comprehensive examples and requirements for restructuring

Version

• Bumped from 1.1.0 → 1.2.0

[1.1.0] - 2026-05-01

Fixed

• CRITICAL: Change name tracking across phases — sub-agents now explicitly pass change name to all /opsx:continue calls
• Issue: When multiple specs exist in openspec/ folder, /opsx:continue without a change name parameter would incorrectly target the wrong spec
• Fix: Phase 3 now instructs sub-agent to capture and report the change name after /opsx:new; Phase 5 sub-agent receives this name and uses /opsx:continue <change-name> for all artifact generation
• Impact: Prevents cross-contamination when working on multiple specs; ensures all artifacts are generated for the correct change
• Completion message now includes the change name for user reference when running /opsx:apply <change-name>

Fixed

• CRITICAL: Phase 3 flow control — explicitly prevent generating specs/tasks during design phase
• Issue: Sub-agent was instructed to run /opsx:continue multiple times in sequence, generating proposal.md, design.md, specs/*, and tasks.md all at once
• Fix: Added explicit STOP instruction after design.md generation; specs and tasks now generated only in Phase 5 after human design review
• Rationale: Design checkpoint is the "brain surgery" moment — must review design before generating implementation artifacts

• Vertical slicing guidance clarity — strengthened instructions with concrete examples and explicit anti-patterns
• Issue: Generated tasks.md still used horizontal (layer-by-layer) slicing despite guidance
• Fix: Added side-by-side ✓/✗ examples, explicit "Deliverable:" requirement, and detailed indicators for detecting horizontal vs vertical structure
• Reference: Real vertical example at /Users/bryankizer/Documents/auditkit-cli/openspec/changes/remove-security-ruleset/tasks.md
• Improvement: Each slice now explicitly requires a testable end-to-end deliverable with verification steps

Changed

• Workflow overview diagram — clarified that design phase outputs proposal.md + design.md only, with explicit [STOP HERE] marker
• Rationale: Visual reinforcement of the two-phase artifact generation (design artifacts → review → task artifacts)

Added

• Parallelization Strategy section — tasks.md now includes explicit section mapping dependencies and parallel opportunities
• Content: Which slices must complete first, which can run in parallel, why they're independent, final integration steps
• Rationale: Makes execution strategy explicit for developers/agents implementing the change

Changed

• Removed manual checkpoint for vertical slice conversion — skill now ALWAYS automatically converts horizontal slicing to vertical slicing
• Rationale: Vertical slicing is always the correct approach per QRSPI methodology; asking users to choose adds friction without value
• Improvement: User experience is now smoother — one less decision point in the workflow

• Added parallelization consideration to vertical slicing logic — slices structured to be independent enough for concurrent implementation
• Rationale: Properly structured vertical slices can be implemented by parallel agents/sub-agents, improving development velocity
• Improvement: Tasks are now explicitly designed with parallelization in mind

Version

• Bumped from 1.0.0 → 1.1.0

Accelint QRSPI Propose

Automate the planning phase of spec-driven development. This skill walks you through Questions → Research → Design → Structure (QRSPI), with mandatory review checkpoints before code gets written.

What This Does

Takes a ticket or feature request and produces a complete OpenSpec change:

• Research questions and answers (what we need to know before building)
• Design document (decisions, trade-offs, architectural choices)
• Delta specs (what changes in the system)
• Task breakdown (vertical slices for implementation)

The skill stops after planning. You run /opsx:apply when you're ready to implement.

When to Use This

Invoke this skill when:

• Planning a new feature or change before writing code
• You have a ticket/issue that needs design work
• You want to follow QRSPI methodology for spec-driven development
• You need human-in-the-loop checkpoints during planning

Trigger phrases:

• "plan this ticket using QRSPI"
• "start a QRSPI workflow"
• "use QRSPI to plan this change"
• "create spec-driven change"

Prerequisites

This skill requires OpenSpec's expanded workflows: explore, new, and continue.

Check if you have them:

openspec config list

Look for these in the workflows: section:

• explore
• new
• continue

Enable if missing:

openspec config profile
# Select "expanded" from the list
openspec update

The skill will check this before running and guide you if configuration is needed.

How It Works

The Five-Phase Workflow

┌─────────────────────────────────────────────────────────────────┐
│  Phase          Context              Output          Checkpoint │
├─────────────────────────────────────────────────────────────────┤
│  Questions      Ticket only          Questions       —          │
│  Research       Questions only       Research doc    —          │
│  Design         Q+R (NO ticket)      design.md       ✓ REVIEW   │
│  Specs/Tasks    Q+R+design           specs/*, tasks  ✓ REVIEW   │
│  Done           —                    Exit            —          │
└─────────────────────────────────────────────────────────────────┘

Phase 1: Questions

Spawn a sub-agent that sees only the ticket and generates research questions. No solutions, just questions about what we need to know.

Phase 2: Research

A fresh sub-agent (new context) sees only the questions and answers them with facts from the codebase. The ticket is kept out of context to prevent "solution-first thinking".

Phase 3: Design Scaffolding

Create the OpenSpec change and generate proposal.md and design.md. A sub-agent receives questions + research (NO ticket) and creates artifacts following your project's config.yaml rules.

Mandatory checkpoint: You review the design before continuing. This is the "brain surgery" moment. Corrections here are cheap; corrections after code is written are expensive.

Phase 4: Specs & Tasks

Generate delta specs and task breakdown. A sub-agent receives questions + research + approved design (NO ticket) and creates remaining artifacts with emphasis on vertical slicing.

Mandatory checkpoint: You review the task breakdown to ensure vertical slicing (not layer-by-layer).

Phase 5: Completion

The skill reports completion and exits. You decide when to run /opsx:apply to start implementation.

Key Concepts

Context Isolation

The ticket text is deliberately kept out of context after Phase 1. This is the core QRSPI insight:

• Questions (ticket IN): "What do we need to know?"
• Research (ticket OUT): Objective facts only, no solution bias
• Design (ticket OUT): Decisions based on research, not ticket suggestions
• Tasks (ticket OUT): Structure based on design, not original request

This prevents "solution bias" where the ticket's suggested solution biases the artifacts.

Human Checkpoints

Two mandatory review gates:

1. After design.md: Catch wrong patterns, missing systems, scope issues 2. After tasks.md: Verify vertical slicing, phase ordering

You can:

• Approve and continue
• Request edits (agent modifies in place)
• Edit manually (you modify, confirm when done)

The skill won't proceed without your explicit approval.

Vertical Slicing

Task phases should deliver testable end-to-end slices, not layer-by-layer work:

Good (vertical):

Phase 1: Basic detection working end-to-end (hardcoded pattern, manual test)
Phase 2: Add configurable patterns (config file, integration test)
Phase 3: Add CLI output formatting (JSON/text, E2E test)

Bad (horizontal):

Phase 1: All database changes
Phase 2: All service layer changes
Phase 3: All API changes
Phase 4: All frontend changes

The skill checks for horizontal slicing and warns you if detected.

No Automatic Implementation

The skill stops after planning. This allows:

• Creating multiple specs before implementation
• Clearing context between planning and coding
• User control over when implementation begins

Run /clear and /opsx:apply when you're ready to start building.

Example Usage

/accelint-qrspi-propose

## Issue #42: Expand array chaining detection

The current filter-then-map rule only catches one pattern.
We need to detect all array method chains that create
intermediate arrays: map-filter, filter-forEach, 3+ chains, etc.

[Skill activates]

Agent: Checking OpenSpec configuration...
✓ Expanded workflows enabled

Generating research questions...
[Questions phase completes]

Answering research questions from codebase...
[Research phase completes]

Creating OpenSpec change and design artifact...
[Design generated]

Design artifact generated. Please review for:
- Wrong pattern references
- Unresolved assumptions
- Missing affected systems
- Scope creep

Options:
(a) Approve — continue to task breakdown
(b) Request edits — tell me what to change
(c) Manual edit — edit the file yourself

User: (a)

[Specs and tasks generated]

Specs and tasks generated. Phase structure: vertical ✓

✅ QRSPI planning phase complete.

Generated artifacts:
- openspec/changes/expand-array-chaining-detection/proposal.md
- openspec/changes/expand-array-chaining-detection/design.md
- openspec/changes/expand-array-chaining-detection/specs/*
- openspec/changes/expand-array-chaining-detection/tasks.md

Next steps:
1. Review the artifacts one more time if needed
2. Run /clear to start fresh context for implementation
3. Run /opsx:apply to begin implementation

Configuration Requirements

The skill assumes your project has:

1. OpenSpec installed (openspec/ directory exists) 2. config.yaml configured with rules for design, specs, tasks (ideally via accelint-onboard-openspec) 3. Expanded profile enabled (workflows include explore, new, continue) 4. Agent behavior defined (AGENTS.md or CLAUDE.md exists, ideally via accelint-onboard-agent)

If anything is missing, the skill will guide you through setup.

Error Handling

If OpenSpec commands fail, the skill surfaces the error and lets you retry or abort. It won't continue automatically.

If a sub-agent fails, you'll see the error and can retry that phase or provide manual input (you write the questions/research yourself).

If artifacts are missing after generation, the skill checks file paths and provides the expected locations for manual inspection.

Tips

Start with clear tickets. The better the input, the better the questions. Include constraints, performance targets, and existing patterns to follow.

The design checkpoint is your leverage point. A 5-minute review here prevents hours of rework later.

If the skill warns about horizontal slicing, listen. Layer-by-layer development hides integration issues until the end.

Don't rush to implementation. It's fine to create multiple specs before coding. Planning artifacts are cheap; code is expensive.

Related Skills

• accelint-onboard-openspec - Set up OpenSpec configuration for your project
• accelint-onboard-agent - Create AGENTS.md with behavior rules
• opsx:apply - Implement tasks from the generated change
• opsx:verify - Verify implementation matches artifacts before archiving