David Ondrej interviews Kun Chen (ex-L8 Meta, ex-Microsoft, ex-Atlassian) about his complete agentic engineering setup. This goes deeper into First Mate (the coordinator agent) and why each tool exists than the Peter Yang interview did.
First Mate: the coordinator pattern
Kun previously managed 20-30 parallel agent sessions manually, juggling tabs and remembering what each was doing. First Mate is his solution: a single agent he talks to that delegates tasks to crew mates. He never looks at the individual sessions anymore - he brain-dumps thoughts to First Mate and it routes work to the right agent with the right model.
The key design choice: First Mate does not do the work itself. If it did, Kun would be blocked from talking to it while it ran. Instead, First Mate dispatches tasks and returns control, while crew mates execute independently. This means Kun is constantly in “brain dump mode” - dumping thoughts and letting First Mate handle everything else.
First Mate’s logic lives in an agents.md file plus bash scripts in a bin/ folder. The scripts handle deterministic steps so First Mate does not waste tokens on obvious operations. Both are in the current directory, so First Mate can modify itself - it patches bugs in its own scripts as it discovers them, making the system “unstoppable” in Kun’s words.
Herder: agent-aware terminal multiplexer
Kun switched from tmux (10+ years) to Herder, a modern terminal multiplexer that understands agents natively. It shows which sessions have active agents working, which are idle, and lets Kun jump directly to any crew mate session when he needs to bypass First Mate and check details directly.
His terminal: Wezterm in frameless mode (no window borders, background blur). Purely aesthetic choice - he wants it to “look good” because he stares at it all day.
Model routing strategy
Tiered routing based on task complexity:
- First Mate agent itself: GPT 5.6 Soul on x-high. Needs the reasoning to rationalize context across projects and dispatch correctly.
- High-complexity design: Fable (Claude). Kun values Fable’s depth and creativity for complex technical/product designs. However, he’s almost out of quota and saving the remainder for tasks that genuinely need Fable.
- Default crew mates: GPT 5.6 Soul on varying reasoning levels.
- Home assistant: Luna - only because it’s fast enough for real-time control of lights and music.
- Grok 4.5: Kun describes it as “Opus but on fast mode.” Fast, capable, but banned in the EU so he can’t use it day-to-day. Grok Build gives free X API access (read posts, search) which otherwise costs money.
Kun avoids open-source models locally because his Mac Mini is his primary compute - running a local LLM would compete with his actual development builds.
The $200 quota problem
Kun hits subscription quota limits consistently. He wants a $500 LLM tier - his monthly spend would be $10,000+ on API pricing, which is not sustainable for an individual. He also wants a slow/cheap mode: many background tasks don’t need speed, they need token throughput. He wishes providers would offer a “slow as possible, dirt cheap” tier for overnight tasks.
Model efficiency insights
Kun shares a key observation from the DeepU benchmark: Sonnet 5 on max reasoning is more expensive than Fable because the model isn’t intelligent enough for that reasoning level - it just wastes cycles thinking hard but not solving the problem. Same dynamic with Luna: it has a tall performance curve, so at high reasoning it burns tokens without proportional gains. Luna’s sweet spot is fast, low-reasoning tasks.
Soul on x-high is Kun’s sweet spot - fast enough, intelligent enough, doesn’t burn tokens unreasonably. He sees little reason to use Terra (Opus) when he can just lower Soul’s reasoning level and get a smarter model cheaper.
Lavish for interactive design reviews
When a design decision has complex tradeoffs, First Mate uses Lavish to generate interactive HTML artifacts (whiteboards with diagrams). Kun can move boxes around, click sections, give feedback, and the agent responds with pinpoint relevance. This replaces the “long wall of text in the terminal” pattern that slows down human-agent collaboration.
No Mistakes validation pipeline: 3-month stats
Kun’s automated code review pipeline runs on virtually every change across 59 repos, ~1000 changes over 3 months. 63% of changes had a mistake caught. The breakdown:
- Adversarial review catches most bugs and edge cases. Kun finds GPT models (especially 5.5+) excellent as reviewers - thorough at identifying edge cases.
- Documentation is the second-biggest hitter - agents frequently make changes without updating stale READMEs and docs.
- The pipeline also handles rebasing, testing with visual evidence, linting, and PR creation with risk assessment.
The key insight: reviewing in a fresh context window is critical. An agent that wrote the code is biased; a fresh agent with no shared context catches far more problems.
Baby Menu: self-modifying software
Kun built Baby Menu, a menu bar app that aggregates GitHub stats, CPU/memory, and Claude/Codex quotas. It started empty and Kun told it what he wanted - it self-modified into something no company would ever build as a product. Kun sees this as the future of software: ship a reasonable base experience, then let users (via their agents) customize it endlessly through conversation. Self-healing loops too - report a bug, an agent fixes it, creates a PR, Code Rabbit reviews, the fix ships within 20 minutes.
Harness preferences
- Pi: primary harness for GPT 5.6. Highly customizable, plugin architecture, built-in Lavish support. Preferred over Codex CLI because Codex lacks features like background process polling.
- Claude Code: used when working with Anthropic models (Anthropic bans non-Claude-Code harnesses).
- Open Code: also smooth TUI, but Kun leans toward Pi.
- Codex CLI: has some strengths (image generation out of the box) but lags in general CLI experience.
The future of software
Kun predicts a massive rebuild of SaaS products: the human UI layer (clickable dashboards, forms) will fade as agents become the primary consumers of software services. Products need headless interfaces designed for agents, not humans. The company that nails the “new GitHub” will win by making their service agent-native, not by bolting on an API.
Lessons worth keeping
- Delegate all routine operations to a coordinator agent; humans should only make ambiguous decisions
- First Mate’s self-modifying
agents.md+ scripts pattern makes the system resilient to bugs - intelligent software cannot be stopped by traditional bugs - Use a fresh context window for code review, never the same session that wrote the code
- 63% of changes will have bugs caught by adversarial review - running this pipeline is not optional at scale
- The $200/month LLM tier is insufficient for heavy agent usage; API pricing is worse ($10k+/mo)
- Prefer slower/cheaper model tiers for background tasks, faster/expensive for interactive ones
- Model selection should be task-routed: coordinator needs reasoning, executors need capability, home assistant needs speed
- Terminal-based setups (Wezterm + Herder) with agent-aware multiplexing reduce cognitive load from session juggling
- Ship tools for your own friction; Kun built all his because the market had nothing that fit
Related
- How This Ex-Meta L8 Engineer Ships 40 PRs a Day with AI Agents
- Fable 5 vs GPT 5.6
- Ultra Mode in Codex
- Codex System Prompt Exposed
- Economics of AI Reasoning
Sources
David Ondrej / L8 Principal’s Agentic Engineering Setup (just copy him) Full transcript: kun-chen-agentic-engineering-setup