🔵 Code Agent Domain

Use the coding assistant as an on-demand personal helper: it researches, builds files, and gets smarter with each use — all running locally.

Seeing the agent work locally first builds intuition before adding complexity (deployment comes later).

Research and build assistant; no hosting at this stage; two example projects (research and slides).

Instead of connecting and configuring each step, you tell the agent the outcome you want; it reasons, adapts, and figures out the steps.

It's the central mindset shift — asking for the finished dish instead of following the recipe.

Describe the end result; the agent reasons, adapts, and self-heals; think of an experienced developer.

Traditional automation is predictable (“boring is beautiful”); generative AI is non-deterministic by nature — the same input can produce different outputs.

Accepting variation keeps you from interpreting it as an error; you focus on specifying outcomes.

Predictability vs. creativity; the agent reasons through alternatives; variation is normal.

Workflows are Markdown files written in natural language (headings, bullets, bold text) that act like a job description or SOP, telling the agent what to do.

It's the framework's first layer — reusable instructions that persist across tasks.

Markdown as an SOP; objective, input, output, and steps; persistent and reusable.

The agent is the code assistant itself: the brain/coordinator that reads the workflows, sees the available tools, and decides which one to use and when.

Understanding that the agent delegates like a project manager clarifies who does what in WAT.

Coordinator/brain; reads workflows + sees tools; decides the route.

The tools are Python scripts that do the actual work, ideally one task each (scrape a website, generate a PDF, analyze data); the AI writes and fixes them.

You don’t need to program—just know the tools exist and what each one does.

One job per tool; generated and repaired by AI; no coding knowledge required.

The agent runs a workflow, finds an error, diagnoses it, fixes the tool, and updates the workflow file so the error doesn’t happen again.

It's what makes runs smoother and faster over time — the system improves on its own.

Diagnose → fix → document; the fix persists in the workflow; continuous improvement.

An onboarding CLAUDE.md that specifies the WAT framework, operating rules, folder structure (workflows/tools/temporary/.env), and style.

It's the document that drives fully automated workflows; keeping it concise prevents rules from getting lost.

WAT onboarding; default folders; keep it under ~500 lines; move details to skills.

Put WAT into action: turn a file of raw notes into a clean, structured document by going through the iteration loop.

It's the first complete build — generates workflows + tools, runs, reviews, and iterates.

Plan Mode; separate building from execution; feedback that updates the workflow + tool; clear the context.

MCP is a protocol that lets a single connection expose many tools/actions; the agent figures out which one to call, when, and with which parameters.

It's the standard way to give the agent new capabilities without rewriting anything.

A single connection exposes actions; the agent decides on its own; Gmail analogy (send/draft/read).

MCP servers live in directories (like mcp.so) and in GitHub search for "MCP server" + service name.

Knowing where to look speeds up choosing the right tool for the task.

Categories: scraping (Firecrawl), databases (Postgres/Supabase), documents (Drive/Notion), communication (Slack/Gmail).

Give the agent the provider’s documentation installation command; it generates the .mcp.json with the server entry and a key placeholder.

Setup is simple, but the key must be entered carefully to avoid exposing it.

Provider command; generated .mcp.json; enter the key manually, never in chat.

The command /mcp shows the installed servers and their status; if one doesn't appear, restarting the assistant usually resolves it.

Knowing how to verify saves hours spent thinking the installation failed.

/mcp lists the status; restarting registers new servers; a common cause of “not showing up.”

An end-to-end workflow: provide a topic, research the web with Firecrawl, synthesize findings, and generate a structured document (plan → build → run).

It's the build that demonstrates MCP in real use by reusing the WAT framework.

Plan Mode; target sources (3-5); CLAUDE.md WAT as config; Firecrawl scrapes multiple sources.

Produce Markdown and convert it into a document file using a generated conversion tool.

Separating content (markdown) from format (document) makes the output flexible and reusable.

Markdown first; conversion tool; updating Markdown doesn’t always update the document.

Give specific feedback ("I like this; change that") and, if something breaks, ask the AI to fix itself (self-healing loop).

The first run is rarely perfect; the loop is what leads to quality.

Structured feedback; the more specific, the better; ask it to fix itself.

Skills are instructions in markdown in a special skills folder, conceptually identical to workflows but invocable as a slash command.

It's how you make a workflow reusable, consistent, and token-efficient.

The .claude/skills folder; one folder per skill; slash command; loaded on demand.

Package a skill when there’s repetition, a need for consistency, complexity, or team sharing; type it out for a one-off or simple task.

Avoid creating too many skills (overkill) or needlessly repeating complex instructions.

Repetition/consistency/complexity/team → skill; one-off/experiment/simple → type it.

Build an "draft email" skill in the official format, with SKILL.md (name, description, arguments, steps), and invoke it as /draft-email.

Shows how a skill becomes instantly reusable with the same rules on every call.

SKILL.md; arguments (bullets, recipient, tone); invoking without arguments prompts for what's missing.

Another WAT build: a workflow that reads a document, extracts the key points, and generates a professional presentation.

Reinforces the CLAUDE.md (WAT) flow → workflow + tools → run → iterate in another artifact.

Extract key points; style; iterate on colors/fonts; layer on a design skill.

Five patterns for consistent results: objective (not steps), specific output, Plan Mode first, feedback (not correction), and treating AI as an expert.

These are habits that improve the quality of any agentic build.

You’re the manager, the AI is the developer; give feedback instead of saying “that’s wrong.”

Context rot: quality degrades as the session gets longer; errors become more common after ~60% usage, when noisy history drowns out the core rules.

Recognizing the zones prevents silent quality loss.

Zones 0-50 (OK), 50-70 (yellow), 70-85 (orange), 85%+ (clear).

/clear resets the entire conversation; /compact creates an intelligent summary that preserves the essentials and compresses the rest.

Choosing the right tool preserves useful context without carrying clutter.

Clear when switching tasks / when quality degrades; compact midway as the context grows.

Strategies to spend less: one task per session, then clear it; define "done"; use skills instead of a giant CLAUDE.md; turn off unused MCPs.

Without a defined endpoint, the agent may search too much and waste tokens.

Definition of "done"; skills save context; each active MCP uses context.

A checklist of 12 best practices for building high-quality agentic workflows, from Plan Mode to context management.

Consolidates everything from the track into a quick reference guide.

Always use Plan Mode; set a clear goal; define "done"; test with multiple inputs; review early.