Y CombinatorConductor CEO Charlie Holtz Walks Us Through His AI Coding Setup
CHAPTERS
- 0:00 – 1:01
Charlie’s AI-first coding workstation: Conductor + voice-driven control
Charlie Holtz introduces Conductor and immediately frames a shift toward talking to computers more. He shows how a simple microphone setup supports frequent voice commands in a busy office environment.
- •Conductor orchestrates multiple coding agents on a Mac
- •Gooseneck mic enables low-friction voice prompting
- •Voice interaction is encouraged as a team habit
- •Open office dynamics make quiet voice input useful
- 1:01 – 2:01
Running multiple agent workspaces in parallel (and reviewing AI output fast)
Charlie demos his core workflow: spinning up new agent workspaces with shortcuts, letting agents work in the background, and bouncing between tasks. He reviews AI-generated PRs, leaves targeted comments, and keeps iteration tight.
- •Create new tasks quickly (keyboard-driven) and let them run in sidebar
- •Parallelize work by switching chats/workspaces while an agent executes
- •Review small PRs quickly; comment when output looks off
- •Treat AI like a collaborator that needs feedback loops
- 2:01 – 2:32
Experimentation as the default: many ideas, few merges
Conductor is used as an experimentation engine—Charlie starts lots of workspaces to explore ideas, expecting many to be discarded. Successful experiments get promoted into more official settings.
- •Many parallel experiments are normal; most won’t ship
- •Workspaces/PRs serve as disposable exploration units
- •Promote only the best experiments into internal/experimental settings
- •Keeps the main codebase stable while exploring broadly
- 2:32 – 2:40
‘Conductor on the go’: starting agent work from your phone
Charlie demonstrates initiating development work from mobile—speaking a feature request into his phone and triggering the computer to begin. The goal is to keep development moving even when away from the laptop.
- •Mobile voice prompt to start a new feature task
- •Agent execution continues on the desktop machine
- •Reduces dependency on being seated at the computer
- •Extends orchestration mindset beyond the workstation
- 2:40 – 3:42
Does the CEO still hand-code? ‘Caveman Mode’ and micro-edits
Charlie explains he rarely writes code manually now, aside from occasional small edits like Tailwind tweaks or environment changes. Conductor includes ‘Caveman Mode’ for direct file editing, but the default is AI-assisted edits via comments or voice instructions.
- •Manual coding is the exception, not the norm
- •‘Caveman Mode’ exists for necessary direct edits
- •Small UI tweaks are often done by telling the AI what to change
- •Workspaces get archived after merge to keep the system clean
- 3:42 – 4:22
Managing agent work like a dashboard: status, checks, and “CEO of a little company”
Charlie shows how Conductor tracks work through stages (in progress → review → done) and experiments with a dashboard view for centralized oversight. The product vision is that users supervise agents like a small company, receiving digestible reports and steering decisions.
- •Status organization: in progress, review, done
- •Dashboard concept: one place to see all agent work and next actions
- •Human role: review, correct, merge, and redirect
- •UI is still evolving to match the oversight metaphor
- 4:22 – 4:58
Other tools in Charlie’s stack: Telegram, local TTS, and hardware choices
Charlie lists supporting apps he uses around Conductor, including Telegram and a local text-to-speech setup. He notes his high-RAM machine enables local models, while also experimenting with low-spec hardware to pressure-test workflows.
- •Telegram for communication (including AI-related workflows)
- •Spokenly for local text-to-speech; Parakeet model
- •High-end Mac (128GB RAM) to run local models
- •Also buying a low-spec MacBook to force constraint-driven usage
- 4:58 – 5:28
Customizations that matter: skills files, ‘Claude MD,’ fast mode, and MCP docs
Charlie highlights the specific customizations that compound over time: large instruction/skills documents and engineered guidance for how the AI should behave in a startup context. He also emphasizes fast mode for heavy usage and a documentation MCP for better context.
- •Extensive ‘Claude MD’/skills files encode engineering norms and constraints
- •Explicitly steer away from enterprise-style overengineering
- •Fast mode as a deliberate choice for high-throughput use
- •Context/documentation via an MCP (Context 7)
- 5:28 – 6:33
Permissions and quality control: ‘slop-free zones’ and human-owned code
Charlie describes a deliberate quality strategy: run agents with broad permissions, but protect critical areas with ‘slop-free zones’ that require human review. This prevents negative feedback loops where AI trains on AI-generated mess and worsens the codebase.
- •Agents run with ‘dangerously accept all permissions’ for speed
- •‘Slop-free zones’ designate human-authored, carefully reviewed areas
- •AI can contribute only if every line is human-read
- •Protects against compounding low-quality code patterns
- 6:33 – 7:04
Conductor’s tech stack: Tauri + TypeScript, plus Elixir/Phoenix on the web
Charlie outlines Conductor’s implementation: a Tauri desktop app with a Rust backend but mostly TypeScript, and a small Elixir/Phoenix web app. He also expresses a strong preference for Elixir where it fits.
- •Desktop: Tauri using Safari WebKit renderer
- •Backend technically Rust; majority of code is TypeScript (90–95%)
- •Web: Elixir Phoenix app (currently minimal functionality)
- •Strong internal advocacy for expanding Elixir usage
- 7:04 – 8:05
Product principle: don’t let the AI be your architect (UI and abstractions need humans)
Charlie argues that key abstractions (like workspaces) and interface decisions must be human-designed to feel crafted. He walks through UI choices and explains why delegating architecture/design to AI can produce unopinionated, uncrafted products.
- •Humans must define core abstractions (e.g., what a ‘workspace’ means)
- •UI layout decisions require intentional craft
- •Example: deliberation around ‘Open in’ behavior and icon display
- •AI-driven design risks losing cohesion and product taste
- 8:05 – 9:35
Where AI gets free rein: contracts, protected core APIs, and enforced PR workflows
Charlie explains a boundary-based approach: keep core APIs/contracts human-owned while letting AI iterate aggressively on peripheral areas. Conductor also enforces a PR-based workflow (worktree → PR → merge) by design to keep changes reviewable and structured.
- •Prefer human-written contracts/APIs at the core
- •Allow AI to explore freely in non-core areas to accelerate iteration
- •Current boundaries are ‘murky’ and being refined
- •Workflow enforcement: no direct edits; changes flow through PR creation and merge
- 9:35 – 9:52
Staying ahead of the frontier: long-running agents and cloud workspaces
Charlie discusses adapting the product to rapidly improving models and longer autonomous runtimes. He anticipates a shift from laptop-bound agents to cloud environments where agents run longer and smarter without local CPU constraints.
- •Tooling must evolve with model capabilities
- •Laptop sleep currently stops agents—this will change
- •Future: agents run 10x longer, 10x smarter
- •Cloud execution environments become necessary as autonomy increases
- 9:52 – 10:40
How Conductor builds conviction: daily dogfooding over analytics
Charlie explains the company’s decision-making style: heavy internal usage and gut feel rather than A/B tests or analytics. The product’s opinionation is reinforced by constant real-world friction testing by the team.
- •Conviction comes from using the product every day
- •Preference for gut feel vs analytics-heavy iteration
- •Aim: flexibility without losing strong defaults
- •UI ‘feels right’ is treated as a legitimate design signal
- 10:40 – 12:53
Claude Code vs Codex, GUI vs terminal, and the economics of tokenmaxxing
Charlie compares when he uses Claude vs Codex, arguing Codex is a durable workhorse while Claude (Opus) is more collaborative and creative. He also defends GUI-first tooling over terminal-only workflows and shares the scale (and philosophy) of token spend.
- •Codex: persistent debugger/workhorse; heavy tool-call tolerance
- •Claude/Opus: better creative partner and back-and-forth for new features
- •GUI beats terminal for human spatial reasoning and richer interactions
- •Tokenmaxxing: heavy spend early ($22k/month), fast mode, high-effort prompts; keep code size under control
- 12:53 – 16:34
Workflow changes, surprising user hacks, and the future: malleable software and ‘code as sawdust’
Charlie notes he now relies less on IDEs and GitHub web UI because Conductor centralizes review and checks. He shares surprising community behavior (mobile hacks, ‘Garry mode’) and ends with a broader thesis: prompts matter more than code, and software will become modifiable like games.
- •Less manual IDE work; review/comments and checks integrated into Conductor
- •PR checks and a ‘checks tab’ bring GitHub feedback into the workflow
- •Surprising hack: a user-built mobile Conductor via IPC spoofing; ‘Garry mode’ exposes tool calls
- •Future: deeper human+AI collaboration (sub-agents, multiplayer); prompts as durable artifacts; software modding as a norm
