Guidelines for Reducing AI Coding Tool Credit Usage

Executive Summary

AI coding tools such as Augment Code, Claude Code, Cursor, GitHub Copilot, and ChatGPT consume credits, tokens, or usage quota based on several factors:

• The amount of context they process, including files, conversation history, logs, and documentation

• The complexity of the selected mode or agent

• Search, execution, and multi-step reasoning workflows

• Unnecessary retries and repeated iterations

• Vague, broad, or poorly scoped prompts

The best way to reduce usage is simple: give precise instructions, limit context, choose the right mode, and guide the AI toward the correct files.

---

Core Principles

1. Be specific before acting — Define exactly what needs to be done, which files matter, and which files are off-limits.

2. Use chat for questions and agents for changes — Chat mode is usually cheaper and better for understanding, planning, and review.

3. Reduce context aggressively — Include only the files, logs, screenshots, and history that are directly relevant.

4. Name exact files and locations — Avoid instructions like “scan the repo.” Point the AI to specific files, folders, classes, or functions.

5. Ask for a plan first — Have the AI outline its approach before it edits code.

6. Avoid broad repository searches — Provide filenames, stack traces, route names, class names, or function names whenever possible.

7. Prefer small, focused tasks — One bug, one component, one endpoint, or one test file per request.

8. Review before iterating — Check the AI’s output before asking for more changes.

9. Define done criteria — Specify what a complete and acceptable solution looks like.

---

Add AI Usage Rules to Project Guidelines

Every project should include AI usage instructions in places such as:

• README.md

• CONTRIBUTING.md

• AGENTS.md

• .cursor/rules

• Augment workspace guidelines

• Engineering handbooks

Example Guideline Block

Before making changes, read only the files explicitly mentioned in the prompt unless more context is required. If more files are needed, explain why before reading them.

Prefer minimal diffs. Do not refactor unrelated code. Do not run broad searches unless necessary. Ask for clarification when the task is ambiguous. Use existing project patterns and avoid introducing new dependencies unless requested.

---

Choose the Correct AI Mode or Agent

Mode	Use When	Typical Usage Cost
Chat	Questions, explanations, architecture discussion, debugging ideas, reviewing snippets, naming suggestions, understanding errors	Low
Coding Agent	Editing files, implementing features, fixing bugs, writing tests, making structured changes	Medium to high
Search / Repo Agent	The relevant code location is unknown and the AI needs to discover the module structure	Medium to high
Terminal / Execution Agent	Running tests, builds, linters, migrations, or shell commands	High
Multi-Agent / Deep Reasoning	Complex architectural changes, difficult bugs, security-sensitive tasks, or large refactors	Very high

Rule: Do not use an agent when you only have a question. Start with chat.

---

Use Chat Instead of an Agent for Questions

Many requests do not require an agent.

Bad

Use the agent to inspect the repo and explain how authentication works.

Better

In chat mode, explain the likely authentication flow based on these files:

- src/auth/LoginController.java
- src/security/JwtAuthenticator.java
- src/config/SecurityConfig.java

Do not edit files.

Good Chat-Only Requests

• “What does this error mean?”

• “How should I design this API?”

• “Can you review this function?”

• “What are the risks of this approach?”

• “Can you explain this code snippet?”

---

Reduce Context Size

Context includes everything the AI has to read and process:

• Prompt text

• Code files

• Conversation history

• Terminal output

• Documentation

• Error logs

• Test output

• Screenshots

• Repository search results

Ways to Reduce Context

1. Start a new conversation for a new task.

2. Remove irrelevant history from previous discussions.

3. Paste only the relevant error message and stack trace, not the full log.

4. Share only the relevant function, class, or file, not the entire module.

5. Avoid large attachments unless they are necessary.

6. Summarize prior decisions instead of keeping entire discussions in the thread.

7. Do not ask the AI to read the whole repository.

8. Exclude generated files, vendor folders, build artifacts, lock files, and large snapshots.

9. Explicitly mention which files or folders are out of scope.

---

Manage Conversation History

In long-running threads, conversation history accumulates and increases the context the AI may need to process on future turns.

How It Works

• Each new message may include prior conversation context.

• Long, unrelated history can increase usage and reduce answer quality.

• Credits or tokens already spent cannot be refunded, but future messages can be made cheaper by reducing irrelevant context.

Best Practices

• Delete irrelevant earlier exchanges if they no longer relate to the current task.

• Start a new conversation when switching to an unrelated task.

• Archive resolved topics by summarizing the outcome in a note, then continue from the summary.

Example

If you have been debugging UserService.java for 10 messages and now need to work on PaymentProcessor.java, start a fresh thread. This prevents the AI from reprocessing the old UserService discussion.

---

Name Exact Files and Locations

Naming exact files prevents unnecessary scanning and reduces wasted usage.

Bad

Fix the checkout bug.

Better

Fix the checkout bug in src/Checkout/CheckoutService.java. The failing behavior is in calculateTotal(). The related test is tests/Checkout/CheckoutServiceTest.java. Do not modify the payment gateway code.

Bad

Update the UI.

Better

Update only these files:

- src/app/components/pricing-card/pricing-card.component.html
- src/app/components/pricing-card/pricing-card.component.scss

Do not change TypeScript logic.

Useful Prompt Template

Task:
[Specific task]

Relevant files:
- [file 1]
- [file 2]

Allowed to modify:
- [file or folder]

Do not modify:
- [file, folder, dependency, public API, or unrelated module]

Expected output:
- [code change / explanation / tests / review]

Before editing:
- Explain your plan briefly.

---

Use Prompt Enhancers

Prompt enhancers turn vague requests into precise instructions before expensive agent work begins.

Workflow

1. Ask chat to improve the prompt.

2. Review and correct the enhanced prompt.

3. Give the enhanced prompt to the coding agent.

Prompt Enhancer Request

Improve this prompt for an AI coding agent. Make it specific, limit the scope, list assumptions, define which files may be touched, and add instructions to avoid unnecessary repository scanning.

Example

Original

Improve the dashboard performance.

Enhanced

Analyze the dashboard performance issue only in these files:

- src/dashboard/DashboardController.java
- src/dashboard/DashboardRepository.java
- src/dashboard/DashboardService.java

Focus on reducing duplicate database queries and unnecessary object creation. Do not refactor unrelated code.

First explain the likely bottlenecks, then propose a minimal patch. Only edit files after confirming the plan.

---

Ask for a Plan Before Code Changes

Asking for a plan first prevents unnecessary edits, broad diffs, and repeated corrections.

Recommended Instruction

Before changing files, give a short plan listing:

- Files you will inspect
- Files you expect to modify
- Assumptions
- Risks
- Tests you will run

Also add:

If the plan looks too broad, stop and narrow the scope before editing.

---

Prefer Small Tasks Over Large Tasks

Smaller tasks consume fewer credits and usually produce better results.

Bad

Refactor the whole payment system.

Better

Extract the discount calculation from PaymentService into a DiscountCalculator class. Only touch these two files and update the existing unit test.

Recommended Task Size

• One bug fix

• One component

• One endpoint

• One test file

• One small refactor

• One migration

• One failing test

---

Avoid Broad Repository Searches

Commands like “search everywhere,” “inspect the whole codebase,” or “understand the entire project” are expensive and often unnecessary.

Better Alternatives

• Provide likely filenames.

• Provide the relevant stack trace.

• Provide the route name, class name, component name, or test name.

• Ask the AI to request more files only if needed.

• Use ripgrep manually and paste the relevant results.

Example

Bad

Find where coupons are handled.

Better

Search only for these terms:

- CouponService
- CouponController
- coupon_validity
- discount_code

Do not inspect unrelated checkout files unless required.

---

Limit Terminal Output

Terminal output can be expensive to process, especially when logs contain thousands of lines.

Guidelines

• Run focused tests instead of the entire suite unless a full run is necessary.

• Paste only the failing part of the output.

• Use concise test commands.

• Avoid sending full build logs.

• Truncate repetitive logs.

• Ask the AI to summarize logs before retrying.

Example

Bad

Here is the full CI log: [10,000 lines]

Better

Here are the first failing test, the stack trace, and the command used.

---

Reuse Existing Knowledge

Teams reduce repeated context by maintaining concise project documentation.

Useful Documents to Maintain

• Architecture overview

• Common commands

• Testing instructions

• Coding conventions

• Module ownership

• Known gotchas

• AI agent instructions

Point the AI to these documents instead of asking it to rediscover everything each time.

---

Avoid Unnecessary Refactoring

Broad refactoring increases usage, review burden, and regression risk.

Recommended Instruction

Make the smallest correct change. Do not refactor unrelated code. Do not rename public APIs unless required. Preserve existing project patterns.

---

Define Done Criteria

Clear acceptance criteria reduce repeated iterations.

Example

Done when:

- The bug is fixed.
- Existing tests pass.
- One regression test is added.
- No unrelated files are changed.
- The public API remains unchanged.

---

Use Diffs and Reviews Efficiently

• Ask the AI to produce a minimal diff.

• Ask it to explain the diff briefly.

• Review the output before requesting another change.

• Avoid asking it to regenerate everything.

• Ask for targeted patches instead of full rewrites.

---

Control File Access

Tell the AI what it may read, what it may edit, and what is forbidden.

Example

You may read files under src/Billing and tests/Billing only.

Do not inspect src/Legacy unless you cannot solve the issue without it.

Ask before expanding scope.

---

Use Checkpoints for Larger Tasks

For larger tasks, checkpoints reduce wasted agent work.

Example Workflow

1. Ask for understanding.

2. Ask for a plan.

3. Approve the scope.

4. Let the AI implement.

5. Ask for a test strategy.

6. Run focused tests.

7. Ask for a final review.

---

Recommended Prompt Template

Task:
[Describe exactly what needs to be done]

Goal:
[Business or technical goal]

Relevant context:
[Short context only]

Relevant files:
- [file path]
- [file path]

Allowed changes:
- [Files or folders the AI may modify]

Do not change:
- [Files, folders, patterns, dependencies, or APIs that are off-limits]

Constraints:
- Keep the change minimal.
- Follow existing project patterns.
- Do not introduce new dependencies unless necessary.
- Do not refactor unrelated code.
- Ask before expanding scope.

Expected output:
- Brief plan first
- Minimal code changes
- Tests or verification steps
- Short summary of changed files

Acceptance criteria:
- [Criterion 1]
- [Criterion 2]
- [Criterion 3]

---

Examples of Credit-Efficient Prompts

1. Bug Fix

Task:
Fix the null pointer exception in UserService.findById() when the user is archived.

Relevant files:
- src/services/UserService.java, around line 42
- src/test/java/services/UserServiceTest.java, around line 156

Do not modify:
- User model
- Database layer

Plan first. Then add the null check and update the test.

2. Test Writing

Task:
Write unit tests for TokenValidator.isExpired().

Relevant files:
- src/security/TokenValidator.java
- src/test/java/security/TokenValidatorTest.java

Write three tests:
- Valid token
- Expired token
- Invalid format

Use existing test patterns in the file.

3. Code Review

In chat mode, review this function for bugs, performance issues, and style problems.

Do not edit files. Only point out risks.

[Paste function here]

4. Small Refactor

Task:
Extract calculateTax() from InvoiceService into a new TaxCalculator class.

Files to modify:
- src/services/InvoiceService.java
- src/tax/TaxCalculator.java

Files to read:
- src/test/java/services/InvoiceServiceTest.java

Keep the public API unchanged. Run the existing tests afterward.

5. Architecture Question

In chat mode, we need to add user preferences. Which option is better?

A. Add columns to the User table
B. Create a separate UserPreferences table
C. Use a JSON column

Compare the options for scalability, flexibility, queryability, migration risk, and fit with the current schema. Do not write code.

---

Anti-Patterns That Waste Credits

Anti-Pattern	Why It Wastes Credits	Better Approach
“Read the whole repo”	The agent scans irrelevant files	Name specific files and folders
“Fix all issues”	The scope is unbounded	Fix one issue at a time
“Make it better”	The goal is undefined	State the exact goal and acceptance criteria
“Refactor this module completely”	Broad changes multiply iterations	Extract one function or class at a time
“Here is a huge log”	Processing thousands of lines is expensive	Paste only the failing part and stack trace
“Keep retrying until it works”	Each retry adds cost and context	Review the plan before starting
“Use the most powerful agent for everything”	Overkill for simple tasks	Use the cheapest effective mode
“Ask agent mode a simple question”	Agents are unnecessary for explanations	Use chat for questions
“Let the AI decide which files to modify”	The AI may touch unrelated code	Explicitly list allowed and forbidden files
“No acceptance criteria”	The AI has to guess what “done” means	Define clear done criteria upfront

---

Checklist Before Using an AI Coding Agent

• [ ] Is the task clear and specific?

• [ ] Have I chosen chat vs. agent correctly?

• [ ] Have I named the relevant files?

• [ ] Have I limited allowed file changes?

• [ ] Have I removed irrelevant context and history?

• [ ] Have I provided acceptance criteria?

• [ ] Have I asked for a plan before edits?

• [ ] Have I avoided broad repository scanning?

• [ ] Have I provided only relevant logs?

• [ ] Have I specified which tests to run?

---

Final Team Policy

Adopt this policy:

Use the cheapest effective AI mode. Start with chat for understanding, planning, and review. Use agents only for implementation or investigation that requires file access. Always limit scope, name relevant files, and ask for a plan before edits. Prefer small, reviewable changes. Avoid broad repository scans unless they are justified.

---

The Golden Rule

The more precisely you guide the AI, the fewer credits it burns and the better the result.