Every morning, Camille opens his terminal. Eight new pull requests are waiting for him. Created, reviewed, and pre-approved while he was asleep.
Not by a team. By his agents.
In this episode of Build with AI, Tanguy Goretti (CTO at Hexa) sits down with Camille Epitalon, CTO and co-founder of Verso, a startup he built entirely solo on the technical side in three months, with over twenty paying enterprise clients already on board. Camille opens his terminal live and walks through, brick by brick, the setup that makes it all possible.
Verso: A full-AI qualitative research platform
Before diving into the setup, a word on what Verso actually does, because it’s inseparable from how Camille codes.
Verso is an AI-native qualitative research platform. In practice: where agencies like Kantar or Ipsos used to charge €100,000 and three months of lead time to conduct qualitative consumer interviews, Verso delivers the same output in three days for a few thousand euros.
The product covers the entire chain: an AI agent co-designs the interview guide with the client, other agents recruit participants, an AI moderator conducts the interviews (video, audio, screen share, emotion analysis), and researcher agents produce a dynamic report from the raw data. The client can then query that data through a built-in chat interface.
The philosophy: giving codebase ownership to your agents
From the very first minutes, Camille lays out the mental framework for everything that follows:
“From day one, I told myself: I’m handing ownership of my codebase to my agents. The codebase belongs to my agents.”
It sounds radical. But Camille is precise about what it means and more importantly, what it doesn’t mean.
Delegating ownership doesn’t mean letting go of the wheel. It means investing heavily in what he calls harness engineering: everything that surrounds the codebase so that agents operate within a safe, consistent, and opinionated framework.
Two conditions are non-negotiable, according to him:
1. Solid foundations in the code. Clear abstract classes, well-defined contracts, enforced patterns. For example, all his repos inherit from an OrgScopedRepo: which ensures that when an agent creates a new repo, it automatically picks up all the security and authentication abstractions. The agent doesn’t need to be told the rules: they’re baked into the structure of the code.
2. Well-equipped agents. Not just with instructions, but with the right tools to observe the environment: logs, tracking, GitHub, CI. An autonomous agent needs to be able to connect to everything it needs to make decisions without constantly asking its human.
The live setup: 6 worktrees, aliases, a terminal as cockpit
Camille moved from VS Code and Cursor to... his terminal.
His setup is built around 6 permanent worktrees, each associated with a color in his terminal (via iTerm). When he opens a profile, the worktree automatically re-syncs with main. The entire lifecycle (reset, sync, opening a PR) is managed through aliases. To launch Claude Code, he types c. Codex: x. Full dev environment: d.
The metaphor he uses is vivid: “My six worktrees are like six different engineers. I try to avoid having them work on the same thing.”
In practice, each worktree maps to one PR. Camille works async, he kicks off a task, switches to another worktree while the first one runs, and comes back to check the result later. Six instances in parallel, but never all active at the same time.
The cron jobs that code through the night
This is the part that raises eyebrows.
Every two hours, and especially overnight, cron jobs launch Claude or Codex agents in headless mode from Camille’s Mac. These agents follow predefined skills, do their work, and open pull requests on GitHub. In the morning, Camille just has to review them.
These cron jobs are primarily focused on clean code and refactoring. A few concrete examples:
Backend audit: reads the Python/FastAPI guidelines, produces a report prioritized by criticality and fix complexity, then picks the best value/effort trade-off to create a targeted PR.
Frontend audit: same principle on the React/TypeScript side.
Skills sync: checks every day that the .claude and .codex config folders are in sync - if a skill was updated on one side but not the other, a PR is automatically opened.
Simplify skill: a Claude built-in skill that identifies over-complex areas in the codebase and proposes simplifications.
The logic: rather than blocking a large refactoring project, agents chip away every night at small, targeted improvements. Day after day, the codebase cleans itself without friction.
“Verso is the codebase that never sleeps.”
The Ralph Loop: launch a feature before bed
For heavier features, Camille uses the Ralph Loop.
The concept: a bash loop running continuously in the terminal. At each iteration, it reads a Markdown spec written upfront, consults a tracking file that records where the implementation stands, spins up a new agent (Claude Code or Codex) to handle only the next step, and updates the tracking file with learnings and results.
Each agent operates with a fresh context and a limited scope, avoiding context bloat and drift over long tasks. The source of truth is never in the context window: it’s in the filesystem.
In practice: Camille writes the spec with an agent’s help before heading to lunch or going to bed. He launches the ralph loop. When he comes back, the feature is implemented, or close to it.
Camille notes that some sessions can burn through all his API credits in a single night on ambitious tasks.
The automated review chain
No PR ships without going through multiple layers of review. Here’s the full chain:
1. Auto-review during implementation. The Implement skill automatically calls Review Current Work at each step. The agent self-reviews before opening a PR.
2. Cross-review between agents. Claude Code and Codex review each other’s work. Camille doesn’t necessarily read the diff himself - he asks Codex to review Claude’s work and vice versa, via the Check Reviews skill, which triages comments and proposes fixes.
3. External AI reviewers. Three tools run on every PR: BugBot, Cubic (a YC startup that Camille says is taking off fast on benchmarks), and Code Rabbit (which he finds less impressive today but keeps out of habit). After each comment, a loop mechanism checks the PR 30 minutes after the push, triages the feedback, fixes what can be fixed, and pushes again.
4. Final human review. Camille steps in last, for high-impact decisions or complex trade-offs. The skills are explicit about this: “Don’t make one-way-door decisions without me.”
The cost of all these tools? A few hundred euros a month. Camille is unequivocal: it’s a non-negotiable expense.
Live Browser QA
To validate front-end changes, Camille uses a browser QA skill inspired by Vercel’s. The agent connects to the local app (each worktree runs its own instance with its own DB), navigates to the given URL, takes screenshots, clicks, interacts, and produces a report detailing what works and what doesn’t.
In the live demo, you can watch the agent open Chrome, auto-login to Verso, find the right component, test it, and validate that a video playback speed control button works correctly.
The current limitation: screenshots don’t capture animations. Camille thinks the real revolution in agentic QA will come when models can read video in real time.
Business skills: the whole team is AI-first
An often-overlooked point: at Verso, agents aren’t reserved for developers.
From day one of onboarding, everyone, including the business team, has access to Claude Code, Codex, and the terminal. Business-specific skills have been built for them: drafting an email, preparing a client’s context in the knowledge base, writing a LinkedIn post, or aggregating all call transcripts and emails from a client to pre-fill study templates.
There’s also the Teach skill: when Camille just accomplished something manually with an agent, he can immediately ask it to document what it just learned as a reusable skill. It’s the self-improvement mechanism of the harness itself.
The agnosticism principle: never get locked in
Camille emphasizes a structural point: his setup has to work regardless of the provider.
Skills are nearly identical between Claude Code and Codex (with minor format adaptations), and a cron job checks every day that both config folders are in sync. When Anthropic has outages he switches to Codex without friction.
“Tomorrow, if another provider is better, I’ll switch with pleasure. Being agnostic and not locked in is pretty important.”
Takeaways for ×10 (or ×100) developer productivity
In closing, Camille and Tanguy summarize the principles they apply at Hexa and Verso:
Invest in foundations first. Agents build on what they see. If the code structure is ambiguous or inconsistent, AI will drift in the wrong direction and it compounds. Clear patterns, well-thought-out abstractions, guidelines documented as Markdown files in the codebase: that’s what determines the quality of everything produced afterward.
Run regular audits. Periodically, ask the agent to cold-analyze the codebase: what are the main separation-of-concerns violations? Where is there code duplication? Which areas have drifted from the guidelines? It’s an effective way to identify technical debt before it accumulates.
Engineer the harness hard. Skills, hooks, agents, cron jobs: everything surrounding the codebase deserves as much attention as the codebase itself. It’s an investment with exponential returns.
Don’t panic about new tools. A new “game-changer” tool drops every week on LinkedIn. Tools change. Principles don’t.
“Vibe coding is the worst name for this practice. It’s real engineering work, defined workflows, clear foundations. It’s not ‘go with the vibe’ at all.” - Camille Epitalon
The bottom line
What Camille built at Verso isn’t just an efficient dev setup. It’s a way of working where agents are treated as real collaborators - with clear responsibilities, a well-defined framework, and progressive autonomy.
The result: an enterprise product in production in three months, built alone. Paying clients. And nights where the code keeps improving while he sleeps.
