Big Idea

The argument in one line.

AI agents do not fail because the AI is bad -- they fail because most people give the AI a task without a job description, no context about who they are, and no instructions for what to do when things go wrong.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You have set up at least one Claude CoWork agent and found that it works inconsistently or stopped using it after a few runs.
You write prompts but have not written a standing job description with quality standards, edge-case rules, and fallback behavior.
You want your agents to sound like you and reflect your voice, audience, and non-negotiables without re-explaining every session.
You are a solo creator, educator, or professional using CoWork for recurring tasks like research briefs, content drafts, or morning summaries.

SKIP IF…

You are building multi-agent pipelines or API-integrated systems -- this video targets the CoWork project-based interface, not code-level agent orchestration.
You are brand new to CoWork and have not yet built your first agent -- there is a beginner video linked at the end that covers that ground first.

TL;DR

The full version, fast.

When an AI agent produces inconsistent or useless output, the root cause is almost never the model -- it is underspecified instructions. This video names three fixes: replace thin prompts with a proper job description that defines what good looks like and what to avoid; add a context anchor file that loads your voice, audience, and non-negotiables into every session automatically; and write a failure protocol that tells the agent exactly what to do when it cannot complete the task as specified. All three can be drafted with Claude's help in about ten minutes.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:31

01 · Hook -- the quiet quitter agent

Addresses CoWork users directly: you built agents that kind of work but stopped using at least one of them. Frames this as a setup problem, not a CoWork problem.

00:32 – 01:43

02 · Origin story -- the broken grading system

University instructor built an AI grading assistant that hallucinated features that no longer existed. Root cause: gave the AI a job without a job description.

01:44 – 02:37

03 · Preview -- three missing components

Sets up the three-part structure. Frames the vending machine vs. real agent contrast.

02:38 – 04:18

04 · #1 Job Clarity

Distinguishes prompt (do this this time) from job description (responsibility, quality standard, edge cases). Shows a real morning brief agent instruction set with source list, format rules, topic thresholds, and null-state behavior.

04:19 – 05:37

05 · #2 Context Anchor

Every session starts knowing agent instructions but not who the user is. A claude.md file loaded automatically carries voice, audience, frameworks, and non-negotiables into every session.

05:38 – 07:11

06 · #3 Failure Protocol

Agents built only to succeed will guess when they hit edge cases -- confidently and wrongly. A failure protocol is fallback instructions built into the job description itself.

07:12 – 08:19

07 · Action step -- build all three with Claude

Shows the exact prompt template to ask Claude to write a job description including failure protocol. Workspace overview: several agents, each with job description plus claude.md plus fallbacks.

08:20 – 09:08

08 · CTA -- Portable AI Working Identity guide

Free guide for building the context anchor file. Final watch-next card.

Atomic Insights

Lines worth screenshotting.

The agent that stopped working after two runs was not broken -- it was under-instructed, and it was guessing.
A prompt tells the AI what to do this time. A job description tells it what it is responsible for, what good looks like, and how to handle the exceptions.
Confident wrong answers are worse than honest admissions of uncertainty -- build the failure protocol before the agent ships.
Every CoWork session starts knowing the agent instructions but not knowing who you are -- your voice, your audience, your non-negotiables are invisible unless you file them.
A context anchor loaded automatically into every project session is the single highest-leverage thing a CoWork user can build.
Agent inconsistency does not come from the agent failing -- it comes from the agent succeeding at the wrong thing because no one defined the wrong thing.
Adding a null-state instruction is one extra line and prevents the agent from fabricating content to fill a gap.
Briefing an AI agent is identical to briefing a new hire for a recurring weekly job they will do without supervision -- same mental model, same information required.
A failure protocol does not make an agent smarter -- it makes it honest, which is more useful than confident-sounding garbage.
The job description and the failure protocol are not separate documents -- the failure conditions are clauses inside the job itself.

Takeaway

Three things every recurring agent needs.

WHAT TO LEARN

An AI agent that guesses is not failing -- it is succeeding at something you never defined, which is why the fix is never about the model and always about the instructions.

A prompt and a job description are not the same thing: a prompt covers one session, a job description covers every session, including the edge cases you have not thought of yet.
Specificity in agent instructions is not pedantry -- it is the only way to close the gap between what the AI thinks you want and what you actually need.
A context anchor file is not a memory hack; it is the answer to why your agent sounds generic even when the output is technically correct.
Failure conditions should be defined before the agent runs, not discovered after it hallucinates three weeks in a row.
The right prompt template for building a job description with failure protocol built in: say the agent is supposed to do X for you every week, then ask Claude to help write a job description that includes what good output looks like, what to avoid, and what to do if it cannot complete the task.

Glossary

Terms worth knowing.

CoWork: Anthropic's Claude.ai Projects interface, which allows users to configure persistent AI agents with standing instructions that activate on every new session within a project.
Job description (agent): A standing instruction set that defines what an agent is responsible for, what good output looks like, what mistakes to avoid, and how to handle edge cases -- distinct from a one-off prompt.
Context anchor: A persistent file loaded automatically into every project session, containing the user's voice, audience, frameworks, and non-negotiables so the agent does not start from zero each time.
Failure protocol: Explicit fallback instructions embedded in an agent's job description that specify what to do when the task cannot be completed as specified -- flag it, ask for clarification, or produce a partial output with a label.
Null-state instruction: A clause that tells the agent what to do when the expected input or output does not exist -- for example, if nothing is worth reporting today, say so instead of fabricating content.

Quotables