I need expert judgment on my big calls, on demand.

Ch. 01 What it is

A second opinion you trust, available the moment you need it — not because the model is pretending to be an expert, but because it's reading from a curated body of real expertise before it answers. The trick isn't the prompt. It's the source the answer is grounded in. Three rungs: one advisor, then a board, then a board you assemble plus a factory that builds more.

Ch. 02 The three ways to build it

Simplest path first. Every tier carries its real setup time and its honest trade-off — the cost is the part most write-ups leave out.

1
Tier 1 · simplest path
One grounded advisor
Setup~30 min
- plain markdown
- a chat model
Pick one domain where you keep making the same kind of call — pricing, hiring, an architecture choice. Gather the few sources you actually trust on it: a book you've read, a framework, your own notes on what's worked. Compact them into one markdown file — the mechanics, not the fluff. Then the rule that makes this work: before the advisor answers your question, it reads that file and cites which principle it's leaning on. The answer comes back as a verdict (sound / conditional / not yet) plus the specific rule it rests on plus what's missing. You're not asking a model to roleplay an expert — you're handing it a body of expertise and making it show its work.
The trade-off
An advisor is only as good as the source you feed it. Garbage corpus, confident garbage answers — and the citation makes the garbage *look* authoritative. Curate honestly: include the framework you'd actually defend, leave out the blog post you half-skimmed. And it grades against what it was given, so it can't catch a blind spot that isn't in the file. This is a sharper second opinion, not an oracle — you still make the call.
2
Tier 2
A board, with a chair
Setup~2 hr
- markdown corpora
- Claude Code (or any agent runner)
One advisor sees one lens. Your real decisions sit where lenses collide — the move that's right on economics and wrong on operations. So stand up two or three advisors, each grounded in its own corpus (one for the money side, one for the people side, one for the build), and put a chair over them. The chair doesn't take a vote; it resolves the conflict by which constraint actually binds this decision. You ask once; the board answers from three grounded angles; the chair tells you where they agree, where they fight, and which lens wins here and why. When two advisors genuinely contradict, that disagreement is the signal — it's pointing at the real trade-off you were about to walk past.
The trade-off
A board agreeing with itself is not the same as being right — if all three advisors were built from your own assumptions, you've just heard your own bias in three voices. Keep at least one advisor grounded in a genuinely outside source, and treat unanimous agreement with mild suspicion, not relief. More advisors also means more to keep current: every corpus rots as its field moves, and a stale board is confidently out of date.
3
Tier 3
A board you assemble — and a factory that builds more
Setup~half day
- Claude Code
- a skill/agent framework
- a held-out test set per advisor
At the top rung the board fires itself. On every big call, the right advisors are selected by the *kind* of decision — a pricing question pulls the money advisor, an architecture question pulls the build one — and each one logs its verdict so you can see, weeks later, where it was right and where it wasn't. The unlock is the factory: a repeatable way to stamp a *new* advisor whenever a gap shows up. You point it at a domain and its canon, and it scaffolds the corpus, writes the grounded pass, and ships a small test set that proves the new advisor actually reasons from its source instead of bluffing. The library grows itself, and each advisor earns more autonomy as its track record proves out — not because you decided to trust it, but because the log shows it earned it.
The trade-off
This is real infrastructure, and it bites if you skip the test set — an advisor that was never checked against held-out cases is a persona wearing a lab coat, and at this tier it runs on your decisions automatically. Build the factory the moment you have three-plus advisors and are copy-pasting to make each one; before that it's machinery you don't need. The standing cost is maintenance: every corpus needs a scheduled refresh, every new advisor needs its own check, and an advisor you let run unaudited will be wrong eventually — quietly, and with a citation.

Ch. 03 The detail

A second opinion you trust, available the moment you need it — not because the model is pretending to be an expert, but because it's reading from a curated body of real expertise before it answers. The trick isn't the prompt. It's the source the answer is grounded in. Three rungs: one advisor, then a board, then a board you assemble plus a factory that builds more.

Category: Agents & workflows · Decision support
Format: System
Level: advanced
Provenance: Own-packaged

agentsadvisorsdecision-supportgroundingknowledge-opsclaude-code

The part everyone gets wrong

The obvious way to get expert judgment out of a model is to ask it to be the expert. “You are a world-class pricing strategist.” It feels like it should work, and it produces something that reads like an answer. But a persona adds no information — the model already knew everything it knew before you named it an expert, and the costume can quietly make its judgment worse by pushing it toward what an expert is supposed to sound like rather than what’s actually true.

A grounded advisor is built the opposite way. You don’t tell it who to be. You give it something to read — a curated body of real expertise on one domain — and you make it answer from that source, citing the specific principle each call rests on. The value isn’t the voice. It’s the corpus, and the discipline of reading before answering. Same shape as reliable memory, pointed at a different job: read-before, reason, cite.

Why it climbs in this order

Start with one advisor on one domain, because the whole mechanism is visible at that size — you can read the corpus, see the citation, and check whether the call actually follows from the rule. Get that honest and the rest is repetition.

Stand up a board when your decisions stop fitting in one lens. Most real calls don’t: the pricing move has an operations cost, the fast architecture has a maintenance tax. A board grounds each lens separately and puts a chair over them whose only job is to find which constraint binds — so the answer names the trade-off instead of burying it. The disagreement between advisors is the most useful output, not a bug to smooth over.

Build the factory only when you’re standing up advisors often enough that doing it by hand has become the bottleneck. Then it pays for itself: a repeatable stamp that scaffolds the corpus, writes the grounded pass, and — the non-negotiable part — ships a small held-out test set that proves the new advisor reasons from its source instead of bluffing. Skip that test and you’ve mass-produced confident personas. Ship it, and the library can grow itself while staying honest.

The honest version

A grounded advisor is a sharper second opinion, not a verdict you hand your judgment to. It’s only as good as the source behind it, it can’t see a blind spot that isn’t in the corpus, and a board of advisors built from your own assumptions will agree with you all the way off a cliff. Keep one lens grounded in something genuinely outside your own head, refresh each corpus on a schedule because every field moves, and treat the citation as a receipt you can check — not a stamp that ends the argument. Used that way, it’s the closest thing a one-person operation has to a room full of advisors. Used lazily, it’s the same guesswork as before, now wearing a footnote.