AI编程 如何降低成本｜附完整命令

在 AI 编程越来越普及的今天，很多开发者、独立开发者、创业团队都开始把 AI 工具接入日常研发流程：写代码、改 Bug、生成测试、解释项目、重构模块、写文档、做 Code Review，甚至直接让 AI 参与需求分析和架构设计。

但随之而来的一个问题也非常明显：AI 编程很好用，但成本可能会失控。

如果你每天都把大段代码、日志、上下文、报错信息丢给大模型，或者频繁使用高价模型进行简单任务，一个月下来 API 账单可能并不低。对于个人开发者来说，这是一笔持续支出；对于团队来说，如果没有规范化使用方式，成本甚至会随着团队规模线性上升。

本文将从实际开发角度出发，系统讲解如何降低 AI 编程成本，并附上可直接使用的完整命令示例，帮助你在不明显牺牲效率的前提下，把 AI 编程费用控制在合理范围内。

一、AI 编程成本主要花在哪里？

要降低成本，首先要知道钱花在什么地方。

AI 编程的成本通常来自以下几个方面：

1. 模型调用费用
2. 输入 Token 成本
3. 输出 Token 成本
4. 重复请求成本
5. 无效上下文成本
6. 高价模型滥用成本
7. 团队多人无规范使用成本

很多人以为 AI 编程贵，是因为模型单价高。实际上，很多时候真正浪费的是：你给了模型太多无关内容，让它反复处理不必要的信息。

例如，你只是想让 AI 帮你修改一个函数，却把整个项目几十个文件都发过去；你只是想解释一段报错，却把几千行日志全部复制进去；你只是想生成一个 README，却使用了最贵的推理模型。

这些行为都会显著增加成本。

二、降低成本的核心原则

降低 AI 编程成本，不是简单地“少用 AI”，而是要做到：

让便宜模型处理简单任务，让高价模型处理复杂任务；让 AI 只看必要上下文；让重复任务自动化；让可缓存内容尽量缓存。

可以总结为五个原则：

1. 任务分级
2. 模型分层
3. 上下文裁剪
4. 本地优先
5. 自动化与缓存

下面逐项展开。

三、任务分级：不要所有问题都用最强模型

AI 编程中的任务可以分为不同等级。

1. 低复杂度任务

例如：

• 变量命名
• 简单正则表达式
• SQL 格式化
• 注释生成
• 简单代码解释
• README 初稿
• Git Commit Message
• 单个函数的轻量优化

这类任务不需要最强模型。你可以使用便宜模型，甚至使用本地模型。

2. 中等复杂度任务

例如：

• 根据接口生成 CRUD 代码
• 写单元测试
• 分析普通 Bug
• 重构某个模块
• 生成 API 文档
• 修改前端组件逻辑

这类任务可以使用中等价格模型，配合明确上下文即可。

3. 高复杂度任务

例如：

• 项目级架构设计
• 多文件复杂 Bug 定位
• 性能瓶颈分析
• 安全漏洞分析
• 复杂业务规则拆解
• 多模块重构方案设计

这类任务适合使用能力更强的模型，但也应该经过准备：先让低价模型或脚本整理信息，再交给高价模型做最终分析。

四、模型分层：建立“便宜模型优先”的使用策略

很多 AI 编程成本失控，是因为所有任务都默认走最贵模型。

更合理的方式是建立模型分层：

简单任务：本地模型 / 低价模型
普通任务：中等模型
复杂任务：高性能模型
关键决策：高性能模型 + 人工复核

例如你可以这样规划：

核心思路是：不要一上来就用最贵模型。

五、上下文裁剪：AI 编程省钱的关键

AI API 通常按 Token 计费。Token 越多，成本越高。

因此降低成本最有效的方法之一，就是减少输入内容。

错误做法

你想让 AI 修改一个登录函数，却把整个项目压缩包上传，或者把一整份 3000 行文件贴进去。

正确做法

只提供：

1. 相关函数
2. 相关类型定义
3. 相关报错
4. 期望行为
5. 当前行为
6. 约束条件

例如：

请只修改下面这个 TypeScript 函数，不要改动其他接口。

当前问题：
当 username 为空字符串时，函数没有返回错误。

期望行为：
username 为空时返回 { ok: false, message: "username required" }

相关代码：
...

这样不仅省钱，模型输出也更稳定。

六、使用 Git 精准提取变更上下文

如果你是基于 Git 开发，可以用命令只提取本次变更内容，而不是把整个项目发给 AI。

查看当前改动

git diff

只查看某个文件的改动

git diff -- src/auth/login.ts

查看暂存区改动

git diff --cached

生成本次变更摘要

git diff --stat

把改动保存到文件，供 AI 分析

git diff > ai-context.diff

然后你可以把 ai-context.diff 的内容发给 AI，让它做 Code Review、生成测试建议或写 Commit Message。

生成最近一次提交的变更内容

git show --stat

git show --format=fuller

git show HEAD -- src/auth/login.ts

这些命令可以帮助你把上下文控制在“刚好够用”的范围内。

七、用 ripgrep 快速定位相关代码

很多人为了让 AI 理解项目，会直接把一堆文件复制进去。更好的做法是先用搜索工具找到相关代码。

推荐使用 rg，也就是 ripgrep。

安装 ripgrep

macOS：

brew install ripgrep

Ubuntu / Debian：

sudo apt update
sudo apt install ripgrep -y

Windows PowerShell：

winget install BurntSushi.ripgrep.MSVC

搜索关键词

rg "login" src

搜索函数名

rg "function login" src

搜索接口定义

rg "interface User" src

搜索错误信息

rg "username required" .

显示行号

rg -n "login" src

只搜索 TypeScript 文件

rg "login" src -g "*.ts"

通过这些命令，你可以先定位真正相关的代码，再把少量代码交给 AI。

八、用 tree 控制项目结构上下文

有时候 AI 不需要看完整代码，只需要知道项目结构。此时可以用 tree 输出目录结构。

安装 tree

macOS：

brew install tree

Ubuntu / Debian：

sudo apt update
sudo apt install tree -y

Windows PowerShell：

winget install GnuWin32.Tree

输出项目结构

tree -L 2

排除 node_modules

tree -L 3 -I "node_modules|dist|build|.git"

保存结构到文件

tree -L 3 -I "node_modules|dist|build|.git" > project-tree.txt

然后你可以把 project-tree.txt 发给 AI，让它先理解项目结构，再决定需要哪些文件。

这比直接上传整个项目更省钱。

九、用 cloc 统计代码规模，避免无意识上传大项目

在让 AI 处理项目之前，可以先统计项目规模。

安装 cloc

macOS：

brew install cloc

Ubuntu / Debian：

sudo apt update
sudo apt install cloc -y

Windows PowerShell：

winget install AlDanial.Cloc

统计代码行数

cloc .

排除目录

cloc . --exclude-dir=node_modules,dist,build,.git

如果你发现项目有十几万行代码，就不应该直接全部交给 AI，而应该拆分任务、精准提取上下文。

十、使用本地模型处理低价值任务

对于简单代码解释、Commit Message、注释生成、文档草稿等任务，可以考虑使用本地模型。

本地模型的优点是：

1. 调用成本低
2. 隐私性更好
3. 适合重复任务
4. 不依赖网络 API
5. 可以处理大量低价值请求

常见工具是 Ollama。

安装 Ollama

macOS / Linux：

curl -fsSL https://ollama.com/install.sh | sh

Windows 可以直接下载安装包，或使用：

winget install Ollama.Ollama

拉取模型

ollama pull qwen2.5-coder:7b

或者：

ollama pull deepseek-coder:6.7b

运行模型

ollama run qwen2.5-coder:7b

用本地模型解释代码

ollama run qwen2.5-coder:7b "请解释下面这段 JavaScript 代码的作用：const arr = [1,2,3].map(x => x * 2)"

让本地模型生成 Commit Message

git diff --cached | ollama run qwen2.5-coder:7b "请根据以下 git diff 生成一个简洁的中文 commit message："

如果你的电脑性能不错，本地模型可以承担很多日常低复杂度任务，从而显著减少云端 API 调用。

十一、把 AI 请求变成“先压缩，再提问”

一个很实用的降本策略是：先用低价模型或本地模型总结上下文，再把总结交给高价模型。

例如，你有一个很长的日志文件：

tail -n 3000 app.log > error-context.log

如果直接把 3000 行日志发给高价模型，成本会比较高。你可以先用本地模型提取关键信息：

cat error-context.log | ollama run qwen2.5-coder:7b "请从日志中提取关键错误、堆栈、时间点和可能原因，输出精简摘要："

然后再把精简后的摘要交给高性能模型分析。

类似地，也可以对代码做预处理：

git diff > change.diff
cat change.diff | ollama run qwen2.5-coder:7b "请总结这次代码变更的核心内容、涉及文件和潜在风险："

这样做的好处是，高价模型看到的是“压缩后的高密度信息”，而不是低价值原始文本。

十二、为 AI 编程建立固定 Prompt 模板

Prompt 写得越模糊，AI 越容易输出无用内容，导致你反复追问，增加成本。

你可以建立固定模板。

Bug 分析模板

你是一名资深软件工程师。请根据以下信息分析 Bug。

目标：
找出最可能原因，并给出最小修改方案。

当前现象：
【填写当前现象】

期望行为：
【填写期望行为】

相关代码：
【粘贴必要代码】

报错信息：
【粘贴关键报错，不要粘贴全部日志】

限制条件：
1. 不要大规模重构
2. 不要引入新依赖
3. 保持现有接口兼容

请输出：
1. 原因分析
2. 修改方案
3. 修改后的代码
4. 需要补充的测试用例

Code Review 模板

请对以下 git diff 做代码审查。

重点关注：
1. 潜在 Bug
2. 安全风险
3. 性能问题
4. 可维护性
5. 是否需要补充测试

请不要重复解释无问题的代码，只输出需要关注的问题。

代码变更：
【粘贴 git diff】

单元测试生成模板

请为以下函数生成单元测试。

要求：
1. 使用 Jest
2. 覆盖正常场景、边界场景、异常场景
3. 不修改原函数
4. 输出完整测试代码

函数代码：
【粘贴函数】

模板的价值在于：减少沟通轮次。每减少一次追问，都是在降低成本。

十三、用脚本自动生成 AI 上下文

如果你经常让 AI 做 Code Review，可以写一个脚本自动收集必要上下文。

创建脚本

mkdir -p scripts
touch scripts/ai-context.sh
chmod +x scripts/ai-context.sh

写入脚本内容

cat > scripts/ai-context.sh <<'EOF'
#!/usr/bin/env bash
set -e

OUTPUT_FILE="ai-context.md"

echo "# AI Context" > "$OUTPUT_FILE"

echo "\n## Git Status" >> "$OUTPUT_FILE"
git status --short >> "$OUTPUT_FILE"

echo "\n## Changed Files" >> "$OUTPUT_FILE"
git diff --name-only >> "$OUTPUT_FILE"

echo "\n## Diff Stat" >> "$OUTPUT_FILE"
git diff --stat >> "$OUTPUT_FILE"

echo "\n## Git Diff" >> "$OUTPUT_FILE"
git diff >> "$OUTPUT_FILE"

echo "AI context generated: $OUTPUT_FILE"
EOF

运行脚本

./scripts/ai-context.sh

它会生成一个 ai-context.md 文件，里面包含当前变更的状态、文件列表、统计信息和 diff 内容。你可以直接把这个文件提供给 AI。

如果文件太大，可以只收集暂存区：

cat > scripts/ai-context-cached.sh <<'EOF'
#!/usr/bin/env bash
set -e

OUTPUT_FILE="ai-context-cached.md"

echo "# AI Context Cached" > "$OUTPUT_FILE"

echo "\n## Git Status" >> "$OUTPUT_FILE"
git status --short >> "$OUTPUT_FILE"

echo "\n## Cached Changed Files" >> "$OUTPUT_FILE"
git diff --cached --name-only >> "$OUTPUT_FILE"

echo "\n## Cached Diff Stat" >> "$OUTPUT_FILE"
git diff --cached --stat >> "$OUTPUT_FILE"

echo "\n## Cached Git Diff" >> "$OUTPUT_FILE"
git diff --cached >> "$OUTPUT_FILE"

echo "AI cached context generated: $OUTPUT_FILE"
EOF

chmod +x scripts/ai-context-cached.sh
./scripts/ai-context-cached.sh

十四、限制输出长度，避免 AI 生成大量无用内容

很多成本也来自输出 Token。比如你只是想要一个修改建议，AI 却输出了大量解释、背景知识和完整文件。

可以在 Prompt 中明确限制：

请只输出必要修改，不要解释背景知识。

请控制在 300 字以内。

请只输出 diff patch，不要输出完整文件。

请只列出最重要的 5 个问题。

例如 Code Review 时可以这样写：

请审查以下 diff。只输出高风险问题，最多 5 条。每条包含：问题、影响、建议。不需要表扬性内容。

这类限制可以明显减少输出成本。

十五、让 AI 输出 Patch，而不是完整文件

如果一个文件有 1000 行，AI 只需要修改其中 10 行，那么最好让它输出 patch。

Prompt 示例：

请基于以下代码问题生成 unified diff patch。
要求：
1. 只修改必要行
2. 不输出完整文件
3. 保持现有代码风格

问题：
【描述问题】

相关代码：
【粘贴相关代码】

你也可以要求 AI 按下面格式输出：

diff --git a/src/auth/login.ts b/src/auth/login.ts
--- a/src/auth/login.ts
+++ b/src/auth/login.ts
@@ -10,7 +10,9 @@

这样可以减少输出长度，也方便人工检查。

十六、使用 API 时设置 max_tokens

如果你是直接调用 API，一定要设置最大输出 Token，避免模型输出过长。

下面是一个 Node.js 示例。

安装依赖

npm init -y
npm install openai dotenv

创建环境变量文件

touch .env

写入：

OPENAI_API_KEY=你的_API_Key

创建调用脚本

touch ask-ai.js

写入：

import 'dotenv/config';
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const prompt = process.argv.slice(2).join(' ');

async function main() {
  if (!prompt) {
    console.error('Usage: node ask-ai.js "your question"');
    process.exit(1);
  }

  const response = await client.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: '你是一名高效的软件工程助手。回答要简洁，优先给出可执行方案。',
      },
      {
        role: 'user',
        content: prompt,
      },
    ],
    max_tokens: 600,
    temperature: 0.2,
  });

  console.log(response.choices[0].message.content);
}

main().catch(console.error);

修改 package.json

npm pkg set type=module

运行

node ask-ai.js "请用中文解释什么是 React useMemo，控制在 200 字以内"

这里的关键是：

max_tokens: 600

它可以防止模型生成过长内容。

十七、使用缓存减少重复请求

如果你经常问类似问题，可以把结果缓存下来。

例如，同一个错误码解释、同一个项目结构说明、同一个模块说明，没必要每次都重新请求 AI。

可以做一个简单的本地缓存。

创建缓存目录

mkdir -p .ai-cache

用 prompt 生成 hash

echo "请解释项目结构" | shasum -a 256

简单缓存脚本示例

cat > scripts/ai-cache.sh <<'EOF'
#!/usr/bin/env bash
set -e

CACHE_DIR=".ai-cache"
mkdir -p "$CACHE_DIR"

PROMPT="$*"

if [ -z "$PROMPT" ]; then
  echo "Usage: ./scripts/ai-cache.sh your prompt"
  exit 1
fi

KEY=$(echo "$PROMPT" | shasum -a 256 | awk '{print $1}')
CACHE_FILE="$CACHE_DIR/$KEY.txt"

if [ -f "$CACHE_FILE" ]; then
  echo "Cache hit: $CACHE_FILE"
  cat "$CACHE_FILE"
  exit 0
fi

echo "Cache miss. Please call your AI API here."
echo "Prompt: $PROMPT" > "$CACHE_FILE"
cat "$CACHE_FILE"
EOF

chmod +x scripts/ai-cache.sh

运行：

./scripts/ai-cache.sh "请解释这个项目的目录结构"

实际使用中，你可以把 API 调用逻辑接进去。缓存并不复杂，但对团队场景非常有用。

十八、团队使用 AI 编程的成本控制规范

如果是团队使用 AI，更需要建立规范。

建议至少明确以下规则：

1. 默认使用低价模型
2. 复杂问题才升级高价模型
3. 禁止上传整个仓库，除非经过确认
4. 禁止上传敏感信息
5. 所有 AI 生成代码必须人工 Review
6. Code Review 优先使用 git diff
7. 日志只提供关键片段
8. 输出必须限制长度
9. 常用 Prompt 模板统一维护
10. 每月统计 API 成本

可以在项目根目录建立一个文档：

touch AI_USAGE.md

写入团队规范：

# AI 使用规范

## 默认原则

- 优先使用低成本模型
- 只提供必要上下文
- 不上传密钥、Token、用户隐私数据
- AI 生成代码必须经过人工 Review

## 推荐上下文

- git diff
- 相关函数
- 关键报错
- 项目结构摘要

## 禁止行为

- 直接上传完整仓库
- 上传 .env 文件
- 上传生产数据库数据
- 让 AI 直接决定关键架构且不复核

十九、保护敏感信息也是降低隐性成本

AI 编程成本不仅是 API 账单，也包括安全风险。

如果你不小心把 .env、数据库密码、用户手机号、访问 Token 发给 AI，一旦造成泄露，代价远高于模型调用费。

在生成 AI 上下文前，可以排除敏感文件。

查找可能的密钥

rg -n "API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY" .

排除 .env 文件

git diff -- . ':(exclude).env' ':(exclude).env.local'

查看 Git 是否跟踪了 .env

git ls-files | rg "^\.env"

从 Git 跟踪中移除 .env

git rm --cached .env

添加到 .gitignore

echo ".env" >> .gitignore
echo ".env.*" >> .gitignore

注意，如果已经提交过密钥，需要立即轮换密钥，而不是只删除文件。

二十、推荐的低成本 AI 编程工作流

下面是一套比较实用的流程。

第一步：明确问题

不要直接问：

这个项目有什么问题？

而是问：

请分析登录接口在 username 为空时没有返回错误的原因。

第二步：收集最小上下文

rg -n "login|username" src

git diff -- src/auth/login.ts

第三步：先用低价模型处理

git diff -- src/auth/login.ts | ollama run qwen2.5-coder:7b "请分析这段 diff 可能引入的问题："

第四步：复杂问题再升级

如果低价模型分析不出来，再把精简后的信息给高性能模型。

第五步：要求输出 patch

请只输出 unified diff patch，不要输出完整文件。

第六步：本地运行测试

npm test

或者：

pnpm test

第七步：让 AI 根据失败测试继续修正

npm test 2>&1 | tail -n 120 > test-error.log

然后只把最后 120 行关键错误发给 AI，而不是把完整日志发过去。

二十一、完整命令清单汇总

下面把本文常用命令集中整理，方便复制使用。

Git 上下文

git diff
git diff --cached
git diff --stat
git diff --name-only
git diff > ai-context.diff
git show --stat
git show --format=fuller
git show HEAD -- src/auth/login.ts

搜索代码

rg "login" src
rg -n "login" src
rg "function login" src
rg "interface User" src
rg "username required" .
rg "login" src -g "*.ts"

项目结构

tree -L 2
tree -L 3 -I "node_modules|dist|build|.git"
tree -L 3 -I "node_modules|dist|build|.git" > project-tree.txt

代码统计

cloc .
cloc . --exclude-dir=node_modules,dist,build,.git

日志裁剪

tail -n 300 app.log
tail -n 3000 app.log > error-context.log
npm test 2>&1 | tail -n 120 > test-error.log

Ollama 本地模型

curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5-coder:7b
ollama pull deepseek-coder:6.7b
ollama run qwen2.5-coder:7b
ollama run qwen2.5-coder:7b "请解释下面这段代码"

用本地模型处理 diff

git diff | ollama run qwen2.5-coder:7b "请总结这次代码变更的核心内容和潜在风险："

生成 AI 上下文脚本

mkdir -p scripts
touch scripts/ai-context.sh
chmod +x scripts/ai-context.sh

cat > scripts/ai-context.sh <<'EOF'
#!/usr/bin/env bash
set -e

OUTPUT_FILE="ai-context.md"

echo "# AI Context" > "$OUTPUT_FILE"

echo "\n## Git Status" >> "$OUTPUT_FILE"
git status --short >> "$OUTPUT_FILE"

echo "\n## Changed Files" >> "$OUTPUT_FILE"
git diff --name-only >> "$OUTPUT_FILE"

echo "\n## Diff Stat" >> "$OUTPUT_FILE"
git diff --stat >> "$OUTPUT_FILE"

echo "\n## Git Diff" >> "$OUTPUT_FILE"
git diff >> "$OUTPUT_FILE"

echo "AI context generated: $OUTPUT_FILE"
EOF

./scripts/ai-context.sh

敏感信息检查

rg -n "API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY" .
git ls-files | rg "^\.env"
git rm --cached .env
echo ".env" >> .gitignore
echo ".env.*" >> .gitignore

二十二、总结

AI 编程并不一定昂贵，真正昂贵的是无策略地使用 AI。

如果你希望长期、稳定、低成本地使用 AI 编程，可以记住以下几点：

1. 简单任务不要用最贵模型
2. 不要把整个项目随便丢给 AI
3. 优先用 git diff 提供上下文
4. 日志和代码都要先裁剪
5. 低价模型可以先做摘要
6. 复杂问题再升级到高性能模型
7. 限制输出长度
8. 让 AI 输出 patch，而不是完整文件
9. 建立团队 Prompt 模板和使用规范
10. 注意敏感信息保护

AI 编程的最佳实践不是“让 AI 看得越多越好”，而是：

让 AI 看到刚好足够的信息，并完成刚好明确的任务。

做到这一点，你不仅能降低成本，还能提高 AI 输出质量，让它真正成为稳定、可控、可持续的研发助手。