Academy

Learn to walk through a living-architecture page: containers, flows replayed on the diagram, states and data, without getting lost in the arrows.

A split ultrawide monitor: Windows on the left, the Mac on the right.

Agent architecture (when an agent, when a workflow, hierarchies), building with the Agent SDK or a hand-written loop, hooks, and the patterns: tool-use loops, subagents, memory.

Look at the two lines of the status bar and know, at a glance, four things: how much context you have left before the session degrades, whether the cache is still warm, whether your work is safe (commit, push, HANDOFF)…

Document your project with ArqViva: research it, copy the template, fill N, E and FLOWS, write the manifest and pass the importer with no privacy hits.

The heaviest domain: from requirements to architecture, the mechanics of the Messages API, engineering basics (REST, JSON, async, git) and configuration management.

Before picking a model, ask whether one is needed at all. Deterministic, repeatable work goes to code that runs without a model (Python/SQL/shell).

Homebrew, Claude Code, gh, and a PATH that also works over SSH.

Its components (rules, skills, commands, agents, memory), session management, slash commands, headless and streaming modes, and the CLAUDE.md and settings.json hierarchy.

Source: home/.claude/rules/context-hygiene.md, home/.claude/rules/thresholds.json, home/.claude/settings.json, home/.claude/statusline.sh, home/.claude/MANUAL.md ch. 2, home/.claude/CLAUDE.md §Status line.

Finding errors and recovery strategies, reading traces, and telling whether a problem lives in the integration layer or in the model's output.

Fixed sections, exact headings:

LLM fundamentals, SDK, REST and streaming basics, picking the model for each task and managing cost and tokens. With D2 it is half of the exam.

Five scripts under home/.claude/hooks/, wired in home/.claude/settings.json. Every hook always exits 0 — a hook must never be the reason a session, a compaction, or the tool it watches fails.

A photo copy with sha256 on an external disk.

Context engineering (window, memory, drift, compaction, isolation), prompt engineering (clarity, few-shot, system vs user, constraints) and defensive output handling.

Source: home/.claude/rules/thresholds.json (full file), docs/statusline-internals.md §Thresholds, home/.claude/statusline.sh, home/.claude/hooks/session-drift-warn.sh, tests/statuslinetest.sh.

macOS 15.3.1 to 27.0.1 and what changed.

Security of AI applications (injection, jailbreaks, PII, leaks), guardrails and safe deployment, hooks as a control, identity, secrets and keys. Few questions, very predictable.

A model reviewing its own output shows measurable self-preference bias; a different model that is at least as strong does not.

Repos by git bundle, port, tests, layered config.

Implementing tools (schema, descriptions, errors, tool_choice, parallel calls, approval), building MCP servers (tools, resources, prompts, stdio vs HTTP) and when to use each extension point.

Source: home/.claude/MANUAL.md (index); home/.claude/skills/manual/SKILL.md.

enjambre run: Windows sends, a branch and a ledger entry come back.

A five-line executive summary of a daily price report, generated in under ten seconds: system prompt, parameters, stop reasons and token accounting, measured.

A night of unsupervised work, with rules and a report.

Turn a scraped product name into valid JSON every time, calling a local catalogue tool when needed: the tool loop by hand, schemas and validation.

Summarize 90 days of reports at the lowest cost: prompt caching for the fixed system prompt, the Batches API for the backlog, and the arithmetic that compares them.

claude, gh and git over SSH with a tmux that is born in your session; the first real job.

Process 200 indicators in under two minutes within the rate limit, survive 429 and 529 without losing work, log every call, and switch prompt or model with evidence.

Blender on Metal: STL to PNG with one line from Windows, Onshape to render, algorithms on both machines.

An agent that downloads, transcribes, classifies and files a batch of videos, confined to one folder by hooks and split into subagents.

enjambre watch knows which nodes are ready; jobs for a downed node wait in a queue.

One MCP server that lets several hosts list, describe and query a synthetic statistical schema read-only, plus a shared skill for the analysis.

Five MLX models with sha256, served one at a time by a manager that Windows reaches through a tunnel.

Attack your own agent with prompt injection, block it with hooks, keep secrets out of the context and redact personal data before it reaches the model.

Audio to text with renamable Speaker N labels; about 24 hours of audio per hour, measured against known truth.

The same tasks on both machines; cloud vs local in claude -p; a local coding model vs Claude Code.

One page with nodes, open sessions, usage, queue and a comparison by task type; a summary in the statusline.

From five hand-picked models to a catalogue, a benchmark with identical inputs and a manager that picks each task's model.

Every Claude Code session on both machines knows the Mac exists; a bare ssh mac is blocked by a hook.

A viewer with two costs and its own history, a redacted web copy with an allowlist, and a tray to drop tasks from the phone.

enjambre script (a command declared in AGENTS.md, $0) and run --detach (an agent with a USD cap): they return at once, heartbeat, resume if they die and leave a line in the ledger; kind: tests gets exactly one Bash command.

A persistent Claude Code on the Mac that Windows talks to (enjambre chat/send/sessions), with Playwright, a ledger per turn and gui yes/no in status; the key's threat model.

Every failure with its cause, grouped; tests kept apart; projects sortable by spend from the phone; a zoomable timeline; usage through lenses and a heat map; local models with logo, state and an editable note.

What is running right now, on top and in green, every 10 s; per node: CPU, GPU, RAM with pressure and swap, thermals, network, 4-hour charts and processes tagged with their job or session.

Four job classes, high > normal > low > night: a low job starts only on a free machine, a high one pauses or evicts it, and it resumes by itself 60 s later. The viewer says why.

Every number in the viewer says when it was measured and where it comes from: the age of each gauge, each chart's window and step measured from its data, and no user name in any screenshot.

No job should stay in unknown forever. If a job cannot run, it must fail on the spot and say why. If it dies before starting, it has to leave a state and a reason on disk.

I left Claude Code working alone for several hours on two computers and 59 repos: the rules I wrote beforehand, what it achieved with evidence, and the mistakes it declared itself.

Getting into the Mac over SSH without a password: own key, alias, hardening with a drop-in, and the mistake of pasting several commands at once.

Twice the Mac changed IP and ssh stopped answering: once from joining the iPhone hotspot and once after updating macOS.

A plain table picks the machine for every job, and why a single measured cell is not a comparison.

One page per project that shows how information flows: the C4 container diagram, plus use cases you can play step by step over it. How to read it, and the rule that keeps it honest.

Which startup file zsh reads depends on whether the shell is interactive or login, and that decides whether your PATH exists over SSH.

The board every card plugs into so that none talks to another directly, and why enjambre has none: Windows reaches the Mac over SSH and the Mac listens only on its own loopback.

Why jobs for an unavailable node wait in a queue of files, and what validating the contract before queuing buys you.

Every command-line program on Windows inherits its parent's console; when there is none, a visible one pops up. Why that matters for background watchers.

How the router hands out IP addresses, why a reservation keeps the Mac's address stable, and what the private Wi-Fi address changes.

How a table plus live state pick the machine for each job, and explain the choice in one line.

Why results travel between machines as branches pushed and fetched through git instead of a shared folder.

What the host key fingerprint proves the first time you connect, and what it means when it changes.

Deskflow uses self-signed certificates and trust on first use: each side shows a fingerprint and the other remembers it, like known_hosts in SSH.

An operation is idempotent if running it twice leaves the system as running it once; why unattended remote commands need that.

A long job nobody watches has to answer two questions on its own: is it still alive, and if it died, can it pick up where it left off?

Giving an agent only the tools it needs, no sudo, and a file for whatever only the owner can do.

Logs, metrics and traces: gather what already exists and do not invent the metric that is missing.

A list of what may pass versus a list of what may not, and why failing closed beats failing open.

A rule written in a document is policy; a hook that enforces it is mechanism. Why you need both.

A spending cap that belongs to one job, not to the account: when the agent reaches it, it stops by itself, leaves what it did and says why. A turn limit is not enough, because each turn costs more than the last.

What the scheduler does with a job's class (high > normal > low > night) before launch, while it runs and afterwards: why pausing frees no memory, why only a job with a checkpoint is evicted, and why only high preempts.

Who starts the conversation, the node that asks or the one that announces, and when each is the better choice.

Three copies, two media, one off-site: how the backup of repos and photos measures up and where it falls short.

Asking each node whether it is alive versus waiting for it to say so, and what each approach can and cannot detect.

An agent that is born, reads the brief, works and dies, against a conversation that survives between messages. What each one needs in the brief and what it keeps.

Several working directories from one repository, so parallel jobs never fight over the same checkout.