# The AI Triad Method

_By Ben Honda Rottler, 2025-11-17_

Most people still talk about AI coding assistants with the same metaphor: the copilot.

There's you, driving. There's an AI sitting next to you, autocompleting some boilerplate, maybe sketching out a function or two while you stay in control. It's a neat story, and for small tasks it's even accurate.

But as soon as you're working on something real: a trading engine, a design system, a complex product, that mental model starts to fall apart. The "one AI in the sidebar" picture is too flat. It treats the AI as a slightly magical text editor instead of what it's actually becoming: another member of the team.

Working on real projects, I've ended up with a very different way of working. Not by design at first; it emerged out of necessity.

It's not "me + one model" anymore.

**It's a triad:**

-   Me, as the orchestrator with access to reality.
-   Claude wired to my repo and tools as the execution engine.
-   ChatGPT and Claude.ai as the systems brain, the reflective thinkers that design policies and make sense of the mess.

![AI Triad: Human orchestrator connected to Engine (execution) and Brain (advisory) agents](/articles/ai-triad.jpg)

And the point of all this isn't "look how many AIs I can juggle." The point is: this setup lets me keep the best parts of vibe coding without quietly destroying the architecture underneath.

First, a disclaimer: if you're expecting a 10x systems engineer talking about agents… that's not me.

I'm a tech-forward designer who's been hacking together code at various times in my career: prototypes, tools, experiments, and then partnering with real engineering teams to actually go build.

The AI triad method I use today wasn't born in a research lab. It was born in that messy space where design intent, software infrastructure, and LLM chaos all crash into each other at 8am.

## What I actually mean by "vibe coding"

When I say vibe coding, I'm talking about the way a lot of us are already working with AI now, whether we call it that or not:

You open a model, throw in some rough context, and start building conversationally. You let it sketch out modules, refactor things, reorganize functions. You ask "what if we structured it like this?" instead of writing a 10-page design doc up front. You follow the feel of the solution as it emerges.

It's intoxicatingly fast. It's also very easy to get into trouble.

The failure modes are familiar:

-   The fix that "sounds right" but doesn't match how your system actually behaves in production.
-   The architecture that emerges piecemeal, with no shared language for why it looks the way it does.
-   The slow creep of AI spaghetti: patterns that work today, but that nobody can reason about six months from now.

For a while, I just accepted that as the tradeoff. You get speed, you pay in future pain.

The triad is my way of cheating that tradeoff.

## Three seats, three kinds of thinking

What changed my mental model was stopping thinking in terms of "tools" and starting to think in terms of roles. There are three distinct seats at the table when I build now.

### 1\. The Orchestrator (human)

This is my job, my role.

I'm the only one who can see and know certain things:

-   The design intent
-   The live logs.
-   The weird edge cases users hit that nobody wrote down.
-   The business constraints and risk appetite around all of it.

I'm also the only one who can say, "this feels wrong, even though the tests pass," or, "this is good enough for today; we'll harden it later."

That's the orchestrator role: not doing all the typing, not holding every module in my head, but deciding:

-   What problem we're actually solving.
-   Which agent to throw it at.
-   When to stop, pivot, or ship.

If the copilot metaphor puts the human in the driver's seat with a helpful assistant, the triad puts the human in the director's chair.

### 2\. The Execution Engine (Claude + code access)

Next seat: the AI that actually touches the repo.

This is Claude wired up to my code, running diagnostics, editing files, refactoring, writing tests. It's the part of the team that can scan the whole codebase in one shot and say, "by the way, this pattern appears in eight places, not one."

When I give this agent work, I'm not asking for philosophy. I'm saying things like:

> "Right now we write signals to the DB and then just hope the cache is right. Let's hook that up properly: after a write, update the in-memory cache and expose a super simple endpoint so we can inspect what the bots are actually reading."

> "Any time a bot decides not to take a trade, I want structured logs for it: which bot, which signal, and a human-readable 'here's why I bailed' field. This is how we debug the weird edge cases later."

Used well, this seat is like a very fast, very diligent junior engineer. It will do an enormous amount of work quickly and consistently, as long as someone tells it what to do and checks that it actually did it.

Used poorly, it becomes a hallucinating architect.

So mostly I don't ask Claude Code to architect, not without having done planning work first.

### 3\. The Systems Brain (ChatGPT + Claude.ai chat)

The third seat is the one that doesn't touch the code directly but cares deeply about how it all hangs together. ChatGPT is great for this. I've also gotten into a rhythm with Claude.ai as a 'detective' in follow up.

When I'm not sure why a system is misbehaving, or I'm about to make a structural decision, or I've just come out the other side of a gnarly bug and want to make sure we don't repeat it, this is the seat I talk to.

It's the one I ask:

> "Here's what I'm seeing, here are the logs, and here's how the signal pipeline is supposed to behave. Give me a short list of theories that could explain all of this in one go, and what you'd check first for each."

> "I want a safer oversight layer for this trading system. I'll describe the current architecture; you help me propose a few patterns and tradeoffs."

Sometimes I'll also hand it chunks of code or stack traces if I want a deep read. Sometimes I'll use Claude chat in the same seat for a long, focused code walkthrough.

The important part is: this seat is where we do systemic thinking. It designs rules. It spots patterns. It turns one-off fixes into "from now on, this is how we do it."

Then I turn around and hand those rules to the execution engine.

## How a triad session actually feels

The easiest way to understand this is to walk through what a typical debugging or building session looks like now. Not a blow-by-blow story, just the shape.

It usually starts with me noticing something in reality: P&L is flat when it shouldn't be, a bot that was aggressive yesterday has gone quiet, or a health check starts logging warnings.

First move is always the same: gather evidence.

I reproduce the problem. I grab logs, stack traces, sometimes a screenshot of the UI next to what I expected. I write two or three sentences describing what I thought would happen and what actually did.

Then, I don't throw that straight at the code-editing model. I brief the systems brain first.

> "Here's the behavior. Here's what I know about how this part of the system is supposed to work. Here's the evidence. Help me reason about it."

What I want at this stage is not a fix, but:

-   A few plausible hypotheses.
-   An ordered plan: "check this, then this, then this."
-   A reminder of the invariants that should hold if the system is healthy.

In the case of one memorable morning, for example, we had:

-   Bots showing as running.
-   The UI happily displaying signals with 70–100% confidence.
-   Zero trades going through. Flatline.

Out of that stew, the systems brain's job was to say, "okay, if bots act as if no signals exist while the UI shows them, either they're reading from different sources, or something is breaking between DB and bot. Here's how to test those possibilities."

Armed with that framing, then I bring in Claude with repo access.

Now I can say: "Here's the plan. Build the diagnostic scripts we need. Instrument the signal flow. Show me where reality diverges from the architecture on paper."

Sometimes that's the end of it. Sometimes the bug turns out to be a hydra that causes a rabbit hole of investigations.

In those cases, once things are calm again, I go back to the systems brain and say: "Okay. We've just fixed the same shape of bug in three different places. Help me articulate the general rule and turn it into something we can enforce."

That usually becomes a page or two of prose:

-   What went wrong.
-   What the rule should be ("treat None as a first-class error state for all external APIs").
-   How we'll enforce it (shared helper functions, test coverage, logging patterns).

Then Claude gets that as input and implements the enforcement. And I get a slightly more robust system and a shared piece of language that we can feed into future sessions.

That loop: evidence → reasoning → implementation → reality check → policy, is the heartbeat of the triad.

## Patterns that keep this from turning into chaos

There are a few habits that make this work and keep it from collapsing back into "one giant, messy chat log."

The first is starting from a baseline. AI conversations tend to drift into abstractions if you let them. Bringing logs, screenshots, and concrete examples into the mix anchors everything. "Here's the actual stack trace." "Here's the warning the bot logged right before it stopped trading." That's what keeps the models from designing a beautiful architecture for a system that doesn't exist.

The second is giving each seat the right kind of work. When I forget this and ask Claude Code to design the architecture as well as implement it, I usually regret it later. It will build something that functions, but the reasoning behind it will be scattered through a dozen chat messages instead of captured as a single, coherent intent.

Conversely, if I treat ChatGPT or Claude.ai like a just code editor and just ask for patches, it's kinda of under using the power of the system. It's much more valuable to say, "Help me explain the shape of this system to Claude Code so they can implement it safely," or, "Help me design an oversight framework that doesn't make everything brittle."

The third is interrupting early. If a model starts doing something I didn't want (spinning up a massive framework, refactoring half the repo, theorizing instead of answering the specific question), I stop it and narrow the scope. "Pause. I don't need a whole framework. I need a 10-line helper function that does X." That's not being rude; that's being a good manager.

I've learned to reset context aggressively. When a chat drags on and the model starts dropping important details, I don't fight it. I open a new conversation with a tight description of the problem and the latest evidence. I keep a small set of stable documents: system overview, policies, key guiding statements that I can paste in as needed.

And finally, small plug, we always use [Decibel Designer MCP](/products/decibel-tools) to record key decisions, establish roadmap items, keep design context (tokens, colors, layout standards, moodboard inspo, rules, guidelines). Being able to point Claude at our design guidelines has saved SO much effort and headache over time.

When the code starts to feel incoherent, I'm blunt about it:

> "This feels like three half-finished ideas stapled together. Help me refactor it into one clear model, even if that means renaming things and killing some old assumptions."

And when handing off to the execution seat, I ask for proof of understanding:

> "Before you touch code, restate what you think the system does in plain English. If your mental model doesn't match what I described, fix that first."

That single step catches so many misalignments before they turn into 200 lines of wrong code.

## Why this matters for design as much as for code

I've been talking mostly about debugging and trading infrastructure, but the same triad pattern shows up everywhere else in my work at Decibel.

When we're designing a new product or feature:

-   I'll sketch the user journey, constraints, and business goals.
-   The systems brain will critique the flows, point out edge cases, and suggest architectures.
-   The execution engine will scaffold the actual screens, components, and endpoints, wired to the design system.

When we're building oversight into an AI-driven experience:

-   I define what "unsafe" or "off-brand" would mean.
-   ChatGPT or Claude.ai turns that into policies and evaluation criteria.
-   Claude Code implements the checks, telemetry, and guardrails.

It's the same triad: orchestration, execution, systems thinking. The details change; the shape doesn't.

And that, for me, is the real promise of multi-agent work.

Not just "better autocomplete," but a way to structure vibe coding so it scales:

-   You still move fast.
-   You still get to experiment conversationally.
-   But you also have an explicit place in the process where you think about architecture, rules, and long-term health, and an explicit agent whose job is to apply those rules consistently.

The result is that those 8am debugging sessions with "two Claudes and a ChatGPT" stop feeling like chaos and start feeling like a team. A strange one, sure. But a team.

## Working this way with Decibel

If you want to build this way, with alacrity but always with a plan and proper eye towards shipping world-class designs, that's exactly what we help teams set up.

---
Source: https://decibel.systems/articles/ai-triad-3-agent-stack
