Desktop Coding Stack

A governed Windows-first control plane that lets Codex coordinate, build, test, review, and recover across repositories with evidence-bound autonomy.

Comment

Inspiration

AI coding agents are powerful, but autonomy becomes fragile when real work spans multiple repositories, worktrees, pull requests, CI, reviewers, credentials, and human authority. Context gets lost, two agents can take the same lane, reviews become stale after code changes, and “done” can be claimed without proof.

I wanted a local workspace where Codex could do substantial engineering independently while every important action remained bounded, reversible, and auditable.

What it does

Desktop Coding Stack turns a Windows workstation into a governed, multi-repository AI development control plane.

  • A workspace map defines canonical repositories, safe worktree locations, retained evidence, and no-write zones.
  • Doctor, enter, and sync commands make the workspace easy to start and verify.
  • Builder remains the governance source of truth while Codex executes bounded work in disposable worktrees.
  • One-owner rules prevent duplicate writers and cross-lane collisions.
  • Evidence receipts bind claims to an exact repository, base, head, tree, validation run, and reviewer identity.
  • Replacement heads invalidate stale review conclusions.
  • Deterministic validators, schemas, CI, negative controls, rollback rules, and stop conditions make failures explicit.
  • Tool and model routing remain separate from permissions and authority.
  • The stack supports Python, PowerShell, TypeScript/React, GitHub Actions, and local-first workflows without storing secrets in the repository.

The result is not an “agent that can do anything.” It is infrastructure for reliable autonomy: agents can move quickly inside an accepted envelope and fail closed when they reach a real boundary.

How we built it

The project is Windows-first and intentionally uses simple, inspectable components:

  • PowerShell for operator entry points and orchestration wrappers
  • Python for validation, automation, evidence processing, and agent-runtime logic
  • YAML and JSON Schema for machine-readable contracts
  • TypeScript, React, and Vite templates for product surfaces
  • Git and GitHub protected pull requests for change delivery
  • pytest, Ruff, Vitest, Playwright, deterministic fixtures, and negative controls for verification

Codex with GPT-5.6 was used as the primary engineering agent. It inspected live repository and worktree state, implemented bounded changes, generated tests and fail-closed controls, reconciled replacement heads, diagnosed CI failures, and produced evidence-bound handoffs. It also coordinated independent review lanes without treating a review result as merge authority.

Challenges we ran into

The hardest part was not generating code. It was proving that concurrent agents were operating on the correct repository, branch, worktree, scope, and authority.

Windows shell behavior, command-permission matching, stale Git locks, long-running reviews, mutable pull-request heads, and privacy-sensitive evidence exposed failure modes that happy-path automation misses. We addressed those by making identity and proof first-class: exact hashes, deterministic manifests, one-writer ownership, explicit acceptance phases, fresh review after replacement heads, and immutable review packets.

Accomplishments that we're proud of

  • A working, portable entry point for a multi-repository AI development workspace
  • Reproducible health checks and machine-readable workspace contracts
  • Governed one-owner worktrees and collision-aware routing
  • Privacy-safe, exact-head evidence and review flows
  • Deterministic negative-control testing
  • A reusable foundation that qualifies and adapts proven components instead of rebuilding them by default

What we learned

Reliable agentic development is primarily a systems and product-design problem. A capable model still needs clear outcomes, constrained authority, exact evidence, independent verification, and a safe way to stop.

More tools and more agents do not create autonomy by themselves. Coherent contracts do.

What's next

The next phase is a unified Operator experience that presents work, decisions, evidence, outcomes, and recovery in one interface while preserving the same authority and verification model underneath. Existing components will be reused or adapted when they satisfy the target contract and replaced only when reuse would compromise integrity.

Built With

Share this project:

Updates