Claude Code Configuration & Workflows

CLAUDE.md files load at multiple levels. User-level applies to just you across all projects; project-level ships with the repo for everyone; directory-level applies within a subtree. More specific levels layer on top of broader ones.

CLAUDE.md فائلیں کئی سطحوں پر لوڈ ہوتی ہیں۔ یوزر لیول صرف آپ پر سب پروجیکٹس میں لاگو؛ پروجیکٹ لیول repo کے ساتھ سب کے لیے آتا ہے؛ ڈائریکٹری لیول ایک ذیلی حصے میں لاگو۔ زیادہ خاص سطحیں وسیع سطحوں کے اوپر لگتی ہیں۔

~/.claude/CLAUDE.md lives in your home directory, not the repo. If a teammate isn't getting an instruction, it may be stuck in someone's user-level config instead of the project.

~/.claude/CLAUDE.md آپ کی ہوم ڈائریکٹری میں ہوتی ہے، repo میں نہیں۔ اگر کسی ساتھی کو کوئی ہدایت نہیں مل رہی، تو شاید وہ پروجیکٹ کے بجائے کسی کے یوزر لیول کنفیگ میں پھنسی ہے۔

@import pulls another file's content into CLAUDE.md, so you can keep a small root file that includes only the standards relevant to each package.

@import کسی اور فائل کا مواد CLAUDE.md میں لے آتا ہے، تاکہ آپ ایک چھوٹی اصل فائل رکھ سکیں جو ہر package کے صرف متعلقہ اصول شامل کرے۔

# CLAUDE.md
@import ./standards/testing.md
@import ./standards/api-conventions.md

Instead of one giant CLAUDE.md, split rules into focused files (testing.md, deployment.md) under .claude/rules/. Easier to maintain and can be path-scoped (see Task 3.3).

ایک بڑی CLAUDE.md کے بجائے قواعد کو مرکوز فائلوں میں بانٹیں (testing.md، deployment.md) .claude/rules/ کے تحت۔ سنبھالنا آسان اور راستے تک محدود کیا جا سکتا ہے (Task 3.3 دیکھیں)۔

When behavior differs person-to-person, trace WHICH file the instruction lives in. A rule in someone's ~/.claude/CLAUDE.md never reaches teammates; moving it to the repo's project-level file fixes the inconsistency.

جب رویّہ ہر شخص پر الگ ہو، تو دیکھیں ہدایت کس فائل میں پڑی ہے۔ کسی کے ~/.claude/CLAUDE.md میں پڑا اصول ساتھیوں تک کبھی نہیں پہنچتا؛ اسے repo کی پروجیکٹ لیول فائل میں لے جانا یہ فرق ختم کر دیتا ہے۔

/memory shows the loaded files:
  ~/.claude/CLAUDE.md   (user - only you)
  ./CLAUDE.md           (project - everyone)
// "use conventional commits" is only in the USER file
// -> teammates never get it; move it into ./CLAUDE.md

Keep the root CLAUDE.md small and pull in only the standards each package needs via @import. Maintainers decide which standard files apply, so context stays relevant instead of dumping everything everywhere.

اصل CLAUDE.md چھوٹی رکھیں اور ہر package کے صرف ضروری اصول @import سے لائیں۔ سنبھالنے والے طے کریں کون سی اصول فائلیں لاگو ہوں، تاکہ سیاق متعلقہ رہے، ہر جگہ سب کچھ ٹھونسنے کے بجائے۔

# CLAUDE.md
@import ./standards/testing.md
@import ./standards/api-conventions.md

A monolithic CLAUDE.md is hard to maintain and always fully loaded. Breaking it into focused rule files is easier to edit and lets each file be path-scoped so it loads only when relevant (Task 3.3).

ایک بڑی CLAUDE.md سنبھالنا مشکل اور ہمیشہ پوری لوڈ رہتی ہے۔ اسے مرکوز rule فائلوں میں توڑنا ایڈٹ کرنا آسان کرتا ہے اور ہر فائل کو راستے تک محدود کرنے دیتا ہے تاکہ صرف متعلقہ ہونے پر لوڈ ہو (Task 3.3)۔

// before: one 400-line CLAUDE.md, always fully loaded
// after:
.claude/rules/testing.md          (paths: ["**/*.test.*"])
.claude/rules/api-conventions.md
.claude/rules/deployment.md
// each focused, editable, and path-scoped to load only when relevant

/memory shows exactly which CLAUDE.md / rule files are currently loaded — the fastest way to explain why behavior differs between sessions or machines.

/memory ٹھیک بتاتا ہے اس وقت کون سی CLAUDE.md / rule فائلیں لوڈ ہیں — یہ جاننے کا تیز ترین طریقہ کہ سیشنز یا مشینوں کے درمیان رویّہ کیوں مختلف ہے۔

/memory
LOADED:
  ~/.claude/CLAUDE.md
  /repo/CLAUDE.md
  /repo/.claude/rules/testing.md   (matched **/*.test.ts)
// explains why THIS session behaves differently from another machine's

A slash command every developer should have on clone/pull goes in the project's .claude/commands/. Personal-only commands go in ~/.claude/commands/.

جو slash command ہر ڈیولپر کو clone/pull پر ملنی چاہیے وہ پروجیکٹ کے .claude/commands/ میں جاتی ہے۔ صرف ذاتی کمانڈز ~/.claude/commands/ میں۔

Skills are on-demand workflows defined by a SKILL.md whose frontmatter configures how they run — isolate them, restrict their tools, and prompt for arguments.

Skills ضرورت پر چلنے والے کام ہیں جو SKILL.md سے بنتے ہیں، جس کا frontmatter طے کرتا ہے وہ کیسے چلیں — انہیں الگ کریں، ٹول محدود کریں، اور دلائل (arguments) مانگیں۔

---
name: analyze-codebase
context: fork          # run isolated, don't pollute main chat
allowed-tools: [Read, Grep, Glob]
argument-hint: <path>  # prompt if invoked with no arg
---

Verbose skills (codebase analysis) or exploratory ones (brainstorming) produce lots of output. context: fork runs them in a separate context and returns just the result, keeping the main session clean.

لمبی skills (کوڈ کا تجزیہ) یا کھوجی skills (brainstorming) بہت آؤٹ پٹ دیتی ہیں۔ context: fork انہیں الگ سیاق میں چلا کر صرف نتیجہ واپس دیتا ہے، اور اصل سیشن صاف رکھتا ہے۔

Want a tweaked version of a shared skill just for you? Put a differently-named variant in ~/.claude/skills/ so teammates' behavior is untouched.

کسی مشترکہ skill کا اپنے لیے بدلا ہوا نسخہ چاہیے؟ الگ نام والا نسخہ ~/.claude/skills/ میں رکھیں تاکہ ساتھیوں کا رویّہ نہ بدلے۔

Anything every developer should have the moment they clone or pull belongs in the project's .claude/commands/ — it's committed and shared. Personal-only commands go in ~/.claude/commands/ instead.

جو چیز ہر ڈیولپر کو clone/pull کرتے ہی ملنی چاہیے وہ پروجیکٹ کے .claude/commands/ میں ہوتی ہے — یہ commit اور شیئر ہوتا ہے۔ صرف ذاتی کمانڈز اس کے بجائے ~/.claude/commands/ میں۔

// committed -> every dev gets /deploy-check on pull
.claude/commands/deploy-check.md
// a personal-only command would instead live in:
~/.claude/commands/my-scratch.md

A skill that generates a wall of discovery output would bury the main conversation. context: fork runs it in a separate sub-agent context and returns only the result, keeping your working session clean.

جو skill کھوج کا ڈھیر آؤٹ پٹ بناتی ہے وہ اصل گفتگو کو دبا دیتی ہے۔ context: fork اسے الگ چھوٹے ایجنٹ کے سیاق میں چلا کر صرف نتیجہ واپس دیتا ہے، اور آپ کا کام کرنے والا سیشن صاف رہتا ہے۔

---
name: analyze-codebase
context: fork      # runs in a separate sub-agent context
---
// its wall of discovery output stays OUT of the main chat;
// only the final summary returns

Scope a skill to just the tools it needs so it can't take actions outside its job. A read-only analysis skill given only Read/Grep/Glob physically cannot modify or delete files.

کسی skill کو صرف اس کے ضروری ٹول تک محدود کریں تاکہ وہ اپنے کام سے باہر کوئی عمل نہ کر سکے۔ صرف پڑھنے والی تجزیہ skill جسے صرف Read/Grep/Glob دیے ہوں، فائلیں بدل یا مٹا ہی نہیں سکتی۔

---
name: audit-code
context: fork
allowed-tools: [Read, Grep, Glob]   # no Write/Bash -> can't mutate anything
---

argument-hint documents the expected input and makes Claude ask for it when a developer runs the skill bare — so a skill that needs a path doesn't silently guess or fail.

argument-hint متوقع ان پٹ بتاتا ہے اور جب ڈیولپر skill بغیر دلیل کے چلائے تو Claude سے وہ مانگواتا ہے — تاکہ راستہ مانگنے والی skill خاموشی سے اندازہ نہ لگائے یا ناکام نہ ہو۔

---
name: review-file
argument-hint: <path>       # prompts when invoked bare
---
/review-file             -> Claude asks: "which file/path?"
/review-file src/api.ts  -> runs directly

A rule file's frontmatter can declare which file paths it applies to. The rule loads only when you're editing a matching file, so unrelated context stays out of the way and tokens are saved.

rule فائل کا frontmatter بتا سکتا ہے یہ کن راستوں پر لاگو ہے۔ اصول صرف تب لوڈ ہوتا ہے جب آپ ملتی فائل ایڈٹ کر رہے ہوں، تاکہ غیر متعلقہ سیاق راستے سے ہٹا رہے اور ٹوکن بچیں۔

---
paths: ["**/*.test.tsx", "**/*.test.ts"]
---
# Testing conventions (loaded only when editing test files)
- Use React Testing Library...

Directory CLAUDE.md is bound to one folder. When the files you care about (tests, terraform, all *.tsx) are scattered across the tree, a glob-scoped rule applies by TYPE regardless of location — which a directory file cannot do.

ڈائریکٹری CLAUDE.md ایک فولڈر تک بندھی ہوتی ہے۔ جب آپ کی مطلوبہ فائلیں (ٹیسٹ، terraform، سارے *.tsx) ٹری میں بکھری ہوں، تو glob والا اصول قسم کے حساب سے لاگو ہوتا ہے، جگہ کوئی بھی ہو — جو ڈائریکٹری فائل نہیں کر سکتی۔

Put the glob in the rule's frontmatter and the conventions activate only while editing matching files — so Terraform standards don't consume context when you're in application code.

glob کو rule کے frontmatter میں رکھیں تو اصول صرف ملتی فائلیں ایڈٹ کرتے وقت فعال ہوتے ہیں — تاکہ Terraform کے اصول تب سیاق نہ کھائیں جب آپ ایپلیکیشن کوڈ میں ہوں۔

---
paths: ["terraform/**/*"]
---
# Terraform conventions (loaded only for IaC files)

A glob matches by pattern anywhere in the tree, so a single rule covers every test file no matter which feature folder it sits in — something a directory-bound CLAUDE.md can't achieve.

glob پورے ٹری میں نمونے سے ملاتا ہے، اس لیے ایک ہی اصول ہر ٹیسٹ فائل کو ڈھانپ لیتا ہے چاہے وہ کسی بھی feature فولڈر میں ہو — جو فولڈر تک بندھی CLAUDE.md نہیں کر سکتی۔

---
paths: ["**/*.test.tsx"]       # matches anywhere in the tree
---
# loads for src/a/x.test.tsx AND src/z/y.test.tsx
# a directory CLAUDE.md could only cover ONE folder

Directory CLAUDE.md only applies within its folder. When the files sharing a convention are scattered (tests, *.tsx, IaC), glob-scoped rules load automatically and deterministically by type — the right tool over a directory file, an optional skill, or inference from a monolith.

ڈائریکٹری CLAUDE.md صرف اپنے فولڈر میں لاگو ہوتی ہے۔ جب ایک اصول والی فائلیں بکھری ہوں (ٹیسٹ، *.tsx، IaC)، تو glob والے اصول قسم کے حساب سے خودبخود اور پکے طور پر لوڈ ہوتے ہیں — ڈائریکٹری فائل، اختیاری skill، یا بڑی فائل سے اندازے کے مقابلے صحیح آلہ۔

Files scattered by TYPE (tests, *.tsx, IaC)? -> .claude/rules/ + globs (auto)
All files in ONE folder?                     -> directory CLAUDE.md is fine
// don't rely on a monolith's inference or an optional skill for this

Plan mode explores and designs before touching code. It's for work where a wrong early decision is expensive — restructuring, migrations, choosing between approaches — so you validate the plan first.

Plan mode کوڈ کو ہاتھ لگانے سے پہلے کھوج اور ڈیزائن کرتا ہے۔ یہ اُس کام کے لیے ہے جہاں شروع کا غلط فیصلہ مہنگا پڑے — ڈھانچہ بدلنا، migration، طریقوں میں سے چننا — تاکہ پہلے منصوبہ جانچ لیا جائے۔

When the change is small and the path is obvious (a one-line fix with a clear stack trace), planning is overhead — just do it.

جب تبدیلی چھوٹی ہو اور راستہ صاف ہو (ایک لائن کا حل، صاف stack trace کے ساتھ)، تو منصوبہ بندی فالتو بوجھ ہے — بس کر دیں۔

During a multi-phase task, discovery generates a lot of noise. The Explore subagent does that digging in its own context and hands back a concise summary, so the main session doesn't fill up.

کئی مرحلوں والے کام میں کھوج بہت شور پیدا کرتی ہے۔ Explore ایجنٹ وہ کھدائی اپنے سیاق میں کرتا ہے اور ایک مختصر خلاصہ واپس دیتا ہے، تاکہ اصل سیشن نہ بھرے۔

When a wrong early decision is expensive — many files, service boundaries, or several viable approaches — explore and design first, then validate the plan before writing code. That upfront investment prevents costly rework.

جب شروع کا غلط فیصلہ مہنگا ہو — کئی فائلیں، سروس کی حدیں، یا کئی ممکن طریقے — تو پہلے کھوج اور ڈیزائن کریں، پھر کوڈ لکھنے سے پہلے منصوبہ جانچیں۔ یہ شروع کی محنت بعد کی مہنگی دوبارہ محنت سے بچاتی ہے۔

"Migrate 45 files from lib v1 -> v2" / "split the monolith into services"
-> Plan mode: explore, design, validate the plan BEFORE editing
// a wrong early decision here is expensive to undo

When the scope is small and the fix is obvious, planning is pure overhead — just make the change. A stack trace pointing at one function is a direct-execution job.

جب دائرہ چھوٹا اور حل صاف ہو، تو منصوبہ بندی خالص فالتو بوجھ ہے — بس تبدیلی کر دیں۔ ایک فنکشن کی طرف اشارہ کرتا stack trace سیدھے کرنے والا کام ہے۔

Stack trace -> TypeError at cart.py:88, off-by-one in the loop
-> Direct execution: just fix it
// planning a one-line, obvious fix is pure overhead

Discovery generates a lot of noise. Delegating it to the Explore subagent keeps that digging in a separate context and returns a concise summary, so the main session's window isn't consumed by file dumps.

کھوج بہت شور پیدا کرتی ہے۔ اسے Explore ایجنٹ کو سونپنا وہ کھدائی الگ سیاق میں رکھتا ہے اور ایک مختصر خلاصہ لوٹاتا ہے، تاکہ اصل سیشن کا window فائلوں کے ڈھیر سے نہ بھرے۔

Task(Explore, "map the auth module: entrypoints, deps, callers")
// the digging happens in Explore's OWN context;
// the main session receives a concise summary, not the file dumps

The two modes aren't exclusive: plan the risky, ambiguous migration first, then switch to direct execution to carry out each well-defined step of the approved plan.

دونوں طریقے ایک دوسرے کے مخالف نہیں: پہلے خطرناک، مبہم migration کا منصوبہ بنائیں، پھر منظور شدہ منصوبے کے ہر صاف قدم کو کرنے کے لیے سیدھے عمل پر آ جائیں۔

1. Plan mode:      design the v1 -> v2 migration (risky, ambiguous)
2. Direct execute: carry out each well-defined step of the approved plan
// plan the hard part, execute the clear part

When a prose spec keeps producing inconsistent results, stop describing and start showing. 2–3 concrete input→output pairs pin down the exact transformation you want.

جب عبارت والی وضاحت بار بار الگ الگ نتیجہ دے، تو بیان کرنا چھوڑ کر دکھانا شروع کریں۔ ۲-۳ ٹھوس ان پٹ←آؤٹ پٹ جوڑے وہ عین تبدیلی طے کر دیتے ہیں جو آپ چاہتے ہیں۔

Write a test suite covering behavior, edge cases, and performance up front, then iterate by feeding Claude the failing test output. Failures are precise, actionable feedback.

پہلے ایسا ٹیسٹ سیٹ لکھیں جو رویّہ، خاص صورتیں اور کارکردگی ڈھانپے، پھر Claude کو ناکام ٹیسٹ کا نتیجہ دے کر بہتری کریں۔ ناکامیاں صاف، قابلِ عمل رائے ہوتی ہیں۔

For unfamiliar domains, ask Claude to interview YOU first — it surfaces edge cases (cache invalidation, failure modes) you hadn't specified, before writing code.

اجنبی موضوعات میں پہلے Claude سے کہیں کہ وہ آپ کا انٹرویو لے — یہ کوڈ لکھنے سے پہلے ایسی خاص صورتیں (cache invalidation، ناکامی کی حالتیں) سامنے لاتا ہے جو آپ نے نہیں بتائی تھیں۔

If two bugs interact, describing both at once lets the model reason about their interaction. Independent issues can be handled one at a time.

اگر دو خرابیاں آپس میں جڑی ہوں تو دونوں ایک ساتھ بتانا ماڈل کو ان کے تعلق پر سوچنے دیتا ہے۔ الگ الگ مسئلے ایک ایک کر کے سنبھالے جا سکتے ہیں۔

When a prose description keeps getting interpreted differently, stop describing and start showing. A couple of input→output pairs pin the exact transformation far more reliably than more adjectives.

جب عبارت والی وضاحت بار بار الگ سمجھی جائے، تو بیان کرنا چھوڑ کر دکھانا شروع کریں۔ چند ان پٹ←آؤٹ پٹ جوڑے مزید صفتوں کے مقابلے عین تبدیلی کہیں زیادہ بھروسے سے طے کر دیتے ہیں۔

in:  "2024-01-05"        out: "Jan 5, 2024"
in:  "2024-12-31"        out: "Dec 31, 2024"
in:  null                 out: "—"   # shows the null case too

Tests written first become precise, actionable feedback: share the failing output and Claude has an exact target to fix, instead of you re-describing the requirement each round.

پہلے لکھے ٹیسٹ صاف، قابلِ عمل رائے بن جاتے ہیں: ناکام نتیجہ دے دیں تو Claude کے پاس ٹھیک کرنے کا واضح ہدف ہوتا ہے، بجائے اس کے کہ آپ ہر بار تقاضا دوبارہ بیان کریں۔

# write the tests first (they fail):
test_parses_iso()     -> FAIL
test_handles_null()   -> FAIL
# share the failing output; Claude gets an exact target to fix,
# instead of you re-describing the requirement in prose each round

For a domain you don't fully know, ask Claude to interview YOU before coding. Its questions surface considerations you hadn't specified — invalidation timing, failure handling — so they're designed in rather than discovered in production.

جو موضوع آپ پوری طرح نہیں جانتے، اس میں کوڈنگ سے پہلے Claude سے اپنا انٹرویو لینے کو کہیں۔ اس کے سوال ایسی باتیں سامنے لاتے ہیں جو آپ نے نہیں بتائیں — invalidation کا وقت، ناکامی سنبھالنا — تاکہ وہ پہلے سے ڈیزائن میں آ جائیں، production میں دریافت نہ ہوں۔

You: "Before coding the cache, interview me."
Claude: "1) invalidation trigger?  2) TTL?  3) behavior when the backend
         is down?  4) is stale-while-revalidate acceptable?"
// surfaces edge cases you hadn't specified, BEFORE any code exists

Target a stubborn edge case by showing the exact input and the output you expect for it (e.g. a null legacy field → the default you want). The concrete pair removes the ambiguity that generic instructions leave.

کسی ضدی خاص صورت کو نشانہ بنانے کے لیے عین ان پٹ اور اس کے لیے متوقع آؤٹ پٹ دکھائیں (مثلاً null پرانا خانہ ← آپ کی مطلوبہ ڈیفالٹ)۔ یہ ٹھوس جوڑا وہ الجھن ختم کر دیتا ہے جو عام ہدایات چھوڑ دیتی ہیں۔

"Legacy rows have a null signup_source. Expected:
   in: { signup_source: null }  ->  out: { signup_source: 'unknown' }"
// the concrete pair removes ambiguity generic instructions leave

In CI there's no human to answer prompts. -p (aka --print) processes the prompt, writes the result to stdout, and exits — so the job never hangs waiting for input.

CI میں پرامپٹ کا جواب دینے والا کوئی انسان نہیں۔ -p (یعنی --print) پرامپٹ چلاتا ہے، نتیجہ stdout پر لکھتا ہے، اور بند ہو جاتا ہے — تاکہ job کبھی ان پٹ کے انتظار میں نہ اٹکے۔

claude -p "Analyze this pull request for security issues"

For posting findings as inline PR comments, you need parseable output. --output-format json with a --json-schema gives you a predictable shape your pipeline can consume.

نتائج کو inline PR کمنٹس کے طور پر لگانے کے لیے آپ کو پڑھنے لائق آؤٹ پٹ چاہیے۔ --output-format json اور --json-schema ایک متوقع شکل دیتے ہیں جسے آپ کی pipeline استعمال کر سکے۔

claude -p "Review changes" --output-format json --json-schema ./review.schema.json

The same CLAUDE.md that guides interactive use also grounds CI runs — documenting fixtures and review criteria raises quality and cuts low-value output.

جو CLAUDE.md لائیو استعمال کی رہنمائی کرتی ہے وہی CI چکروں کو بھی بنیاد دیتی ہے — fixtures اور جائزے کے اصول لکھنا معیار بڑھاتا اور کم قیمتی آؤٹ پٹ گھٹاتا ہے۔

A model that just wrote the code carries its own reasoning and is less likely to question it. A fresh, independent instance catches subtle issues the author-instance rationalizes away.

جس ماڈل نے ابھی کوڈ لکھا وہ اپنی سوچ ساتھ رکھتا ہے اور اس پر شک کم کرتا ہے۔ ایک تازہ، الگ instance وہ باریک مسائل پکڑتا ہے جنہیں لکھنے والا instance صفائیاں دے کر ٹال دیتا ہے۔

CI has no human to answer prompts. -p/--print processes the prompt, writes output to stdout, and exits — so the job completes instead of blocking forever on input. (CLAUDE_HEADLESS and --batch aren't real flags.)

CI میں پرامپٹ کا جواب دینے والا انسان نہیں۔ -p/--print پرامپٹ چلاتا ہے، آؤٹ پٹ stdout پر لکھتا ہے، اور بند ہو جاتا ہے — تاکہ job ان پٹ پر ہمیشہ اٹکنے کے بجائے مکمل ہو۔ (CLAUDE_HEADLESS اور --batch اصلی flags نہیں۔)

claude -p "Analyze this pull request for security issues"

To turn review output into inline PR comments your pipeline must parse it reliably. Requesting JSON against a fixed schema guarantees a predictable shape instead of free-form prose you'd have to scrape.

جائزے کے آؤٹ پٹ کو inline PR کمنٹس بنانے کے لیے آپ کی pipeline کو اسے بھروسے سے پڑھنا ہوگا۔ ایک طے شدہ schema کے مطابق JSON مانگنا ایک متوقع شکل یقینی بناتا ہے، بجائے آزاد عبارت کے جسے کھرچنا پڑے۔

claude -p "Review changes" --output-format json --json-schema ./review.schema.json

On each re-run, feed in what was already reported and instruct Claude to surface only new or still-open issues — otherwise it re-posts the same comments.

ہر بار دوبارہ چلانے پر جو پہلے رپورٹ ہو چکا وہ ساتھ دیں اور Claude کو کہیں کہ صرف نئے یا ابھی کھلے مسئلے دکھائے — ورنہ وہ وہی کمنٹس دوبارہ لگا دے گا۔

claude -p "Review the new commits. ALREADY REPORTED (do not repeat):
  - L42 SQL injection
  - L88 missing null check
Report ONLY new or still-unaddressed issues."
// otherwise it re-posts the same comments on every push

Show the test-generation run what's already covered so it fills gaps instead of re-writing tests that exist. Without that context it duplicates scenarios and produces low-value noise.

ٹیسٹ بنانے والے چکر کو دکھائیں کیا پہلے سے ڈھکا ہوا ہے تاکہ وہ موجود ٹیسٹ دوبارہ لکھنے کے بجائے خالی جگہیں بھرے۔ اس سیاق کے بغیر وہ صورتیں دہراتا اور کم قیمتی شور پیدا کرتا ہے۔

claude -p "Add tests for payments.py. EXISTING coverage:
  test_payments.py already covers refunds + the happy path.
Fill gaps only (declined cards, partial refunds)."
// without this it duplicates covered scenarios = low-value noise

The CLAUDE.md that grounds interactive work also grounds CI runs. Documenting fixtures, naming conventions, and review criteria means generated tests match house style and the reviewer flags what the team actually cares about.

جو CLAUDE.md لائیو کام کو بنیاد دیتی ہے وہی CI چکروں کو بھی۔ fixtures، ناموں کے اصول، اور جائزے کے معیار لکھنے سے بنائے گئے ٹیسٹ گھر کے انداز سے ملتے ہیں اور جائزہ لینے والا وہی نشان زد کرتا ہے جس کی ٹیم کو واقعی پرواہ ہے۔

# CLAUDE.md
## Testing
- use pytest + the `db_session` fixture (never a real DB)
- name tests test_<unit>_<condition>_<expected>
// CI test-gen now matches house style instead of inventing its own