上一篇文章介绍了一些简单的使用技巧，本文演示一下基本功能和一个很好用的Plan功能。
# 基本功能
当我们claude登入后，直接和它对话即可，这就是claude的基本功能。和所有的AI工具一致
```
❯ 你好，什么是贪吃蛇游戏

● 贪吃蛇（Snake）是一款经典的电子游戏：

  - 玩法：玩家控制一条蛇在屏幕上移动，吃掉食物后蛇身变长
  - 目标：尽可能吃更多食物，获得更高分数
  - 游戏结束条件：蛇撞到墙壁或撞到自己的身体
  - 操作：通常用方向键（上下左右）控制移动方向

  这是一款简单但上手容易、极具挑战性的益智游戏，最早出现在1970年代，诺基亚手机版本（1998年）使其广为人知。

```
# Plan模式
我们是不是经常会遇到这样的情况：

和AI沟通的时候，要么自己表述有问题，没有清晰的把自己的需求说出来，要么AI理解有问题，没有理解你的表述

在这两种情况下，如果按照基本模式去工作，很容易让claude直接按照错误的意思干活去了，这导致claude干了不是你意思的活。导致你要么需要clear重新来，要么rewind重新问。

Plan模式就是解决这种困境的。

Plan mode让你和Claude提前对话，让它尝试理解你的意思，在理解完成之后，给出包含你意思的计划书。当你认为这个计划书没问题的时候，你可以让他按照这个计划书来干活。这样的好处就是，claude不会提前干活，且你能够很精确的确保claude干的活符合你的需求(因为你会检查计划书)。

下面开始演示
两种方式启动plan mode
* `/plan` 直接启动
* `shift + tab` 快捷键选中到plan mode

成功之后显示如下
```
  ⏸ plan mode on (shift+tab to cycle)                                                               ◐ medium · /effort
╭─── Claude Code v2.1.63 ───────────────────────────────────────────────────────────────────────────────────────────╮
│                                               │ Tips for getting started                                          │
│                 Welcome back!                 │ Run /init to create a CLAUDE.md file with instructions for Claude │
│                                               │ ───────────────────────────────────────────────────────────────── │
│                    ▐▛███▜▌                    │ Recent activity                                                   │
│                   ▝▜█████▛▘                   │ No recent activity                                                │
│                     ▘▘ ▝▝                     │                                                                   │
│                                               │                                                                   │
│   Sonnet 4.6 · Claude Pro                      │                                                                   │
│                 ~/                  │                                                                   │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
可以看到plan mode开启成功了，接下来我们对话，让它开发一个贪吃蛇小游戏，它不会直接开始干，而是理解你的需求，提供一份计划书，如下
```
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ Plan to implement                                                                                                    │
│                                                                                                                      │
│ 网页贪吃蛇游戏开发计划                                                                                               │
│                                                                                                                      │
│ Context                                                                                                              │
│                                                                                                                      │
│ 用户需要一个网页版贪吃蛇游戏，通过键盘上下左右方向键控制蛇的移动。                                                   │
│                                                                                                                      │
│ 实现方案                                                                                                             │
│                                                                                                                      │
│ 创建单个 HTML 文件 ~/snake.html，包含完整的 HTML + CSS + JavaScript。                                     │
│                                                                                                                      │
│ 核心功能                                                                                                             │
│                                                                                                                      │
│ - Canvas 绘制：使用 HTML5 Canvas 绘制游戏画面                                                                        │
│ - 蛇的移动：通过键盘方向键（↑↓←→）控制方向                                                                       │
│ - 食物生成：随机位置生成食物，蛇吃到后身体增长                                                                       │
│ - 碰撞检测：撞墙或撞自身则游戏结束                                                                                   │
│ - 分数显示：实时显示当前得分                                                                                         │
│ - 重新开始：游戏结束后可按空格键重新开始                                                                             │
│                                                                                                                      │
│ 技术细节                                                                                                             │
│                                                                                                                      │
│ - 画布大小：400x400 像素，网格单元 20x20                                                                             │
│ - 游戏循环：使用 setInterval，初始速度 150ms/帧                                                                      │
│ - 防止反向移动（如向右时不能直接向左）                                                                               │
│ - 页面居中显示，深色背景，视觉清晰                                                                                   │
│                                                                                                                      │
│ 文件                                                                                                                 │
│                                                                                                                      │
│ - 新建：~/snake.html（单文件，无外部依赖）                                                                │
│                                                                                                                      │
│ 验证                                                                                                                 │
│                                                                                                                      │
│ - 浏览器打开 snake.html，方向键控制蛇移动                                                                            │
│ - 吃到食物后蛇变长、分数增加                                                                                         │
│ - 撞墙/撞自身游戏结束，空格键重新开始                                                                                │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
我们只需要检查这个计划书是否符合我们的需求，如果符合，就直接同意执行即可

```
· Incubating…
●IWrite(snake.html)
●──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⎿  Wrotei205 lines to snake.html                                                                                           <!DOCTYPE html>────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏵⏵ <html lang="zh-CN">on (shift+tab to cycle) · esc to interrupt                                  ◐ medium · /effor
     <head>                                                                                                                  <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">                                                  <title>贪吃蛇游戏</title>                                    t
     <style>
       * { margin: 0; padding: 0; box-sizing: border-box; }
       body {
         background: #1a1a2e;
     … +195 lines (ctrl+o to expand)

●I已创建 ~/snake.html。浏览器打开即可游玩：

  - 方向键 控制蛇移动（按下即开始）                                                                                       - 吃到红色食物蛇变长，得分 +10
  - 撞墙或撞自身游戏结束                                                                                                  - 空格键 重新开始                                                                                                     
```
等待一会儿，claude 按照计划完美完成任务了，我们检查一下效果

![image.png](/static/img/090afee448f333b68172622d22774936.image.webp)

真的可以玩，功能无误。这个任务完美完成了。

# 总结
plan mode是典型的先规划后执行的思维方式，我们在处理一个认为比较重要的事情的时候，先和他不断沟通，把沟通的决策记录下来，保存为设计文档。如果你觉得和你的需求有不一致的地方，你可以和它反复沟通修改计划书。当计划满意之后，直接执行即可

# 附录
源码
```
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>贪吃蛇游戏</title>
<style>
  * { margin: 0; padding: 0; box-sizing: border-box; }
  body {
    background: #1a1a2e;
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
    font-family: 'Segoe UI', Arial, sans-serif;
    color: #eee;
  }
  #container {
    text-align: center;
  }
  h1 {
    margin-bottom: 10px;
    font-size: 28px;
    color: #0f0;
  }
  #score {
    font-size: 20px;
    margin-bottom: 10px;
  }
  canvas {
    border: 2px solid #0f0;
    background: #16213e;
    display: block;
    margin: 0 auto;
  }
  #message {
    margin-top: 12px;
    font-size: 16px;
    color: #aaa;
    height: 20px;
  }
</style>
</head>
<body>
<div id="container">
  <h1>贪吃蛇</h1>
  <div id="score">得分：0</div>
  <canvas id="game" width="400" height="400"></canvas>
  <div id="message">按方向键开始游戏</div>
</div>
<script>
(function () {
  const canvas = document.getElementById('game');
  const ctx = canvas.getContext('2d');
  const scoreEl = document.getElementById('score');
  const messageEl = document.getElementById('message');

  const GRID = 20;
  const COLS = canvas.width / GRID;
  const ROWS = canvas.height / GRID;
  const SPEED = 150;

  let snake, direction, nextDirection, food, score, gameOver, timer, started;

  function init() {
    snake = [
      { x: 5, y: 10 },
      { x: 4, y: 10 },
      { x: 3, y: 10 }
    ];
    direction = { x: 1, y: 0 };
    nextDirection = { x: 1, y: 0 };
    score = 0;
    gameOver = false;
    started = false;
    scoreEl.textContent = '得分：0';
    messageEl.textContent = '按方向键开始游戏';
    placeFood();
    draw();
    if (timer) clearInterval(timer);
    timer = null;
  }

  function placeFood() {
    while (true) {
      food = {
        x: Math.floor(Math.random() * COLS),
        y: Math.floor(Math.random() * ROWS)
      };
      if (!snake.some(s => s.x === food.x && s.y === food.y)) break;
    }
  }

  function update() {
    direction = nextDirection;
    const head = { x: snake[0].x + direction.x, y: snake[0].y + direction.y };

    if (head.x < 0 || head.x >= COLS || head.y < 0 || head.y >= ROWS) {
      endGame();
      return;
    }

    if (snake.some(s => s.x === head.x && s.y === head.y)) {
      endGame();
      return;
    }

    snake.unshift(head);

    if (head.x === food.x && head.y === food.y) {
      score += 10;
      scoreEl.textContent = '得分：' + score;
      placeFood();
    } else {
      snake.pop();
    }

    draw();
  }

  function endGame() {
    gameOver = true;
    clearInterval(timer);
    timer = null;
    messageEl.textContent = '游戏结束！按空格键重新开始';
    draw();
  }

  function draw() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    // Draw grid lines (subtle)
    ctx.strokeStyle = '#1a1a3e';
    for (let i = 0; i <= COLS; i++) {
      ctx.beginPath();
      ctx.moveTo(i * GRID, 0);
      ctx.lineTo(i * GRID, canvas.height);
      ctx.stroke();
    }
    for (let i = 0; i <= ROWS; i++) {
      ctx.beginPath();
      ctx.moveTo(0, i * GRID);
      ctx.lineTo(canvas.width, i * GRID);
      ctx.stroke();
    }

    // Draw food
    ctx.fillStyle = '#e74c3c';
    ctx.beginPath();
    ctx.arc(food.x * GRID + GRID / 2, food.y * GRID + GRID / 2, GRID / 2 - 2, 0, Math.PI * 2);
    ctx.fill();

    // Draw snake
    snake.forEach(function (seg, i) {
      ctx.fillStyle = i === 0 ? '#2ecc71' : '#27ae60';
      ctx.fillRect(seg.x * GRID + 1, seg.y * GRID + 1, GRID - 2, GRID - 2);
    });

    // Game over overlay
    if (gameOver) {
      ctx.fillStyle = 'rgba(0,0,0,0.55)';
      ctx.fillRect(0, 0, canvas.width, canvas.height);
      ctx.fillStyle = '#fff';
      ctx.font = 'bold 30px sans-serif';
      ctx.textAlign = 'center';
      ctx.fillText('游戏结束', canvas.width / 2, canvas.height / 2 - 10);
      ctx.font = '18px sans-serif';
      ctx.fillText('得分：' + score, canvas.width / 2, canvas.height / 2 + 20);
    }
  }

  document.addEventListener('keydown', function (e) {
    if (e.key === ' ' && gameOver) {
      e.preventDefault();
      init();
      return;
    }

    const key = e.key;
    if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(key)) {
      e.preventDefault();
    }

    if (key === 'ArrowUp' && direction.y !== 1) {
      nextDirection = { x: 0, y: -1 };
    } else if (key === 'ArrowDown' && direction.y !== -1) {
      nextDirection = { x: 0, y: 1 };
    } else if (key === 'ArrowLeft' && direction.x !== 1) {
      nextDirection = { x: -1, y: 0 };
    } else if (key === 'ArrowRight' && direction.x !== -1) {
      nextDirection = { x: 1, y: 0 };
    }

    if (!started && !gameOver) {
      started = true;
      messageEl.textContent = '';
      timer = setInterval(update, SPEED);
    }
  });

  init();
})();
</script>
</body>
</html>

```






AI使用指南(3)-基本功能和plan功能演示

在完成claude的安装之后，本文基于claude的简单命令进行介绍，用来进一步了解claude的基本使用技巧

# login
我们有两种办法登录，一个是订阅pro/max方法的登录，一个是apikey的登录。

关于apikey的登录上一个文章已经介绍了。这里介绍订阅的办法。

首先需要能够正常访问claude.ai，如下

![image.png](/static/img/9daaabb0eb60e1edf01615b582aff17e.image.webp)

如果不能访问此网站，需要做如下两个事情
* 你所在是不支持的国家
* 没有能够登录claude.ai的账号

如果登入进去之后，可以看到付费情况

![image.png](/static/img/df337df5ac33d184303a63295507a14e.image.webp)

此时我们需要手机付款，手机付款需要满足如下条件
* 非中国区域apple账号/android账号
* 支付宝购买礼品卡
* 购买pro/max会员

上面都完成了之后，首次登录需要login，此时敲入`/login`后信息如下

![image.png](/static/img/a8022275a5def4b8fe00c409a202f8ba.image.webp)

此时选择第一个 subscription 即可。然后在浏览器的url上成功验证登录即可

当login完成之后，

```
# claude
  ▐▛███▜▌   Claude Code v2.1.83
▝▜█████▛▘  Sonnet 4.6 · Claude Pro
  ▘▘ ▝▝    ~/
```
可以看到，claude pro订阅会员已经正常了。

# init
在一个仓库上进行自动分析代码和文本的时候，可以先尝试init进行分析。这样可以在本地创建记忆文件CLAUDE.md，下次再加载的时候，不需要重复学习
```
● Explore(Explore codebase structure)
  ⎿  Done (8 tool uses · 28.4k tokens · 28s)
  (ctrl+o to expand)

● Write(CLAUDE.md)
  ⎿  Wrote 33 lines to CLAUDE.md
     # CLAUDE.md

     This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

     ## Running the Server

     ```bash
     # Default upload directory (./uploads)
     python3 run.py

     … +23 lines (ctrl+o to expand)

● Created CLAUDE.md. It covers:
  - How to run the server (with default and custom upload dir)
  - The single-file architecture and key components
  - Security measures already implemented

✻ Sautéed for 51s

```
可以看到claude会自动分析，探索当前目录的下的一切内容，最终生成一份记忆给你
# memory
可以针对当前项目自动生成的`CLAUDE.md`进行自我改造，调整记忆中和你认为偏差的地方
```
❯ /memory

─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Memory

    Auto-memory: on
    Auto-dream: off · never

  ❯ 1. Project memory           Saved in ./CLAUDE.md
    2. User memory              Saved in ~/.claude/CLAUDE.md
    3. Open auto-memory folder

  Learn more: https://code.claude.com/docs/en/memory
```
此时可以随时修改 当前目录/当前用户/自动记忆 三个地方的记忆

# permissions
管理权限，默认情况下每次write和select都会提醒你选择，你可以管理你的权限，如下
```
❯ /permissions

─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Permissions:  Allow   Ask   Deny   Workspace

  Claude Code can read files in the workspace, and make edits when auto-accept edits is on.

    -  ~/fileupload (Original working directory)
    1. Add directory…
```
当前，也可以管理claude接管的所有目录，当你涉及的目录很多的时候，可以直接通过此命令管理
# context
不同的模型可拥有的上下文长度不一样，可以实时的查看自己用了多少的上下文，如下
```
❯ /context
  ⎿  Context Usage
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛁   claude-sonnet-4-6 · 20k/200k tokens (10%)
     ⛁ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 6.9k tokens (3.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 8.1k tokens (4.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Memory files: 346 tokens (0.2%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Skills: 776 tokens (0.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Messages: 4.3k tokens (2.1%)
     ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛶ Free space: 147k (73.3%)
     ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛝ Autocompact buffer: 33k tokens (16.5%)
```
可以看到，我这里总共200k的上下文使用了20k上下文。并且提供了tokens的分类。
# clear
如果一次问答完成，可以清空上下文，让claude给你干下一份工作
```
❯ /clear
  ⎿  (no content)

❯ /context
  ⎿  Context Usage
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛀   claude-sonnet-4-6 · 16k/200k tokens (8%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 6.9k tokens (3.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 8.1k tokens (4.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Memory files: 346 tokens (0.2%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Skills: 776 tokens (0.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Messages: 110 tokens (0.1%)
     ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛶ Free space: 151k (75.4%)
     ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛝ Autocompact buffer: 33k tokens (16.5%)
```
这里可以看到，我clear之后并没有清空我的上下文，主要原因是我自己安装了agent，skill，plugin，mcp，这些东西的description会占用我的上下文。

也就是说，如果你真的很少用到这些skill，清空你的skill是你最佳选择

# effort
我们可以随时调整claude的推理等级（low/medium/high/max），通过effort可以看到当前的推理等级
```
❯ /effort
  ⎿  Effort level: auto (currently medium)
```
# model
同样也可以在里面选择模型，订阅用户可以有如下选项自行选择
```
❯ /model

─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Select model
  Switch between Claude models. Applies to this session and future Claude Code sessions. For other/previous model names, specify with --model.

  ❯ 1. Default (recommended) ✔  Sonnet 4.6 · Best for everyday tasks
    2. Opus                     Opus 4.6 · Most capable for complex work
    3. Haiku                    Haiku 4.5 · Fastest for quick answers

  ◐ Medium effort (default) ← → to adjust
```
默认情况下Opus更聪明，我们可以选择Opus
# resume
默认情况下，每次我们打开一个claude的时候都重新创建了一次会话，而实际在使用过程中，我们经常期望接着之前的工作继续做，所以可以使用resume唤醒之前的会话
```
Resume Session
╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ⌕ Search…                                                                                                                                                                                                                                 │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

❯ /init
  1 hour ago · HEAD · 74.2KB

  Ctrl+A to show all projects · Ctrl+B to toggle branch · Ctrl+V to preview · Ctrl+R to rename · Type to search · Esc to cancel ·

```
正常情况下这里会提供之前使用的所有会话。除非你手动clear过

# 其他基本命令

```
/help	显示帮助信息及可用命令列表
/model	切换或查看当前使用的 AI 模型
/cost	显示当前会话的 Token 使用量和预估费用
/stats	显示当前会话的详细统计数据（如请求次数、Token 消耗等）
/clear	清除终端屏幕上的对话内容
/reset	重置当前对话上下文（清空历史记录，重新开始）
/undo	撤销上一步对文件进行的更改
/retry	重新运行上一个请求
/compact	压缩对话上下文以节省 Token 空间
/config	查看或修改 Claude Code 的配置（如设置、忽略规则等）
/bug	报告错误或向 Anthropic 提供反馈
/init	在当前目录初始化 Claude Code 配置
/exit	退出当前 Claude Code 会话
/resume	切换到其他会话
/rename	重命名当前会话
/memory	查看/编辑 CLAUDE.md 和自动记忆
/permissions	查看/管理权限规则
/hooks	浏览已配置的 Hooks
/agents	创建/管理子代理
/commit	创建 Git 提交
/context	检查上下文窗口使用情况
/effort	设置推理努力等级（low/medium/high/max）
/vim	切换 Vim 编辑模式
/theme	更换终端主题
/terminal-setup	配置终端功能
/statusline	设置状态栏显示
/desktop	发送会话到桌面应用
/teleport	拉取 Web 会话到终端
/btw	快速旁问（不影响对话历史）
```
当然，这里还有三个很重要的命令，后续会逐一介绍，分别为
```
/branch  为此刻创建分支，让你思维存在分支
/rewind  主动移除之前错误的对话
/btw     问一些无关当前探索的问题，不污染当前上下文
```
# 总结
本文介绍了claude的基本命令使用技巧，掌握这些基本命令就可以进行claude的基础使用了。接下来以一个实际的例子来演示claude的基础使用

AI使用指南(2)-基本命令使用

本文介绍ubuntu2404上的opengrok搭建步骤，opengrok是专用于大型代码查看的工具。通过ctags支持源码搜索。本步骤涉及的安装组件有三个： opengrok，tomcat，ctags

# tomcat
```
apt install -y tomcat10
```
如果没有java的话，安装一下java
```
apt install openjdk-21-jdk
```
此时重启tomcat10可以看到服务应该正常
```
systemctl restart tomcat10
```
网页登录后看到如下画面即可

![image.png](/static/img/c9ba51f03fcf46a0293b1a127ec5b968.image.webp)

# ctags
下载代码和安装
```
    $ git clone https://github.com/universal-ctags/ctags.git
    $ cd ctags
    $ ./autogen.sh
    $ ./configure  # use --prefix=/where/you/want to override installation directory, defaults to /usr/local
    $ make
    $ make install # may require extra privileges depending on where to install
```
# opengrok
我们先找到最新的opengrok的release

![image.png](/static/img/fc80ae1f0eb012495661e6e081e6a65e.image.webp)

此时拉取release bin即可
```
wget https://github.com/oracle/opengrok/releases/download/1.14.11/opengrok-1.14.11.tar.gz
```
将其解压
```
tar xvzf opengrok-1.14.11.tar.gz
```
然后找到安装python管理工具
```
python3 -m pip install tools/opengrok-tools.tar.gz
```
创建工作目录
```
export OPENGROK_HOME=/root/work/opengrok/opengrok-1.14.11
mkdir OPENGROK_HOME/{src,data,dist,etc,log}
```
复制war包给tomcat
```
cp $OPENGROK_HOME/lib/source.war /var/lib/tomcat10/webapps/
```
修改tomcat的端口，这里以22222端口为例
```
vim /etc/tomcat10/server.xml
    <Connector port="22222" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               maxParameterCount="1000"
               />

```
再次重启tomcat
```
systemctl restart tomcat10
```
我们22222端口能进入即可，此时进入`localhost:22222/source`可以看到初始化页面如下

![image.png](/static/img/29eec98f73a4e09e4621f303eef80738.image.webp)

注意，此时没有Repository和Project

# index
接下来就是索引代码仓库了，因为我需要反复阅读内核代码，所以索引内核源码，如下
```
ln -sf path/to/kernel $OPENGROK_HOME/src/kernel
```
这样我们开始index，index的脚本如下
```
export OPENGROK_HOME=/root/work/opengrok/opengrok-1.14.11

java -Xmx16g \
    -Djava.util.logging.config.file=${OPENGROK_HOME}/doc/logging.properties \
    -jar ${OPENGROK_HOME}/lib/opengrok.jar \
    -c /usr/local/bin/ctags \
    -s ${OPENGROK_HOME}/src/ -d ${OPENGROK_HOME}/data -P -S -G \
    -W ${OPENGROK_HOME}/etc/configuration.xml -U http://localhost:22222/source
```
注意，如果需要索引git commit信息，那么加上`-H`，不过会浪费内存。

因为我是mainline kernel，commit message实在太多，索引不了，所以没有`-H`

这里索引会大概1-2小时，等待结束即可

# 最终效果
当索引完成之后，我们直接登入`localhost:22222/source`再看

![image.png](/static/img/d8bb24510f0cbc55ae354c3d2cfffa22.image.webp)

可以看到有kernel仓库了，我们直接找关键函数，例如`scheduler_tick`,直接找到信息如下

![image.png](/static/img/e5397f7e8939d8fcb0ad61ed1a3e9fdc.image.webp)

可以看到，准确找到了sched/core.c的位置

# 参考
> https://github.com/oracle/opengrok/wiki/How-to-setup-OpenGrok


opengrok搭建

今年26年一开始，工作性质就来了王炸，claude在工作的高效使用使得绝大部分专业人士都在推崇ai。当然，最近还有另一个东西很火，那就是openclaw，我也把openclaw搭建在自己的服务器上。可是我个人观点是，对于专业技术行业，我们更需要的是claude，而不是openclaw。

对于claude还是openclaw我们可以思考一下，我们自己更需要的是更强大的大脑，还是替你干活的小弟。

对我而言，我认为最需要的是更强大的大脑。所以，关于ai系列的文章，我选中claude而不是openclaw。

# 什么是claude
Claude 是 Anthropic 公司开发的专有大语言模型系列，Claude 强调少幻觉、更诚实、更安全，特别适合编码、文档分析、金融法律推理和企业级自动化场景

正是这些优点，使得目前绝大部分公司内的工作都可以让Claude代替你。

但是值得注意的是，是claude代替你，而不是openclaw代替你。

打个比方，openclaw是你的私人管家，它可以调用各种应用程序来执行任务，它干的活是你本身会的活

而claude更像是一个顶级大脑，超强的推理和编码，我们只需要提供想法，它能够聪明的自主完成工作。

也就是说，充分的使用claude，是我们工作性质接下来一环我认为必不可少的一个技能。

claude的最佳场景：
1. 软件开发全流程（架构设计、编码、调试、审查）。
2. 企业知识工作（合同分析、金融建模、法律研究、多文档总结）。
3. 自动化工作流（Agent Teams 处理跨工具任务）。
4. 教育、研究与内容创作（准确性要求高）。

大家可以对号入座，哪些场景是能够让claude替代我们工作的。

举个我构想的例子：

一个软件公司，从 测试环境，测试执行，BUG系统，日志分析，调试设备，代码提交，代码审核，问题复盘，问题汇总，代码注释，设计文档，技术方案 都可以让claude完美的接管执行。那么每个公司和部门只需要plugin和skills就可以替代这些工作内容了。

# claude的缺点
Claude的缺点我认为如下
1. 如何更精准的描述你的需求
2. 如何将工作抽象成skill/plugin
3. 如何让claude为你24小时干活

简单来说就是，怎么将Claude用的更好，就是每个人的实际竞争力。

当然，我仅仅针对个人工作观点，个人工作主要涉及操作系统及底层，其他非此行业不做评价。

# 安装
鉴于不是每个人都会linux，虽然我大部分时间都在linux上操作，为了更多的受众，我以windows为例介绍claude的搭建，比较claude搭建非常简单，跟着下面的办法就能够很快的将claude环境搭建成功。

## nvm安装
我们可以使用nvm来一键安装claude，所以先安装nvm，访问github
> https://github.com/coreybutler/nvm-windows/releases


![image.png](/static/img/9aecd6e11d91604bf628264e467ae269.image.webp)

下载后点击安装即可。

安装完成之后可以看到版本生效
```
nvm --version
1.2.2
```
## nodejs安装
管理员打开powershell，如下运行
```
# 安装最新 LTS 版本
nvm install lts

# 使用该版本
nvm use lts
```
安装完成之后，验证是否成功
```
node --version
v12.16.2
npm --version
11.9.0
```
## 安装claude
这里直接npm安装
```
npm install -g @anthropic-ai/claude-code
```

当然也有很多其他办法安装，claude官网说的很详细，可以自行查看
> https://claude.ai/downloads

安装成功后，查看版本
```
claude --version
2.1.78 (Claude Code)
```
## 配置config
我们直接创建.claude目录，如下命令
```
New-Item -Path "$env:USERPROFILE\.claude" -ItemType Directory -Force
```
可以看到创建成功
```


    目录: C:\Users\xxx


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----         2026/3/18     23:09                .claude
```
接下来新建文件，如下
```
@"
{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "YOUR_API_KEY",
    "ANTHROPIC_BASE_URL": "YOUR_BASE_URL",
    "ANTHROPIC_MODEL": "YOUR_MODEL"
  },
  "enabledPlugins": {
    "gopls-lsp@claude-plugins-official": true
  }
}
"@ | Out-File -FilePath "$env:USERPROFILE\.claude\settings.json" -Encoding UTF8
```
此时找到`C:\Users\xxx\.claude`目录，打开settings.json，我们需要填入
* YOUR_API_KEY
* YOUR_BASE_URL
* YOUR_MODEL

填入之后启动claude会提示如下错误
```
 Unable to connect to Anthropic services

 Failed to connect to api.anthropic.com: ERR_BAD_REQUEST

 Please check your internet connection and network settings.

 Note: Claude Code might not be available in your country. Check supported countries at
 https://anthropic.com/supported-countries
```
我们运行如下
```
@"
{
  "hasCompletedOnboarding": true
}
"@ | Out-File -FilePath "$env:USERPROFILE\.claude.json" -Encoding UTF8
```
然后输入claude即可出现如下画面
```
 claude

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Accessing workspace:

 C:\WINDOWS\system32

 Quick safety check: Is this a project you created or one you trust? (Like your own code, a well-known open source
 project, or work from your team). If not, take a moment to review what's in this folder first.

 Claude Code'll be able to read, edit, and execute files here.

 Security guide

 > 1. Yes, I trust this folder
   2. No, exit

 Enter to confirm · Esc to cancel
```
此时正常了如下
```
 claude                                                                                          ╭─── Claude Code v2.1.78 ──────────────────────────────────────────────────────────────────────────────────────────╮
│                                              │ Tips for getting started                                          │
│                 Welcome back!                │ Run /init to create a CLAUDE.md file with instructions for Claude │
│                                              │ ───────────────────────────────────────────────────────────────── │
│                    ▐▛███▜▌                   │ Recent activity                                                   │
│                   ▝▜█████▛▘                  │ No recent activity                                                │
│                     ▘▘ ▝▝                    │                                                                   │
│                                              │                                                                   │
│   qwen-max             · API Usage Billing   │                                                                   │
│             D:\claude                        │                                                                   │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

  ↑ Opus now defaults to 1M context · 5x more room, same pricing

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
> Try "edit <filepath> to..."
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ? for shortc… Claude Code has switched from npm to nativeinstall er. Run ` laude install` or see https://docs.anth…
```

# 总结
到这里claude就完全安装成功了。





















AI使用指南(1)-claude介绍

下面继续分析其他的patch
# [PATCH 12/15] sched: Introduce latency-nice as a per-task attribute
这里为 task_struct 提供了 latency_prio 字段，类似于 weight 的 nice value，所以latency_prio越低，则时延要求越高。
```
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -791,6 +791,7 @@ struct task_struct {
 	int				static_prio;
 	int				normal_prio;
 	unsigned int			rt_priority;
+	int				latency_prio;
 
 	struct sched_entity		se;
 	struct sched_rt_entity		rt;

```
所以新增一个 SCHED_FLAG_LATENCY_NICE 代表 用户态可以通过 sched_setattr 来定制化 sched_latency_nice
```
--- a/include/uapi/linux/sched.h
+++ b/include/uapi/linux/sched.h
@@ -132,6 +132,7 @@ struct clone_args {
 #define SCHED_FLAG_KEEP_PARAMS		0x10
 #define SCHED_FLAG_UTIL_CLAMP_MIN	0x20
 #define SCHED_FLAG_UTIL_CLAMP_MAX	0x40
+#define SCHED_FLAG_LATENCY_NICE		0x80
 
 #define SCHED_FLAG_KEEP_ALL	(SCHED_FLAG_KEEP_POLICY | \
 				 SCHED_FLAG_KEEP_PARAMS)
@@ -143,6 +144,7 @@ struct clone_args {
 			 SCHED_FLAG_RECLAIM		| \
 			 SCHED_FLAG_DL_OVERRUN		| \
 			 SCHED_FLAG_KEEP_ALL		| \
-			 SCHED_FLAG_UTIL_CLAMP)
+			 SCHED_FLAG_UTIL_CLAMP		| \
+			 SCHED_FLAG_LATENCY_NICE)
 
 #endif /* _UAPI_LINUX_SCHED_H */

```
 sched_latency_nice的范围是 -20 至 19 
```
 /*
  * Extended scheduling parameters data structure.
@@ -98,6 +99,22 @@ struct sched_param {
  * scheduled on a CPU with no more capacity than the specified value.
  *
  * A task utilization boundary can be reset by setting the attribute to -1.
+ *
+ * Latency Tolerance Attributes
+ * ===========================
+ *
+ * A subset of sched_attr attributes allows to specify the relative latency
+ * requirements of a task with respect to the other tasks running/queued in the
+ * system.
+ *
+ * @ sched_latency_nice	task's latency_nice value
+ *
+ * The latency_nice of a task can have any value in a range of
+ * [MIN_LATENCY_NICE..MAX_LATENCY_NICE].
+ *
+ * A task with latency_nice with the value of LATENCY_NICE_MIN can be
+ * taken for a task requiring a lower latency as opposed to the task with
+ * higher latency_nice.
  */
 struct sched_attr {
 	__u32 size;
@@ -120,6 +137,8 @@ struct sched_attr {
 	__u32 sched_util_min;
 	__u32 sched_util_max;
 
+	/* latency requirement hints */
+	__s32 sched_latency_nice;
 };
 
 #endif /* _UAPI_LINUX_SCHED_TYPES_H */

```
其初始值是 DEFAULT_PRIO
```
--- a/init/init_task.c
+++ b/init/init_task.c
@@ -78,6 +78,7 @@ struct task_struct init_task
 	.prio		= MAX_PRIO - 20,
 	.static_prio	= MAX_PRIO - 20,
 	.normal_prio	= MAX_PRIO - 20,
+	.latency_prio	= DEFAULT_PRIO,
 	.policy		= SCHED_NORMAL,
 	.cpus_ptr	= &init_task.cpus_mask,
 	.user_cpus_ptr	= NULL,
@@ -89,7 +90,7 @@ struct task_struct init_task
 		.fn = do_no_restart_syscall,
 	},

```
fork的时候，prio是 nice 0
```
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -4719,6 +4719,8 @@ int sched_fork(unsigned long clone_flags
 		p->prio = p->normal_prio = p->static_prio;
 		set_load_weight(p, false);
 
+		p->latency_prio = NICE_TO_PRIO(0);
+
 		/*
 		 * We don't need the reset flag anymore after the fork. It has
 		 * fulfilled its duty:

```
__sched_setscheduler 的具体实现
```
+static void __setscheduler_latency(struct task_struct *p,
+				   const struct sched_attr *attr)
+{
+	if (attr->sched_flags & SCHED_FLAG_LATENCY_NICE)
+		p->latency_prio = NICE_TO_PRIO(attr->sched_latency_nice);
+}
+
 /*
  * Check the target process has a UID that matches the current process's:
  */
@@ -7641,6 +7650,13 @@ static int __sched_setscheduler(struct t
 			return retval;
 	}
 
+	if (attr->sched_flags & SCHED_FLAG_LATENCY_NICE) {
+		if (attr->sched_latency_nice > MAX_NICE)
+			return -EINVAL;
+		if (attr->sched_latency_nice < MIN_NICE)
+			return -EINVAL;
+	}
+
 	if (pi)
 		cpuset_read_lock();
 
@@ -7675,6 +7691,9 @@ static int __sched_setscheduler(struct t
 			goto change;
 		if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP)
 			goto change;
+		if (attr->sched_flags & SCHED_FLAG_LATENCY_NICE &&
+		    attr->sched_latency_nice != PRIO_TO_NICE(p->latency_prio))
+			goto change;
 
 		p->sched_reset_on_fork = reset_on_fork;
 		retval = 0;
@@ -7763,6 +7782,7 @@ static int __sched_setscheduler(struct t
 		__setscheduler_params(p, attr);
 		__setscheduler_prio(p, newprio);
 	}
+	__setscheduler_latency(p, attr);
 	__setscheduler_uclamp(p, attr);

```
# [PATCH 13/15] sched/fair: Implement latency-nice

新增设置 latency_prio 函数
```
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -1305,6 +1305,12 @@ static void set_load_weight(struct task_
 	}
 }
 
+static inline void set_latency_prio(struct task_struct *p, int prio)
+{
+	p->latency_prio = prio;
+	set_latency_fair(&p->se, prio - MAX_RT_PRIO);
+}
+

```
然后使用接口来实现设置latency prio，这样可以获得如下映射
* latency-nice 19: ~204.8ms (尽力而为)
* latency-nice -20: ~0.034ms (极低延迟)

```
 /*
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -952,6 +952,21 @@ int sched_update_scaling(void)
 }
 #endif
 
+void set_latency_fair(struct sched_entity *se, int prio)
+{
+	u32 weight = sched_prio_to_weight[prio];
+	u64 base = sysctl_sched_base_slice;
+
+	/*
+	 * For EEVDF the virtual time slope is determined by w_i (iow.
+	 * nice) while the request time r_i is determined by
+	 * latency-nice.
+	 *
+	 * Smaller request gets better latency.
+	 */
+	se->slice = div_u64(base << SCHED_FIXEDPOINT_SHIFT, weight);
+}
+

```
set_latency_fair 在 set_latency_prio 下使用，这里乘以1024，然后除上weight来计算期望的slice

# [PATCH 14/15] sched/fair: Add sched group latency support
这笔patch针对 cgroup 的 task_group 来完善set latency
```
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -378,6 +378,8 @@ struct task_group {
 
 	/* A positive value indicates that this is a SCHED_IDLE group. */
 	int			idle;
+	/* latency priority of the group. */
+	int			latency_prio;
 
 #ifdef	CONFIG_SMP
 	/*
@@ -488,6 +490,8 @@ extern int sched_group_set_shares(struct
 
 extern int sched_group_set_idle(struct task_group *tg, long idle);
 
+extern int sched_group_set_latency(struct task_group *tg, int prio);
+

```
```
+static int cpu_latency_nice_write_s64(struct cgroup_subsys_state *css,
+				     struct cftype *cft, s64 nice)
+{
+	int prio;
+
+	if (nice < MIN_NICE || nice > MAX_NICE)
+		return -ERANGE;
+
+	prio = NICE_TO_PRIO(nice);
+
+	return sched_group_set_latency(css_tg(css), prio);
+}
 #endif

```
```
@@ -11408,6 +11432,12 @@ static struct cftype cpu_files[] = {
 		.read_s64 = cpu_idle_read_s64,
 		.write_s64 = cpu_idle_write_s64,
 	},
+	{
+		.name = "latency.nice",
+		.flags = CFTYPE_NOT_ON_ROOT,
+		.read_s64 = cpu_latency_nice_read_s64,
+		.write_s64 = cpu_latency_nice_write_s64,
+	},
 #endif
 #ifdef CONFIG_CFS_BANDWIDTH

```
这样在cgroup v2上的cpu.latency.nice，直接作用到cpu_latency_nice_read_s64和cpu_latency_nice_write_s64上

同样

新增的 sched_group_set_latency 可以对 task_group 更新 latency prio，这里lantency prio 一旦更新，group 下所有 se 的 slice 值也同步更新

# [PATCH 15/15] sched/eevdf: Use sched_attr::sched_runtime to set request/slice
```
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -7494,10 +7494,18 @@ static void __setscheduler_params(struct
 
 	p->policy = policy;
 
-	if (dl_policy(policy))
+	if (dl_policy(policy)) {
 		__setparam_dl(p, attr);
-	else if (fair_policy(policy))
+	} else if (fair_policy(policy)) {
 		p->static_prio = NICE_TO_PRIO(attr->sched_nice);
+		if (attr->sched_runtime) {
+			p->se.slice = clamp_t(u64, attr->sched_runtime,
+					      NSEC_PER_MSEC/10,   /* HZ=1000 * 10 */
+					      NSEC_PER_MSEC*100); /* HZ=100  / 10 */
+		} else {
+			p->se.slice = sysctl_sched_base_slice;
+		}
+	}
 
 	/*
 	 * __sched_setscheduler() ensures attr->sched_priority == 0 when
@@ -7689,7 +7697,9 @@ static int __sched_setscheduler(struct t
 	 * but store a possible modification of reset_on_fork.
 	 */
 	if (unlikely(policy == p->policy)) {
-		if (fair_policy(policy) && attr->sched_nice != task_nice(p))
+		if (fair_policy(policy) &&
+		    (attr->sched_nice != task_nice(p) ||
+		     (attr->sched_runtime && attr->sched_runtime != p->se.slice)))
 			goto change;
 		if (rt_policy(policy) && attr->sched_priority != p->rt_priority)
 			goto change;
@@ -8017,12 +8027,14 @@ static int sched_copy_attr(struct sched_
 
 static void get_params(struct task_struct *p, struct sched_attr *attr)
 {
-	if (task_has_dl_policy(p))
+	if (task_has_dl_policy(p)) {
 		__getparam_dl(p, attr);
-	else if (task_has_rt_policy(p))
+	} else if (task_has_rt_policy(p)) {
 		attr->sched_priority = p->rt_priority;
-	else
+	} else {
 		attr->sched_nice = task_nice(p);
+		attr->sched_runtime = p->se.slice;
+	}
 }
 
 /**

```
鉴于某些应用有精确的延迟要求，这里提供更精确的设置办法

# 总结
EEVDF的patch基本上都分析完成了，关于调度相关的原理的东西基本完结，但是针对调度而言，个人认为还有如下未尽事宜。
1. sched_ext 原理
2. eas 调度
3. PREEMPT_RT 补丁
4. RTLA分析：https://retis.sssup.it/~d.casini/papers/2025/TC2025/Timerlat_TC.pdf
5. Deadline 调度
6. bench工具：Schbench/Hackbench/Cyclictest
7. 维测工具：perfetto

鉴于现在AI特别的火，系统性的学习AI也至关重要，上面未尽事宜等什么时候有空再更新。转战AI。


# 参考
> https://lore.kernel.org/lkml/20230531124604.410388887@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.477939524@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.546980086@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.615053451@infradead.org/










