This agent should be used when the user needs to design how a specific feature should be implemented within an existing codebase, or when the arn-code-feature-spec skill needs architectural analysis of a feature proposal. <example> Context: Invoked by arn-code-feature-spec skill during iterative refinement user: "feature spec" assistant: (invokes arn-code-architect with feature idea + codebase context) </example> <example> Context: User asks how to implement a specific feature user: "how should I implement authentication in this project?" </example> <example> Context: User wants to understand integration points for a feature user: "what files would I need to change to add caching?" </example>

This agent should be used when the arn-code-batch-planning skill needs to pre-generate draft feature specifications for multiple features in parallel. Takes a single feature from any source (greenfield F-NNN, GitHub issue, Jira issue, or plain description) and produces a DRAFT_FEATURE_*.md file that feature-spec's draft detection can consume. <example> Context: Invoked by arn-code-batch-planning during parallel pre-analysis for a greenfield feature user: "batch planning" assistant: (invokes arn-code-batch-analyzer with greenfield feature F-003 context) <commentary> Batch planning spawns one batch-analyzer per selected feature in parallel. Each analyzer reads the feature file, UC documents, and codebase patterns, then writes a DRAFT_FEATURE_*.md to the specs directory. </commentary> </example> <example> Context: Invoked by arn-code-batch-planning for a GitHub issue user: "batch planning" assistant: (invokes arn-code-batch-analyzer with GitHub issue #42 reference) <commentary> For GitHub issues, the analyzer fetches the issue via gh CLI, extracts title/body/labels/comments, and produces a draft spec with moderate detail. </commentary> </example> <example> Context: Invoked by arn-code-batch-planning for a Jira issue user: "batch planning" assistant: (invokes arn-code-batch-analyzer with Jira issue PROJ-42 reference) <commentary> For Jira issues, the analyzer fetches the issue via MCP, extracts summary/description/acceptance-criteria, and produces a draft spec. </commentary> </example> <example> Context: Invoked by arn-code-batch-planning for a plain description user: "batch planning" assistant: (invokes arn-code-batch-analyzer with a text description) <commentary> For plain descriptions, the analyzer produces a basic draft with architect analysis and placeholder sections that the user will refine during exploration. </commentary> </example> This is a background agent with no user interaction — it runs autonomously and returns a structured file artifact.

This agent should be used when the arn-code-batch-merge skill needs to analyze multiple open batch PRs for cross-cutting issues before guiding the user through per-PR review. Fetches CI status, review status, mergeable status, and file changes for each PR, builds a conflict map, checks for cross-PR patterns (duplicated code, inconsistent approaches), and returns a concise structured summary. <example> Context: Invoked by arn-code-batch-merge after discovering 5 open batch PRs user: "batch merge" assistant: (invokes arn-code-batch-pr-analyzer with PR list and CHANGE_RECORD paths) <commentary> Batch merge delegates the heavy analysis to this agent to keep the main session context clean. The agent reads all PR diffs internally and returns only a distilled summary. </commentary> </example> <example> Context: Re-invoked after a PR is merged to refresh remaining PR status user: "batch merge" assistant: (re-invokes arn-code-batch-pr-analyzer with fewer PRs after one was merged) <commentary> After each merge, the agent is re-run with the remaining PRs to refresh conflict and CI status. Fewer PRs = faster analysis. </commentary> </example>

This agent should be used when a bug has been diagnosed and a fix plan exists (either inline or structured), and the fix needs to be implemented with test verification and a bug fix report. <example> Context: Invoked by arn-code-bug-spec after user approves a simple fix plan user: "fix the bug" assistant: (invokes arn-code-bug-fixer with fix plan + test instructions) </example> <example> Context: User wants to assign a bug fix task to an agent user: "assign this to the bug fixer" </example> <example> Context: Bug fix needs implementation with test coverage user: "implement the fix and make sure tests pass" </example>

This agent should be used when the user asks to "analyze codebase", "find codebase patterns", "explore project structure", "what patterns does this project use", or when invoked by the arn-code-save-plan skill to gather codebase intelligence before structuring a plan. <example> Context: User is about to save a plan and needs codebase context user: "analyze the codebase patterns for my project" </example> <example> Context: Invoked by arn-code-save-plan skill user: "save plan" assistant: (invokes arn-code-codebase-analyzer as part of the save-plan workflow) </example> <example> Context: User wants to understand codebase conventions user: "what conventions and patterns does this codebase follow?" </example>

This agent should be used when the arn-code-report skill needs to diagnose Arness workflow issues in the current session, or when the arn-code-init skill needs a comprehensive health check during an upgrade flow. Analyzes Arness configuration, directory structure, and skill behavior against expected patterns documented in the knowledge base. Reports only Arness-specific issues — never reads or reports user project code or business logic. <example> Context: User reports that arn-code-save-plan failed to find templates user: "arn-code-save-plan couldn't find the templates after I ran arn-code-init" assistant: Invokes arn-code-doctor to check template directory, checksums file, and ## Arness config for template-related issues. </example> <example> Context: User reports strange behavior during plan execution user: "arn-code-execute-plan kept skipping tasks that should have been unblocked" assistant: Invokes arn-code-doctor to check task list state, dependency graph, and execution flow against expected behavior. </example> <example> Context: User reports arn-code-init didn't set up GitHub labels user: "I ran arn-code-init but the GitHub labels weren't created" assistant: Invokes arn-code-doctor to check Git/GitHub detection results, gh auth status, and label creation step. </example> <example> Context: arn-code-init upgrade flow needs a full health check user: "upgrade arness" (triggers arn-code-init, which selects Upgrade) assistant: Invokes arn-code-doctor for comprehensive check of all config fields, directories, templates, checksums, Git/GitHub state, labels, and pattern schema. </example>

This agent should be used when the arn-code-plan skill needs to generate or revise an implementation plan from a Arness specification and codebase patterns. <example> Context: Invoked by arn-code-plan skill to generate an initial plan user: "arness plan FEATURE_websocket-notifications" assistant: (invokes arn-code-feature-planner with spec content, pattern docs, and output path) </example> <example> Context: Invoked by arn-code-plan skill to revise a plan based on user feedback user: "split phase 2 into separate API and UI phases" assistant: (resumes or re-invokes arn-code-feature-planner with feedback and current plan path) </example> <example> Context: Invoked by arn-code-plan skill for a bug fix plan user: "arness plan BUGFIX_checkout-500" assistant: (invokes arn-code-feature-planner with bugfix spec and codebase patterns) </example>

This agent should be used when the arn-code-bug-spec skill needs diagnostic investigation of a bug, or when the user needs to trace a bug's root cause through the codebase with hypothesis-driven analysis. <example> Context: Invoked by arn-code-bug-spec skill during investigation phase user: "bug spec: users are getting 500 errors on checkout" assistant: (invokes arn-code-investigator with bug description + codebase context) </example> <example> Context: User wants to understand why something is broken user: "why is the cache returning stale data after updates?" </example> <example> Context: User needs to investigate unexpected behavior in a specific area user: "the payment webhook handler is silently dropping events — no error logged but orders aren't updating" </example>

This agent should be used when the user is starting a new project from scratch and needs recommended code patterns, testing strategies, and architectural best practices for their chosen technology stack. This agent creates patterns rather than discovering existing ones. <example> Context: User is setting up a new project with no existing code user: "I'm starting a new FastAPI project, recommend patterns" </example> <example> Context: Invoked by arn-code-init skill for greenfield projects user: "arness init" (in an empty project) assistant: (invokes arn-code-pattern-architect with user's technology choices) </example> <example> Context: User wants architecture recommendations for a new project user: "suggest best practices and project structure for a new Django app" </example>

This agent should be used when the arn-code-bug-spec skill's simple fix path needs a brief, structured fix plan before execution, or when any skill needs to compile a small set of fix instructions into a structured document. <example> Context: Invoked by arn-code-bug-spec Step 6A when user wants "write small plan first" user: "write a small plan first" assistant: (invokes arn-code-planner with bugfix template + inline proposal context) </example> <example> Context: User requests a revision of an existing inline fix plan user: "update the plan to also handle the edge case for empty inputs" assistant: (invokes arn-code-planner with existing plan + revision instructions) </example> <example> Context: Skill needs a brief structured document from investigation findings user: "compile the investigator's findings into a fix plan" assistant: (invokes arn-code-planner with investigation output + bugfix template) </example>

This agent should be used when the user needs security analysis for a feature, or when the arn-code-feature-spec-teams skill needs a security specialist perspective during team debate, or when arn-code-feature-spec needs lightweight security hints. Specializes in threat modeling, OWASP Top 10 analysis, and security pattern evaluation. <example> Context: Invoked by arn-code-feature-spec-teams during team debate user: "feature spec teams: add payment processing" assistant: (invokes arn-code-security-specialist with feature idea + codebase context) <commentary> Feature involves payment data. Security specialist joins the debate team to advocate for secure-by-default design alongside the architect. </commentary> </example> <example> Context: User needs security guidance for a specific feature user: "what security considerations should I have for this auth system?" </example> <example> Context: Invoked by arn-code-feature-spec for lightweight security hints user: "feature spec: add user registration with email verification" assistant: (invokes arn-code-security-specialist with focused prompt after architect) <commentary> Feature involves authentication. Security specialist provides brief threat/mitigation list. </commentary> </example>

This agent should be used when the arn-code-sketch skill needs to create or update an interface preview using the project's actual framework, component library, and styling system. Adapts output based on the paradigm (web, CLI, TUI, or other) to produce real, runnable artifacts that match the project's conventions exactly. <example> Context: Invoked by arn-code-sketch skill to create an initial web sketch user: "sketch the settings page" assistant: (invokes arn-code-sketch-builder with feature context, paradigm, framework info, and target page) </example> <example> Context: Invoked by arn-code-sketch skill to create a CLI sketch user: "sketch the deploy command" assistant: (invokes arn-code-sketch-builder with feature context, paradigm=cli, CLI framework, and target module) </example> <example> Context: Invoked by arn-code-sketch skill to create an initial TUI sketch user: "sketch the dashboard screen" assistant: (invokes arn-code-sketch-builder with paradigm=tui, Textual framework, and target screen context) </example> <example> Context: Invoked by arn-code-sketch skill during iteration user: "move the form to the left and use a Card wrapper" assistant: (invokes arn-code-sketch-builder with feedback, current sketch files, and component library context) </example> <example> Context: Invoked by arn-code-sketch skill for promotion user: "promote this sketch to the real codebase" assistant: (invokes arn-code-sketch-builder to copy files, update paths, and integrate) </example>

This agent should be used when a single phase plan task needs to be executed, either for implementation or testing. Reads INTRODUCTION.md for codebase patterns, follows PHASE_N_PLAN.md directives, generates reports, and self-heals during testing. Executes one assigned task and returns. <example> Context: Invoked by arn-code-execute-plan skill to execute a specific task user: "Execute task 5 — implement Phase 2 data layer" assistant: (spawns arn-code-task-executor for this single task) <commentary> The skill assigns one task. The executor reads pattern docs, executes the task, generates its report, and returns a completion summary. </commentary> </example> <example> Context: Invoked by arn-code-execute-plan skill to run tests for a phase user: "Execute task 8 — test Phase 3 API endpoints" assistant: (spawns arn-code-task-executor for this single testing task) <commentary> Single testing task. The executor reads all pattern docs first, writes and runs the specified tests, self-heals any failures, and generates the report. </commentary> </example> <example> Context: Invoked by arn-code-execute-task for a single implementation task user: "execute task 3" assistant: (spawns arn-code-task-executor for this single task from the task list) <commentary> Single task execution via arn-code-execute-task. The executor reads pattern docs, implements the task, and generates its report. </commentary> </example>

This agent should be used to validate a completed task's implementation against stored pattern documentation, phase plan acceptance criteria, and test results. Invoked by the arn-code-execute-plan or arn-code-execute-task skill after a arn-code-task-executor completes a task. Returns a structured verdict: pass, pass-with-warnings, or needs-fixes. <example> Context: Invoked by arn-code-execute-plan after executor completes Task 3 user: "review the implementation of Task 3" assistant: (spawns arn-code-task-reviewer to validate implementation against patterns and acceptance criteria) <commentary> Executor completed Task 3. Reviewer reads pattern docs, re-runs tests, checks acceptance criteria, and returns a verdict with findings. </commentary> </example> <example> Context: Single task review requested by arn-code-execute-task skill user: "review task 5 implementation" assistant: (spawns arn-code-task-reviewer for focused validation) <commentary> Single-task review via arn-code-execute-task. Reviewer validates just this task's implementation and returns findings. </commentary> </example> <example> Context: Invoked after a failed task needs re-review user: "re-review task 3 after executor applied fixes" assistant: (spawns arn-code-task-reviewer to re-validate the fixed implementation) <commentary> Re-review after fixes. Reviewer checks whether previous error findings are resolved and returns an updated verdict. </commentary> </example>

This agent should be used when the user needs to run the project's test suite and interpret results, or when the arness-assess skill needs test execution as a quality gate before shipping implementation changes. <example> Context: Invoked by arn-code-assess after all improvements are executed user: "assess codebase" assistant: (invokes arn-code-test-specialist to run full test suite before shipping) <commentary> The assess skill triggers this agent at the pre-ship test gate to verify that all implemented changes pass the existing test suite. </commentary> </example> <example> Context: User wants to run tests and get a structured report user: "run the tests and tell me what's failing" <commentary> Direct invocation to run the test suite and identify failures with structured output including file paths and error details. </commentary> </example> <example> Context: User wants to verify test health before shipping user: "run the full test suite and give me a report" <commentary> Pre-ship verification — user wants confirmation that all tests pass before committing or creating a PR. </commentary> </example>

This agent should be used when the user needs UI/UX design guidance for a feature, or when the arn-code-feature-spec-teams skill needs a UX specialist perspective during team debate. Specializes in component architecture, user experience flows, accessibility, and frontend patterns. <example> Context: Invoked by arn-code-feature-spec-teams during team debate user: "feature spec teams: add a dashboard for analytics" assistant: (invokes arn-code-ux-specialist with feature idea + codebase context) <commentary> Feature has UI components. UX specialist joins the debate team to advocate for user experience alongside the architect. </commentary> </example> <example> Context: User needs UI design guidance for a specific feature user: "how should the user interface for the settings page work?" </example> <example> Context: Backend project adding frontend for the first time user: "we need to add a web UI to our API — what should the frontend look like?" <commentary> No existing frontend. UX specialist operates in recommendation mode, proposing a UI stack and component patterns from scratch. </commentary> </example>

This skill should be used when the user says "assessing", "arness assessing", "assess", "assess codebase", "technical review", "codebase assessment", "find improvements", "what should I improve", "tech debt review", "pattern compliance check", "codebase health check", "improvement plan", "review my codebase", "what needs fixing", "code quality check", "audit my code", "run an assessment", "arn-assessing", or wants a comprehensive technical assessment of the codebase against stored patterns followed by prioritized improvement execution. Chains to arn-implementing if improvements are identified.

This skill should be used when the user says "arness code assess", "arn-code-assess", "assess codebase", "technical review", "codebase assessment", "find improvements", "what should I improve", "tech debt review", "tech debt audit", "pattern compliance check", "codebase health check", "assess the project", "improvement plan", "review my codebase", "what needs fixing", "code quality check", "audit my code", "run an assessment", or wants a comprehensive technical assessment of the codebase against stored patterns followed by prioritized improvement execution through the full Arness pipeline.

This skill should be used when the user says "batch implement", "implement all", "batch execution", "implement all features", "parallel implement", "implement in parallel", "arness batch implement", "arn-code-batch-implement", "run batch implementation", "implement everything", "launch batch workers", or wants to spawn parallel worktree-isolated background agents to implement multiple pending features simultaneously. Each worker runs as a full independent session with all tools. This skill requires pending plans in .arness/plans/ — run arn-code-batch-planning first if none exist.

This skill should be used when the user says "batch merge", "merge batch", "arness batch merge", "arn-code-batch-merge", "merge all PRs", "merge batch PRs", "merge the batch", "merge implemented features", "batch merge PRs", "merge open PRs", "merge all feature PRs", "combine batch PRs", "land the batch", "land all PRs", or wants to discover open batch implementation PRs, analyze them for conflicts, determine an optimal merge order, and execute merges with user-guided conflict resolution. This skill is typically invoked after arn-code-batch-implement completes and chains to arn-code-batch-simplify upon completion.

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.

This skill should be used when the user says "batch simplify", "cross-feature simplify", "batch simplification", "simplify all features", "cross-feature quality pass", "batch code cleanup", "consolidate across features", "deduplicate across features", "cleanup after batch merge", "cross-feature deduplication", "arness batch simplify", "arn-code-batch-simplify", "simplify merged features", "post-merge simplify", "find cross-feature duplication", or wants to run a post-merge quality pass that finds duplication and consolidation opportunities across independently implemented features. This requires merged features in .arness/plans/ — run arn-code-batch-merge first if none are merged.

This skill should be used when the user says "bug spec", "arness code bug spec", "investigate this bug", "help me debug", "trace this bug", "diagnose this issue", "I found a bug", "something is broken", "why is X not working", "fix this bug", "debug this", "why is this not working", or wants to iteratively investigate a bug through guided conversation with diagnostic analysis. Bridges the gap between a bug report and either a direct fix or a structured bug specification for the Arness pipeline.

This skill should be used when the user says "catch up", "catch-up", "arness code catch up", "retroactive docs", "document old commits", "backfill artifacts", "what did I miss", "undocumented commits", "catch up on commits", "document past work", "backfill records", or wants to retroactively document commits that were made outside the Arness pipeline.

This skill should be used when the user says "create issue", "file issue", "arness code issue", "arness code create issue", "arn-code-create-issue", "report bug", "request feature", "add to backlog", "create GitHub issue", "create Jira issue", "file a bug", "submit issue", "log issue", "open issue", or wants to create an issue in the current repository with Arness labels for type and priority. Requires an issue tracker (GitHub or Jira) to be configured. Do NOT use this for picking/browsing existing issues — use /arn-code-pick-issue for that.

This skill should be used when the user says "document project", "generate docs", "create documentation", "write docs", "arness code document", "arn-code-document-project", "document this feature", "document this fix", or wants to generate developer documentation for a completed feature or bug fix. Reads plan artifacts, spec files, execution reports, and git diff to produce accurate documentation. Do NOT use this for general-purpose documentation — this is specifically for Arness pipeline projects.

This skill should be used when the user says "ensure config", "check arness config", "arn-code-ensure-config", "verify arness setup", or wants to verify that Arness Code configuration is present for the current project. This skill is primarily consumed as a reference by entry-point skills (arn-planning, arn-implementing, arn-shipping, arn-reviewing-pr, arn-assessing, arn-code-feature-spec, arn-code-bug-spec, arn-code-swift, arn-code-standard) which read the ensure-config reference as Step 0 before proceeding with their workflow.

This skill should be used when the user says "execute plan with teams", "run plan teams", "execute with agent teams", "team execution", "execute plan with agent teams instead of subagents", "teams mode", "agent teams mode", "execute with teams", or wants to execute a structured project plan using Claude Code's experimental Agent Teams feature. Creates a team of executor, reviewer, and architect teammates that collaborate on task implementation with built-in quality gates. Requires the experimental Agent Teams feature to be enabled. For standard subagent-based execution, use arn-code-execute-plan instead.

This skill should be used when the user says "execute plan", "run the plan", "start execution", "execute project", "execute all tasks", "run all tasks", "run plan in parallel", "execute with review gates", or wants to execute a full structured project plan after tasks have been created via arn-code-taskify. This skill runs ALL tasks from the task list — for executing a single specific task, use arn-code-execute-task instead. For Agent Teams mode, use arn-code-execute-plan-teams. Do NOT use this skill when executing a single task — use `/arn-code-execute-task` instead.

This skill should be used when the user says "execute task N", "run task N", "implement task N", "re-run task N", "retry task N", "run single task", or wants to execute a single specific task from the task list with optional review. This is for ONE task only — for executing the full plan (all tasks), use arn-code-execute-plan instead.

This skill should be used when the user says "feature spec teams", "arness code feature spec teams", "team feature spec", "debate this feature", "collaborative feature spec", "spec with agent teams", "multi-agent feature spec", "feature spec debate", or wants to develop a feature idea through structured debate between multiple specialist agents (architects, UX experts, and security specialists) before writing the specification. Uses Claude Code's experimental Agent Teams feature. Requires Agent Teams to be enabled. For standard single-agent feature spec, use arn-code-feature-spec instead.

This skill should be used when the user says "feature spec", "arness code feature spec", "arn-code-feature-spec", "spec this feature", "help me spec", "design this feature", "feature design", "write a spec", "create a specification", "I have an idea for a feature", "let's flesh out this feature", "decompose feature", "spec XL feature", "resume spec", "continue spec", "finish my spec", "break down feature", or wants to iteratively develop a feature idea into a well-formed specification through guided conversation with architectural analysis. For XL features with decomposition hints, creates multiple sub-feature specs with full traceability. Produces specification documents capturing WHAT to build and WHY, which then feed into plan creation.

This skill should be used when the user says "arness code help", "where am I", "what's next", "show pipeline", "pipeline status", "what step am I on", "arness code status", "arn-code-help", "show workflow", or wants to see their current position in the Arness workflow pipeline and get guidance on the next step.

Optional customization and upgrade tool. This skill should be used when the user says "initialize arness code", "arness code init", "arn-code-init", "init arness code", "setup arness code", "arness code setup", "set up arness code", "start arness code", "upgrade arness code", "update arness code", "configure arness code for this project", "add arness code to this project", "reconfigure arness code", "review arness config", "customize arness config", "arness settings", or wants to customize Arness configuration, review current settings, or upgrade after a plugin update. Handles both existing codebases (analyzes patterns) and greenfield projects (recommends patterns based on technology choices). Also handles upgrades after plugin updates.

This skill should be used when the user says "pick issue", "work on issue", "arness code pick", "arness code pick issue", "arn-code-pick-issue", "grab issue", "pick from backlog", "what should I work on", "show issues", "find issue", "browse issues", "next issue", "select issue", "choose issue", "what's unblocked", "work on next feature", "pick from feature tracker", or wants to browse issues filtered by Arness labels, select one, and route it to the appropriate Arness pipeline skill for implementation. Supports local-first dependency resolution from a greenfield feature backlog when available. Requires an issue tracker (GitHub or Jira) to be configured for remote issue browsing. Do NOT use this for creating new issues — use /arn-code-create-issue for that.

This skill should be used when the user says "arness code plan", "arn-code-plan", "plan this", "write a plan", "create plan", "implementation plan", "plan feature", "plan the spec", "plan from spec", "generate plan", "arness code plan FEATURE_X", "plan the bugfix", "plan bugfix", "make a plan", or wants to generate an implementation plan from a Arness specification. The skill invokes the arn-code-feature-planner agent to generate the plan, presents it for review, and iterates on user feedback until approved. Produces a PLAN_PREVIEW file that feeds into /arn-code-save-plan.

This skill should be used when the user says "report issue", "arness code report", "code report", "something went wrong", "report a bug", "file arness code issue", "arness code broke", "report arness code problem", "diagnose issue", "arness doctor", "run doctor", "diagnose arness code", "arn-code-report", or wants to report a problem with an Arness Code workflow skill. Invokes the arn-code-doctor agent to diagnose the issue, then files a GitHub issue on the Arness plugin repository. Do NOT use this for filing issues on the user's own project — use /arn-code-create-issue for that. For Spark issues use /arn-spark-report. For Infra issues use /arn-infra-report.

This skill should be used when the user says "review implementation", "review the project", "check implementation", "quality review", "validate implementation", "implementation review", or wants a post-execution quality gate to verify that the implementation follows the project's stored code and testing patterns and matches the plan. Reports issues as ERRORS, WARNINGS, INFO with a verdict. Do NOT use this for reviewing PRs (use arn-code-review-pr) or validating plans (use arn-code-review-plan).

This skill should be used when the user says "review plan", "validate plan", "check plan", "sanity check the plan", "verify plan", "review my plan", "audit plan", "is my plan ready", or wants to validate a structured project plan for completeness, correctness, and pattern compliance before execution. Checks structural completeness, document quality, dependency graph consistency, codebase reference validity, and pattern compliance. Offers to fix found issues interactively and can proceed directly to arn-code-taskify when the plan passes.

This skill should be used when the user says "review PR", "review pull request", "check PR comments", "review PR feedback", "review PR 123", "analyze PR comments", "validate PR review", "address PR feedback", "fix PR issues", "what did the reviewer say", "review Bitbucket PR", or wants to validate GitHub or Bitbucket PR review comments, categorize findings, and optionally connect back into the Arness pipeline for fixes. Do NOT use this for creating PRs (use arn-code-ship) or reviewing implementation quality (use arn-code-review-implementation).

This skill should be used when the user says "save plan", "save the plan", "arness code save plan", "structure this plan", "create project from plan", "export plan", "export project plan", "organize this plan", "set up project structure", "turn this into a project", "generate project structure", "finalize the plan", or wants to convert a planning conversation into an actionable phased project structure with implementation and testing plans.

This skill should be used when the user says "ship it", "arness code ship", "create PR", "open pull request", "push and PR", "commit and push", "wrap up", "ship the feature", "ship the fix", "ready to ship", "push changes", "finalize", "finish up", or wants to commit, push, and optionally open a pull request. Guides through branching, staging, committing with meaningful messages, pushing, and PR creation. Works standalone or as the final Arness pipeline step. Do NOT use this for reviewing PRs — use /arn-code-review-pr for that.

This skill should be used when the user says "simplify", "arness code simplify", "simplify code", "code simplification", "clean up code", "reduce complexity", "remove duplication", "check for reuse", "find duplicates", "optimize code", "efficiency review", "simplify implementation", "arn-code-simplify", or wants to review recently implemented code for reuse opportunities, quality issues, and efficiency problems after execution completes. Do NOT use this for full implementation correctness review (use arn-code-review-implementation) or PR review (use arn-code-review-pr).

This skill should be used when the user says "sketch", "arness code sketch", "preview this", "show me what this looks like", "UI preview", "sketch the feature", "visual preview", "sketch this page", "what will this look like", "mock this up", "prototype this UI", "preview the design", "sketch the UI", "preview this command", "show me what the output looks like", "sketch the TUI", "what will the CLI look like", "mock up the terminal output", or wants to see a working interface preview of a feature in the context of their existing application before committing to full implementation. Creates real, runnable artifacts using the project's actual framework and conventions, rendered in a dedicated sketch namespace.

This skill should be used when the user says "standard", "standard mode", "standard implementation", "arn-code-standard", "standard change", "medium change", "standard feature", "standard fix", or wants a mid-ceremony implementation for a change that needs lightweight architectural context (spec-lite) and task-tracked execution but not the full feature-spec/plan pipeline. Bridges the gap between arn-code-swift and the full thorough pipeline. Includes spec-lite generation, structured plan, in-session execution, review-lite, and a unified change record.

This skill should be used when the user says "swift", "arness code swift", "quick change", "small change", "just do this", "quick feature", "quick implementation", "swift fix", "implement this quickly", "add this quickly", "simple change", "just implement this", "arn-code-swift", "swift mode", "quick task", or wants a lightweight, pattern-aware implementation for a small feature or enhancement (1-8 files) without going through the full Arness pipeline. Bridges the gap between raw Claude Code and the full feature-spec/plan pipeline. Includes architectural assessment, targeted testing, and pattern compliance review.

This skill should be used when the user says "taskify", "create task list", "create tasks", "convert plan to tasks", "generate tasks from plan", "create tasks from plan", "turn plan into tasks", "arness code taskify", or wants to convert a structured project plan's TASKS.md into an executable Claude Code task list with proper dependency management.

This skill should be used when the user says "implementing", "arness implementing", "start implementing", "execute the plan", "build it", "implement this", "run the tasks", "execute", "start building", "implement the feature", "implement the fix", "quick change", "swift", "swift mode", "quick implementation", "standard", "standard mode", "standard implementation", "start execution", "build the feature", "arn-implementing", or wants to execute an implementation plan, run a quick implementation, a standard-tier implementation, or manage the build-simplify-review cycle. Chains to arn-shipping at completion.

This skill should be used when the user says "planning", "arness planning", "plan a feature", "start planning", "I want to build", "new feature", "plan something", "what should I build", "pick an issue", "plan a bug fix", "I have an idea", "spec and plan", "plan from scratch", "plan this", "feature planning", "bug planning", "plan this issue", "arn-planning", or wants to go from an idea, issue, or bug report through to a complete implementation plan ready for execution. Handles severity-aware scope routing across three ceremony tiers (swift, standard, thorough), routing between feature specs, bug specs, and quick implementations, and produces a reviewed plan ready for execution. Chains to arn-implementing at completion.

This skill should be used when the user says "reviewing pr", "arness reviewing pr", "review PR", "review pull request", "check PR comments", "PR feedback", "address PR feedback", "fix PR issues", "what did the reviewer say", "handle review comments", "review PR 123", "arn-reviewing-pr", "PR review", "check review", or wants to validate PR review comments, categorize findings, and fix or defer issues. Chains back to arn-implementing if substantial fixes are needed.

This skill should be used when the user says "shipping", "arness shipping", "ship it", "ship", "create PR", "open pull request", "push and PR", "commit and push", "wrap up", "ship the feature", "ship the fix", "ready to ship", "push changes", "finalize", "finish up", "done", "arn-shipping", or wants to commit, push, and optionally create a pull request. Handles branching, staging, committing, pushing, and PR creation as a single guided flow. Chains from arn-implementing at completion.