implement

What this skill does

<tool_restrictions>

# MANDATORY Tool Restrictions

## REQUIRED TOOLS — use these when specified in the process:

- **`AskUserQuestion`** — Preserve the one-question-at-a-time interaction pattern at every decision point marked with `AskUserQuestion:` in the process below. In Claude Code, use the tool. In Codex, ask one concise plain-text question at a time unless a structured question tool is actually available in the current mode. Do not narrate missing tools or fallbacks to the user.

## BANNED TOOLS — calling these is a skill violation:

- **`EnterPlanMode`** — BANNED. Do NOT call this tool. This skill has its own structured process — planning (via detail skill) and execution (via build agents). Claude's built-in plan mode would bypass this entire orchestration. Follow the phases below instead.
- **`ExitPlanMode`** — BANNED. You are never in plan mode. There is nothing to exit.

If you feel the urge to "plan before acting" — that urge is satisfied by following the `<process>` phases below. Phase 0 creates the plan via the detail skill. Phases 1-7 execute it. Execute them directly.
</tool_restrictions>

<arc_runtime>
This workflow requires the full Arc bundle, not a prompts-only install.

Paths in this skill use these conventions:

- `agents/...`, `references/...`, `disciplines/...`, `templates/...`, `scripts/...`, `rules/...`, `skills/<name>/...` are Arc-owned files at the plugin root. Resolve the plugin root from this skill's filesystem location — it's the directory containing `agents/` and `skills/`.
- `./...` is local to this skill's directory.
- `.ruler/...`, `docs/...`, `src/...`, or any project-relative path refers to the user's project repository.
  </arc_runtime>

<required_reading>
**Read these reference files NOW:**

1. references/testing-patterns.md
2. references/task-granularity.md
3. references/checkpoint-patterns.md
4. references/subagent-statuses.md
5. references/arc-paths.md

**Load these only when relevant:**

- references/model-strategy.md — when choosing build models
- references/maintainability-review.md — when a task touches large files, shared abstractions, ownership boundaries, duplicated logic, or risks creating a god file
- disciplines/dispatching-parallel-agents.md — when parallel reviewers/build agents are needed
- disciplines/finishing-a-development-branch.md — before finalizing the branch
- disciplines/subagent-driven-development.md — when executing through build agents
- disciplines/verification-before-completion.md — before closing the work
  </required_reading>

<build_agents>
**Available build agents in `agents/build/`:**

| Agent                      | Model  | Use For                                                                |
| -------------------------- | ------ | ---------------------------------------------------------------------- |
| `implementer`              | opus   | General task execution — utilities, services, APIs, business logic     |
| `fixer`                    | haiku  | TypeScript errors, lint issues — fast mechanical fixes                 |
| `debugger`                 | sonnet | Failing tests — systematic root cause analysis                         |
| `unit-test-writer`         | sonnet | Unit tests (vitest) — pure functions, components                       |
| `integration-test-writer`  | sonnet | Integration tests (vitest + MSW) — API, auth                           |
| `e2e-test-writer`          | opus   | E2E tests (Playwright) — user journeys                                 |
| `figma-builder`            | opus   | Build UI directly from Figma URL                                       |
| `test-runner`              | haiku  | Run vitest, analyze failures                                           |
| `e2e-runner`               | opus   | Playwright tests — iterate until green or report blockers              |
| `spec-reviewer`            | sonnet | Spec compliance check — nothing missing, nothing extra                 |
| `code-reviewer`            | haiku  | Quick code quality gate — no `any`, proper error handling, tests exist |
| `plan-completion-reviewer` | sonnet | Whole-plan gate — all tasks built, nothing skipped, no scope creep     |

**Before spawning a build agent:**

1. Read the agent file: `agents/build/[agent-name].md`
2. Use the model specified in the agent's frontmatter
3. Include relevant context from the task

**Spawn syntax:**

```
Task [agent-name] model: [model]: "[task description with context]"
```

</build_agents>

<rules_context>
**Check for project coding rules:**

**Use Glob tool:** `.ruler/*.md`

**If `.ruler/` exists, detect stack and read relevant rules:**

| Check                                                           | Read from `.ruler/`   |
| --------------------------------------------------------------- | --------------------- |
| Always                                                          | code-style.md         |
| `next.config.*` exists                                          | nextjs.md             |
| `react` in package.json                                         | react.md              |
| `tailwindcss` in package.json                                   | tailwind.md           |
| `.ts` or `.tsx` files                                           | typescript.md         |
| `vitest` or `jest` in package.json                              | testing.md            |
| Always                                                          | error-handling.md     |
| Always                                                          | security.md           |
| `drizzle` or `prisma` in package.json                           | database.md           |
| `wrangler.toml` exists                                          | cloudflare-workers.md |
| `@clerk/nextjs` or `@workos-inc/authkit-nextjs` in package.json | auth.md               |

These rules define MUST/SHOULD/NEVER constraints. Follow them during implementation.

**If `.ruler/` doesn't exist:**

```
No project-local coding rules found. Continue with the project's existing conventions and consult Arc's internal rules selectively when relevant.
```

Project-local rules are optional. Do not copy Arc's rule bundle into the project unless the user explicitly asks for that setup.

**For UI/frontend work, also load interface rules:**

| Check                     | Read from `rules/interface/`                                                                 |
| ------------------------- | -------------------------------------------------------------------------------------------- |
| Building components/pages | design.md, colors.md, spacing.md, layout.md, tailwind-authoring.md, surfaces.md, sections.md |
| Typography changes        | typography.md                                                                                |
| Adding animations         | animation.md, performance.md                                                                 |
| Form work                 | forms.md, interactions.md, buttons.md                                                        |
| Interactive elements      | interactions.md, buttons.md                                                                  |
| Marketing pages           | marketing.md                                                                                 |

**Additional references (load as needed):**

- `references/component-design.md` — React component patterns
- `references/animation-patterns.md` — Motion design
- `references/nextjs-app-router.md` — Next.js App Router patterns (if using Next.js)
- `references/tanstack-query-trpc.md` — TanStack Query + tRPC patterns (if data fetching)
- `references/tanstack-table.md` — TanStack Table v8 patterns (if data tables)
  </rules_context>

<process>

**You are here in the arc:**

```
/arc:ideate     → Feature spec ✓
     ↓
/arc:implement  → Plan + Execute ← YOU ARE HERE
     ↓
/arc:review     → Review (optional, can run anytime)
```

## Phase 0: Scope Detection

Assess what is being asked before choosing