Token Optimization

كيفية تقليل استهلاك التوكن في Claude Code بنسبة 75%

2026-09-02·14 دقيقة قراءة دقائق قراءة·LLMPodium Team

### إجابة سريعة: كيف تجعل Claude يستهلك توكن أقل؟

لتقليل استهلاك التوكن في Claude Code بنسبة تصل إلى 75%، نفذ أربعة تحسينات أساسية: إعداد ملف .claudeignore صارم لاستبعاد مخرجات البناء وملفات القفل، الاستفادة من خصم 90% لقراءة الـ Prompt Caching من Anthropic بتثبيت البادئات الثابتة، عزل المهام الفرعية عبر وكلاء استكشاف (Scout) لتفادي تدهور السياق (Context Rot)، واختيار claude-3-7-sonnet أو claude-3-5-haiku للمهام الاستكشافية قبل التوجه إلى Opus.

1. مقدمة: الاستنزاف الخفي لرصيد التوكن في وكلاء الطرفية

أحدث وكلاء البرمجة الذاتيون داخل الطرفية (Terminal Agents)، مثل Claude Code من شركة Anthropic، نقلة نوعية في هندسة البرمجيات. فعلى عكس أدوات الإكمال التلقائي التقليدية في بيئات التطوير (IDEs)، يعمل Claude Code في حلقة تنفيذ ذاتية كاملة: يفحص شجرة المجلدات، ويقرأ ملفات برمجية تضم آلاف الأسطر، وينفذ أوامر الشل، ويحلل سجلات المترجم، ويطبق تعديلات برمجية دقيقة على الكود المصدري.

ومع ذلك، فإن هذا العمل الذاتي ينطوي على تكلفة باهظة في واجهة برمجة التطبيقات (API). فبدون إعداد مسبق دقيق، يمكن لأمر بسيط مثل "أعد هيكلة وسيط المصادقة لدعم تدوير رموز JWT" أن يستهلك ما بين 1.5 إلى 3.5 مليون توكن في جلسة واحدة. ويرجع هذا التضخم إلى أربعة عوامل رئيسية:

  1. تراكم السياق وتدهوره (Context Rot): تبقى مخرجات أوامر bash ونتائج grep وسجلات التتبع والملفات المقروءة بالكامل عالقة داخل نافذة السياق النشطة للوكيل.
  2. إعادة قراءة البيانات دون استغلال الكاش: يؤدي التعديل العرضي للرسائل الأولى في المحادثة إلى إبطال نافذة الـ 5 دقائق المؤقتة لخاصية الـ Prompt Caching الخاصة بـ Anthropic.
  3. مسح الملفات غير الضرورية: أثناء عمليات البحث الشاملة باستخدام التعبيرات النمطية (Regex)، يقرأ Claude Code مراراً وتكراراً مجلدات البناء (dist/ و target/ و .next/) وملفات القفل الضخمة (package-lock.json و pnpm-lock.yaml) وتفريغات قواعد البيانات.
  4. تخصيص نماذج تفوق حجم المهمة: استخدام نماذج الاستدلال المعقدة فائقة التكلفة (claude-3-opus أو Sonnet مع تمكين أقصى تفكير) لمهام بسيطة مثل استعراض الملفات أو فحص مسارات المجلدات.

ومن خلال اعتماد قيود معمارية ممنهجة — مثل تنظيم ملف .claudeignore، واستغلال آليات التخزين المؤقت، وعزل السياق بالوكلاء الفرعيين، وضبط إعدادات الـ CLI — تستطيع فرق التطوير تقليص استهلاكها اليومي للتوكن بنسبة 70% إلى 80%، مع تحسين معدلات نجاح المهام البرمجية في نفس الوقت.

2. الاقتصاديات الكمية: أسعار التوكن وبنية التخزين المؤقت

لفهم أين تُهدر وحدات التوكن، نراجع جدول أسعار واجهة برمجة تطبيقات Anthropic وطبقات التخزين المؤقت (أسعار عام 2026):

طراز نموذج Claude الدخل الأساسي ($/1M) كتابة الكاش ($/1M) قراءة الكاش ($/1M) الخرج ($/1M) اختبار SWE-bench الدور المثالي في الطرفية
Claude 3.5 / 3.7 Haiku $0.80 $1.00 $0.08 $4.00 41.2% البحث عن الرموز، تصفية regex، كتابة رسائل commit
Claude 3.7 Sonnet (Standard) $3.00 $3.75 $0.30 $15.00 70.3% إعادة الهيكلة الأساسية، تعديل ملفات متعددة، الاختبارات
Claude 3.7 Sonnet (Extended Thinking) $3.00 (دخل) $3.75 (كتابة) $0.30 $15.00 (تفكير+خرج) 72.8% الأخطاء المعمارية المعقدة، مشاكل التزامن (Race Conditions)
Claude 3 Opus / Opus 4.6 $15.00 $18.75 $1.50 $75.00 74.1% التدقيق الأمني الحرج، إعادة تصميم الأنظمة الكبرى

الحساب الرياضي لتقليص التكلفة والتوكن بنسبة 75%

لنفترض جلسة عمل نموذجية مكونة من 15 خطوة لإعادة هيكلة نقطة نهاية REST API في مستودع TypeScript يضم 150,000 سطر برمجي: 

[جلسة تقليدية غير محسنة]
الخطوة 1: قراءة شجرة المستودع + package-lock.json + المخطط (180,000 توكن)
الخطوات 2-5: مخرجات grep الكاملة، سجلات البناء، قراءة ملفات كاملة (تراكمي 240,000 توكن/خطوة)
معدل فقدان الكاش: 45% (إلغاء الكاش بسبب الترويسات والأدوات المتغيرة)
إجمالي التوكن المدخل المعالج: 3,250,000 توكن
التكلفة الفعلية (Sonnet): ~9.75$

[جلسة محسنة: .claudeignore + Prompt Cache + وكلاء فرعيون]
الخطوة 1: ملخص AST نقي ومضغوط (18,000 توكن) -> تم حفظه في الكاش من الخطوة 1
الخطوات 2-5: فوارق برمجية تراكمية، وكيل الاستكشاف يعيد تقريراً موجزاً (22,000 توكن/خطوة)
معدل نجاح الكاش: 92% (قراءة بسعر مخفض قدره 0.30$/1M)
إجمالي التوكن المدخل المعالج: 410,000 توكن (انخفاض فعلي في التوكن بنسبة 87.3%)
التكلفة الفعلية (Sonnet): ~0.82$ (انخفاض حقيقي في النفقات بنسبة 91.5%)

3. الركيزة الأولى: إتقان .claudeignore لحجب السياق غير المفيد

الإجراء الأكبر عائداً وفائدة في أي مستودع برمجي هو إنشاء ملف .claudeignore احترافي وصارم.

يراعي Claude Code قواعد ملف .gitignore افتراضياً، إلا أن ملفات .gitignore التقليدية تسمح بمرور ملفات ضخمة تلوث نافذة سياق النموذج اللغوي. يجب ألا تدخل ملفات القفل والمستندات ومجلدات البناء والحزم المضغوطة إلى سياق الوكيل أبداً.

قالب .claudeignore الموصى به لبيئات الإنتاج

ضع هذا الملف في المجلد الجذري لمشروعك: 

# ==============================================================================
# .claudeignore - مصفوفة استبعاد التوكن غير الضروري للإنتاج
# يمنع Claude Code من قراءة الملفات الضخمة أثناء عمليات glob و grep
# ==============================================================================

# ملفات قفل الحزم (ملفات JSON/YAML ضخمة لا فائدة منها لتحليل الكود AST)
package-lock.json
pnpm-lock.yaml
yarn.lock
bun.lockb
composer.lock
Gemfile.lock
Cargo.lock
poetry.lock

# مجلدات وحزم البناء البرمجي المترجمة
dist/
build/
out/
.next/
.nuxt/
.astro/
.svelte-kit/
storybook-static/
target/
*.min.js
*.min.css
*.map

# تقارير تغطية الاختبارات وسجلات التشغيل والتتبع
coverage/
.nyc_output/
*.lcov
*.log
npm-debug.log*
yarn-debug.log*
pnpm-debug.log*
*.heapsnapshot
*.cpuprofile

# الصور والوسائط والملفات الثنائية
public/assets/
public/images/
*.png
*.jpg
*.jpeg
*.gif
*.svg
*.webp
*.avif
*.ico
*.pdf
*.zip
*.tar.gz
*.wasm

# التوثيق والمواصفات البرمجية الخارجية
docs/
*.mdx
specs/swagger/
*.postman_collection.json

# ملفات المتغيرات البيئية والمفاتيح الأمنية
.env*
!.env.example
*.pem
*.key
*.cert

# ترحيلات قواعد البيانات وتفريغات SQL
*.sql
*.dump
prisma/migrations/

التأثير العملي لملف .claudeignore

عندما يقوم Claude Code بعمليات الفحص المتكرر، فإن ملف package-lock.json غير المستبعد (والذي يتراوح بين 25,000 إلى 80,000 سطر) يلتهم بمفرده ما يزيد عن 120,000 توكن في قراءة واحدة. وبمجرد حجب ملفات القفل ونواتج الترجمة، ينخفض حجم السياق الأولي من ~180k توكن إلى أقل من 15k توكن.

4. الركيزة الثانية: معمارية الـ Prompt Caching واستغلال خصم 90%

تحتفظ ميزة الـ Prompt Caching من Anthropic برموز التوكن المدخلة على الخوادم لمدة تصل إلى 5 دقائق (ويعاد تجديد المؤقت مع كل قراءة ناجحة للكاش). تكلفة قراءة التوكن المخزن مؤقتاً تبلغ 10% فقط من التكلفة الأساسية للإدخال (0.30$/1M مقابل 3.00$/1M في طراز Sonnet). 

+-------------------------------------------------------------------------+
|                  دورة حياة التخزين المؤقت للـ Prompt في Anthropic       |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
| [تعليمات النظام وتعاريف الأدوات] (بادئة ثابتة - محفوظة دائماً في الكاش) |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
| [خريطة بنية المستودع والقواعد البرمجية] (نقطة تحقق محفوظة في الكاش)     |
+-------------------------------------------------------------------------+
                                     |
                                     v (نقطة كسر الكاش وتجدده!)
+-------------------------------------------------------------------------+
| [أوامر المستخدم المتغيرة وسجل استدعاء الأدوات] (نهاية غير مخزنة بالكاش) |
+-------------------------------------------------------------------------+

ثلاث قواعد ذهبية للحفاظ على الكاش

  1. لا تضف طوابع زمنية متغيرة في سياق النظام: تجنب وضع تواريخ حية أو معرفات جلسات متغيرة في ملف CLAUDE.md. فتغيير حرف واحد في بداية البادئة يبطل جميع وحدات التوكن المخزنة تالياً له.
  2. جمّع التفاعلات ضمن إطار الـ 5 دقائق: العمر الافتراضي للكاش هو 300 ثانية. إذا توقفت لمدة 6 دقائق لمراجعة الكود، فستتحمل في الطلب التالي تكلفة كتابة الكاش بالكامل (3.75$/1M).
  3. رتب التعليمات من الأكثر ثباتاً إلى الأكثر تغيراً: يضع محرك Claude Code التعليمات الثابتة في مقدمة حزمة الـ API. تأكد من بقاء التوجيهات في ملف CLAUDE.md حتمية وثابتة.

5. الركيزة الثالثة: إطلاق الوكلاء الفرعيين وعزل المهام

أحد أكبر مصادر هدر التوكن في الطرفية هو فخ الجلسة الأحادية المطولة (Monolithic Session Trap). ففي محادثة واحدة طويلة، يطلب المطور من Claude فحص خطأ برمجي، وكتابة اختبارات، وإعادة هيكلة الكود، وتشغيل اختبارات التكامل، وكتابة التوثيق.

وبحلول الخطوة 12، تمتلئ نافذة السياق بمئات الأسطر من سجلات الاختبارات الفاشلة وأخطاء المترجم ونسخ الكود القديمة. وكل سؤال جديد يُعاد فيه إرسال هذا الركام البرمجي بالكامل إلى واجهة الـ API.

بنية الوكيل ثنائية الطبقات: المستكشف (Scout) والمنفذ (Worker)

افصل مرحلة الاستكشاف والبحث عن مرحلة التعديل البرمجي المباشر: 

[طلب المستخدم]
       |
       v
+---------------------------------------------+
|  الطبقة 1: وكيل استكشاف فرعي (للقراءة فقط) |
|  - يعمل بنموذج claude-3-5-haiku الخفيف      |
|  - يستخدم Glob و Grep وقراءة نطاقات محددة   |
|  - يضغط 500,000 توكن في ملخص بحجم 2 كيلوبايت|
+---------------------------------------------+
       |
       v (تسليم السياق المركز)
+---------------------------------------------+
|  الطبقة 2: الوكيل المنفذ الرئيسي            |
|  - يعمل بنموذج claude-3-7-sonnet            |
|  - يستلم مسارات الملفات والرموز المحددة بدقة|
|  - يطبق تعديلات جراحية محددة بالأسطر        |
+---------------------------------------------+

تطبيق عزل المهام عملياً في Claude Code

قسّم المهام الكبرى إلى خطوات طرفية منفصلة: 

# طريقة خاطئة: جلسة واحدة تضخم السياق بشكل هائل
claude "ابحث عن كل المسارات التي تستخدم نظام المصادقة القديم، وحولها إلى OAuth2، وأصلح الاختبارات وحدث التوثيق"

# طريقة صحيحة: استكشاف معزول -> تنفيذ مركز
# الخطوة 1: استكشاف منخفض التكلفة
claude --model claude-3-5-haiku -p "حدد مسارات الملفات وأرقام الأسطر التي تستخدم وسيط المصادقة القديم فقط، وأخرج النتيجة كقائمة JSON." > auth-audit.json

# الخطوة 2: تعديل جراحي في سياق نظيف
claude --model claude-3-7-sonnet "أعد هيكلة المسارات المذكورة في auth-audit.json لتستخدم وسيط OAuth2. لا تعدل أي ملف آخر."

6. الركيزة الرابعة: الاختيار الذكي للنموذج — أي نماذج Claude تستهلك توكن أقل؟

لا تستهلك جميع نماذج Claude نفس المقدار من التوكن لأداء المهمة ذاتها:

  • ميزانية التفكير (Thinking Budget): تولد النماذج ذات التفكير الموسع آلاف رموز التفكير الداخلية التي تُحسب كرموز خرج وتُسعّر بالسعر الكامل (15.00$/1M في Sonnet).
  • إسهاب استدعاء الأدوات: تطرح بعض النماذج مقدمات توضيحية مطولة قبل تشغيل الأدوات، مما يزيد من استهلاك التوكن.
  • كفاءة البحث: النماذج الذكية تحدد المطلوب عبر أمر أو أمرين دقيقين من أوامر grep، بينما تفرط النماذج الأضعف في قراءة ملفات ضخمة دون داعٍ.

مقارنة استهلاك التوكن حسب طبيعة المهمة

نوع المهمة Claude 3.5 Haiku Claude 3.7 Sonnet (العادي) Claude 3.7 Sonnet (8k Thinking) Claude 3 Opus
البحث عن رمز في المستودع 12k توكن / 0.01$ 14k توكن / 0.04$ 24k توكن / 0.18$ 18k توكن / 0.27$
إصلاح خطأ في دالة واحدة 28k توكن / 0.03$ 22k توكن / 0.07$ 35k توكن / 0.24$ 30k توكن / 0.45$
إعادة هيكلة (5 ملفات) نسبة فشل مرتفعة 140k توكن / 0.48$ 190k توكن / 1.25$ 220k توكن / 3.30$
مشكلة تزامن معقدة (Race) يعجز عن الحل 320k توكن (فشل) 240k توكن (نجاح) / 1.60$ 280k توكن / 4.20$

مصفوفة التوصيات البرمجية

  • النموذج اليومي الأساسي: اعتمد claude-3-7-sonnet بالوضع العادي لإنجاز 80% من مهام البرمجة اليومية.
  • الاستكشاف والبرمجة النصية: استخدم claude-3-5-haiku للبحث في المجلدات، وإنشاء تعبيرات regex، وفحص سجلات الاختبارات.
  • حصر التفكير الموسع: فعّل التفكير الممتد (thinking: { budget_tokens: 4000 }) فقط عند التعامل مع مسائل خوارزمية معقدة أو أخطاء بناء مستعصية فشل الحل فيها من المحاولة الأولى.

7. إعدادات Claude Code المتقدمة وتحسين .claude/config.json

يتيح Claude Code ضبط سلوكه بدقة عبر ملف ~/.claude.json للإعدادات العامة، أو .claude/config.json لكل مشروع.

ملف تكوين عالي الكفاءة .claude/config.json

{
  "$schema": "https://json.schemastore.org/claude-code-config.json",
  "model": "claude-3-7-sonnet",
  "maxThinkingTokens": 2048,
  "autoCompactContext": true,
  "contextCompactionThreshold": 0.65,
  "allowedTools": [
    "Edit",
    "Bash",
    "Glob",
    "Grep",
    "Read"
  ],
  "toolLimits": {
    "bashOutputMaxLines": 150,
    "readFileMaxLines": 300
  },
  "enableTelemetry": false
}

شرح المعاملات الرئيسية

  1. maxThinkingTokens: 2048: يضع حداً أقصى لميزانية التفكير لتجنب استهلاك ما بين 8k إلى 16k توكن (0.12$ - 0.24$) في مهام عادية.
  2. autoCompactContext: true: يطلق تلخيصاً تلقائياً لسجل المحادثة بمجرد وصول استيعاب السياق إلى 65% (contextCompactionThreshold: 0.65).
  3. bashOutputMaxLines: 150: يمنع سكب آلاف أسطر مخرجات الاختبارات أو تنزيل الحزم مباشرة داخل سياق النموذج.

8. أنماط توجيه الأوامر التكتيكية في الطرفية

تتحكم صياغة الأوامر بنسبة تصل إلى 40% من إجمالي التوكن المستهلك في الجلسة:

النمط 1: تحديد نطاقات الأسطر المطلوبة بدقة

بدلاً من السماح بقراءة الملف كاملاً، حدد أرقام الأسطر المستهدفة: 

# غير فعال: يقرأ 1,800 سطر (قرابة 14,000 توكن)
"اقرأ src/auth/session.ts واعرف سبب فشل التحقق من توكن المستخدم"

# فعال: يقرأ 60 سطراً فقط (قرابة 450 توكن)
"افحص الأسطر 120-180 في src/auth/session.ts حيث تم تعريف دالة verifyJwt()"

النمط 2: حصر وتصفية مخرجات الأوامر

عند تشغيل الاختبارات أو البناء، اطلب مخرجات موجزة: 

# غير فعال: يسكب آلاف أسطر الاختبارات الناجحة في السياق
"شغل npm test وأصلح الخطأ"

# فعال: يقيد المخرجات
"شغل npm test -- --reporter=dot أو صَفِّ النتائج بواسطة grep للأخطاء فقط. لا تطبع الاختبارات الناجحة."

النمط 3: ضبط وتنظيف السياق دورياً (/compact و /clear)

استخدم أوامر Claude Code المدمجة بانتظام:

  • /compact: يضغط سياق المحادثة الحالي فوراً ويحوله إلى ملخص تقني موجز.
  • /clear: يمسح ذاكرة السياق تماماً قبل الانتقال لمهمة غير متصلة دون الحاجة لإعادة فتح الطرفية.

9. مصفوفة المقارنة الشاملة لاستراتيجيات تقليص التوكن

استراتيجية التحسين نسبة التوفير المعتادة صعوبة التنفيذ المخاطرة على جودة الكود آلية التأثير الرئيسية
ملف .claudeignore صارم 40% – 60% منخفضة (5 دقائق) معدومة حجب ملفات القفل ومجلدات البناء والوسائط
ضغط السياق (/compact) 30% – 50% فورية (أمر طرفية) منخفضة حذف مخرجات الأوامر القديمة والنسخ السابقة
استكشاف بالوكلاء الفرعيين 35% – 55% متوسطة منخفضة جداً فصل القراءة الضخمة عن التعديل الدقيق
سقف لميزانية التفكير 20% – 35% منخفضة (تعديل ملف) منخفضة-متوسطة كبح التفكير المفرط في التعديلات العادية
ترقيع محدد بالأسطر 15% – 25% منخفضة (أسلوب توجيه) منخفضة استبدال إعادة كتابة الملفات بفوارق أسطر محددة
محاذاة التخزين المؤقت 10% – 20% (التكلفة) متوسطة معدومة تثبيت البادئات للحصول على خصم 90%

10. الخلاصة وقائمة التحقق العملية من 5 خطوات

إن تقليص استهلاك التوكن في Claude Code بنسبة 75% لا يتطلب التضحية بجودة الكود البرمجي المكتوب. بل على العكس تماماً، فالسياق المركز والنظيف يمنع تشتت انتباه النموذج والهلوسة، مما يرفع دقة الحلول البرمجية.

قائمة التحقق السريعة من 5 خطوات:

  1. [ ] أنشئ .claudeignore: ضع القالب الموصى به في جذر المشروع لحجب ملفات القفل والمخرجات المترجمة.
  2. [ ] اضبط config.json: قيد توكن التفكير بحد 2048، وفعل التلخيص التلقائي autoCompactContext عند نسبة 0.65.
  3. [ ] وظف النموذج المناسب: اجعل claude-3-7-sonnet للبرمجة، و claude-3-5-haiku للمسح، واقصر التفكير الموسع على المسائل الصعبة.
  4. [ ] اضبط مخرجات الطرفية: استخدم خيارات اختبارات مختصرة (--reporter=min والتصفية بـ grep) لإبقاء المخرجات دون 100 سطر.
  5. [ ] نظف السياق باستمرار: نفذ الأمر /compact أو /clear بين المهام للقضاء على ظاهرة Context Rot.

باتباع هذه المعايير الهندسية في روتينك اليومي، ستحافظ على كامل القوة الذاتية لـ Claude Code مع تخفيض فواتير الـ API الشهرية إلى حدودها الدنيا.

→ كل المقالات
0 / 4
قارن الآن ←