claude-agent-teams

Architect produces a full web-app system design from the approved product vision and prototype (the **Design** phase of the spec-driven loop) — extracted architecture drivers, deep exploration of each load-bearing (one-way-door) decision weighed against those drivers, ADRs (architecture style, framework, DB, auth, rendering strategy, multi-tenancy), C4 context/container diagrams, data model, API contracts, component breakdown, observability + security plan, technical verification criteria that bind back to the vision's product criteria, and a phased implementation plan. Use after product vision and prototype are approved.

Architect decomposes the approved web-app system design into milestones and INVEST-sized tasks, splitting each feature slice into a backend task (API + business logic + data, test-driven) and a dependent frontend task (the UI that consumes it), with acceptance criteria, dependencies, and a parallelization plan (the **Tasks** phase of the spec-driven loop). Each task declares its discipline and which system-design verification criteria it advances, so the spec→implementation lineage is explicit. Starts with a walking skeleton (real, deployable, end-to-end). Use after system design is approved.

CEO revisits the product vision and knowledge base — re-reads everything, checks what's changed, talks to the client, and updates the strategic documents. Use when priorities shift, scope changes, or the CEO needs a full refresh.

DBA designs the database schema for a web application from the system design — tables, indexes, constraints, RLS, zero-downtime migration plan. Defaults to Postgres + Redis. Produces .claude/database-schema.md. Use after system design is approved.

Designer extracts a web design specification from the approved HTML prototype — design tokens (CSS custom properties for color/type/spacing/radius/shadow), component inventory, screen map with visual acceptance criteria per screen, responsive behavior, and interaction states. This becomes the single source of truth for UI implementation. Use after the prototype is approved.

Project kickoff — CEO has a natural conversation with the client, plays devil's advocate, crystallizes the product vision (the **Specify** phase of the spec-driven loop) with explicit verification criteria, then iterates with the designer on visuals until approved. No implementation details — pure product thinking. Use at the very start of a new project.

CEO runs the task execution cycle — picks the next task, routes it to the backend engineer (test-driven) or the frontend engineer (UI) by its discipline, confirms the engineer's self-reviewed work (tests green; designer + ux-engineer for UI), and marks it done. Updates task status in .claude/tasks/. Repeats until milestone is complete. Use when ready to start building.

DevOps sets up the full web-app infrastructure — CI/CD with per-PR preview environments, Docker, web hosting (Vercel/Netlify/Railway/Render/Fly/Cloudflare), managed Postgres, edge CDN, observability stack, feature flags, WAF/rate limiting. Creates handoff guides for actions requiring the client. Works from the system design. Use after system design is approved, before or during sprint.

Architect produces a full iOS-app system design from the approved product vision and prototype (the **Plan** phase of the spec-driven loop) — ADRs (architecture pattern, modularization, navigation API, state ownership, persistence tier, sync strategy, concurrency posture, signing posture), C4 context / container diagrams, repository / service contracts, capabilities + entitlements list, privacy posture (PrivacyInfo.xcprivacy, ATT, purpose strings), and technical verification criteria that bind back to the vision's product criteria. Use after product vision and prototype are approved.

Architect decomposes the approved iOS-app system design into milestones and INVEST-sized vertical-slice tasks (UI + ViewModel + repository + persistence + signing) with acceptance criteria, dependencies, and a parallelization plan (the **Tasks** phase of the spec-driven loop). Each task declares which system-design verification criteria it advances. Starts with a concrete walking skeleton — App launches → primary screen → ViewModel roundtrip → persistence read/write → signed TestFlight build installable on a real iPhone. Use after system design is approved.

CEO revisits the iOS product vision and knowledge base — re-reads everything (vision, design spec, screen map, SF Symbols inventory, system design, packaging plan), checks what's changed in the codebase and the platform landscape, talks to the client, and updates the strategic documents. Use when priorities shift, scope changes, the iOS landscape moves (new iOS major, App Store policy update, Swift evolution), or the CEO needs a full refresh.

Data agent designs the local persistence layer for a native iOS app from the system design — schema for SwiftData (iOS 17+) or Core Data (iOS 16 floor) with appropriate migrations, encryption posture (Data Protection class + Keychain access class), CloudKit sync configuration when needed, multi-screen data coherence via `@Query` / `@FetchRequest`, sandbox filesystem discipline (Documents / Application Support / Caches / tmp), atomic file writes. Produces `.claude/data-schema.md`. Use after system design is approved.

Designer extracts an iOS design specification from the approved HTML prototype — design tokens (asset-catalog color tokens with Any + Dark Appearance, typography mapped to Dynamic Type semantic styles, spacing on the 8pt grid), component inventory, screen map with visual acceptance criteria per screen, plus the iOS-specific artefacts every native app needs on day one — a **screen map** (navigation graph: every screen, transitions, modal presentations) and an **SF Symbols inventory** (every symbol used, weight, where surfaced). Use after the prototype is approved.

DevOps sets up the full iOS packaging + release pipeline — Xcode project / `.xcconfig` settings (deployment target, Swift version, strict concurrency, build configurations), code signing (Apple Developer Program enrollment guidance, certificates, provisioning profiles, fastlane match), fastlane lanes (`gym` builds, `pilot` for TestFlight, `deliver` for App Store metadata + screenshots, `match` for cert sync), capabilities + entitlements file, `PrivacyInfo.xcprivacy`, all `NSUsageDescription` purpose strings, App Tracking Transparency wiring (if needed), Sign in with Apple capability (if needed), GitHub Actions macOS matrix with Xcode pinned, App Store Connect metadata as code via `fastlane/metadata/`. Produces `.claude/packaging-plan.md` plus per-action handoff guides under `.claude/handoff/`. Use after system design is approved, before or during sprint.

Project kickoff for a native iOS application — CEO has a natural conversation with the client, plays devil's advocate, crystallizes the product vision (the **Specify** phase of the spec-driven loop) with explicit verification criteria, then iterates with the designer on visuals until approved. Captures iOS-specific decisions — supported devices (iPhone only, iPad too, Apple Vision later), minimum iOS version, distribution model (free, paid, IAP, subscription), background-resident behavior, sync needs — at the vision level. No implementation details. Use at the very start of a new iOS project.

CEO runs the iOS-app task execution cycle — picks the next task, sends developer to implement (View + ViewModel + repository slices, with simulator + xcrun simctl for visual verification on UI tasks), tester verifies critical repository contracts and XCUITest flows on demand, reviewer is the only path to ship and enforces the iOS reject-on-sight checklist. Updates task status in `.claude/tasks/`. Repeats until milestone is complete. Use when ready to start building.

CEO does a quick sync for an iOS project — reviews recent changes (commits, new repositories, navigation routes, Info.plist drift, fastlane / Xcode version bumps), updates the strategic knowledge base. Use regularly to stay current on the project. Faster than `brief` — surgical update, not a full refresh.

Tester drafts a test strategy for an iOS app from the system design — pyramid shape, framework picks (XCTest for unit + integration; XCUITest end-to-end against a pinned simulator; `swift-snapshot-testing` for stable views in light + dark + Dynamic Type baselines; in-memory `ModelContainer` / `NSPersistentContainer(NSInMemoryStoreType)`), per-test state isolation via launchArgument-driven Debug reset, simulator pinning in test plans (device + iOS version), `XCAccessibilityAudit` for automated accessibility gates, coverage map per task, Definition of Done. Use after system design and task breakdown are approved.

Verify UI on the iOS Simulator — boot the pinned sim, build for simulator destination, install, launch with reset state, capture screenshots at every acceptance-criteria state, optionally stream `os_log`, then have the ux-engineer review the screenshots against `.claude/design-spec.md` for HIG conformance, Dynamic Type behavior, dark-mode parity, and accessibility. Drives the simulator entirely through `xcodebuild` and `xcrun simctl` over `Bash`. Use after a UI task is implemented and before marking it done; also useful for ad-hoc visual exploration during design review.

CEO revisits the desktop product vision and knowledge base — re-reads everything (vision, design spec, menu map, shortcut map, system design, packaging plan), checks what's changed in the codebase and the platform landscape, talks to the client, and updates the strategic documents. Use when priorities shift, scope changes, the OS landscape moves (e.g. new macOS version, Windows signing rules change), or the CEO needs a full refresh.

Project kickoff for a desktop Electron application — CEO has a natural conversation with the client, plays devil's advocate, crystallizes the product vision (the **Specify** phase of the spec-driven loop) with explicit verification criteria, then iterates with the designer on visuals until approved. Captures desktop-specific decisions — target platforms, distribution channels, auto-update strategy, foreground vs background-resident — at the vision level. No implementation details. Use at the very start of a new desktop project.

CEO runs the desktop-app task execution cycle — picks the next task, sends developer to implement (renderer + preload + main slices, with Playwright `_electron` for visual verification on UI tasks), tester verifies critical IPC contracts and packaged-build behavior on demand, reviewer is the only path to ship and enforces Electron security red lines. Updates task status in `.claude/tasks/`. Repeats until milestone is complete. Use when ready to start building.

Architect produces a full Electron-app system design from the approved product vision and prototype (the **Plan** phase of the spec-driven loop) — ADRs (process model, IPC contracts, security posture, builder choice, auto-update strategy, native-module policy, persistence tier, multi-window architecture), C4 context/container diagrams, IPC contract sketches with zod, fuses table, CSP, packaging strategy, and technical verification criteria that bind back to the vision's product criteria. Use after product vision and prototype are approved.

Architect decomposes the approved Electron-app system design into milestones and INVEST-sized vertical-slice tasks (UI + IPC + main-process logic + persistence + packaging) with acceptance criteria, dependencies, and a parallelization plan (the **Tasks** phase of the spec-driven loop). Each task declares which system-design verification criteria it advances. Starts with a concrete walking skeleton — window opens → IPC roundtrip → persistence read/write → packaged installer signed + notarized + self-updating. Use after system design is approved.

Data agent designs the local persistence layer for a desktop Electron app from the system design — schema for better-sqlite3 (with WAL + foreign_keys + busy_timeout), Drizzle migrations keyed by `PRAGMA user_version`, encryption-at-rest via safeStorage-wrapped key + optional better-sqlite3-multiple-ciphers, rolling backup/restore plan, multi-window data coherence, atomic file writes via write-file-atomic. Produces `.claude/data-schema.md`. Use after system design is approved.

Designer extracts a desktop design specification from the approved HTML prototype — design tokens, component inventory, screen map with visual acceptance criteria per screen, plus the desktop-specific artefacts every Electron app needs on day one — a **menu map** (per-platform application menu), a **shortcut map** (every accelerator with its `CmdOrCtrl` form and OS-chord conflicts), and a window-state spec (single vs SDI vs tabbed; persistence; multi-monitor restore). Use after the prototype is approved.

DevOps sets up the full Electron packaging + release pipeline — Forge 7.x (default) or electron-builder, code signing for macOS (Developer ID + @electron/notarize → notarytool + staple) and Windows (Azure Trusted Signing as the post-EV-hardware default), electron-updater ≥ 6.3.9 with `verifyUpdateCodeSignature` ON, the @electron/fuses table including ASAR integrity, cross-platform CI matrix on native runners (no QEMU), `@electron/rebuild` per-arch, and client handoff guides for everything the client must do (Apple Developer enrollment, Azure Trusted Signing tenant). Produces `.claude/packaging-plan.md` plus per-action handoff guides under `.claude/handoff/`. Use after system design is approved, before or during sprint.

CEO does a quick sync for a desktop project — reviews recent changes (commits, IPC channels added, packaging config drift, electron-updater version bumps), updates the strategic knowledge base. Use regularly to stay current on the project. Faster than `brief` — surgical update, not a full refresh.

Tester drafts a test strategy for an Electron desktop app from the system design — pyramid shape, framework picks (Vitest for renderer + main pure modules; Playwright `_electron.launch()` against the **packaged** build with electron-playwright-helpers; zod IPC contract tests; @axe-core/playwright for renderer a11y), per-test userData isolation, single-instance-lock disable in tests, Linux CI `xvfb-run`, coverage map per task, Definition of Done. Use after system design and task breakdown are approved.

CEO does a quick sync — reviews recent changes, updates the strategic knowledge base with new information. Use regularly to stay current on the project.

Audit an existing team under `teams/<slug>/` for correctness, install-safety, frontmatter validity, name collisions, hook hygiene, and quality. Delegates to the `team-reviewer` subagent and returns a punch list with a verdict. Use before publishing or after substantial edits.

Scaffold a brand-new team under `teams/<slug>/` for the claude-agent-teams CLI. Gathers the goal from the user, sketches the component list, then delegates to the `team-author` subagent to generate files and verify install round-trip. Use when the user says "create a team for X" or "add a new team".

Make a surgical change to a single component (agent, skill, command, hook, script, or MCP entry) in an existing `teams/<slug>/`. Delegates to the `team-editor` subagent, which preserves the rest of the team and verifies the install round-trip. Use for targeted fixes, not rewrites.