Claude Code Agent Prompt Patterns: Repo Tasks Without Bloat

Claude Code agent prompt patterns are short repo task briefs that tell the agent what to change, which paths stay off-limits, and how to prove done without dumping the whole codebase into chat. You leave with path-fence templates, lean ticket shapes for one-shot and looped work, and standing-job wording that fits Agent Skills when the same chore repeats. This page owns bloat control. The sibling claude-code-prompts-guide covers full long-session task specs and loop CTA wording. Soft draft path for reusable standing jobs: https://promptmake.net/claude-skill-generator. PromptMake writes config and prompt text only. It does not run Claude Code or touch your repo.

Who these Claude Code agent prompt patterns help

You need these patterns when Claude Code sessions swell because someone pasted README walls, full stack traces, and three packages of "related" context into every ticket. The agent then re-reads noise, edits the wrong tree, and burns tokens before the first useful diff. Lean briefs reverse that: one finish line, path fences, one failing command excerpt, verify lines, and an escalate stop.

Strong fit: engineers who run Claude Code on monorepos, tech leads who standardize agent tickets across a team, and builders who want the same lint or docs chore encoded as a Skill instead of retyping it. Weak fit: one-line questions that belong in plain chat, or full Agent Skill format deep-dives (those live in how-to-create-a-claude-skill and anthropic-skills-format on this blog).

As of mid-2026, Claude Code commonly runs Claude Fable 5, Claude Opus 5, Claude Sonnet 5, or Haiku 4.5 for coding. Model choice matters less than whether the brief names allowed paths and a measurable done state. Keep the brief under two screenfuls so critical fences sit near the top and bottom of the message.

PromptMake at https://promptmake.net/claude-skill-generator scaffolds Skill-shaped standing instructions when a pattern becomes a weekly job. You still paste into Claude Code, preview Skills locally, and supervise edits on a branch.

Path fences that stop context bloat

A path fence is an explicit allow list and deny list for reads and edits. Without it, agents optimize globally. With it, they stay inside the ticket. Fences also shrink what you paste: you stop attaching sibling package docs "just in case" because the brief already forbids those trees.

Write fences as paths, not vibes. Prefer packages/api/src/routes over "the API area." Prefer do not edit packages/web over "leave the frontend alone." Name generated folders once: dist, node_modules, .next, vendor. Name secrets once: never open .env or credential files unless the goal says rotate a named key.

Pair fences with a context budget. Paste the failing test name and twenty lines of output, not the whole CI log. Link the ticket. Mention the branch. Skip pasting CLAUDE.md or AGENTS.md into the user message when the project already loads them. Duplicate standing rules inflate the middle of the context window and invite lost-in-the-middle drift.

When a job must read outside the edit fence, say so: "Read-only: packages/shared/types. Edit: packages/api only." That split lets the agent follow types without "helpfully" rewriting the shared package.

Allow, deny, and read-only lines you can paste

Allow: packages/billing/src, packages/billing/tests. Deny edits: packages/web, infra/, migrations/ unless the goal names a migration. Read-only: packages/shared/src/types. Skip: dist/, node_modules/, coverage dumps.

Closing REMINDER: "If a fix seems to require files outside Allow, stop, list the paths, and escalate. Do not expand scope silently."

What to paste once vs what stays in Skills

Paste once per session: ticket id, branch, failing command, one stack excerpt, acceptance notes from review. Keep in a Skill or project standing file: house lint rules, commit bans, default verify ladder, forever-denied paths. Mixing those layers is how briefs grow into novels.

Lean repo task briefs (one-shot and looped)

A lean brief has five blocks: Goal, Scope, Inputs, Verify, Escalate. Goal is observable. Scope holds fences. Inputs hold the minimum paste. Verify holds commands. Escalate holds the stop script when blocked or when a turn cap fires. You can run this as a single Claude Code message or wrap the same spine in a /goal style loop when iteration is expected.

Keep Goal to one paragraph a reviewer can audit without reading chat. Keep Inputs short enough that you would not mind pasting them twice. If Inputs need a fourth file dump, split the ticket. Bloat often signals a goal that is really two jobs.

For looped work, add a turn cap next to Verify: "or stop after 12 turns." Cap craft lives in turn-cap-agent-prompts on this blog. Here the point is not to invent a new loop dialect. It is to keep the agent brief thin enough that each turn does not re-ingest a manifesto.

Haiku 4.5 class models suit narrow, path-fenced fixes with clear verify. Opus 5 or Sonnet 5 class models suit refactors inside a fence when judgment matters. Do not compensate for a vague brief by picking a heavier model.

One-shot fix skeleton

Goal: npm test --workspace packages/api -- auth.spec.ts exits 0; no public export signature changes. Scope: edit only packages/api/src/auth and packages/api/tests/auth. Inputs: paste the failing assertion block once. Verify: run the named test, then lint on touched files. Escalate: if the failure is env or missing secret, stop and report; do not invent credentials.

Looped batch skeleton

Goal: migrate the next 5 call sites listed in docs/migration-checklist.md to the new helper; targeted tests for those sites exit 0; or stop after 10 turns. Scope: only paths listed for this batch. Abort if any file outside the list would change. Escalate on cap: remaining call-site count, files touched, last failing command.

Skills-friendly standing jobs

Some agent prompt patterns should not stay as one-off tickets. Lint-on-touched-files, sync OpenAPI from handlers, refresh changelog from conventional commits, and "docs match CLI flags" are standing jobs. Encode them as Agent Skills with a trigger-rich description and an imperative body so Claude Code can load them when the user asks in natural language.

Skills cut bloat because the standing rules live outside the chat. The live message stays thin: "run the billing OpenAPI sync Skill on this branch." The Skill body holds fences, verify, and escalate. That split matches how Anthropic documents Skills as of mid-2026: description for trigger matching, body for procedure.

Draft Skills when you have run the same brief three times with small noun swaps. Earlier than that, you overfit. Later than that, teammates reinvent fences. Soft scaffold: https://promptmake.net/claude-skill-generator for description plus body text. PromptMake does not upload to Anthropic or install Skills into your repo.

Keep Skills scoped. One Skill per job class. A mega-Skill that claims to "handle all repo hygiene" will fire on the wrong turns and pull irrelevant procedure into context. Prefer a billing-openapi-sync Skill over repo-housekeeping.

Description lines that trigger cleanly

Good description fragment: "Use when the user asks to sync OpenAPI or regenerate API docs from Express handlers in packages/api." Bad: "Helps with documentation." Trigger words should match how humans ask. List two or three phrasings.

Body shape for a standing Claude Code job

Body order: purpose one-liner, allow/deny paths, steps as imperatives, verify commands, escalate rules, never-do list. Keep examples short. Point to repo files by path instead of pasting their contents into the Skill.

Step-by-step: ship a lean agent brief today

Run this once on a real failing test before you template it for the team. Success means a green verify command and a diff that stays inside the fence, not a long transcript. Expect ten minutes of writing and one supervised Claude Code session on a clean branch.

If the first run expands scope, tighten Deny before you raise model tier. If the agent asks for files you already pasted as walls of text, delete the paste and keep a twenty-line excerpt. Measure token waste by whether the agent re-summarizes your README.

Guest free use on PromptMake skills paths is about three generations per day; free registered accounts about five per day as of mid-2026. Anthropic usage is separate.

Step 1: Write Goal and Scope offline

In notes: one observable Goal, Allow paths, Deny paths, Read-only paths. Example Goal: "All tests in packages/notifications pass; no schema migrations." Example Deny: "packages/web, infra/." Do not open Claude Code yet.

Step 2: Attach minimum Inputs and Verify

Add the failing command and a short excerpt. Add Verify as ordered checks: cheap lint or typecheck on touched files, then the targeted test. Add Escalate: stop on missing secrets, identical errors three times, or any need to leave Allow.

Step 3: Run, then decide Skill vs ticket

Paste into Claude Code. Supervise the first tool calls for fence respect. If the job will recur weekly, move standing lines into a Skill draft via https://promptmake.net/claude-skill-generator and keep only ticket nouns in chat next time.

Common mistakes that bloat Claude Code sessions

Mistake 1: Pasting the full monorepo README into every ticket.

Mistake 2: Scope as adjectives ("be careful with billing") instead of paths.

Mistake 3: Mixing standing house rules into every user message instead of Skills or project instructions.

Mistake 4: Treating this page as a clone of claude-code-prompts-guide. That guide owns long-session six-block specs and loop CTA depth. This page owns bloat control and Skills-friendly standing jobs.

Mistake 5: Encoding a one-off bugfix as a Skill on day one.

Mistake 6: Assuming PromptMake runs the agent. It drafts Skill or brief text. You paste and supervise.

Mistake 7: Raising turn caps to compensate for missing fences. You buy more expensive thrashing.

Model and format notes for mid-2026

Claude Code sessions as of mid-2026 commonly expose Claude Fable 5, Claude Opus 5, Claude Sonnet 5, and Haiku 4.5. Route narrow, path-fenced unit fixes to cheaper tiers when your host allows model routing. Reserve Opus-class judgment for refactors where API design choices sit inside the Allow list. Prompt quality still beats model badges: a fenced Haiku run beats an unfenced Opus tour of the monorepo.

Agent Skills use SKILL.md with a trigger-rich description and an imperative body. Keep ticket nouns out of the Skill body when possible. Project instructions and CLAUDE.md-style standing files hold forever rules; Skills hold job-class procedures; chat holds the failing command of the day. Collapsing those layers is how context bloat returns.

Loop command text remains separate from Skills. When the job is run-until-verify with a turn cap, draft on the loop generator. When the job is standing expertise the agent should load on phrase match, draft on https://promptmake.net/claude-skill-generator. Mixing both into one mega-file creates trigger noise.

Confirm live slash command names and Skill install steps in Anthropic docs when versions move. This article stays on brief craft: fences, thin pastes, and Skills-friendly standing jobs.

Soft next steps with the Claude skill generator

Pick one recurring chore. Strip it to Goal, fences, Verify, Escalate. Run it once as a ticket. If it wins, scaffold a Skill at https://promptmake.net/claude-skill-generator, install per Anthropic's Skill docs, and keep chat messages thin. For pure loop command text with turn caps, use the loop generator instead. For one-off long specs, reuse the skeleton from claude-code-prompts-guide without pasting this article's Skill angle into every loop.

FAQ

What are Claude Code agent prompt patterns?

Claude Code agent prompt patterns are reusable brief shapes for repo work: goal, path fences, minimum inputs, verify, and escalate. They keep tool-using sessions aligned without flooding context. You adapt the same spine for one-shot fixes, capped loops, and standing Skills. PromptMake can draft Skill text; Claude Code still executes locally.

How do path fences reduce context bloat?

Path fences name Allow, Deny, and Read-only trees so you stop pasting "extra" packages for safety. The agent also wastes fewer turns exploring off-limits folders. Write paths, not moods. Put a REMINDER that expanding scope requires escalate.

When should I turn a brief into an Agent Skill?

After three successful runs of the same job class with only noun swaps. Skills hold standing procedure and fences. Chat holds ticket facts. Draft at https://promptmake.net/claude-skill-generator when the blank SKILL.md stalls you. Do not Skill a unique production incident.

How is this different from claude-code-prompts-guide?

That guide teaches full task specs that survive long sessions, with loop-oriented CTA. This article focuses on Claude Code agent prompt patterns that fight bloat: tighter fences, thinner pastes, and Skills-friendly standing jobs. Read both when you standardize team templates.

Do I still need verify criteria and turn caps?

Yes for looped work. Verify defines done. Caps bound cost when done never arrives. This page assumes those lines exist; turn-cap-agent-prompts and verify-criteria-prompt-patterns go deeper. Lean briefs make those lines easier to see.

Can PromptMake run Claude Code for me?

No. https://promptmake.net/claude-skill-generator outputs Skill-oriented text you paste and maintain. PromptMake does not access repositories, schedule agents, or spend Anthropic tokens. Guests get about three generations per day on that path; free registered accounts about five.

Which model should I pick for fenced repo tasks?

Use Haiku 4.5 class models for narrow test fixes inside a tight Allow list. Use Sonnet 5 or Opus 5 class models when the fenced change needs heavier judgment. Fix the brief before you escalate model cost. As of mid-2026, confirm the label in your Claude Code session; public names move.