Coding Wife

A Live2D pair-programming workspace that turns long-running Codex sessions into bounded decisions, reviewable commits, and human-readable evidence.

Comment

Inspiration

Coding agents can write and test meaningful changes, but developers still have to reconstruct what happened across chat, tool output, file edits, tests, and Git history. As a session grows, the review burden grows with it: What changed? Why? Was it verified? Where is human judgment still required?

At the same time, a purely transactional agent interface can make a long coding session feel isolating. We wanted the rigor of a reviewable local development workflow and the warmth of working beside someone who reacts to progress. That led to Coding Wife: a bilingual native workspace where Codex can do real repository work, a Live2D character makes that work feel present, and the resulting commit remains easy to inspect.

What it does

Coding Wife brings a coding session, character presence, and commit review into one desktop workspace.

  • GPT-5.6 Sol (gpt-5.6-sol) runs the main Codex session. It is the only model role with coding tools and write authority: it can understand an open-ended task, inspect the repository, edit files, run verification, and create a commit.
  • GPT-5.6 Luna (gpt-5.6-luna) is an isolated, zero-tool presence director. It receives only a bounded, privacy-screened excerpt from an eligible completed Sol message. Its validated reaction drives a short caption plus the Live2D character's expression and motion, with optional text-to-speech.
  • GPT-5.6 Terra (gpt-5.6-terra) is an isolated, zero-tool commit explainer. It can receive only bounded read-only evidence from a verified commit; it never joins Sol's write-capable session.

The roles form one orchestration pipeline without sharing authority. Deterministic TypeScript and Rust contracts route each exact model, bound and redact inputs, validate outputs, deduplicate events, and fail closed on unsupported data.

The interface is intentionally quiet. Chat omits speaker labels, timestamps, and decorative success checks. Tool rows communicate the kind of action and command; successful work stays visually quiet, while failure receives restrained red emphasis. Commit changes follows a familiar GitHub-style hierarchy: commit summary, changed files, additions and deletions, search, and a selected unified diff with old and new line numbers. This reduces the amount of agent-internal metadata a developer must read before judging the actual patch.

How we built it

React 19 and TypeScript render the bilingual workspace, semantic timeline, Live2D stage, and Git review experience. Tauri 2 and Rust form the native trust boundary around the authenticated local Codex App Server, typed IPC, process supervision, redacted SQLite recovery, optional speech, and path-bounded read-only Git observation. The WebView has no generic shell, arbitrary filesystem, or arbitrary Git authority.

We also used Codex as the implementation partner for the Build Week project. Humans wrote behavior, user journeys, acceptance criteria, and authority boundaries; Codex traced the frontend, native, persistence, and test surfaces and implemented bounded vertical slices. Focused agents worked in parallel where tasks were independent, while meaningful commits preserved the reasoning and verification trail.

The most useful instructions were product constraints rather than one giant implementation prompt. We repeatedly directed Codex to:

  1. keep the main session capable of genuine coding work;
  2. connect downstream model output to Live2D speech, expression, and motion without giving it technical authority;
  3. reduce human review load through concise chat and a GitHub-like diff experience;
  4. prioritize the hackathon baseline, documentation, demo evidence, and downloadable release over lower-value polish; and
  5. parallelize independent work, commit at coherent boundaries, and restrict late fixes to important issues.

Those constraints shaped both the product and our development process. They made authority, evidence, and failure behavior explicit instead of leaving them as assumptions inside a long agent conversation.

Challenges we faced

The hardest engineering problem was translating a rich asynchronous Codex protocol into a stable product story. Tool activity, completed messages, decisions, interruption, process recovery, and UI remounts can overlap. Rendering the raw stream would have created another log viewer, so we built a semantic event model with strict workspace, generation, thread, and sequence identity plus bounded persistence and recovery.

The hardest product problem was balancing personality with trust. A character can make progress legible and delightful, but it must never hide a failed test or imply that work was verified. Luna therefore owns presentation only. Its text is privacy screened, its output is constrained, and equivalent captions remain visible even when speech is off.

Terra exposed another important boundary during the accepted demo. The provider rejected its bounded user_request and one user_retry before generation. Coding Wife recorded the explanation as unavailable and failed closed with zero tools and zero writes. We deliberately show that result instead of fabricating a successful explanation. The failure demonstrates why Terra is isolated from Sol and why unsupported provider events cannot become review evidence.

Desktop distribution was also demanding. The app must preserve Live2D and dependency notices, package native resources correctly, and remain honest about unsigned distribution. We prepared a public macOS Apple Silicon judge build and a cross-platform v0.1.6 release candidate; at the time this story was prepared, v0.1.6 was still moving through Pull Request and release checks rather than being claimed as published.

Accomplishments that we're proud of

  • The accepted 2:45 demo records a real gpt-5.6-sol coding turn on a disposable repository, three passing tests, and commit d68adc0.
  • Two distinct gpt-5.6-luna reactions visibly change the caption, Live2D expression, and motion while Luna retains zero tools and repository authority.
  • The same verified patch appears in the GitHub-style Commit changes view, tying agent activity to reviewable Git evidence.
  • Terra's provider-policy rejection is presented truthfully as an unavailable, fail-closed result rather than a generated explanation.
  • The public macOS judge build can be downloaded without rebuilding, and the final video passed full-frame privacy, media, caption, and audio QA.
  • The repository contains typed cross-boundary contracts, focused regression tests, bilingual documentation, legal notices, release automation, and a reproducible judge path.

What we learned

Agent supervision is primarily an evidence and continuity problem, not a chat-volume problem. A coherent chain from request to actions, verification, and commit is more valuable than a larger transcript.

We also learned that multi-model orchestration is strongest when roles differ by authority, input boundary, and latency—not merely by personality. Sol needs full coding context and tools. Luna needs a small live signal and fast presentation response. Terra needs immutable commit evidence and no write path. Deterministic software should enforce those boundaries before and after every model call.

Finally, personality and rigor can reinforce each other. Live2D presence makes the session feel human, while typed boundaries and honest failure states keep that presence trustworthy.

What's next for Coding Wife

First, we will finish the reviewed v0.1.6 distribution and validate the downloadable installers on their native platforms. Next, we want to broaden production parity beyond the current macOS Apple Silicon full-flow target, improve compatibility diagnostics for Luna and Terra provider events, and study whether the combined timeline and commit review measurably reduce review time. Code signing, notarization, automatic updates, remote collaboration, and broader character tooling are later milestones; we do not claim them today.

Built With

  • codexappserver
  • git
  • gpt-5.6
  • hiyorilive2dmodel
  • live2dcubismsdk
  • node.js
  • openai
  • openaicodex
  • openaitexttospeech
  • pnpm
  • radixui
  • react
  • rust
  • shadcn-ui
  • sqlite
  • tailwindcss
  • tauri
  • typescript
  • vite
  • vitest
  • webdriverio
Share this project:

Updates