/arn-code-standard

name: arn-code-standard
description: >-
  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.
version: 1.0.0

Arness Standard

Implement medium-complexity features and enhancements through a mid-ceremony, pattern-aware workflow: spec-lite generation, structured plan, task-tracked execution, verification, review-lite, and unified change record -- all in a single session. Every standard implementation produces three artifacts in `<plans-dir>/STANDARD_<name>/`: a plan (`STANDARD_<name>.md`), a report (`STANDARD_REPORT.json`), and a change record (`CHANGE_RECORD.json`), giving robust auditability with less overhead than the full thorough pipeline.

This skill follows the same execution model as arn-code-swift's moderate path but adds a Spec-Lite front-end (lightweight architectural specification) and a unified CHANGE_RECORD.json envelope for downstream consumption.

This is an execution skill. It runs in normal conversation (NOT plan mode).

Step 0: Ensure Configuration

Read `${CLAUDE_PLUGIN_ROOT}/skills/arn-code-ensure-config/references/step-0-fast-path.md` and follow its instructions. This guarantees a user profile exists and `## Arness` is configured with Arness Code fields before proceeding.

Pipeline Position

              arn-code-standard (this skill)
              ============================
              For medium-complexity changes
              routed here by the scope router

Entry:  arn-planning (scope router) --> standard tier
          |
          v
        arn-implementing --> arn-code-standard
          |
          v
        Spec-Lite --> Plan --> Execute --> Report --> Review-Lite --> Change Record --> Ship
          |
          v
        <plans-dir>/STANDARD_<name>/
        +-- STANDARD_<name>.md      (plan with spec-lite)
        +-- STANDARD_REPORT.json    (execution report)
        +-- CHANGE_RECORD.json      (unified envelope)

Workflow

Step 1: Capture and Load Context

1. Accept the user's description. This can be anything from a sentence ("add rate limiting to /api/users") to detailed requirements. If the user already provided the description in their trigger message, use that directly without asking again.

2. Confirm understanding with a brief restatement (1-2 sentences).

3. Read the project's CLAUDE.md and extract the `## Arness` section to find:

• Code patterns path
• Plans directory
• Template path
• Template version and Template updates preference (if present)

4. Load pattern documentation from the code patterns directory:

• `code-patterns.md` (required)
• `testing-patterns.md` (required)
• `architecture.md` (required)
• `ui-patterns.md` (if it exists)
• `security-patterns.md` (if it exists)

5. **If pattern documentation files are missing** (no `code-patterns.md`, `testing-patterns.md`, or `architecture.md` in the Code patterns directory):

Inform the user: "This is the first time pattern documentation is being generated for this project. Analyzing your codebase to understand its patterns, conventions, and architecture. This is a one-time operation — future invocations will use the cached results."

Then invoke the `arn-code-codebase-analyzer` agent (existing codebase) or `arn-code-pattern-architect` (greenfield) to generate fresh analysis. Write the results to the Code patterns directory.

Hold this context for use throughout the workflow.

---

Step 2: Spec-Lite Generation

2a. Pre-check specialist relevance

Before invoking any agents, read `${CLAUDE_PLUGIN_ROOT}/skills/arn-code-ensure-config/references/specialist-pre-check.md` and apply the pre-check logic using the pattern documentation loaded in Step 1 and the user's feature description. This produces two boolean flags:

• `ui_involved`: true if ANY of: (1) `ui-patterns.md` exists AND contains a `## Sketch Strategy` section, (2) the feature description contains UI terms (component, page, form, button, layout, dashboard, UI, UX, screen, view, modal, dialog, command, terminal, output, widget, window, panel, console, display, prompt, menu, toolbar, status bar, progress, table, tree -- case-insensitive), (3) `architecture.md` contains a frontend, CLI, TUI, desktop, or mobile framework in its Technology Stack section
• `security_relevant`: true if BOTH: (1) `security-patterns.md` exists, AND (2) the feature description contains security terms (auth, login, password, token, payment, upload, API key, PII, encrypt, permission, session, cookie, CORS, CSRF, rate limit, secret, credential -- case-insensitive)

2b. Parallel agent dispatch

Dispatch the following agents in parallel based on the pre-check results:

• **Always:** `arn-code-architect`
• **If `ui_involved`:** also `arn-code-ux-specialist` (requires `ui-patterns.md` to exist)
• **If `security_relevant`:** also `arn-code-security-specialist` (requires `security-patterns.md` to exist)

All dispatched agents run in parallel (independent analyses, no cross-agent dependencies).

**For `arn-code-architect`, provide:**

**User expertise context:**

--- BEGIN USER EXPERTISE ---
[Read from ~/.arness/user-profile.yaml or .claude/arness-profile.local.md (project override takes precedence)]
Role: [role]
Experience: [development_experience]
Technology preferences: [technology_preferences]
Expertise-aware: [expertise_aware]
--- END USER EXPERTISE ---

--- BEGIN PROJECT PREFERENCES ---
[Read from .arness/preferences.yaml if it exists, otherwise omit this section]
--- END P