CHAPTERS
- 0:00 – 3:03
Defining an AI harness: code that wraps an agent for a specific job
Claire demystifies the term “harness,” defining it as code around an AI agent that makes it more effective for a particular use case. She frames the episode goal: show a real harness, explain why it helps, and how to build one with Claude’s Agent SDK plus real tools.
- •A harness is “code around an AI agent” to improve effectiveness
- •Harnesses can include AI components, but don’t have to
- •The purpose is usefulness for a specific use case, not general capability
- •The episode will include a live demo and build/architecture walkthrough
- 3:03 – 3:33
What a harness contains: context, actions, and outcomes
She breaks the concept down into the core ingredients that make a harness work reliably. The emphasis is on encoding repeatable structure—what the agent should know, what it can do, and what it must produce.
- •Harness components: specific context, specific actions, specific outcomes
- •Reduces ambiguity by baking in expectations
- •Turns “prompting” into reusable structure
- •Optimizes the agent for a constrained job-to-be-done
- 3:33 – 4:35
When it’s worth building a harness (and what jobs fit)
Claire explains that harnesses make sense when a workflow repeats with the same setup and desired results. She lists examples across engineering and non-technical work where deterministic steps and tool use benefit from structure.
- •Best for repeated workflows with consistent setup and outcomes
- •Useful when work mixes deterministic steps with AI judgment
- •Examples: coding, incident management, release prep, support escalations, migrations
- •Non-technical examples: structured research, doc consolidation
- 4:35 – 6:06
Choosing the use case: why bug triage and Sentry debugging
She describes how she looked for a recurring internal workflow at ChatPRD that AI could do better with more structure. Bug triage is chosen because it needs tooling, internal context, and consistent follow-ups like Linear tracking and documentation.
- •Selection criteria: repeated, consistent workflow with room for improvement
- •Bug fixing/triage is structured and tool-heavy
- •Focus narrowed to Sentry issue investigation + follow-up actions
- •Desired outcomes include Linear updates and team-usable docs
- 6:06 – 8:08
Why not just use Claude Code/Codex directly: control, consistency, and safety
Claire outlines the limitations of general-purpose coding agents for a narrow workflow: you must restate intent, police tool usage, and babysit steps. A harness encodes allowed actions, repeatable process, and can even support model routing.
- •Harness avoids re-explaining intent each time (e.g., paste link and go)
- •Tool restrictions can be enforced (investigate-only vs. edit)
- •Repeatable step-by-step process and outputs become guaranteed
- •Supports multi-model routing and workflow-specific policies
- 8:08 – 11:09
Demo: terminal UI harness experience and run lifecycle
She demos the harness interface built as a terminal UI and explains how it mirrors the harness process: runs, evidence gathering, streaming activities, and artifact creation. She starts an investigation by pasting a Sentry link and selecting investigate-only mode.
- •TUI is optional—harness can be CLI, web app, etc.
- •UI shows past runs and structured stages of the workflow
- •Investigation run kicks off a Claude SDK session
- •Mode selection enforces behavior (investigate without modifying files)
- 11:09 – 12:41
Architecture overview: runs, tasks, flags, Claude Agent SDK, artifacts, and integrations
Claire presents the system design: a front-end interface triggering runs, each run executing a task with inputs and permission flags. The core planning uses Claude Agent SDK, persists artifacts to a file store, and connects to production tools like Sentry, Vercel, Linear, and GitHub.
- •Front end (TUI/CLI) triggers a “run” that executes a “task”
- •Flags control permissions (edit source, message customers, etc.)
- •Claude Agent SDK handles agentic planning and file primitives
- •Artifacts are saved for traceability and future reference
- •Real integrations: Sentry, Vercel, Linear, GitHub; model choice: Sonnet 4.6
- 12:41 – 13:42
Harness prompting strategy: custom system framing, tool policies, and guaranteed outputs
Instead of generic “you are a coding agent” prompts, she uses ChatPRD-specific instructions and requires specific return formats. These prompts, policies, and artifact requirements are encoded into the harness so they execute consistently without manual copy/paste.
- •Custom prompt anchors the agent in a specific environment and mission
- •Artifacts are treated as source-of-truth for the workflow
- •Tool-call policies restrict what the agent can do
- •Multiple custom prompts are embedded as harness steps
- •Outputs are standardized (return X/Y/Z every run)
- 13:42 – 15:13
Building the harness with Codex + Claude: lessons from ‘dueling’ coding agents
Claire explains her build process using both Claude Code and Codex sessions, noting it wasn’t one-shot. The models initially pushed toward deterministic code, so she had to be explicit about where AI reasoning belonged and why an Agent SDK was necessary.
- •Used “dueling” Claude Code and Codex to implement the harness
- •Not a one-shot—required iteration and tighter specs
- •Models tended to avoid adding AI unless explicitly instructed
- •Recommendation: be precise about workflow, tools, and where prompts belong
- •Agent SDKs (Claude/OpenAI) help get the intended agentic behavior
- 15:13 – 16:43
Code map: adapters, opinionated tool usage, workflows, and artifact generation
She walks through the file layout: a TUI entry point plus a small set of modules for integrations and workflows. Key design choice: build opinionated adapters (e.g., Sentry) that fetch only what’s useful, then generate structured artifact bundles and reports.
- •Small codebase: entry/index + ~8 functional files
- •Opinionated Sentry adapter (not letting the agent “wander” through everything)
- •Integrations: Linear, Vercel, GitHub tailored to bug triage
- •Workflow module (“bug hunter”) defines the step-by-step investigation
- •Artifacts include run logs, summaries, and an HTML report
- 16:43 – 19:15
How it runs in practice: CLI/TUI commands and artifact store as traceable history
Claire shows how the harness can be invoked via TUI for humans or via quick CLI commands with flags. The artifact folder updates per run, enabling you to inspect exactly what happened and reuse evidence later.
- •Supports both interactive TUI and direct CLI execution
- •Flags enable/disable capabilities per run
- •Artifacts persist per run for auditability and reuse
- •Harness structure enables delegation/orchestration by other agents
- 19:15 – 21:17
Live investigation outcome: evidence, hypotheses, and next-step recommendations
She reviews a completed investigation artifact for a Sentry warning affecting users, including missing Vercel logs and ranked likely root causes. The harness recommends creating a Linear issue, specifies verification steps, and declines to auto-fix due to insufficient information—matching the intended “investigate-only” behavior.
- •Confirms impact and frequency; distinguishes warning vs error
- •Notes data gaps (e.g., Vercel logs unavailable)
- •Proposes likely root causes and identifies code-level blind spots
- •Recommends verification actions (fetch raw Sentry event)
- •Suggests creating/assigning a Linear issue; does not enable patch mode
- 21:17 – 22:49
How to build your own harness: workflow-first design and permissions + interface choices
Claire distills the process: write down the workflow, choose data sources, build adapters, define artifacts, and set rules/permissions. Then implement with an Agent SDK and create any interface (TUI/CLI/web) that makes the harness easy to use.
- •Identify a repeatable workflow and document the steps
- •Select data sources and implement opinionated adapters/APIs
- •Define structured artifacts (reports, briefs, logs) as outputs
- •Set permissions and tool rules (what’s allowed vs forbidden)
- •Pick model/SDK strategy (Claude Code, Codex, routing) and build an interface
- 22:49 – 24:35
Wrap-up: ‘it’s not the model, it’s the harness’—structure upgrades AI work
She reiterates that harnesses range from simple wrappers to complex products like Cursor, Claude Code, and Codex. The core idea is consistent: structure around AI calls yields better reliability, efficiency, and job-specific outcomes.
- •Harness = structure around AI work, not a mysterious new concept
- •General-purpose coding tools are sophisticated harnesses
- •Custom harnesses deliver consistent outcomes for narrow jobs
- •Harnesses can be terminal apps, CLIs, or web apps
- •Encourages viewers to propose future builds/demystifications
