# Build brief — a focused alternative to Aight

> **Verdict:** Partly, if you narrow it · **Buildability:** 49/100 · **Category:** Dev Tools
> **Source:** https://www.canitbevibecoded.com/aight
> Independent editorial assessment from Can It Be Vibe Coded? Not affiliated with, endorsed by, or derived from Aight. Verify current pricing and capabilities before acting.

## Context

**Aight** — Native iOS and macOS control surface for self-hosted AI agents and coding CLIs. It currently costs $4.99/mo.

A focused multi-backend iPhone prototype is a realistic build when a local companion normalizes each agent protocol, but hardening all four adapters plus Aight's hosted relay, voice, orchestration, sync, and App Store polish is a much larger body of product work.

This brief describes a focused, single-operator replacement for the part of Aight that is genuinely reproducible. It is deliberately narrower than the product it replaces, and it says so in writing. Build the useful core; do not pretend to have rebuilt the rest.

## What you are building

Build one SwiftUI client and a local adapter service that can start, resume, stream, interrupt, and approve work across Codex, Claude Code, OpenClaw, and Hermes.

- Build the focused developer workflow you use repeatedly, with local configuration.
- A responsive interface with real empty, loading, success, and error states.

## Requirements

### Functional

- Mac with Xcode.
- IPhone running iOS 18.
- Node.js 22.
- At least one supported agent installed.
- Apple ID for device signing.
- Tailscale on both devices.

### Data and integrations

- Credentials for each enabled agent.

Each of these needs a real account, credential, or quota. Set them up before writing feature code.

### Non-functional

- Accessibility: semantic markup, labelled controls, visible focus, and reduced-motion support.
- Security: server-side secrets, validated input, and no credentials in the client bundle.
- Reliability: retries with backoff on external calls, and a clear failure state when a provider is down.
- Portability: the operator can export their data and leave without losing it.

## Implementation brief

Build me a local-first iPhone client for Codex, Claude Code, OpenClaw,
and Hermes. Requirements:

- Use Swift 6, SwiftUI, and iOS 18. Generate Xcode from a checked-in
  XcodeGen project.yml so `xcodegen && xcodebuild` works on a clean clone.
- Build the Node.js 22 TypeScript companion with Fastify and WebSockets. Expose
  start, resume, prompt, event, approval, interrupt, and capability operations;
  session listing is optional and capability-gated.
- Ship real adapters for all four. Disable unavailable agents at runtime; all
  adapters must compile and pass fixture tests without every agent installed.
- Codex: pin the CLI version, run `codex app-server generate-ts`, and supervise
  app-server over stdio using the generated v2 types.
- Claude Code: use `@anthropic-ai/claude-agent-sdk`, its session APIs,
  async-iterable input for interrupt(), and canUseTool for permissions.
- OpenClaw: use the official Gateway WebSocket client, pair once, request only
  read/write/approvals/questions scopes, and store its device token securely.
- Hermes: use /v1/runs and its event, approval, and stop endpoints; use
  session headers for continuity and discover features from /v1/capabilities.
- Keep backend models in the companion and expose one versioned protocol. The
  iOS app stores its wss:// endpoint and bridge bearer token in Keychain.
- Provide backend/session pickers, streamed Markdown and tool events, approval
  cards, Stop, capability-aware controls, and deny approvals on disconnect.
- Bind to 127.0.0.1 and compare the random `.env` token in constant time;
  expose it only through private Tailscale Serve HTTPS, and never enable Funnel.
- Add bounded reconnects and local completion notifications. No app accounts,
  cloud database, analytics, or telemetry; agent model-provider calls remain.
- Out of scope: hosted relay, voice, cross-backend groups, templates, community
  skills, themes, multi-device sync, and a macOS client.
- Test adapter fixtures plus denial, interruption, and reconnection. README:
  setup for all four, `.env.example`, Tailscale, signing, permissions, limits.

## Delivery standard

- Inspect the repository first, then write a short implementation plan before writing code.
- Deliver the smallest complete end-to-end workflow first; every primary control must work against persisted data.
- Use real validation and storage; never substitute fake dashboards, decorative controls, hard-coded success states, or mock integrations.
- Include responsive layouts plus genuine empty, loading, success, validation, and failure states.
- Keep secrets server-side in environment variables, provide .env.example, and never commit credentials or user data.
- Add structured logs around every external call and return actionable errors without leaking sensitive details.
- Write unit tests for the core logic and one automated test of the main user journey.
- Finish with a README covering setup, architecture, data location, backups, tests, deployment, and known limitations.

## Acceptance criteria

- [ ] A clean install starts the app using only the README and .env.example.
- [ ] The primary journey works from first visit through saved result, reload, edit, export, and deletion where applicable.
- [ ] Invalid input, missing configuration, provider failure, and an empty database each have a usable state.
- [ ] The interface works at 390px and 1440px, is keyboard navigable, and shows visible focus on every control.
- [ ] Tests, type checking, linting, and a production build all pass with no ignored failures.
- [ ] No part of the interface implies a live integration, security guarantee, or scale capability that was not actually built and verified.

## Non-goals

Do not build these, and do not claim to have replaced them:

- Managed encrypted relay and push notifications.
- Voice mode with local speech models.
- Cross-agent teams and group-chat orchestration.
- Pre-built agent/team templates and community skill browsing.
- The last 20 percent is sync, migration fidelity, speed, and edge cases.
- Connectors, OAuth flows, and vendor API changes require constant upkeep.

## What you still own after launch

- Run migrations, backups, restores, and dependency updates.
- Test the critical journey after every model, API, or hosting change.
- Monitor failures and fix the edge cases a first prompt will miss.
- Maintain every third-party integration as APIs and OAuth rules change.

## Risk

**Operational risk.** The code is achievable; dependable data, integrations, and ongoing operations are the real cost.

Editorial confidence in this assessment: high. No independent one-shot implementation is linked yet.

## Prior art

Working open-source software you can read, fork, or borrow from before starting:

- [Happy](https://github.com/slopus/happy) — Open-source mobile and web client for Codex and Claude Code with end-to-end encryption
- [CodexAppMobile](https://github.com/shuto-S/codex-app-mobile) — Open-source SwiftUI iOS client for a remote Codex app-server

---

Generated by [Can It Be Vibe Coded?](https://www.canitbevibecoded.com) · Full report: https://www.canitbevibecoded.com/aight