Your agent job worked once, then quietly drifted. The prompt was a procedure with no way to check itself.

Two habits that make agent jobs drift

When I look at the prompt behind a drifting job, I almost always find one of two habits.

The prompt is a procedure. “First read the commits, then group them, then write the entries.” Older models needed that. Current models do better with the end state, the constraints and a way to check the result, then room to work. A procedure locks the model into your guess at the right path, and it breaks the moment reality differs from your assumptions.

There’s no way to verify. This is the expensive one. If Claude can’t confirm its own work, you have to inspect the output yourself, and then the automation saves nothing. Unattended runs stall and drift for exactly this reason: nothing in the loop can tell good output from bad.

Neither habit is a skill problem. They’re what people write when they sit down with a blank prompt box. So the fix isn’t a better template. It’s a few questions asked before the prompt exists.

An interview before the prompt

prompt-workflow-architect is a skill for Claude Code, Cowork and claude.ai. You describe a rough task, and before drafting anything it interviews you, one question at a time.

1. Outcome. “What’s the actual outcome you want: not the steps to get there, the end state?” If you answer with a procedure, it pushes back and asks again.
2. Scope. Is this one-time or recurring? If one-time: small and single-shot, or large with many phases? If recurring: does it need your machine, and how often should it run?
3. Verification. “How will Claude know it’s actually done, without you checking manually?” A test, a comparison, a rubric. This one is a hard gate. Without an answer, the skill won’t finish the prompt.
4. Guardrails. What must not be touched or broken: files, systems, budgets, style rules.
5. Existing prompt. Is there already an instruction somewhere covering this task? If so, the output tells you to remove the old one, so the two don’t fight.

The scope answers decide how the job runs, with no judgment call on your part. One-time and small runs as a single agent. One-time and large runs as a workflow that fans out across phases. Recurring and dependent on your machine (a local database, a VPN, unpushed work) runs as a loop, and your machine has to stay on. Recurring with only a repository and some APIs runs as a routine in the cloud, and your machine can be off.

What comes out

The repo walks through one case: keeping a changelog current. The person starts with a procedure: “well, first read the commits, then group them, then write the entries.” The interview turns it into this, assembled from the example’s own answers:

Keep CHANGELOG.md accurate: its Unreleased section always covers every
merged pull request since the last tag.

Guardrails: never edit released sections above "## [Unreleased]";
never touch git tags.

Verification: compare the PR numbers cited in the Unreleased section
against the merged PRs since the last tag date, and confirm every
merged PR appears exactly once.

Execution mode: routine, daily. It only needs the repository and the
GitHub API, so it can run in the cloud.

Notice what’s missing: steps. Claude decides how to read the history and group the entries. Notice what’s present: a check Claude can run itself, so a missed or doubled entry gets caught by the job instead of by a reader. And because an older “keep the changelog updated” instruction already existed, the output also says to remove it.

The skill only drafts. It never creates a schedule, a routine or a file for you. Setting the job running stays your decision.

How to run it

In Claude Code:

/plugin marketplace add promptmetrics/prompt-workflow-architecture
/plugin install promptmetrics-prompt-workflow@prompt-workflow-architecture

It also triggers on its own when you ask for help writing a prompt or setting up a recurring job. For Cowork and claude.ai, upload the skill as a zip. The steps are in the repo. It needs no scripts, no credentials and no network access, and it’s open source under MIT.

If you run recurring agent jobs against tools you already pay for, try it on the job you trust least. The interesting moment is question three. If you can’t answer how Claude would know it’s done, you’ve found why that job drifts.