Claude Code ఒకేసారి అనేక చోట్ల నుంచి ప్రాజెక్ట్ సూచనలను లోడ్ చేయగలదు. మీరు ఇద్దరు క్లయింట్ల ప్రాజెక్టులను నిర్వహిస్తుంటే, ప్రతి డైరెక్టరీలో కొత్త సెషన్ ప్రారంభించడం ద్వారా ఏ సూచనల ఫైళ్లు నిజంగా ఆయా సందర్భాల్లో చేరాయో తనిఖీ చేయవచ్చు. ఉపయోగకరమైన ఫలితం నమోదు చేసిన రెండు ఫైల్ జాబితాలు; పక్కపక్కన ఉన్న ఫోల్డర్లు క్లయింట్ సమాచారాన్ని వేరు చేస్తాయనే ఊహ కాదు.

ప్రధాన మార్పు

ఏమి మారింది: Claude Code డాక్యుమెంటేషన్‌లో ఉన్న సూచనల క్రమవ్యవస్థను, ఇప్పటికే ఉన్న అనుమతించిన రెండు ప్రాజెక్ట్ డైరెక్టరీల మధ్య పునరావృతం చేయగల పోలికగా ఈ గైడ్ మారుస్తుంది. ప్రారంభంలో లోడ్ అయిన ఫైళ్లను నమోదు చేసి, అనుమతించిన ఫైల్ పఠనం తర్వాత లోపలి సూచనల ఫైల్ కనిపిస్తుందో తనిఖీ చేస్తారు.

ఇది ఎందుకు ముఖ్యం: ఉమ్మడి పైస్థాయి డైరెక్టరీ, వ్యక్తిగత సూచన, దిగుమతి, నియమం లేదా సెట్టింగ్ రెండు ప్రాజెక్టులనూ ప్రభావితం చేయవచ్చు. /context నడుస్తున్న సెషన్‌లో లోడ్ అయిన మెమరీ ఫైళ్లను చూపిస్తుంది. కాబట్టి క్లయింట్ పని ప్రారంభించే ముందు అనుకోని మార్గాన్ని పరిశీలించవచ్చు.

గమనించాల్సినవి: లోడ్ అయిన సూచనలు Claude ఏ ఫైళ్లను యాక్సెస్ చేయగలదో పరిమితం చేయవు; ప్రతి సూచననూ పాటిస్తుందని హామీ ఇవ్వవు. ఎంచుకున్న ప్రొవైడర్‌కు క్లయింట్ కంటెంట్ పంపే ముందు వాస్తవ ఖాతా, అనుమతులు, దిగుమతులు, hooks, డేటా వినియోగ నిబంధనలను సమీక్షించండి.

మీకు కావలసినవి

ఇద్దరు క్లయింట్లకు చెందిన ఇప్పటికే ఉన్న రిపోజిటరీలను, వాటి Claude Code కాన్ఫిగరేషన్‌ను పరిశీలించడానికి అనుమతి ఉన్న డెవలపర్ కోసం ఈ విధానం. మీరు ఉపయోగించదలచిన నిర్దిష్ట ప్రాజెక్ట్ కంటెంట్‌ను ఎంచుకున్న Claude ఖాతా లేదా ప్రొవైడర్‌కు పంపేందుకు విడిగా అనుమతి పొందండి. స్థానిక ఫైళ్లను మార్చే అనుమతి మాత్రమే ఆ నిర్ణయాన్ని నిర్ధారించదు. టెర్మినల్ యాక్సెస్, ఇన్‌స్టాల్ చేసిన Claude Code, అర్హత ఉన్న ఖాతా లేదా ప్రొవైడర్, ఒక ప్రాజెక్ట్‌లో లోపలి డైరెక్టరీలో ఇప్పటికే ఉన్న సున్నిత సమాచారం లేని ఫైల్ అవసరం. మీరు ఉపయోగించే మార్గానికి Anthropic అందించే సెటప్, ఖర్చు మరియు డేటా వినియోగ డాక్యుమెంటేషన్‌ను చూడండి.

క్రింది అమరిక గుర్తించాల్సిన మార్గాలను చూపిస్తుంది; కొత్త క్లయింట్ ప్రాజెక్టులు సృష్టించమని చెప్పడం కాదు. కమాండ్లలోని ప్రతి ఉదాహరణ మార్గాన్ని సంబంధిత నిజమైన, అనుమతించిన మార్గంతో మార్చండి. పైస్థాయి CLAUDE.md ఫైల్ ఐచ్ఛికం; రెండు ప్రాజెక్టులకూ ఆమోదించిన సూచనలు మాత్రమే అందులో ఉండాలి. లోపలి ఫైల్, సున్నిత సమాచారం లేని పత్రం ఎంచుకున్న ఖాతా డేటా మార్గానికి ఇప్పటికే తగినవిగా ఉండాలి.

Text
AUTHORIZED_PARENT/
  CLAUDE.md                 optional shared instructions
  project-A/
    CLAUDE.md               A's project instructions
  project-B/
    CLAUDE.md               B's project instructions
    subdir/
      CLAUDE.md             B's nested instructions
      README.md             authorized, nonsensitive read target

1. రెండు ప్రాజెక్టుల మార్గాలను నిర్ధారించండి

ఉపయోగించాల్సింది ఏదో ఒకటి : PowerShell లేదా Bash. వేరియబుల్స్‌ను రెండు నిజమైన డైరెక్టరీలకు సెట్ చేయండి. ఈ తనిఖీలకు ఇప్పటికే ఉన్న మార్గాలు అవసరం; ఫలితంగా వచ్చిన మార్గపు స్ట్రింగ్‌లను పోల్చి, B పఠన లక్ష్యం ఉందని నిర్ధారిస్తాయి. PowerShellలోని Resolve-Path symlink లేదా junction ప్రత్యామ్నాయ పేరును అలాగే ఉంచవచ్చు; స్ట్రింగ్‌లు వేరుగా ఉండటం మాత్రమే అవి వేర్వేరు భౌతిక ప్రాజెక్టులని నిరూపించదు. రెండు ప్రారంభ మార్గాల్లో, వాటి పైస్థాయి డైరెక్టరీల గొలుసుల్లో లింకులు, junctionలను పరిశీలించి, వాటి లక్ష్యాలను అనుసరించండి. కొనసాగించే ముందు A, B నిజంగా వేర్వేరు ప్రాజెక్టులని నిర్ధారించండి. మార్గాలు, లక్ష్య తనిఖీలు, తర్వాతి సందర్భ జాబితాలను వ్యక్తిగత పని రికార్డులో ఉంచండి.

PowerShell
$a = (Resolve-Path -LiteralPath 'C:\actual\authorized\project-A' -ErrorAction Stop).Path
$b = (Resolve-Path -LiteralPath 'C:\actual\authorized\project-B' -ErrorAction Stop).Path
if (-not (Test-Path -LiteralPath $a -PathType Container)) { throw 'A must be an existing directory' }
if (-not (Test-Path -LiteralPath $b -PathType Container)) { throw 'B must be an existing directory' }
if ($a -eq $b) { throw 'A and B must be different directories' }
$target = Join-Path $b 'subdir/README.md'
if (-not (Test-Path -LiteralPath $target -PathType Leaf)) { throw 'Choose an existing authorized nonsensitive file in B/subdir' }
$a
$b
$target
Terminal
a=$(realpath -- /actual/authorized/project-A) || exit 1
b=$(realpath -- /actual/authorized/project-B) || exit 1
test -d "$a" || { printf '%s\n' 'A must be an existing directory' >&2; exit 1; }
test -d "$b" || { printf '%s\n' 'B must be an existing directory' >&2; exit 1; }
test "$a" != "$b" || { printf '%s\n' 'A and B must be different directories' >&2; exit 1; }
target="$b/subdir/README.md"
test -f "$target" || { printf '%s\n' 'Choose an existing authorized nonsensitive file in B/subdir' >&2; exit 1; }
printf '%s\n' "$a" "$b" "$target"

ప్రాజెక్టులు ఒకే పైస్థాయి డైరెక్టరీ కింద లేకపోతే, వాటి వాస్తవ పైస్థాయి డైరెక్టరీ గొలుసులను విడివిడిగా నమోదు చేయండి. చిత్రాన్ని చూసి ఉమ్మడి పైస్థాయి డైరెక్టరీ ఉందని ఊహించవద్దు.

2. ఏ ప్రాజెక్టునూ తెరవకముందే ఏమి లోడ్ కావచ్చో పరిశీలించండి

నిర్ధారించిన ప్రారంభ డైరెక్టరీల్లో ప్రతిదానికి , CLAUDE.md, .claude/CLAUDE.md, CLAUDE.local.md, AGENTS.md మరియు .claude/AGENTS.md ఫైళ్లను ఆ డైరెక్టరీలోనూ, ఫైల్‌సిస్టమ్ మూలం వరకూ ప్రతి పైస్థాయి డైరెక్టరీలోనూ పరిశీలించండి. మీ ఆపరేటింగ్ సిస్టమ్‌కు వర్తించే నిర్వహిత సూచనలు, ~/.claude/CLAUDE.md, వినియోగదారు నియమాలు, ప్రాజెక్ట్ .claude/rules/ ఫైళ్లను కూడా పరిశీలించండి. మెమరీ మాన్యువల్ ప్రకారం కనుగొన్న CLAUDE.md ఫైళ్లు కలుస్తాయి; దగ్గరలోని ఫైల్ పైస్థాయి ఫైల్ పాఠ్యాన్ని చెరపదు. లోపలి CLAUDE.md సాధారణంగా Claude అక్కడ మరో ఫైల్‌ను చదివినప్పుడు, రాసినప్పుడు లేదా సవరించినప్పుడు లోడ్ అవుతుంది. మార్గానికి పరిమితమైన నియమాలు సరిపోలే ఫైల్‌ను యాక్సెస్ చేసినప్పుడు లోడ్ కావచ్చు.

ఫైల్ కంటెంట్ చూపకుండా, మార్గాలను మాత్రమే చూపే ఈ కమాండ్లు పైస్థాయి డైరెక్టరీల జాబితాను ఇస్తాయి. వచ్చిన ఫైళ్లను సంబంధిత యజమాని అధికార పరిధిలో సమీక్షించండి. రెండు వేరియబుల్స్‌తో పునరావృతం చేయండి; Bashలో లూప్ రెండింటినీ స్వయంచాలకంగా కవర్ చేస్తుంది.

PowerShell
foreach ($start in @($a, $b)) {
  $dir = [System.IO.DirectoryInfo]::new($start)
  while ($null -ne $dir) {
    Get-Item -LiteralPath $dir.FullName -Force | Select-Object FullName,LinkType,Target
    foreach ($name in @('CLAUDE.md', 'CLAUDE.local.md', 'AGENTS.md', '.claude/CLAUDE.md', '.claude/AGENTS.md')) {
      $candidate = Join-Path $dir.FullName $name
      if (Test-Path -LiteralPath $candidate -PathType Leaf) { $candidate }
    }
    $dir = $dir.Parent
  }
}
Terminal
for start in "$a" "$b"; do
  dir=$start
  while :; do
    for name in CLAUDE.md CLAUDE.local.md AGENTS.md .claude/CLAUDE.md .claude/AGENTS.md; do
      test -f "$dir/$name" && printf '%s\n' "$dir/$name"
    done
    test "$dir" = / && break
    dir=$(dirname -- "$dir")
  done
done

వాస్తవ సూచనల ఫైళ్లను, వాటి @path దిగుమతులను చదవండి; సాపేక్ష దిగుమతుల మార్గాలు వాటిని కలిగి ఉన్న ఫైల్ ఆధారంగా నిర్ణయించబడతాయి. ప్రతి PowerShell ప్రారంభ మార్గంలోనూ, పైస్థాయి డైరెక్టరీ గొలుసులోనూ ఉన్న symlink లేదా junctionను అనుసరించి, సెషన్‌పై ప్రభావం చూపగల పేరుతో ఉన్న, లక్ష్యంగా ఉన్న రెండు క్రమవ్యవస్థలనూ పరిశీలించండి. సూచనల ఫైల్ symlink లక్ష్యాలను, claudeMdExcludes నమూనాలను తనిఖీ చేయండి. .claude/settings.json, .claude/settings.local.json, వినియోగదారు మరియు నిర్వహిత సెట్టింగ్‌లు, ఏవైనా --settings లేదా --setting-sources ప్రారంభ ఎంపికలు, కాన్ఫిగర్ చేసిన hooks, ప్రతి ప్రాజెక్ట్ విశ్వాస స్థితిని పరిశీలించండి. CLAUDE_CONFIG_DIR వినియోగదారు కాన్ఫిగరేషన్ ఫోల్డర్‌ను మార్చగలదు; కాబట్టి ~/.claude అని ఊహించే ముందు తనిఖీ చేయండి. వర్క్‌స్పేస్‌ను విశ్వసించడానికి అంగీకరించే ముందు hook నడపగల కమాండ్లను సమీక్షించండి. పని డైరెక్టరీ బయట ఉన్న దిగుమతికి ఆమోదం అడగవచ్చు; తిరస్కరించిన దిగుమతి ఆశించినట్లు కనిపించదు. సెట్టింగ్‌ల మాన్యువల్ ప్రతి సెట్టింగ్ ఏ పొర నుంచి వస్తుందో, ఏ ప్రాజెక్ట్ సెట్టింగ్‌లు విశ్వాసం కోసం వేచి ఉంటాయో వివరిస్తుంది.

ఈ Project instructions ఎంపికను /config లో లేదా దాని వినియోగదారు/నిర్వహిత plugin సెట్టింగ్‌లో తనిఖీ చేయండి. ప్రస్తుత Claude Code డాక్యుమెంటేషన్ AGENTS.md ను, అర్హత గల ప్రాజెక్ట్ లేదా పైస్థాయి CLAUDE.md లేదా CLAUDE.local.md లేనప్పుడు షరతులతో ఉపయోగించే ప్రత్యామ్నాయంగా వివరిస్తుంది; claude-md-and-agents-md రెండింటినీ లోడ్ చేస్తుంది. నేరుగా AGENTS.md మద్దతు వెర్షన్, ప్రారంభించిన pluginపై ఆధారపడి ఉంటుంది. పాత వెర్షన్లు, కొన్ని సెట్టింగ్‌లు దాన్ని వదిలేయవచ్చు; BIG CHANGEలోని AGENTS.md feature flag నివేదికలో వివరించిన వెర్షన్-నిర్దిష్ట సమస్య కూడా అందులో ఉంది. అది ఎప్పుడూ లోడ్ అవుతుందని ఊహించకుండా మీ వాస్తవ వెర్షన్, సెట్టింగ్, /context ఫలితాన్ని ఉపయోగించండి.

విడిగా నమోదు చేయండి: --add-dir ఆర్గ్యుమెంట్లు మరియు CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD . --add-dir ఫైల్ యాక్సెస్‌ను విస్తరిస్తుంది; డిఫాల్ట్‌గా ఆ అదనపు డైరెక్టరీలోని CLAUDE.mdను లోడ్ చేయదు. ఎన్విరాన్‌మెంట్ స్విచ్ అదనపు డైరెక్టరీల నుంచి సూచనలను లోడ్ చేయడానికి వీలు కల్పిస్తుంది. ఆటో మెమరీని /memory తో ప్రత్యేక మార్గంగా తనిఖీ చేయండి: ఒకే రిపోజిటరీలోని worktrees, ఉపడైరెక్టరీల మధ్య అది పంచబడవచ్చు; నిల్వ స్థానాన్ని మార్చవచ్చు. పోలికను అర్థం చేసుకునే ముందు వాస్తవ స్థానం, కంటెంట్‌ను పరిశీలించండి. ఉదాహరణ సూచనల్లో లేదా బహిరంగ రికార్డులో ఆధారపత్రాలు లేదా ప్రచురించని క్లయింట్ విషయాలను ఎప్పుడూ పెట్టవద్దు.

ప్రారంభించే ముందు, మీరు ఉపయోగించబోయే అదే shellలో ఈ ఎన్విరాన్‌మెంట్ విలువలను తనిఖీ చేయండి. ఖాళీ Bash విలువ అంటే సెట్ చేయలేదు లేదా ఖాళీగా ఉంది; PowerShell ఉన్న వేరియబుల్స్‌ను మాత్రమే చూపిస్తుంది. ఈ shell విలువలు సెట్టింగ్‌ల ఫైల్ విలువలను తోసిపుచ్చవు; కాబట్టి ప్రతి సెషన్‌లో క్రియాశీల సెట్టింగ్‌లను నిర్ధారించండి.

PowerShell
Get-Item Env:CLAUDE_CONFIG_DIR,Env:CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD -ErrorAction SilentlyContinue | Select-Object Name,Value
Terminal
printf 'CLAUDE_CONFIG_DIR=%s\n' "${CLAUDE_CONFIG_DIR-}"
printf 'CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=%s\n' "${CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD-}"

3. ప్రాజెక్ట్ Aలో కొత్త సెషన్ ప్రారంభించండి

నమోదు చేయండి: claude --version మరియు ఖచ్చితమైన ప్రారంభ కమాండ్. A నుంచి కొత్త ప్రాసెస్ ప్రారంభించండి; --resume లేదా --continue ఉపయోగించవద్దు. సెట్టింగ్‌లు, hooksను పరిశీలించిన తర్వాతే విశ్వాసానికి అంగీకరించండి. /context ముందుగా నడపండి; ఆ తర్వాతే B లేదా ఏ లోపలి ఫైల్‌నైనా తెరవమని Claudeను అడగండి. మెమరీ ఫైళ్లు, నియమాల కింద ఖచ్చితమైన మార్గాలను నమోదు చేయండి; ఏవి ఉన్నాయో తనిఖీ చేయడానికి జాబితాను ఉపయోగించండి, చేర్పు క్రమాన్ని ఊహించడానికి కాదు. /memory ఉపయోగించి కనిపించే వ్యక్తిగత, ప్రాజెక్ట్, ఆటో మెమరీ అంశాలను, వాటి నిల్వ స్థానాన్ని పరిశీలించండి. తర్వాత సెషన్ నుంచి నిష్క్రమించండి.

PowerShell
claude --version
Set-Location -LiteralPath $a -ErrorAction Stop
claude
Terminal
claude --version
cd -- "$a" && claude

Claude Codeలో, /status క్రియాశీల సెట్టింగ్‌ల మూలాలను గుర్తిస్తుంది; /permissions ప్రస్తుత సాధన నియమాలను, వాటి మూలాలను చూపిస్తుంది. సూచనల జాబితాతోపాటు వాటిని నమోదు చేయండి:

Text
/context
/memory
/status
/permissions
/exit

పరిశీలించిన సెట్టింగ్‌లు, మినహాయింపులకు లోబడి, వర్తించే A మరియు ఉమ్మడి పైస్థాయి సూచనలు కనిపించాలి. Bకు మాత్రమే చెందిన ఫైల్ A ప్రారంభ క్రమవ్యవస్థలో ఉండకూడదు. దిగుమతి, లింక్, అదనపు డైరెక్టరీ లేదా మరో మార్గం ద్వారా కనిపిస్తే, ఆ విధానాన్ని నమోదు చేయండి. అది లేకపోవడం B ఫైళ్లను యాక్సెస్ చేయలేమని నిరూపించదు.

4. ప్రాజెక్ట్ Bలో వేరు సెషన్ ప్రారంభించి, ఒక లోపలి ఫైల్ చదవండి

ఉపయోగించాల్సింది కొత్త Claude Code ప్రాసెస్; Bలో అదే ఇన్‌స్టాల్ చేసిన వెర్షన్, ఖాతా/ప్రొవైడర్ మార్గంతో ప్రారంభించండి. లోపలి ఫైల్ చదవడానికి ముందు /context మరియు /memory నమోదు చేయండి. ఆమోదించిన ఖచ్చితమైన సున్నిత సమాచారం లేని ఫైల్‌ను మాత్రమే చదవమని Claudeను అడగండి. పఠనం జరిగిందని సెషన్‌లో నిర్ధారించి, /context మళ్లీ నడిపి మార్గాల ఉనికిని పోల్చండి. మాన్యువల్‌లోని లోడింగ్ నియమం ప్రకారం Bలోని subdir/CLAUDE.md అక్కడ మరో ఫైల్‌ను Claude యాక్సెస్ చేసిన తర్వాత సందర్భంలో చేరుతుంది; సెట్టింగ్, మినహాయింపు లేదా వెర్షన్-నిర్దిష్ట ప్రవర్తన ఫలితాన్ని మార్చితే తప్ప.

PowerShell
Set-Location -LiteralPath $b -ErrorAction Stop
claude
Terminal
cd -- "$b" && claude

Claude Codeలో, అనుమతించిన లక్ష్యానికి వేరే సాపేక్ష మార్గం ఉన్నప్పుడు మాత్రమే పఠన అభ్యర్థనను మార్చండి:

Text
/context
/memory
/status
/permissions
Read only subdir/README.md. Tell me whether that exact file was read; do not open other files or display its contents.
/context
/exit

Claude Code సాధన అనుమతి అడగవచ్చు లేదా మరో చర్య ప్రతిపాదించవచ్చు. ఖచ్చితంగా అనుమతించిన పఠనానికే ఆమోదం ఇచ్చి, సాధనం నిజంగా ఆ ఫైల్‌ను తెరిచిందని నిర్ధారించండి. చదివానని చెప్పే సమాధానం ఒక్కటే తగిన ఆధారం కాదు.

5. జాబితాలను పోల్చి తేడాలను పరిష్కరించండి

నిర్ధారించిన A, B మార్గాలు, రిపోజిటరీ మూలాలు, Claude Code వెర్షన్, ఖాతా/ప్రొవైడర్ మార్గం, ప్రారంభ కమాండ్లు, విశ్వాస స్థితి, సెట్టింగ్‌ల మూలాలు, అదనపు డైరెక్టరీలు, సూచనల ఫైల్ మరియు నియమాల మార్గాలు, దిగుమతులు, ఆటో మెమరీ స్థానాలు, గమనించిన మూడు /context జాబితాలతో వ్యక్తిగత పట్టిక ఉంచండి: A ప్రారంభంలో, B పఠనానికి ముందు, B పఠనం తర్వాత. ఆశించిన ప్రతి ఫైల్‌ను ఉంది, లేదు లేదా వివరణ లేదు అని గుర్తించండి. క్లయింట్ సూచనల పాఠ్యాన్ని బహిరంగ నివేదికలోకి కాపీ చేయవద్దు.

ఆశించిన ఫైల్ లేకపోతే, ముందుగా ప్రారంభ డైరెక్టరీ, వాస్తవ ఫైల్ మార్గాన్ని నిర్ధారించండి. తర్వాత Project instructions సెట్టింగ్, plugin/వెర్షన్, claudeMdExcludes, --setting-sources, దిగుమతులు మరియు బాహ్య దిగుమతి ఆమోదం, నియమాల మార్గ నమూనాలు, symlinks, నిర్ధారించిన లోపలి పఠనాన్ని తనిఖీ చేయండి. అనుకోని ఫైల్ కనిపిస్తే, పైస్థాయి డైరెక్టరీలు, వినియోగదారు లేదా నిర్వహిత సూచనలు, దిగుమతులు, నియమాలు, hooks, అదనపు డైరెక్టరీ మెమరీ లోడింగ్, ఆటో మెమరీ ద్వారా దాని మూలాన్ని అనుసరించండి. ఉమ్మడి పైస్థాయి డైరెక్టరీ లేదా వ్యక్తిగత సూచన ఉద్దేశపూర్వకంగా ఉండవచ్చు; రెండు ప్రాజెక్టుల్లో ఉండాలో లేదో దాని మూలం, కంటెంట్ నిర్ణయిస్తాయి.

సంబంధిత క్లయింట్ అధికారంతోనే సూచన లేదా సెట్టింగ్ మార్చండి. ప్రతిపాదించిన diffను సమీక్షించి, ఇప్పటికే ఉన్న పరిమితులను కాపాడండి; మార్పు తర్వాత రెండు కొత్త సెషన్‌ల పరిశీలనలను పునరావృతం చేయండి. ఒక మార్గాన్ని వివరించలేకపోయినా, ప్రభావం చూపే మార్గాన్ని పరిశీలించే అనుమతి లేకపోయినా, క్లయింట్ పనిని నిలిపి ఆ నిర్దిష్ట అనిశ్చితిని పరిష్కరించమని యజమాని లేదా నిర్వాహకుడిని అడగండి.

రెండు ప్రారంభ జాబితాలు, Bలో లోపలి పఠనానికి ముందు/తర్వాత నిర్ధారించిన జాబితా, ముఖ్యమైన ప్రతి అనుకోని మార్గానికి వివరణ ఉన్నప్పుడు ఈ పని పూర్తవుతుంది. ఆ సెషన్‌లలో గమనించిన సూచనల ఉనికిని ఇది నిర్ధారిస్తుంది. గోప్యతా సరిహద్దు, ఫైల్ యాక్సెస్ వేరుచేయడం, తప్పనిసరి అనుసరణ లేదా మోడల్ ఆ సూచనలను ఉపయోగించిన ఖచ్చితమైన క్రమాన్ని ఇది నిర్ధారించదు. ఇప్పటికే ఉన్న సంభాషణను పరిశీలించి కొనసాగించడానికి మా ప్రత్యేక Claude Code సెషన్ సందర్భ గైడ్ చూడండి.

ఖాతా ఛార్జీలు, వినియోగ పరిమితులు ప్లాన్, ప్రమాణీకరణ, ప్రొవైడర్‌పై ఆధారపడతాయి. ప్రస్తుత నిబంధనల కోసం Anthropic ఖర్చు గైడ్ చూడండి. ఈ వ్యాసం డాక్యుమెంటేషన్ ఆధారంగా తయారైంది: BIG CHANGE క్లయింట్ ఫైళ్లను పరిశీలించలేదు, A/B Claude సెషన్‌లు నడపలేదు, మోడల్ ఫలితాన్ని పరీక్షించలేదు, సమయం లేదా ఖర్చు కొలవలేదు.

మూలాలు మరియు తదుపరి పఠనం