From arn-code
This skill should be used when the user says "batch planning", "batch plan", "arness batch planning", "arn-code-batch-planning", "plan multiple features", "plan all features", "plan unblocked features", "plan the backlog", "plan from backlog", "batch spec and plan", "plan next features", "sequential planning", "multi-feature plan", "plan the next batch", "plan these features", "batch plan GitHub issues", "batch plan from Jira", "plan issues in batch", or wants to plan multiple features from the greenfield Feature Tracker, GitHub issues, or Jira issues in a single session. Pre-analyzes all selected features in parallel, then guides sequential spec review with pipelined plan generation. This skill is typically invoked directly or after arn-brainstorming completes and chains to arn-code-batch-implement upon completion. For single-feature planning, arn-planning is the correct entry point.
npx claudepluginhub appsvortex/arness --plugin arn-codeThis skill uses the workspace's default tool permissions.
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Searches prompts.chat for AI prompt templates by keyword or category, retrieves by ID with variable handling, and improves prompts via AI. Use for discovering or enhancing prompts.
Designs and optimizes AI agent action spaces, tool definitions, observation formats, error recovery, and context for higher task completion rates.
Plan multiple features in a single session with parallel pre-analysis and pipelined plan generation. Supports features from greenfield Feature Tracker (F-NNN), GitHub issues, Jira issues, or plain descriptions. Pre-analyzes all selected features in parallel using arn-code-batch-analyzer agents to generate draft specs, then guides the user through sequential review. Plans are generated in the background while the user reviews the next spec.
This skill is a sequencer. It MUST NOT duplicate sub-skill logic. All pipeline work is done by the invoked skills and agents (arn-code-batch-analyzer, arn-code-feature-spec, arn-code-feature-planner, arn-code-save-plan). Arness-code-batch-planning handles: source detection, feature selection, parallel pre-analysis orchestration, sequential spec review, pipelined plan generation, plan review, and chaining.
Pipeline position:
Sources:
arn-spark (greenfield) -> feature-backlog.md ─┐
GitHub issues ─────────────────────────────────┤
Jira issues ───────────────────────────────────┤
v
**arn-code-batch-planning**
|
+-- Step 2.5: scope assessment (score each feature → swift/standard/thorough)
+-- Step 2.6: generate SWIFT/STANDARD plans (auto, no review)
+-- Step 2.7: parallel arn-code-batch-analyzer (thorough only → draft specs)
+-- Step 3: per thorough feature: arn-code-feature-spec (resume from draft)
+-- Step 3.5: per thorough feature: plan review → save-plan
|
v
arn-code-batch-implement
Read ${CLAUDE_PLUGIN_ROOT}/skills/arn-code-ensure-config/references/ensure-config.md and follow its instructions. This guarantees a user profile exists and ## Arness is configured with Arness Code fields before proceeding.
After configuration is ensured, extract the following from ## Arness:
github, jira, or none)Batch planning supports multiple feature sources. Check them in order — the first match determines the primary source.
Read the backlog-selection reference: ${CLAUDE_PLUGIN_ROOT}/skills/arn-code-batch-planning/references/backlog-selection.md. Follow its procedure to scan the Feature Tracker and identify unblocked features.
If greenfield backlog exists with 2+ unblocked features: Proceed to Step 2 with greenfield features (input_type: greenfield for each).
If greenfield backlog exists with exactly 1 unblocked feature:
Inform the user: "Only 1 unblocked feature found: F-XXX [Feature Name]. Batch planning is designed for 2+ features."
Ask (using AskUserQuestion):
"How would you like to proceed?"
Options:
If Plan this feature: invoke Skill: arn-code:arn-planning with the F-XXX reference. Exit batch-planning.
If Proceed with batch anyway: continue to Step 2 with the single feature pre-selected.
If Exit: STOP.
If greenfield backlog exists with zero unblocked features:
Inform the user: "No unblocked features found. All pending features have incomplete dependencies." Present the summary counts.
Ask (using AskUserQuestion):
"No features are available for batch planning. What would you like to do?"
Options:
If Switch: invoke Skill: arn-code:arn-planning. Exit batch-planning.
If Exit: STOP.
If no greenfield Feature Tracker exists (no Vision directory field, or no feature-backlog.md) BUT Issue tracker is github or jira:
Ask (using AskUserQuestion):
"No greenfield feature backlog found, but [GitHub/Jira] issues are available. How would you like to select features?"
Options:
If Browse issues:
gh issue list --state open --limit 20 --json number,title,labelsgithub_issue or jira_issueIf Switch: invoke Skill: arn-code:arn-planning. Exit.
If Exit: STOP.
If no greenfield backlog AND no Issue tracker configured:
Inform the user: "Batch planning requires either a greenfield feature backlog or an issue tracker (GitHub/Jira). Run arn-brainstorming to set up the greenfield pipeline, or configure an issue tracker in ## Arness." Offer: "Or run arn-planning to plan a single feature by description." STOP.
Present the unblocked features in a table sorted by phase then priority:
Unblocked features ready for planning:
| # | ID | Feature | Priority | Phase | Deps |
|---|------|---------|----------|-------|------|
| 1 | F-001 | [Name] | Must-have | Foundation | None |
| 2 | F-003 | [Name] | Should-have | Core | F-001 |
| ... | ... | ... | ... | ... | ... |
Also show summary: "[total] features in tracker, [unblocked] unblocked, [in-progress] in progress, [done] done."
If 4 or fewer unblocked features:
Ask (using AskUserQuestion, multiSelect: true):
"Which features would you like to plan for batch implementation? Select all that apply."
Options: list each unblocked feature as F-XXX: [Feature Name]
If more than 4 unblocked features:
Use layered selection to stay within the 4-option AskUserQuestion limit.
First, ask (using AskUserQuestion):
"There are [N] unblocked features. How would you like to select?"
Options:
If All unblocked features: select all, proceed to Step 2.5.
If Let me choose: present features in groups of 4 using sequential AskUserQuestion calls (multiSelect: true). After each group, ask if the user wants to select from the next group or proceed with current selections. Continue until all groups are offered or the user says proceed.
After feature selection is confirmed, inform the user about the batch workflow:
"Batch planning workflow: After all features are planned, the specs and plans will be committed to a new branch, pushed, and a PR will be opened to merge them into main. This is required before batch implementation — workers need the plans on main to find them. You'll be asked to confirm the PR merge before any implementation begins."
If Git is no: instead inform: "Plans will be saved locally. Note: batch implementation requires git — you can implement features one at a time with /arn-implementing."
Score each selected feature to determine its ceremony tier. This is a lightweight assessment using only the feature description and pattern documentation — no codebase reading required. The same scope router used by arn-planning (Step 3C) is applied here per feature.
Read (if not already loaded):
<code-patterns-dir>/architecture.md<code-patterns-dir>/code-patterns.md${CLAUDE_PLUGIN_ROOT}/skills/arn-planning/references/scope-router-criteria.mdFor each selected feature, apply the scope router criteria from the reference:
Show the results table:
Scope Assessment: [N] features scored
| # | ID | Feature | Score | Tier | Key Factor |
|---|------|---------|-------|------|-----------|
| 1 | F-001 | [Name] | [N] | swift | [one-sentence rationale] |
| 2 | F-003 | [Name] | [N] | standard | [one-sentence rationale] |
| 3 | F-005 | [Name] | [N] | thorough | [one-sentence rationale] |
Do NOT present individual criterion scores (per scope-router-criteria.md: "This assessment is internal — do not present the scoring table to the user"). Present only the recommended tier and a one-sentence rationale.
Show pipeline summary:
Pipeline routing:
[N] swift — workers plan + execute autonomously (no interactive review)
[M] standard — workers plan + execute autonomously (no interactive review)
[K] thorough — interactive spec review below, then workers execute
Ask (using AskUserQuestion):
"Tier assignments look right?"
Options:
If Looks good: proceed to Step 2.6.
If Adjust tiers: for each feature the user wants to change, ask which tier to assign (swift, standard, or thorough). No warning is needed for downgrades — the recommendation is advisory per scope-router-criteria.md rule 4. After adjustments, re-display the final table and proceed.
For features assigned to swift or standard tiers, generate plan artifacts immediately. These features skip the interactive spec review — batch-implement workers will read these plans and handle execution autonomously.
Read the plan templates:
${CLAUDE_PLUGIN_ROOT}/skills/arn-code-swift/references/swift-plan-template.md (for swift features)${CLAUDE_PLUGIN_ROOT}/skills/arn-code-standard/references/standard-plan-template.md (for standard features)For each swift feature:
SWIFT_<kebab-case-name> (from feature name)mkdir -p <plans-dir>/SWIFT_<name>/SWIFT_<name>.md following the swift plan template, populated from:
For each standard feature:
STANDARD_<kebab-case-name> (from feature name)mkdir -p <plans-dir>/STANDARD_<name>/STANDARD_<name>.md following the standard plan template, populated from:
If greenfield source: Update the Feature Tracker status to in-progress for each swift/standard feature.
Show each generated plan to the user with a brief summary:
Swift/Standard Plans Generated: [N] features
1. SWIFT_<name>.md — [1-2 sentence summary of scope, files, approach]
2. STANDARD_<name>.md — [1-2 sentence summary of scope, key requirements, files]
...
For each plan, show: the tier, problem statement (or scope summary), files to modify, and key patterns that will be followed. This gives the user a quick sanity check without full interactive exploration.
Ask (using AskUserQuestion):
"Review these plans before proceeding?"
Options:
If Looks good: proceed to Step 2.7.
If Review one: present the plans as options (max 4, layered if more). When user selects a plan, show its full content. Ask:
"What would you like to do with this plan?"
Options:
If Approve: return to the plan selection (for reviewing another) or proceed. If Edit: let the user modify the plan, write updated version. Return to selection. If Upgrade to thorough: move this feature from the swift/standard list to the thorough list. It will go through Step 2.7 pre-analysis and Step 3 interactive review.
If Adjust tiers: return to Step 2.5d (tier override gate) with current assignments.
After all reviews complete, proceed to Step 2.7.
If no features were assigned to the thorough tier, skip this step entirely and proceed to Step 3.
Pre-generate draft specs for thorough features only using arn-code-batch-analyzer agents. Swift and standard features already have plan artifacts from Step 2.6 and do not need pre-analysis.
Show progress:
Pre-analyzing [K] thorough features in parallel...
(Swift and standard features already have plans — skipping pre-analysis for those.)
For each thorough feature, spawn a arn-code-batch-analyzer agent with:
run_in_background: true${CLAUDE_PLUGIN_ROOT}/skills/arn-code-feature-spec/references/feature-spec-template.md${CLAUDE_PLUGIN_ROOT}/skills/arn-code-feature-spec/references/greenfield-loading.mdALL agents MUST be spawned in a SINGLE message for true parallelism.
Wait for all agents to complete. As each completes, report:
Pre-analysis complete: F-XXX [Name] (draft spec written)
If any agent fails: Retry that specific feature's batch-analyzer (up to 2 retries). If it still fails after 3 total attempts, pause and inform the user:
"Pre-analysis failed for F-XXX [Name] after 3 attempts: [error details]"
Ask (using AskUserQuestion):
"How would you like to handle this?"
Options:
Never silently fall back to a degraded flow. The user must always know what happened and explicitly choose how to proceed.
After all agents complete, show summary:
[K] draft specs ready for thorough features. Starting interactive review.
Proceed to Step 3.
If no features were assigned to the thorough tier, skip this step and proceed to Step 3.5.
Show the plan:
Batch Planning: [N] features selected
Order: F-XXX -> F-YYY -> F-ZZZ -> ...
For each selected feature, sequentially:
Reviewing feature [current/total]: F-XXX [Feature Name]
─────────────────────────────────────────────────────
If the source is greenfield: update the Feature Tracker status to in-progress for this feature. Re-write feature-backlog.md with the updated tracker.
Revert on failure: If this feature is later skipped (via error handling) or the batch is aborted, revert the feature's status from in-progress back to pending before proceeding.
Invoke Skill: arn-code:arn-code-feature-spec with the feature context.
Feature-spec will detect the pre-built DRAFT_FEATURE_*.md file (written by the batch-analyzer in Step 2.7) and offer: "Resume or start fresh?" The user picks "Resume" and exploration starts immediately with the pre-built analysis — no agent wait.
Sketch context for batch workflows (conditional): If the batch-analyzer reported UI involvement for this feature (check the draft's Architectural Assessment or UI Design sections for non-empty content), prepend this context to the feature description before invoking feature-spec:
"This feature is being planned for batch implementation. Completing the sketch during planning is strongly recommended — batch workers cannot interact with users to iterate on sketches during implementation. Sketch completion ensures workers can promote validated components autonomously."
If the batch-analyzer did not detect UI involvement, omit this context entirely — it would be confusing for non-UI features. Feature-spec will present the sketch offer with this additional context when it detects UI involvement. The user's decision within feature-spec is final.
After feature-spec completes and the finalized spec file exists (FEATURE_*.md):
arn-code-feature-planner agent with:
run_in_background: trueSpec: linkage line in the plan)code-patterns.md contenttesting-patterns.md contentarchitecture.md contentui-patterns.md content (if exists)security-patterns.md content (if exists)<plans-dir>/PLAN_PREVIEW_<spec-name>.mdImmediately proceed to Step 3a for the NEXT feature. The plan generates in the background while the user reviews the next spec.
Print:
Feature F-XXX [Name] spec finalized. Plan generating in background. [remaining] remaining.
If feature-spec fails (error or unexpected exit):
Ask (using AskUserQuestion):
"Feature spec for F-XXX encountered an error. How would you like to proceed?"
Options:
If the user says "stop" mid-loop:
Show what has been completed so far (completed specs and any plans already generated). Inform the user: "Batch planning paused. [M] of [N] features spec'd. Plans are generating in background for completed specs. Run /arn-code-batch-implement when ready — it will pick up completed plans."
If no features were assigned to the thorough tier, skip this step and proceed to Step 4.
After all thorough specs are reviewed, collect and review all generated plans for thorough features. Swift and standard plans were already written in Step 2.6 and do not need user review.
Wait for any still-running background planners to complete. Show progress:
Waiting for plan generation to complete: [N] plans ready, [M] still generating...
For each feature (in order):
If PLAN_PREVIEW exists: present a summary of the plan (phases, deliverables, key decisions).
If planner failed: retry once in the foreground. If it fails again, inform the user with the error and ask:
Ask (using AskUserQuestion):
"Plan generation failed for F-XXX. How would you like to proceed?"
Options:
Ask (using AskUserQuestion):
"Does this plan for F-XXX look right?"
Options:
If Approve: invoke Skill: arn-code:arn-code-save-plan. Proceed to the next feature's plan.
If Adjust: let the user provide feedback. Spawn the arn-code-feature-planner agent (foreground) with revision instructions and the current plan path. Re-present with the same 3 options. Repeat until approved or skipped.
If Skip: remove this feature from the batch. Revert Feature Tracker status to pending if applicable. Continue with the next feature's plan.
Present a summary table after all features are processed:
Batch Planning Complete: [completed]/[total] features ready
| Feature | Tier | Source | Sketch | Plan Path |
|---------|------|--------|--------|-----------|
| F-001: [Name] | swift | auto-planned | N/A | .arness/plans/SWIFT_[name]/ |
| F-003: [Name] | standard | auto-planned | N/A | .arness/plans/STANDARD_[name]/ |
| F-005: [Name] | thorough | interactive | Done | .arness/plans/[project]/ |
Source column:
auto-planned — plan generated by batch-planning (Step 2.6), worker handles executioninteractive — spec reviewed interactively, plan saved via save-planSketch detection (thorough features): Check if arness-sketches/<feature>/ exists with a status file indicating kept → Done. Otherwise → N/A. Swift and standard features always show N/A for sketch.
If any features were skipped, list them separately: "Skipped: F-XXX (spec error), F-YYY (user skipped)"
Before launching batch-implement, all planning artifacts must be on main so workers can find them.
Read ${CLAUDE_PLUGIN_ROOT}/skills/arn-code-batch-planning/references/plan-shipping.md and follow its procedure. This handles:
If Git is no: skip shipping. Inform the user that plans are local only and batch-implement requires git. Offer to exit or implement features one at a time via /arn-implementing.
After plans are on main (PR merged and pulled):
Ask (using AskUserQuestion):
"Plans are on main. Launch batch implementation?"
Options:
Skill: arn-code:arn-code-batch-implementIf Launch batch implementation: invoke Skill: arn-code:arn-code-batch-implement.
If Not yet: "Run /arn-code-batch-implement when ready. All plans are saved on main."