The
Consultant
An AI consulting engine I built with Claude Code.
I bring it a problem in my own words. It works out what is really being asked, runs the research and the analysis in separate AI sessions, has every piece graded by a session that didn’t write it, and keeps a record of every step.
It has run 226 engagements.
How it’s counted
Every engagement gets its own number and a line in The Consultant’s record. I count the different numbers.
The method in public: a showcase on GitHub, with one invented sample engagement →
What it has built for me
Some of what it has done on my own work. It shows what I can build by working with Claude.
A second AI vendor
Does another vendor’s tool earn a place in my checks?
A diagnosis.
An always-on machine
Moving my AI work off my laptop, onto a machine that is always on.
A diagnosis, then a plan built on it.
My own AI set-up
How my own AI projects fit together, and why they stopped working as one system.
Diagnoses in turn, and a plan on the latest one, waiting for my reading.
What each engagement found stays private: the page shows the steps, never the content.
How it works, click by click
Every station from a problem to a closed engagement. Pick one to see who acts, what it makes, what can stop it, and whether it has run. The badges are honest: some stations are written into the method and haven’t run yet.
The clientAn AI sessionA script, no AIMy own window
Has runHas run, and my call overrode itHas run, as an experimentNot run yet
Each AI session is a fresh Claude Code session; none shares a context with another.
Intake Before anything is launched
-
The problem, in the client’s words (the intake conversation)Has run
The clientAn AI session
- What it makes
- The client’s words, filed as they were said, and a first check of the problem’s shape: well framed, or the wrong shape.
- What can stop it
- A problem in the wrong shape gets a reframe offered before any searching starts.
- Has it run?
- Has run
-
Has this been done before? (the prior-project check)Has run
A scriptAn AI session
- What it makes
- A list of earlier engagements that match and, when one does, a review of it by an AI reader.
- What can stop it
- A printed check reads every earlier engagement on record.
- Has it run?
- Has run
-
Is this an engagement? (acceptance)Has run
The client
- What it makes
- The client’s answer, filed word for word: open an engagement, answer it now, or park it.
- What can stop it
- Only the client decides.
- Has it run?
- Has run
-
A review of anything the client hands over (the material review)Has run
An AI session
- What it makes
- An independent review of what the client gave it, by a fresh AI session.
- What can stop it
- A fail sends the material back to be put together again and reviewed by a new session, or set aside. No reader starts beside this check.
- Has it run?
- Has run
-
AI readers search what is already known (the intake readers)Has run
An AI session
- What it makes
- Read-only reports, one question per reader, and a critic that checks the search was complete.
- What can stop it
- A printed check: every reader a different session, each folder accounted for.
- Has it run?
- Has run
-
The read-backHas run
An AI sessionThe client
- What it makes
- What it heard and what it found, read back to the client.
- What can stop it
- The client confirms or corrects it, every time, even when the search found nothing.
- Has it run?
- Has run
-
The interviewHas run
An AI sessionThe client
- What it makes
- A record of the client’s answers, confirmed at the end.
- What can stop it
- One question at a time, each with a recommended answer. No guess at the answer until the record is confirmed.
- Has it run?
- Has run
-
The BriefHas run
An AI session
- What it makes
- The problem and its reframe; a first guess at the answer, with the test that would prove it wrong; what could go wrong; what it will not chase, and what would reopen it; and the numbered questions the work must answer.
- What can stop it
- Nothing here stops it: the next station grades it.
- Has it run?
- Has run
-
The Brief is graded (the Brief review)Has run, and my call overrode it
An AI session
- What it makes
- A review by a fresh AI session that didn’t write the Brief, with its verdict.
- What can stop it
- A fail: the Brief is fixed and graded once more. A second fail comes to me, not to a third round.
- Has it run?
- Has run, and my call overrode it It sends Briefs back more often than it passes them. Sometimes I launched although no review had passed: my call as the client, written into the approval.
-
The client’s word on the Brief (approval)Has run
The client
- What it makes
- The client’s answer, filed: approve, redirect, keep the kind of engagement they chose, or reject.
- What can stop it
- Nothing starts until the client approves. The approval is the launch.
- Has it run?
- Has run
- Where the work goes back
- A redirect sends it back to the diagnosis. The Brief is never patched.
-
Diagnostic The work, checked at every stop
-
Launch (the launcher)Has run
A script
- What it makes
- The engagement’s own numbered folder with its own history, the table of who checks each stop, the auditor’s checklist, one line in the record, and the first session.
- What can stop it
- The launch is refused without the client’s approval on file.
- Has it run?
- Has run
-
The work (the consultant)Has run
An AI session
- What it makes
- The outline of the final document first, written before any analysis exists; then the work itself.
- What can stop it
- Its own red-team checks aim the grade; they never replace it.
- Has it run?
- Has run
-
Specialists, when the question needs themHas run
An AI session
- What it makes
- A charter for each, graded before it goes out; then each specialist’s work and a short hand-over, each in its own session.
- What can stop it
- A cap on how many specialists, and on how far work is handed on.
- Has it run?
- Has run
- Where the work goes back
- A finding that breaks a charter has the charter issued again. Research that isn’t deep enough gets one more pass on a new charter, never a third.
-
It stops, and a fresh grader reads it (the overseer)Has run
A scriptAn AI session
- What it makes
- A verdict, filed in the folder of the work it judged. The grader is a new session that never saw the work being made.
- What can stop it
- A fail sends the work back with the findings, for as many rounds as the verdicts demand. One test can veto on its own: did it tell the client something they didn’t walk in knowing?
- Has it run?
- Has run It sends work back more often than it passes it: that is what it is for.
- Where the work goes back
- A fail sends the work back, with the findings.
-
Pulling the specialists’ work together (the synthesis check)Has run
An AI session
- What it makes
- A verdict on coverage, contradictions and knock-on effects, and a fresh look at the diagnosis itself.
- What can stop it
- A fail sends it back. A diagnosis that no longer holds would go to the client with three choices: keep going as planned, refocus within the scope, or widen it. That choice hasn’t come up yet.
- Has it run?
- Has run
- Where the work goes back
- A diagnosis that no longer holds would go to the client first, then back to the start. That choice hasn’t come up yet.
-
The last read before it reaches the client (the senior partner)Has run, and my call overrode it
An AI session
- What it makes
- A verdict on the whole: the premise checked, the work compared clause by clause with the client’s own words, and every company or person it names checked.
- What can stop it
- A blocker holds it: do not send. The hold doesn’t lift on a promise.
- Has it run?
- Has run, and my call overrode it It has held work back before it reached the client. Sometimes I closed with its last verdict still a fail: my call as the client, and the record says so.
- Where the work goes back
- A blocker sends it back to the work, and the last reviewer reads it again.
-
Stops that reach me (waiting on you)Has run
A scriptThe client
- What it makes
- A line in the record with a one-line note. Nothing runs while it waits.
- What can stop it
- Only stops that need judgment come to me; routine ones are handled and logged.
- Has it run?
- Has run Not all were judgment calls: some were faults in the machinery itself.
-
The client reads it (the client’s reading)Has run
The client
- What it makes
- The client’s reading, filed as they wrote it.
- What can stop it
- The reading has to happen before the close; what it says is a data point. Agree, and it closes. Push back, and a round of changes runs.
- Has it run?
- Has run
- Where the work goes back
- A push-back runs a round of changes, then the checks again.
-
Plan A follow-up project, on the same machinery
-
A follow-up, on an earlier engagement (a follow-up engagement)Has run
The clientAn AI sessionA script
- What it makes
- A new engagement that opens with the earlier one’s snapshot and a scan of what changed since, never a full re-scan. It runs the same stations again: the Brief, the work, the grades, the last read, the reading, the close.
- What can stop it
- The same checks as a diagnosis. The phases are states of one engagement on one machinery: the content differs, the machinery doesn’t.
- Has it run?
- Has run
-
Implementation The build
-
From plan to build: one approvalNot run yet
The client
- What it makes
- The client’s approval writes a line in the decision log and starts the first build session in the same turn.
- What can stop it
- Nothing is built without it.
- Has it run?
- Not run yet
-
The build, and its checksNot run yet
An AI session
- What it makes
- The build on the client’s accounts by AI build sessions, then checked by fresh AI sessions; a go-live checklist and an upkeep list.
- What can stop it
- Every step that can’t be undone is checked on its own first. The old way stays until the new one has taken over. It’s checked on the real account. A schedule counts only after it has run for real. Anything that must keep running proves its alarm.
- Has it run?
- Not run yet
-
Close The close, and what comes after
-
The closeHas run
An AI sessionA script
- What it makes
- What happened, what was observed, seeds for next time, recommendations and a receipt. At the full level, more fresh sessions join it: an audit of how it ran, an assessment, and a grade of the seeds.
- What can stop it
- The auditor refuses the close until every record is on disk. The receipt prints what applied, what is present, and what a complete receipt does not mean.
- Has it run?
- Has run The auditor has refused closes until the missing records were on disk.
-
The outside read (the trustee)Has run
An AI sessionMy own window
- What it makes
- Grades on whether the work is reliable, complete and remarkable, in two lanes: a blind one that sees only the finished work, the Brief, the method and the claims, and an informed one filed from my own window on the engagement.
- What can stop it
- The blind read goes out only after the informed one is filed.
- Has it run?
- Has run
-
Checking the checkers (grader calibration)Has run, as an experiment
A script
- What it makes
- A row comparing the blind outside read with the last reviewer’s verdict.
- What can stop it
- A check that keeps passing what the blind read fails is marked out of calibration.
- Has it run?
- Has run, as an experiment Nothing has validated it yet.
-
The method reviews itself (the methodology review)Not run yet
An AI sessionThe client
- What it makes
- Dated changes to the method, from an engagement of its own.
- What can stop it
- It fires after enough closes, after a set time, or when I ask.
- Has it run?
- Not run yet Its own review is next, with a deadline of the end of November.
-
The paths back
A check that only ever opens forward is a log line, not a check. These are the places the work goes back.
- The client’s word on the Brief: A redirect sends it back to the diagnosis. The Brief is never patched.
- Specialists, when the question needs them: A finding that breaks a charter has the charter issued again. Research that isn’t deep enough gets one more pass on a new charter, never a third.
- It stops, and a fresh grader reads it: A fail sends the work back, with the findings.
- Pulling the specialists’ work together: A diagnosis that no longer holds would go to the client first, then back to the start. That choice hasn’t come up yet.
- The last read before it reaches the client: A blocker sends it back to the work, and the last reviewer reads it again.
- The client reads it: A push-back runs a round of changes, then the checks again.
The send-backs have run, on real engagements.
Who does what, and what each one can’t see
Nobody grades their own work. Every seat is one of three kinds, and each one is cut off from something on purpose.
The client
The client
Decides whether it is an engagement, approves the Brief, reads the work, and approves the move from plan to build. Every stop that needs judgment comes to me, and anything sent to an outside party goes through my hand.
My own window
The informed half of the outside read is filed from my own chat on the project. It is my seat, not a fresh session.
AI sessions
The worker (the consultant)
Sees the Brief and its charters.
Can’t choose who checks it, or where the work goes next.
The fresh grader (the overseer)
Sees the work on disk, and the list of what it must answer.
Can’t see the work being made: it starts only after the worker stops.
The last reviewer, who reads it the way the client will (the senior partner)
Sees the finished work beside the client’s own words.
Can’t let it through on a promise.
The blind outside read (the trustee)
Sees the finished work, the Brief, the method and the claims.
Can’t see anything else, including how the work was made.
Readers, specialists, critics and the close sessions
Each works alone, in its own session.
Scripts, no AI
The launcher
Two moves and no others: start the next session, or write a waiting state.
Sees the table of who checks each stop, the stop line, the verdict file, the charters and its own records.
Can’t read anything the worker wrote.
The auditor
A checklist written at launch, hooks that read each session as it works, and a gate before the close. It pages my phone on any flag.
The dispatcher
Starts each reviewer and stamps its identity on the first line of what it writes, so every grade shows which session wrote it.
The engine’s own check
Checks the record, the Brief gate, the receipts, and the launcher’s guards, asserted on its own code.
One real project, replayed
My latest diagnosis: how my own AI projects fit together. Every session, every verdict and every stop, in order, from launch to the outside read. Only the steps: what the project found stays private.
Stops came to me along the way: some were judgment calls, some were faults in the machinery, and two were the close being refused until a record was on disk.
- The recordLaunched: the Brief approved, the project’s folder and its record made.
- A sessionThe work (the consultant).
- A sessionA fresh grader reads it (the overseer): sent it back.Sent back
- A sessionThe work (the consultant).
- The recordA stop came to me: a fault in the machinery, not a judgment.
- The recordResumed on my word.
- A sessionThe work (the consultant).
- The recordA stop came to me: a fault in the machinery, not a judgment.
- The recordResumed on my word.
- A sessionThe work (the consultant).
- A sessionA fresh grader reads it (the overseer): passed it.Passed
- A sessionThe work (the consultant).
- A sessionThe synthesis check (pulling the specialists’ work together): sent it back.Sent back
- A sessionThe work (the consultant).
- A sessionThe synthesis check (pulling the specialists’ work together): passed it.Passed
- A sessionThe work (the consultant).
- A sessionThe last reviewer reads it the way I will (the senior partner): held it back.Held back
- A sessionThe work (the consultant).
- A sessionThe last reviewer reads it the way I will (the senior partner): let it through.Let through
- The recordReady for my reading as the client. Nothing ran while it waited.
- The recordI read it as the client and pushed back.
- A sessionThe work: changes after my push-back (the consultant).
- A sessionA fresh grader reads it (the overseer): passed it.Passed
- A sessionThe last reviewer reads it the way I will (the senior partner): held it back.Held back
- The recordA third review round was refused: the work had been graded twice, so the judgment came to me.
- The recordResumed on my word.
- A sessionThe work (the consultant).
- The recordThe fixes came back to me before I ruled on the close.
- The recordOn my word, it went to the close.
- A sessionThe close session (the consultant).
- The recordThe close was refused: the auditor found a record missing or a check failing.
- The recordThe close was refused: the auditor found a record missing or a check failing.
- The recordClosed, with every record on disk.
- The recordThe outside read was filed, both lanes. The blind lane: reliable, partly; complete, partly; remarkable, partly. Archived.
The checks, and what they caught
A check that never sends anything back isn’t checking. Every one of these has caught something on real engagements.
The fresh grader
Sends the work back with its findings, round after round, until it passes. Most rounds have sent it back: that is what the checks are for.
The last read
Holds the work back before it reaches the client, until its blockers are fixed.
The Brief review
Sends the Brief back before any work starts.
The close
Refused until every record is on disk.
On its very first run, its own receipt caught the launcher treating a failed final check as a pass.
“If it finds a problem, the work goes back to be fixed.”
From How I work
My calls as the client
That is the rule, and the checks above show it working. On engagements where I was the client, I have sometimes overruled a check: launching although no Brief review had passed, or closing with the last reviewer’s verdict still a fail.
Each call is written into that engagement’s own record, in plain words. One receipt says it outright: the work ships over a failing check, not under a passing one.
What it hasn’t proven yet
My own test of a successful project
I scored my latest diagnosis against it, condition by condition:
- Not metFrom launch to close, with no fix to the engine in the middle of the run.
- MetThe final check graded the whole diagnosis. (with one limit stated)
- Not metEvery stop that reached me was a decision only I could make.
- MetEvery part of the method ran and left its proof on disk. (as to presence: what ran left its proof)
Not every condition was met, so it hasn’t passed my own test yet. The next step on the engine’s road waits for an engagement that does.
What a finished receipt doesn’t prove
- A complete receipt shows that the machine ran, never that the work is right. My latest receipt prints its own blind spots.
- The outside read is an AI review, not a person.
- Whether any recommendation was acted on, the records don’t show.
Where it is going
Now
A plan on my latest diagnosis has run, and it is waiting for my reading.
Next
The method’s own review, run as a project of its own, with its changes landing inside the run (its deadline is the end of November).
Then
Several engagements running side by side.
And the build
The build phase is written into the method and hasn’t run yet.