Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Browser & automation

ring:executing-plans

Controlled plan execution with human review checkpoints - loads plan, executes in batches, pauses for feedback. Supports one-go (autonomous) or batch modes.

LerianStudio · AI review on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add LerianStudio/ring --skill ring:executing-plans

About this skill


name: ring:executing-plans description: | Controlled plan execution with human review checkpoints - loads plan, executes in batches, pauses for feedback. Supports one-go (autonomous) or batch modes.

trigger: |

  • Have a plan file ready to execute
  • Want human review between task batches
  • Need structured checkpoints during implementation

skip_when: |

  • Same session with independent tasks → use ring:subagent-driven-development
  • No plan exists → use ring:writing-plans first
  • Plan needs revision → use ring:brainstorming first

sequence: after: [ring:writing-plans, ring:pre-dev-task-breakdown]

related: similar: [ring:subagent-driven-development]

Executing Plans

Overview

Load plan, review critically, choose execution mode, execute tasks with code review.

Core principle: User chooses between autonomous execution or batch execution with human review checkpoints.

Two execution modes:

  • One-go (autonomous): Execute all batches continuously with code review, report only at completion
  • Batch (with review): Execute one batch, code review, pause for human feedback, repeat

Announce at start: "I'm using the ring:executing-plans skill to implement this plan."

The Process

Step 1: Load and Review Plan

  1. Read plan file
  2. Review critically - identify any questions or concerns about the plan
  3. If concerns: Raise them with your human partner before starting
  4. If no concerns: Create TodoWrite and proceed to Step 2

Step 2: Choose Execution Mode (MANDATORY)

⚠️ THIS STEP IS NON-NEGOTIABLE. You MUST use AskUserQuestion before executing ANY tasks.

Ask: "How would you like to execute this plan?" Options: (1) One-go (autonomous) - all batches with code review, no human review until completion (2) Batch (with review) - pause for human review after each batch

Based on response: One-go → Steps 3-4 loop until done | Batch → Steps 3-5 loop

Why AskUserQuestion is Mandatory (Not "Contextual Guidance")

This is a structural checkpoint, not optional UX polish.

User saying "don't wait", "don't ask questions", or "just execute" does NOT skip this step because:

  1. Execution mode affects architecture - One-go vs batch determines review checkpoints, error recovery paths, and rollback points
  2. Implicit intent ≠ explicit choice - "Don't wait" might mean "use one-go" OR "ask quickly and proceed"
  3. AskUserQuestion takes 3 seconds - It's not an interruption, it's a confirmation
  4. Emergency pressure is exactly when mistakes happen - Structural gates exist FOR high-pressure moments

Common Rationalizations That Mean You're About to Violate This Rule:

RationalizationReality
"User intent is crystal clear"Intent is not the same as explicit selection. Ask anyway.
"This is contextual guidance, not absolute law"Wrong. It says MANDATORY. That means mandatory.
"Asking would violate their 'don't ask' instruction"AskUserQuestion is a 3-second structural gate, not a conversation.
"Skills are tools, not bureaucratic checklists"This skill IS the checklist. Follow it.
"Interpreting spirit over letter"The spirit IS the letter. Use AskUserQuestion.
"User already chose by saying 'just execute'"Verbal shorthand ≠ structured mode selection. Ask.

If you catch yourself thinking any of these → STOP → Use AskUserQuestion anyway.

Step 2.5: Context Switching for Multi-Module Plans

If plan has tasks with target: and working_directory: fields:

  1. Track current module:

    current_module = None
    current_directory = "."
    
  2. Before each task, check for context switch:

    IF task.target != current_module AND current_module != None:
      # Prompt user for confirmation
      AskUserQuestion:
        question: "Switching to {task.target} module at {task.working_directory}. Continue?"
        header: "Context"
        options:
          - label: "Continue"
            description: "Switch to {task.target} and execute task"
          - label: "Skip task"
            description: "Skip this task and continue with next"
          - label: "Stop"
            description: "Stop execution for manual review"
    
      IF answer == "Continue":
        current_module = task.target
        current_directory = task.working_directory
      ELIF answer == "Skip":
        Mark task as skipped → proceed to next
      ELSE:
        Stop execution → report progress
    
  3. Load module-specific PROJECT_RULES.md:

    IF {task.working_directory}/PROJECT_RULES.md exists:
      Instruct agent to read module-specific rules
      Module rules override root rules
    
  4. Pass working directory to agent:

    Task(
      subagent_type=task.agent,
      prompt="Working directory: {task.working_directory}
    
      Before executing, cd to the working directory:
      cd {task.working_directory}
    
      If PROJECT_RULES.md exists in this directory, read and follow it.
    
      {task.prompt}"
    )
    

Optimization: To minimize context switches, batch tasks by module when possible:

  • Original: [backend, frontend, backend, frontend]
  • Optimized: [backend, backend, frontend, frontend]
  • Only reorder if no dependencies between modules

Step 3: Execute Batch

Default: First 3 tasks

Agent Selection: Backend Go → ring:backend-engineer-golang | Backend TS → ring:backend-engineer-typescript | Frontend → ring:frontend-bff-engineer-typescript | Infra → ring:devops-engineer | Testing → ring:qa-analyst | Reliability → ring:sre

For each task: Check context switch (Step 2.5) → Mark in_progress → Dispatch to agent with working_directory → Follow plan steps exactly → Run verifications → Mark completed

Step 4: Run Code Review

After each batch, REQUIRED: Use ring:requesting-code-review (all 7 reviewers in parallel)

Handle by severity:

  • Critical/High/Medium: Fix immediately (no TODO) → re-run all 7 reviewers
Read the complete source ↗