/arn-code-swift

name: arn-code-swift
description: >-
  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.
version: 1.1.0

Arness Swift

Implement small features and enhancements through a lightweight, pattern-aware workflow: quick architectural assessment, inline plan, direct execution, verification, and review -- all in a single session. Every swift implementation produces a plan (`SWIFT_<name>.md`) and a report (`SWIFT_REPORT.json`), giving the same auditability as the full pipeline without the overhead.

This skill follows the `arn-code-bug-spec` dual-path architecture: assess complexity, route simple tasks to direct execution, escalate moderate tasks to task-tracked execution, and redirect complex tasks to the full pipeline.

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-swift (this skill)
              ========================
              For changes touching 1-8 files
              with no new architectural patterns

Entry:  User describes a small change
          |
          v
Full:   init --> [ feature-spec | bug-spec | SWIFT ] --> plan --> ...
                                              |
                          +-------------------+-------------------+
                          |                   |                   |
                       SIMPLE              MODERATE            COMPLEX
                      (1-3 files)         (4-8 files)         (9+ files)
                          |                   |                   |
                       Plan -->            Plan -->           Redirect to
                       Execute             TaskCreate -->     /arn-code-feature-spec
                       in session          Execute
                          |                   |
                       Review              Review
                          |                   |
                       Ship                Ship

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
• Specs 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: Quick Architectural Assessment

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 EX