Kun Chen, ex-Meta L8 engineer and ex-Microsoft, demos his full agentic development workflow live. Everything he builds is open-source. The core insight: he spends most of his time in the planning phase using visual artifacts, trusts agents to do all the coding, and runs a heavy automated validation pipeline that he doesn’t need to watch.
Plan heavy, code light
The key structural shift from traditional coding: most of Kun’s time goes into planning, not coding. He writes detailed specs with measurable goals before letting agents loose. The more precise the plan, the longer agents can run autonomously without needing re-prompting.
Short prompt = agent finishes quickly, needs you back in the loop. Detailed spec with measurable goal = agent experiments and iterates independently for much longer. His flow starts from a screenshot of the current UI, points out what’s wrong, and asks the agent to propose options visually rather than dumping a wall of text.
Visual planning via Lavish
Lavish (open source, npx lavish-axi) is an HTML-based artifact editor Kun built after reading the “HTML over Markdown” article. Instead of agents returning plain markdown plans, they generate rich interactive HTML artifacts that are far easier for humans to scan and interact with.
The key advantage: you can annotate directly on the artifact. Click a section, say “I don’t like this”, and the agent gets pinpoint feedback. No copy-pasting, no describing where in a long wall of text the problem is. The agent proposes multiple visual options (e.g. four layout directions for a screen redesign) with buttons to select one. Selecting sends structured feedback back to the agent’s context.
He embeds best practices into Lavish itself - the agent already knows how to collaborate this way when it calls the tool.
Parallel sessions and Treehouse
Kun keeps at least 5-10 active agent sessions simultaneously, totalling 20-30 agents. While one agent codes or validates, he switches to another session. He never stares at a running agent waiting for output.
The bottleneck was git worktree management. Git worktrees are useful for parallel dev sessions but have high cognitive load - you have to remember which worktree is doing what, which ones are safe to clean up, and dependencies aren’t pre-installed in new worktrees.
He built Treehouse to solve this: a dead-simple CLI that manages a pool of worktrees with pre-installed dependencies. Every time he needs a new session, he just types treehouse and gets dropped into a ready-to-use worktree. Zero cognitive overhead.
No Mistakes validation pipeline
Kun doesn’t review agent-generated code line by line. He built No Mistakes (nm alias), an automated pipeline that runs every time an agent finishes a change:
- Branch creation - agent names and creates a branch automatically
- Rebase - rebases on latest remote main to avoid merge conflicts later
- Review - a fresh-context agent scrutinizes the change. Fresh context is deliberate: reviewing in the same session that wrote the code is heavily biased. A new agent with no shared context catches far more edge cases
- Auto-fix vs. escalate - obvious bugs get auto-fixed silently. Changes with product implications get escalated to Kun for judgment
- Test - runs end-to-end tests (not just unit tests) with evidence: screenshots or videos proving the change actually works and doesn’t regress other flows
- Documentation - finds and updates all docs affected by the change
- Push and create PR - generates a PR with intent summary, change list, risk assessment, and test evidence
Kun validates the pipeline by running it in parallel with his own manual review until he found he “never catches anything the agents don’t catch”. He skips the full pipeline only for trivial documentation changes. For medium/high risk PRs, he reads the diff. For low risk, he just skims the risk assessment and merges.
10x velocity breaks org processes
When one person ships 20-40 PRs/day, traditional team workflows break. PR review queues become impractical. Kun observed this at his last company - he had to deliberately slow down because the team couldn’t keep up.
Smaller startups are adapting by treating PRs as records rather than blocking gates, merging immediately and relying on agent reviews. The trade-off is stability, but Kun argues that a proper validation pipeline (No Mistakes) closes that gap.
Move yourself out of the loop
The meta lesson: whenever Kun finds himself doing something manually in his dev workflow, he turns it into an agent instruction or tool. The goal is to reduce the parts of the workflow that need him to the planning phase (beginning) and the occasional escalated judgment call (end). Everything in between should be agents running in parallel while he works on the next thing.
His advice for getting there: build lots of things (“even throwaway toys”), use more tokens and run more agents in parallel (it’s a forcing function to move yourself out of the loop), and adopt AI in every part of your workflow, not just coding.
Lessons worth keeping
- Invest time in planning with measurable goals - it unlocks longer autonomous agent runs
- Interactive HTML artifacts beat walls of markdown text for human-agent collaboration
- Review agent code in a fresh context window, never the same session that wrote it
- Build tools for your own friction points - Kun built Lavish, Treehouse, and No Mistakes because nothing else fit
- If you’d slow down your team by shipping faster, the org process is the bottleneck, not you
- Running agents in parallel forces better workflow design by removing you from the loop
Related
Sources
Peter Yang / How This Ex-Meta L8 Engineer Ships 40 PRs a Day with AI Agents | Kun Chen Full transcript: kun-chen-40-prs-ai-agents