Patriola's Guide to ClaudeThe Series
Every serious Claude workflow.
Each book covers one topic in depth — you can read them in order or go straight to what you need.
Productivity Automations Self-Publishing Memory AI Teams Removing AI Tells Self-Verifying Pipelines SSH to the GPU Build a HUD Voice Cloning Agent Messaging Trust Scoring Token Budgets Red-Teaming Long-Horizon Evals Measuring Claude Building Data QA Infrastructure Research Navigator Writing White Papers Building a Methodology Build a Domain FAQ SSH to Your Web Host Build a Self-Deploying App One Button Claude Build a Newsletter System UI Aesthetics Federation Hallway Rules Authority Gates Memory Diary Serverless Backends Build a Database Cross-AI Workflows Escape WordPress Multi-User Dashboards + Google Auth Build a Browser Extension Kaspa Affiliate Systems Static Site Generators Custom Desktop Environments Writing Fiction with Claude Behavioral Annotation Pipelines Designing Valid Evals What Operators Reveal Building Feedback Loops Annotation Scheme Design Data Curation Pipelines Preference Data and Comparative Judgment Multi-Agent Book Writing Autonomous Morning Reports Overnight Brainstorming The Council Pattern Specifying Behavior
Productivity
The foundation. How to build a working system around Claude that holds up over time. Session memory, inbox triage, task tracking, prompt patterns that compound, and the daily loop that makes Claude genuinely useful.
Start here. Everything in later books assumes you have a working daily loop.
Automations
Claude hooks, cron-style scheduling, and background tasks that run while you sleep. Pipelines that chain Claude calls together without you watching — from simple daily digests to multi-step workflows.
Prerequisites: comfortable with Productivity's daily loop.
Self-Publishing
Using Claude to write, edit, and publish books on Kindle Direct Publishing — from manuscript to live listing. Drafting workflows, self-editing passes, KDP metadata, cover briefs, and the review loop that makes books worth reading.
Standalone — no prerequisites.
Memory
Persistent context systems that make Claude remember what matters across sessions. Session memory files, semantic search, project memory, and the patterns that keep context coherent over weeks of real work.
Prerequisites: Productivity.
AI Teams
Orchestrating multiple specialized Claude agents that coordinate, delegate, and share state across complex long-running jobs. Model routing, parallel dispatch, supervision loops, and the trust architecture that keeps agent teams reliable.
Prerequisites: Productivity, Automations, and Memory.
Removing AI Tells
How to identify and eliminate the rhetorical patterns that mark AI-generated text — echo devices, parallel structures, banned constructions, staccato reduction, and the detection pipeline that flags them before they ship.
Standalone — no prerequisites.
Self-Verifying Pipelines
Gates, verification passes, and sign-off contracts that check Claude's output before it moves forward. Build pipelines where each stage proves its own work — input gates, processing gates, output metric gates, and the deploy check that runs before anything ships.
Prerequisites: Automations.
SSH to the GPU
Move heavy compute off the laptop to better hardware over SSH. Remote Claude Code sessions, file movement between machines, and long-running GPU jobs that finish while you work on something else.
Standalone — no prerequisites.
Build a HUD
A live status dashboard that surfaces queue depth, agent health, and pipeline state across your whole Claude setup. State files, a session statusline, queue readers, and the wiring that keeps everything visible without switching windows.
Prerequisites: Automations, AI Teams.
Voice Cloning
Train a voice model on your own recordings and serve it from a local endpoint. Dataset architecture, training on rented GPU hardware, reading the training run, and a verification pass that confirms the model before it ships to production.
Standalone — no prerequisites.
Agent Messaging
An inbox, an archivist, and a dispatcher that wire Claude agents together so they can pass work without sharing context. Schema versioning, the write-prohibition rule, an event log, and a council protocol for multi-agent deliberation.
Prerequisites: AI Teams.
Trust Scoring
A scoring layer that accumulates task outcomes as credit deltas and maps them to routing-grade tier labels. A tier-aware dispatcher, a crossing detector with an independent verification gate, deliberation weighting, and score aging via half-life decay.
Prerequisites: AI Teams, Self-Verifying Pipelines, Agent Messaging.
Token Budgets
Measure and cap what a Claude session actually spends. Context sizing, prompt caching, per-session budget gates, and the readouts that show where the tokens go before the bill does.
Standalone — no prerequisites.
Red-Teaming
Seven methods for breaking your own agents on purpose: leaked system context, prompt injection through retrieved content, multi-turn instruction drift, boundary violations, adversarial input construction, and pipeline regressions caught at the commit. Each one ships a working test artifact.
Prerequisites: Self-Verifying Pipelines.
Long-Horizon Evals
Seven instruments that measure what a twenty-minute eval cannot: a failure catalog, a scenario template, a degradation tracker, a silent-failure probe, a context profiler, a reliability scorer, and a pipeline that runs them as one reproducible test over hours.
Prerequisites: Self-Verifying Pipelines, Red-Teaming.
Measuring Claude
Seven instruments that convert output quality into a number: a hard-fail gate, a spec built from observed failures, a prose metrics suite, an instruction-adherence checker, a drift analyzer, and a quality pipeline that signs off a batch with a durable acceptance certificate.
Prerequisites: Self-Verifying Pipelines.
Building Data QA Infrastructure
A quality stack between collection and training: coverage analysis, consistency scoring, drift detection, acceptance certificates, and a packaging step that hands a certified batch downstream with its provenance attached. Claude runs every gate; the heavy passes scale to a remote machine.
Prerequisites: SSH to the GPU.
Research Navigator
Ten chapters walk the full empirical study loop with Claude: frontier mapping, gap analysis, methodology spec, measurement pipeline, comparison with confounds, claim verification, adversarial review, and a research record that bundles everything a stranger needs to rerun it.
Prerequisites: Building Data QA Infrastructure.
Writing White Papers
Seven stages from research question to upload-ready preprint PDF: an argument skeleton with source-tagged claims, an audit loop that recomputes every number from the source dataset, a reconciliation chapter for when the audit catches a mismatch, submission compliance documents, and a headless-browser PDF build.
Prerequisites: Research Navigator.
Building a Methodology
Seven stages that lock every consequential design decision before data collection begins: measurement question, research frontier map, gap analysis, label architecture with edge-case definitions, causal pathway with verification predictions, replication-ready methodology document, and pre-registration in a public repository.
Pairs with: Research Navigator, Writing White Papers.
Build a Domain FAQ
Seven stages from web crawl to searchable reviewed database: a trafilatura-based crawler, multi-source ingestion from GitHub and forums, Claude drafting with structured output, automated validation and deduplication, a CLI review interface, embedding-based search, and drift detection that flags entries when their source content changes.
Prerequisites: Self-Verifying Pipelines.
SSH to Your Web Host
Connect to a shared host over SSH and SFTP, then use that connection to deploy files, manage configs, and run maintenance scripts without leaving the terminal. Credential setup, key-based auth, and the scripted deploy that replaces a full FTP client.
Standalone — no prerequisites.
Build a Self-Deploying App
A web app that deploys its own updates on commit — no manual FTP, no manual SSH. Git hook triggers a remote pull, a health check confirms the deploy succeeded, and a rollback step fires automatically if it didn't.
Prerequisites: SSH to Your Web Host.
One Button Claude
A single endpoint that triggers a full Claude workflow remotely — from a phone, a browser bookmark, or any HTTP trigger. Authentication, payload routing, and the job queue that prevents concurrent collisions.
Prerequisites: Build a Self-Deploying App.
Build a Newsletter System
A subscriber-to-delivery pipeline from scratch: list management, queue-based dispatch, unsubscribe handling, and a delivery log that shows exactly what went to whom and when. Self-hosted, no third-party ESP required.
Prerequisites: Build a Self-Deploying App.
UI Aesthetics
Moving from assembled CSS to intentional design systems — spacing scales, typographic hierarchy, a design-token approach at the component level, and the audit pass that confirms visual consistency before a deploy ships.
Standalone — no prerequisites.
Federation
The governance layer that makes a multi-node Claude system safe to operate. Six artifacts: a node registry, a route map, a session router, a task envelope schema, behavioral rules, and a health checker that catches stray files before they compound.
Prerequisites: Memory.
Hallway Rules
Behavioral constraints that survive Claude session resets. A SQLite rule store, a cache layer, a constraint enforcer, and a session hook that loads rules before any agent acts — a governance layer agents check, not one they hope to remember.
Prerequisites: Federation.
Authority Gates
Two real gate patterns: a Python OAuth client for Google APIs and a hardened PHP session gate for shared hosting. Covers the full token lifecycle, bcrypt verification, rate limiting, and the pre-deploy audit checklist.
Standalone — no prerequisites.
Memory Diary
A diary layer that fires at session close, writes entries dense enough to be cheap and accurate enough to let a cold start resume without re-deriving what the previous session already knew. Precompact hook, pipe-separated format, cold-start recovery pipeline.
Prerequisites: Memory.
Serverless Backends
Move secrets off the shared host with AWS Lambda and KMS. Eight chapters build one working signing backend — Lambda, API Gateway, IP whitelist, API secret, and SNS notification — called from PHP over HTTPS.
Standalone — no prerequisites.
Build a Database
Claude as schema design partner across two real production systems: SQLite for KaspaFAQ and MySQL for a trading card game. Covers schema review, engine choice, normalization, indexing, the query layer, FULLTEXT search, and live migrations with rollback scripts.
Standalone — prior SQL knowledge assumed.
Cross-AI Workflows
Drive tools that have no API. Claude plans, a Playwright script executes against the web interface, and Claude verifies through the vision API. The worked example generates 192 picture-book illustrations overnight, ranked by Claude by morning.
Standalone — Python and basic web automation assumed.
Escape WordPress
Migrate off WordPress with full control over the result. A complete inventory-to-cutover migration from a real project — a Montessori school's site rebuilt as plugin-free PHP on shared hosting, with Claude classifying plugins, generating schema, and reviewing every handler.
Standalone — SSH, basic PHP/MySQL, and Python scripting assumed.
Multi-User Dashboards + Google Auth
Secure multi-user PHP dashboards with Google Auth. A real rebuild from single hardcoded credentials to bcrypt, session isolation, rate limiting, and a Google Sign-In path that lands in the same session state — sized to what shared hosting actually provides.
Standalone — basic PHP and an existing single-user auth system assumed.
Build a Browser Extension
Ship a live price tracker from manifest to Add-ons store. Six unbundled files, one architectural decision per chapter, and a real Firefox extension — a live KAS/USDT tracker with a canvas chart and sidebar panel — that passed AMO review.
Standalone — JavaScript and DOM familiarity assumed.
Kaspa Affiliate Systems
Secure Kasplex EVM affiliate commissions with Lambda. The private key lives in AWS Lambda, encrypted at rest by KMS, and a Solidity contract on Kasplex zkEVM tracks commissions in basis points — a real production system, not a tutorial scaffold.
Standalone — Solidity, AWS Lambda, and PHP familiarity assumed.
Static Site Generators
Data-driven Eleventy author sites via a single JSON file. Thirty-three novels, three series, one record per book — every time a title ships, zero HTML files change. A real site, built with Claude, live in production.
Standalone — terminal and SFTP deploy familiarity assumed.
Custom Desktop Environments
Animated wallpapers, custom icons, remote deployment. One palette applied everywhere, then staged silently to a second machine over SSH while it was actively in use — built with Claude.
Standalone — PowerShell and SSH familiarity assumed.
Writing Fiction with Claude
Preserve your voice in AI co-writing. A voice document, a session architecture, and a vocabulary engineering layer that keep your signature intact through the generation pass, instead of flattening into generic, dead prose.
Standalone — assumes you already write and have a manuscript sample to anchor from.
Behavioral Annotation Pipelines
Reproducible multi-tier annotation workflows. A formal ethogram and decision codebook, built before the data accumulates, with ELAN, BORIS, and Claude enforcing the contract session after session.
Standalone — no prior ELAN or BORIS experience assumed.
Designing Valid Evals
What your benchmark is and isn't measuring. Construct validity, confound control, and decomposing aggregate scores back into the failures they hide — built from an audit that caught three failures a paper had already survived.
Standalone — no statistics background beyond what the worked examples build.
What Operators Reveal
How intensive use generates a behavioral map. A correction-collection system — seeded by hand, organized by drift category, promoted one entry at a time — that turns accumulated correction data into a queryable record.
Standalone — no existing correction-logging system assumed.
Building Feedback Loops
Mastering constraint reliability and monitoring. Auto-loading constraints, hold-failure detection, and audit loops that turn silent degradation into a visible, dated record — built on top of the manual correction system.
Assumes Book 43’s manual correction system as a prerequisite.
Annotation Scheme Design
Operational protocols for reliable annotation. What deployment reveals that a pilot calibration never does — codebook, monitoring, checklist, and a versioning system that survives schema evolution.
Builds on Book 20’s label-architecture foundation.
Data Curation Pipelines
The pipeline ran three weeks with zero rejections and thirty percent of its output was wrong. Nine chapters build the crawler, drafter, automated pre-gate, review interface, and overnight runner with the human gate in place from the start.
Standalone — no prerequisites.
Preference Data and Comparative Judgment
Most A/B ratings are noisy because the comparison was designed wrong, not because the rater was careless. Eight chapters build the A/B instrument, condition control, inter-rater reliability for comparison pairs, and an export format that survives as training signal.
Prerequisites: Designing Valid Evals, Annotation Scheme Design.
Multi-Agent Book Writing
A fabricated citation survived four polish passes because it sounded right. Eleven specialist agents, a shared context contract, parallel research without cross-contamination, and a council review protocol built on a real 25-chapter academic project.
Standalone — assumes existing multi-agent Claude Code workflows.
Autonomous Morning Reports
An overnight run errored at check 2 and every downstream step silently didn’t execute — the log file still had a timestamp, because the process had launched. Ten chapters build the checklist and aggregated-scan report shapes that surface the truth before the first decision, not after.
Builds on Automations (Book 2) and AI Teams (Book 5); fleet patterns assume Build a HUD (Book 9).
Overnight Brainstorming
A file called morning_briefing.txt shows up in a folder that wasn’t there the night before — twelve scored ideas, the top three already drafted. Eleven chapters build the constrained overnight session, from the three constraint documents through the standing practice that compounds over time.
Builds on Automations (Book 2) and Autonomous Morning Reports (Book 49).
The Council Pattern
A structural reviewer approved a change that was structurally fine and operationally disastrous — nobody had a mandate to ask the second question. Eleven chapters build a named deliberation council with distinct perspective roles that converts ratified decisions into enforced, queryable constraints.
Advanced — assumes an existing multi-agent Claude Code practice.
Specifying Behavior
CLAUDE.md is not parsed specially — the model reads it as prose, weighted by position and phrasing. Eleven chapters treat behavioral specification as a craft with learnable failure modes, using eight real project files as source material.
Practical — for anyone running Claude against a real project instruction file.
New books in this series
One short email per book launch.
Self-hosted. Not shared, not sold.