Nova Data

Context Nova is an e-commerce analytics SaaS. Product decisions leaned on scattered Mixpanel events and PostgreSQL tables, and diagnosing why a feature underperformed meant manual, ad hoc digging. I wanted a repeatable way to go from raw usage data to a defensible redesign hypothesis, without the LLM inventing conclusions the data didn't support. What I built Remixpanel, a four-stage feature-analysis pipeline: 1. Mixpanel ingestion of event data. 2. Live PostgreSQL analyzers running deterministic queries against product data. 3. A UX overlay generator mapping findings back onto the interface. 4. A report stage producing evidence-tied redesign hypotheses. The analyzer is Claude-powered, but grounded: I built a custom MCP (Model Context Protocol) server exposing Mixpanel and PostgreSQL as structured tools, so the model reasons over real data instead of guessing. The analyzer is constrained to verbatim-grounded, confidence-tiered diagnoses, so every claim is tied to evidence and flagged by how sure it is.Approach The design principle is deterministic analysis first, LLM diagnosis second. Deterministic PostgreSQL analyzers establish the facts; the Claude analyzer interprets them under a hard rule that diagnoses must cite the underlying data and carry a confidence tier. That combination keeps the AI useful without letting it drift into confident fiction. Outcome The pipeline produced structured diagnoses and evidence-tied redesign hypotheses on real Nova features, feeding concrete feature redesigns and iterations. It is a working example of pairing an MCP-connected coding/reasoning agent with deterministic data tooling to make product decisions on evidence rather than intuition.Stack: TypeScript / Node, PostgreSQL, Mixpanel, Claude, custom MCP server, MCP tool integration.

Turning raw Mixpanel and PostgreSQL data into evidence-tied redesign hypotheses, using a Claude-powered analyzer wired to a custom MCP server, with every diagnosis grounded and confidence-tiered.

LLMs / Large language models

Software Craftsmanship

UX Audit: AI-assisted product feature analysis

Context Coding agents (Claude Code, Codex, opencode) are powerful but non-deterministic: run the same task twice and you get different results, no guardrails, and credentials handed straight to the model. I wanted a way to run a coding-agent skill end-to-end against a real repo with hard, reproducible gates instead of trusting a single agent's one-shot output. What I built Contremaitre is a deterministic multi-agent orchestration shell in Python. It runs a coding task through a pipeline of specialized roles:- A proposer agent and an adversarial critic grill a design until it settles. - The design is implemented under drift-watch. - An independent reviewer gates a draft PR, and a revise loop fixes what it flags.It runs Claude Code, Codex, and opencode headless behind one actor protocol, so agents are mixable per role. It runs each agent in an isolated container where the agent never holds credentials: a host-side proxy injects the bearer token per request, a two-layer egress lock (internal network plus provider allowlist) blocks exfiltration, and deterministic hard gates (forbidden-path scan, diff-hash match, clean worktree) gate every PR. Approach The core idea is determinism over trust: instead of asking one agent to "do it well," the system decomposes the work into proposer / critic / reviewer / reviser and puts machine-checkable gates between stages. It is the orchestration shell around Matt Pocock's improve-codebase-architecture skill, not a rewrite of the methodology itself. Outcome Open source and public: <a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/jbmoutout/contremaitre">https://github.com/jbmoutout/contremaitre</a> (v0.2.0, MIT). It is the project I use to reason about how to make coding agents safe and reproducible enough to trust with real repository changes.Stack: Python, Docker, Claude Code / Codex / opencode headless, host-side credential proxy, egress allowlist.

A deterministic Python shell that drives Claude Code, Codex, and opencode headless to take a coding task from design to draft PR, with an adversarial critic loop, host-owned credentials, and hard reproducible gates. Open source (MIT).

DevOps

Clean Code

Clean Architecture

Contremaitre: multi-agent orchestration for coding agents

Context Most eval work assumes an executable oracle: run the code, check the tests. But for advisory coding tasks (architecture review, "what's wrong with this codebase") there is no oracle. The output is prose, and the usual failure is that a smaller-model judge or simulator quietly contaminates the score. I wanted a methodology that measures whether a coding-agent skill actually helps, without kidding itself.What I built Evals is an evaluation methodology built on LangChain's OpenEvals and opencode, with two paired measurements:- Skill ablation: Docker-isolated skill-on vs skill-off runs, scored with curator-anchored, FActScore-style ground truth so recall is measured against a fixed set of real findings rather than vibes.- Multi-turn simulator: an agent-vs-simulated-SWE harness scored by a human-calibrated 86-point rubric across fact grounding, constraint coverage, design quality, and simulator fidelity.Runs are gated by a validity tier that flags reps where a smaller-model simulator contaminated the substance, so a good-looking score built on a compromised simulator gets caught instead of counted. Approach The guiding principle is that output shape can mislead: a response can look tier-1 (dense citations, right structure, clean gate) while catching almost no real bugs. So the methodology separates surface signals (citation density, vocabulary fidelity, structural discipline) from verified substance (bug-catch against known defects), and treats the simulator itself as something that must be validated, not trusted. Outcome Public writeup: <a target="_blank" rel="noopener noreferrer nofollow" href="https://jbmoutout.github.io/evals.html">https://jbmoutout.github.io/evals.html</a>. The methodology is what I reach for when a task has no clean pass/fail and I still need a defensible answer to "did this actually help." Stack: OpenEvals (LangChain), opencode, Docker isolation, FActScore-style recall, human-calibrated rubric.

How do you score an AI agent's advice when there's no test suite to run against it? A methodology pairing Docker-isolated skill ablation (FActScore-style recall) with a multi-turn agent vs simulated-SWE harness, gated by a validity tier that catches simulator contamination

Jean-Brice Moutout

Lead Software Engineer

About me

Work experience

Lead Software Engineer

Lead Software Engineer

Co-Founder

Freelance Developer

Frontend Developer

Gallery Manager

Education

Le Wagon

Hanken School of Economics

EDHEC Business School

Aix-Marseille University

Portfolio

UX Audit: AI-assisted product feature analysis

Nova Data

Contremaitre: multi-agent orchestration for coding agents

own

Evals: scoring AI agent advice with no oracle

own

Talents

Recruiters

About