Workshop and capstones

The Playground: build your prompt

Theory is useless without practice. The Playground (its own tab at the top) has you assemble a production-quality prompt by ticking the building blocks from module 2: role, context, data in tags, instructions, examples, thinking, format, guardrails. You watch the prompt build live, and you copy it.

Exercise: rebuild three prompts from scratch, without looking at the lessons.

1. A contact-detail extractor from an email (role + tags + JSON format + Unknown guardrail).
2. A security auditor of a code snippet (role + thinking + format by severity).
3. A writer of a Sept-Tools product sheet (role + brand tone + few-shot example + language constraint).

When you can write them from memory, module 2 is learned. The rest of the Bible is just tooling around that core.

Capstones: from beginner to expert

Four synthesis projects, one per level. Do the one that matches where you are; come back for the next.

Beginner. Create a Claude.ai Project for one of your recurring topics. Put your permanent instructions in it (tone, language, format) and a reference document. Run three conversations on it and notice you never re-paste your brief again.

Intermediate. Install Claude Code on a small repo. Write a CLAUDE.md (commands, conventions, one absolute rule). Have it accomplish a real task in plan mode, approve the plan, let it execute.

Advanced. Create a homemade skill. Pick a workflow you repeat (a deploy, a review, a type of writing), write the SKILL.md with a good description, and invoke it. Bonus: wire an MCP server onto one of your tools.

Expert. Build the seed of a second brain: a memory/ folder with a MEMORY.md index and three notes (a feedback, a project, a reference), woven by wikilinks. Add a consolidation rule after each batch. You have the skeleton of Pierre's system.

The practitioner's checklist

The operational digest to reread before each big task. These are the reflexes that separate the amateur from the practitioner.

• Before prompting: what does the model actually have in its context? Am I explicit about the format, language, length?
• Data: any big block goes in tags, separated from instructions.
• Facts: I give the sources, I offer an "Unknown" exit, I search the web for the present.
• Reasoning: hard task = I make it reason before concluding.
• Claude Code: CLAUDE.md up to date, plan mode for big changes, /clear between subjects, /compact mid big task.
• Context: stable prefix, I compact big outputs, I push exploration into sub-agents.
• Models: Opus for architecture/debug, Sonnet/Haiku delegated for the repetitive.
• Multi-agent: pipeline by default, barrier only for a global dependency, I verify before concluding.
• Memory: I consolidate after each batch, I weave the links, the index stays an index.
• Safety: no committed secret, I archive never delete, I verify before believing.

Print it. When a result disappoints, run through it: the cause is almost always a line you skipped.

Capstone: ship a small feature

This capstone walks you through adding one real feature to a project using Claude Code (the CLI coding agent you run from your terminal or IDE). You will go from a plain-English description to committed, working code without writing a single line yourself.

The workflow has four stages:

1. Orient: open Claude Code in your project folder and let it read the codebase (/init). Claude maps files and dependencies so its suggestions stay accurate.
2. Plan: describe the feature in one clear sentence. Ask Claude to draft a plan before touching any file. Review the plan and confirm or correct it.
3. Build: tell Claude to implement the plan. It will create or edit files, run tests if a test command exists, and report what changed.
4. Verify: run the app yourself (or use /run if your project skill supports it), check the feature works, then commit with /commit.

A key discipline here is one feature, one session. Scope creep (adding extra ideas mid-session) is the main reason capstone builds go off the rails. If a new idea appears, note it and open a fresh session for it.

Capstone: build your second brain

A second brain is a personal knowledge system that captures what you learn so you can recall and reuse it without relying on memory alone. In the context of Claude and Claude Code, it means maintaining notes, linking related ideas, and refreshing your knowledge base regularly so every new session starts with context already loaded.

The three pillars are capture (writing things down immediately), linking (connecting notes with wikilinks such as [[topic]] so related ideas surface together), and recall (querying your notes instead of re-reading every file from scratch, which saves tokens and time). A fourth pillar, refresh, keeps the system alive by updating notes after each session rather than waiting for a backlog to build.

Claude Code supports this workflow through its CLAUDE.md files (project-level instructions loaded automatically), its memory system (notes persisted across sessions), and hooks (automated scripts that run before or after Claude acts). Together these let you wire Claude into a living knowledge loop rather than a stateless chat session.

• Write one atomic note per concept (one idea, one file) so links stay precise.
• Use a MOC (Map of Content) file as a hub that lists related notes, giving you one entry point per topic cluster.
• After each session, run a sync: update the relevant note, add wikilinks to connected notes, and update your main index (MEMORY.md or equivalent).
• Schedule a nightly consolidation pass (a script or cron job) to rebuild any graph indexes so the next session loads fresh context.

Capstone: a multi-agent review

A multi-agent review means launching several Claude instances in parallel, each acting as a specialist reviewer, then collecting their verdicts and synthesizing a final judgment. Claude Code supports this pattern through its subagent system: one orchestrator agent fans out tasks to independent workers, waits for all results, then merges them.

The fan-out step typically uses --print (non-interactive, machine-readable output) combined with a prompt that assigns a strict role: security auditor, UX critic, performance analyst. Keeping roles separate prevents reviewers from anchoring on each other's opinions, which is the main advantage over asking one agent to "review everything."

The verification step is critical. Before synthesizing, the orchestrator checks each reviewer's output for completeness: did it address the target file? Did it cite concrete line numbers or evidence? Outputs that fail this check are flagged or re-run rather than silently included in the summary.

Synthesis collects the verified verdicts and asks a final Claude call to:

• Deduplicate overlapping findings across reviewers.
• Rank issues by severity (critical, major, minor).
• Produce a single action list the author can work from immediately.
• Note any conflicts between reviewers so a human can decide.

Capstone: a content pipeline

A content pipeline is a sequence of steps that takes a raw idea and turns it into a finished, published asset. In this capstone you will wire together the techniques from this module: briefing, drafting, editing, and publishing, all driven by Claude Code (the command-line and IDE coding agent) and Claude.ai (the chat interface).

The pipeline has four stages:

1. Brief: define the topic, target audience, word count, and tone in a short text file.
2. Draft: prompt Claude (via claude CLI or Claude.ai) to generate a first draft from the brief.
3. Edit and refine: run a second prompt asking Claude to critique and rewrite for clarity, then do a final human review.
4. Publish: use a Claude Code slash command or a shell script to copy the finished file to your output folder or call a publishing API.

Chaining prompts in a file-based workflow (reading the brief, writing the draft, reading the draft, writing the edit) keeps each step auditable and repeatable. You can run the whole pipeline again on a new brief in seconds.

The graduation checklist

You have covered the full arc from first prompt to agentic workflow. Before you move on, run through this checklist honestly. Each item maps to a real skill you can demonstrate right now, not just a concept you have read about.

The checklist is split into three tiers: Foundations (things every user must own), Practitioner (things that separate a power user from a casual one), and Advanced (things that put you in the top tier of non-developer users).

• Foundations: write a clear, scoped prompt; use /clear to reset context; know the difference between Claude.ai (chat), Claude Code (coding agent, CLI and IDE), and Claude Cowork (desktop file agent); pick the right model (Opus claude-opus-4-8 for reasoning, Sonnet claude-sonnet-4-6 for speed, Haiku claude-haiku-4-5 for high-volume tasks).
• Practitioner: use /init to create a CLAUDE.md project memory file; run claude --model claude-sonnet-4-6 --print "your task" in non-interactive (headless) mode; add a tool permission with /permissions; craft a system prompt that enforces a house style; explain what a token is and why context windows matter.
• Advanced: build a multi-step agentic loop with checkpoints; pipe Claude into a shell script; set up a hook that fires automatically before or after a task; compare two model outputs side by side for the same prompt; evaluate a response for hallucination risk and ask a targeted follow-up to verify it.

If you can tick every item above without hesitation, you have genuinely graduated from this course. If two or three items feel shaky, go back to those lessons now rather than later. Competence compounds: one weak link can break an otherwise solid workflow.