How I Run My Tutoring Company on Claude Code and Obsidian (the Real Stack Before ClassQuill)

What’s the actual AI workflow for running a tutoring company?

Here’s the honest version, not the theory. I run my tutoring company on four off-the-shelf tools wired together by hand: Claude Code, a voice-typing app (Wispr Flow), Obsidian for notes, and Google Drive for delivery. Before each session I turn a student’s marked tests into a targeted prep pack; after each session I turn what happened into a revision plan and a parent-ready update — about fifteen minutes a student, and it works well.

But it only works because I’m one technical operator willing to glue four apps together — and that gap, the bit that doesn’t scale to a team, is the whole reason I’m building ClassQuill. The twist: the student-facing half of this already runs automatically in the product; the manual rig below is me hand-doing what one button now does.

This is the stack post — the operational rig around a session, not what happens inside one. For the seven specific ways AI earns its place inside a session (marking, explaining, the between-session tutor), see Top ways tutors can use AI to enhance their sessions. What follows is the tools, the folder structure, the prompts I dictate, and the exact points where the whole thing is held together by me and only me.

The whole stack, in one place

Four tools, each doing one job:

• Claude Code — the AI assistant that does the reading, the diagnosis and the drafting. Everything below is built around Claude Code specifically, not NotebookLM — the difference isn’t the quality of the answers, it’s that Claude Code can plug straight into other tools over a protocol called MCP, which is what actually files the practice set into the student’s folder instead of me copy-pasting it in. NotebookLM is a different shape of tool: good for uploading a stack of documents and asking questions against them, but it doesn’t connect out and act on other software, so it can’t do the “write it, file it, export it” half of this rig.
• Wispr Flow — voice-to-text. This is the unlock that makes the whole thing fast. I’m not typing prompts; I’m talking. Describing a student out loud takes thirty seconds; typing the same brief takes five minutes.
• Obsidian — where everything lives. Plain markdown notes, one folder per student, organised so I can walk into any session and find exactly where that student is.
• Google Drive — delivery. The finished plan or revision sheet becomes a PDF and lands in the student’s own Drive folder, so it’s waiting for them and their parent.

There’s a fifth piece that’s really the glue, and it’s worth actually explaining rather than waving at: MCP, or Model Context Protocol, the open standard behind all of this. Anthropic describes it as a USB-C port for AI tools — a standard way for an assistant like Claude Code to connect directly to a piece of software and both read from it and act on it, instead of you copy-pasting text back and forth between two windows.

The Obsidian MCP is the concrete example running underneath this whole post: it connects Claude Code straight to my vault, so when I say “put this in the student’s folder,” it actually writes the file — no copy-paste, no me opening Obsidian to paste anything in. (There are a few community MCP servers that do this — search “Obsidian MCP” plus your client of choice to find one that fits your setup.) That connection is the difference between “AI that drafts text I then file” and “AI that files it for me” — and it’s also the most technical bit of the whole rig, which is the first hint at why this doesn’t hand off to a team.

The same idea works pointed at a piece of business software instead of a notes app — which is exactly what I’ve done with ClassQuill itself, below.

Nothing else here is exotic. No custom software, no code I maintain. That’s deliberate — it’s what makes it reproducible at all. It’s also exactly why it’s fragile, which I’ll get to.

How do you set up Obsidian to run a tutoring business?

A folder per student, a sub-folder per topic.

The single most useful decision was giving every student their own folder, and inside it a sub-folder per topic — so prep is “open this student, open this topic,” with no hunting and no cold start.

Inside each topic I keep the same numbered notes, in the order I actually work through them:

• 01 — Test Review — the diagnosis: every question they lost on their last test, what the actual slip was, grouped by sub-topic. Not “did the homework,” but “loses marks making the unknown the subject when it’s buried in a fraction — skips the isolate first step.”
• 02 — Topic Checklist — every sub-skill in the topic, so nothing falls through the cracks.
• 03 — Practice Set (target weaknesses) — targeted questions, each one mapped to a question they lost. Where a question uses letters, I get the AI to give the numeric version first, then the same thing in letters, back to back, so the student sees it’s the same move.
• 04 — Worked Solutions — the answers, in a separate note, so they attempt first and check after.
• 05 — Full Test Worked Solutions — for when we redo a whole paper.

Two shared folders sit alongside the topics: Formula Sheets (one per topic) and How To Solve — the fixed, step-by-step methods I build for a student who freezes on a particular kind of question (the trig example below is one). These process notes live in their own folder and get reused across sessions, rather than buried inside a single practice set.

Every session writes back into these, so a student’s folder is a living map of where they actually are — not a pile of dated session notes nobody re-reads.

[IMAGE: a real (anonymised) student’s Obsidian folder — the per-topic sub-folders, with the 01–05 notes inside one of them open.]

Before a session: turning marked tests into a prep pack (~10 min)

The biggest upgrade in my week isn’t in the session — it’s the ten minutes before it. The goal is to walk in already knowing where the marks are leaking, with targeted practice already built.

The steps:

1. Collect the evidence. I text the student and ask for whatever they’ve had marked recently — tests, results, and a photo of every single question they got stuck on. It all goes into one document.
2. Hand it to the AI. I drop that document into Claude Code and, dictating through Wispr Flow so it’s fast, brief it on the student.
3. Ask for the notes. I tell it to diagnose the weaknesses and build the targeted practice, and — through the Obsidian MCP — write it straight into the student’s topic folder.

I don’t keep a saved prompt; I talk it each time, but it’s always close to this:

This is [student], Year [X], doing [subject] — [topic]. I’m attaching their last test and photos of the questions they got wrong. Go through it and: (1) write a short Test Review listing every question they lost and what the actual slip was, grouped by sub-topic; (2) build a Practice Set that targets exactly those weaknesses — two questions for each one they got wrong, and wherever a question uses letters, give the numeric version first then the same question with letters so they see it’s the same move; (3) write the Worked Solutions in a separate note; (4) where they freeze on a whole problem-type, add a step-by-step “how to solve every [type]” method. Put it all in their [topic] folder in Obsidian as separate notes, and link the practice set to the test review and the solutions.

The shape in that prompt — review → targeted practice → solutions → a fixed method — is the whole pedagogy. “Numeric twin then letters” is specific to one student who’s strong on numbers and freezes on algebra; yours would encode your own student’s real pattern. Ten minutes, and the prep pack is sitting in the folder — I walk in knowing exactly which step they keep missing, instead of opening with “so… how did the homework go?”

After a session: turning what happened into a revision plan and a parent update (~5 min)

Once the session’s done, the second pass takes about five minutes and produces two things: something the student can revise from, and something the parent can see.

I talk — again through Wispr Flow — through what the student did well and where they came unstuck, and have the AI turn it into a fixed, repeatable process. One of mine answers fast but never shows his working, so on trigonometry — solving for the hypotenuse or an adjacent side — he’d freeze. I described exactly that and had the AI build him a process to follow every time:

1. Label every side of the triangle
2. Write out the formula
3. Write down what you know and what you’re solving for
4. Rearrange
5. Solve

The after-session prompt is the same deal — talked, not saved, but close to:

Update [student]'s notes from today. They did [X] well and got stuck on [Y]. Turn it into a short step-by-step method they can follow every time for this kind of question, add it to their “How To Solve” folder, and write a two-line parent update on what we covered and what’s next.

The export step is almost embarrassingly low-tech: I ask Claude Code to turn the note into a PDF — no special plugin, the Obsidian MCP writes the file out — then drop it into the student’s Google Drive folder by hand. That last drop is the one bit that’s still me.

[IMAGE: a real (anonymised) “how to solve” step-by-step method as a PDF — e.g. the 5-step process for solving a trig side — sitting in the student’s Google Drive folder.]

What this actually costs me: about 15 minutes a student

Per student I spend roughly ten minutes before a session and five after — fifteen minutes all up — covering the pre-session diagnosis, the targeted practice, the after-session revision plan, and the parent-facing update. It’s the best-value quarter-hour in my week.

The parent-facing half is what quietly drives the business. Parents don’t renew because sessions ran on time; they renew because they can see their child improving. A clear plan and a regular update is the evidence — and when budgets get tight, the companies that can show evidence are the ones that keep their clients.

The work also compounds: the practice I build for one student’s weakness is reusable for the next student with the same gap. Over a term you stop starting from scratch and start pulling from a growing bank of targeted questions — you can even point the AI at it: look at the questions I’ve already got for this topic, then build a set for this student’s specific gaps. That’s the point where the manual rig starts describing its own replacement: building and reusing a question bank by hand, in Obsidian, works — but it’s the kind of thing software should just do.

The honest part: this works because it’s me

Everything above is real and it earns its place. But I have to be straight about why it works, because the why is the whole point.

It doesn’t fall apart on me — I’ve never had a week where it collapsed. That’s exactly the problem: it works because it’s me. I’m one technical operator comfortable gluing five tools together, who knows how to brief Claude Code, who’s set Obsidian up the way I like, and who’s happy exporting a PDF by hand. None of that is hard for me — it just doesn’t survive contact with a team:

• Every tutor would have to wire up the same stack — Claude Code, Wispr Flow, Obsidian, Drive, the MCP — and keep it in sync. Most won’t, and shouldn’t have to. Tutors should be teaching, not maintaining a personal software stack.
• There’s no shared visibility. All the intelligence lives in my Obsidian vault. As an owner, if I want to know whether a topic is sinking a whole cohort across several tutors, this rig can’t tell me — every tutor’s notes are siloed in their own vault, in their own format.
• The seams are manual. The marking is me reading the student’s photos. The PDF export and the Drive drop are me. The folder structure stays consistent only because I’m the only one touching it.
• Nothing is auto-marked. I’m doing the diagnosis by eye from photographed questions. That’s fine at my volume; it’s the first thing that falls over when you scale up the number of students.

So I’ve got a workflow that makes a single operator genuinely more effective — and completely fails to scale to a tutoring company. That’s not a tooling problem I can fix with a better Obsidian plugin. It’s structural.

Why I’m building ClassQuill (and what already runs automatically)

The reason this rig made me build a product: the student-facing half of everything above already runs automatically in ClassQuill, and the manual seams are exactly what it removes. The weakness diagnosis I do by photographing tests, it does from how students actually answer. The targeted practice I build by hand, it serves on its own. The marking I do by eye, it does instantly — and times it, if you want an exam.

No tutor wiring up four tools, and an owner gets the cross-tutor visibility a stack of siloed Obsidian vaults never could.

I’ve written the in-app walkthrough — exactly which features do which part of this rig, and what’s live versus still coming — as its own piece: “How ClassQuill turns student weaknesses into assigned, auto-marked homework” (link on publish).

The honest framing doesn’t change: the founder rigs this by hand; ClassQuill is that workflow productised and consistent across a whole team. I’m not claiming it exports your notes to Obsidian or drops PDFs in Drive — those are my manual steps, and the point of the product is that you shouldn’t need them.

If you recognise the rig — the apps, the manual seams, the fact that it only works because you’re the one holding it together — see how ClassQuill turns it into one place →.

Can you connect Claude Code to ClassQuill itself through MCP?

Yes — ClassQuill runs its own hosted MCP server today, live now, not a roadmap item. Everything above is Claude Code talking to my Obsidian vault; the same connection also works pointed at ClassQuill’s own data, which matters if you’re running the business on ClassQuill instead of hand-rigging it the way I’ve described.

ClassQuill runs a hosted MCP server at mcp.classquill.com: the same read-only, org-scoped access as ClassQuill’s own REST API, exposed as tools an AI assistant can call directly. Connect it and ask “How much did each tutor earn last week?” or “List the invoices that are still outstanding” and get an answer pulled straight from your organisation’s real data — no dashboard, no export, no filtering a report by hand.

How you connect depends on the client:

• claude.ai (the web app) adds it as a custom connector — Settings → Connectors → Add custom connector, paste https://mcp.classquill.com/mcp, log in. It’s OAuth, so there’s no key to manage.
• Claude Code, Codex, Composio, Cursor, Windsurf point the same hosted endpoint at an API key instead. In Claude Code: claude mcp add classquill --transport http https://mcp.classquill.com/mcp --header "Authorization: Bearer ei_live_...", using a key you create yourself in Settings → Developers.
• Prefer not to depend on a hosted endpoint? There’s also a published npm package, equateit-mcp, that runs the same server locally for the same clients.

Either way it covers sessions, tutors and their earnings, payments and invoices, students and parents (including a parent’s balance), subjects, classrooms, student groups, lesson plans, homework, results, mileage, expenses, and an owner’s reports summary — one read-only tool per part of the business. Read-only means connecting it can’t change anything in your account; it can only answer questions about what’s already there.

It’s the direct, productised version of the same trick this whole post has been describing by hand: instead of me manually collecting a student’s results and typing them into Claude Code, an owner on ClassQuill can point Claude Code straight at their own data and just ask.

Examples (real output)

[EXAMPLES — Brandon to attach: export a real (anonymised) set from a student’s folder as PDFs and link them here — a Test Review, the Practice Set (target weaknesses) it produced, and the Worked Solutions — so readers see the actual output, not just the workflow. The Linear Relations practice set (numeric-twin-then-letters, each question mapped to a test mistake) is a strong example.]