Previously in Part 12, ClinicLive went live behind nginx. The app is done. Before the retro, two things are left to learn: the power tools that make AI development faster — and the judgment to know when to leave the AI out entirely. The second half of this post is the half that matters.

Parallel agents: fan out, don't hand off

A subagent is a second AI session your main session spawns: its own context, its own task, reporting back when done. The unlock is running several at once — and the rule for when that helps is simple: fan out work that is independent. Four documentation pages that don't touch each other? Four agents, drafted in parallel, done in the time of one. A review pass like Part 11's? Fan it out one agent per dimension — one reads the codebase asking only about auth, one only about data integrity, one only about what a hostile user can reach — and each stays sharper than one agent juggling all three questions.

Now the trap, because there is one: don't delegate what one focused session does better. Every agent starts cold. It re-reads the files, re-derives the conventions, re-establishes the context your main session already holds — and pays tokens for every bit of it. Splitting one tightly coupled feature across three agents buys you three partial understandings and an integration problem. Independent work parallelizes; entangled work doesn't. If the pieces need to agree with each other, keep them in one head.

Slash commands and skills: stop repeating yourself

The third time you type the same instructions, they should be a file. Claude Code lets you turn repeated prompts into custom slash commands — a markdown file becomes /deploy or /review. Here's the Part 11 prompt, promoted to a command: 

# .claude/commands/review.md
Review the changes on this branch the way a hostile security reviewer
would. List everything, ranked by severity, with the file that proves
it. Do not fix anything yet — findings first.

The deploy runbook from Part 12, the schema-review checklist from Part 4 — anything you found yourself pasting twice is a candidate. The mental model that keeps this tidy has two layers: CLAUDE.md is the always-on layer — the rules that apply to every session, loaded every time, so keep it short because you pay for it constantly. Commands and skills are the on-demand layer — expertise that loads only when the task calls for it. Always-on for principles, on-demand for procedures.

MCP: stop letting the AI guess

Everything so far in this series had the AI working from what we pasted into the conversation. The Model Context Protocol removes that ceiling: it's a standard plug between the AI and real systems. A Postgres MCP server means "what indexes exist on appointments?" gets answered by querying your actual database — not by the model's memory of a schema file you pasted two hours and thirty edits ago. A GitHub server lets it read the real issue instead of your summary of it; a browser server lets it drive the real page. The pattern is the same everywhere: replace "the AI's plausible guess about your system" with "the answer".

One honest paragraph before you wire anything up: every connection widens what the AI can touch, and prompt-injected or simply confused models do occasionally run the wrong thing. Scope credentials the way you would for a contractor you just met: a read-only role, the development database — never production — and only the permissions the task in front of you needs. The convenience is real; so is the blast radius.

Keeping the meter sane

ClinicLive cost ≈ $6.20 because we spent deliberately, and the habits generalize (the model names below are mid-2026's — the names will rotate, the principle won't):

  • Mix models per task. Haiku-class for the mechanical (renames, boilerplate, formatting), Sonnet-class for the daily work (CRUD, tests, scaffolds), Opus-class for the hard thinking (specs, schema, hub design, the bugs that hide). Most people either overpay for everything or cheap out on exactly the steps where mistakes compound.
  • Use effort levels. Within a model, thinking effort is a dial. Turn it up for design conversations, down for grunt work.
  • Keep sessions focused. A long, meandering chat drags its whole history behind it — every new message pays a context tax on everything said before. New task, new session. It's cheaper and the answers get better.

Model pick: the whole series' rule in one line — pay for thinking where mistakes compound (spec, schema, real-time design), go mid-tier where the path is well-worn (scaffold, CRUD, tests), and go cheap where the work is mechanical. Match the spend to the consequence of error, not to the difficulty of the typing.

When to say no

Everything above makes it easier to route more work through the AI. Fourteen parts of building ClinicLive taught us the opposite lesson just as firmly: the best AI-assisted developers are distinguished by what they don't delegate. Say no when:

  • It's security-critical and you can't review it confidently. If you can't tell a correct auth check from a plausible-looking one, AI output here is a liability, not a shortcut. Part 11's open self-registration shipped precisely because nobody questioned template auth code. Learn the domain first, or bring in someone who has.
  • You'll maintain it but don't understand it yet. Accepting code you can't explain is learning debt, and its interest compounds at 2am with the board stuck on "reconnecting…". If it's your first SignalR hub, write part of it by hand — the understanding is the asset; the code is almost incidental.
  • It's a one-line fix. You know the line. Typing it takes eight seconds; describing it, waiting, and reviewing takes two minutes. Prompting has overhead — respect the crossover point.
  • You can't define "correct". This is the deep one. AI optimizes for plausible, and without a spec, a test, or an oracle, you cannot tell plausible and correct apart — Part 9's tautological test is what that looks like in the wild. No definition of correct, no delegation.
  • It's a novel algorithm at the edge of your competence. On well-trodden ground the AI is superb. On genuinely new ground it produces confident, fluent, subtly-wrong drafts — and you, at your edge, are the least equipped to catch the subtlety. AI is a multiplier of judgment. It multiplies whatever judgment you bring, including not enough.

Skill atrophy is real. The developers thriving with these tools in 2026 are the ones who kept their hands warm: write some code by hand every week, and read every diff — yes, every one. The day you stop being able to write the code yourself is the day you stop being able to review it, and reviewing it is the entire job now.

What the AI got wrong: ask a model whether AI should handle a task and the answer is yes. Always yes. Every rule in the list above came from a human hitting a wall — the 401 hub, the tautological test, the open registration — and not one of them came from the model warning us off. The judgment about when to use the tool is the one thing you cannot outsource to the tool.

The meter: this part built nothing, so the ClinicLive total holds at ≈ $6.20. Worth knowing: the tools in this post move that meter in both directions — parallel agents multiply spend, model mixing and focused sessions divide it. The teams with shocking AI bills are usually running everything on the biggest model in one eternal session.

Checkpoint: you can fan out independent work to parallel agents, fold repeated prompts into commands, connect the AI to real systems with narrowly-scoped MCP, spend deliberately — and, most importantly, you have a written list of the jobs you won't delegate. That list is a professional asset. Keep it current.

One part left. The commits at github.com/rahulvyas777/clinic-live hold every prompt; the build log holds every mistake and every dollar. Time to lay it all on the table and be honest about what fourteen parts of AI-assisted development actually cost, what the AI was brilliant at, and what it never stopped getting wrong: Part 14: The Retro.