从 Prompt Engineering 到 Harness Engineering：AI 编程的四次进化

# 自定义 ESLint 规则：禁止前端直接访问 localStorage（必须走 Tauri 后端）
# .eslintrc.js
module.exports = {
  rules: {
    'no-restricted-globals': ['error', 'localStorage', 'sessionStorage'],
  }
};

# Rust clippy 配置：禁止 unwrap()，强制用 Result 处理错误
# clippy.toml
disallowed-methods = [
    { path = "core::result::Result::unwrap", reason = "Use ? or proper error handling" },
    { path = "core::option::Option::unwrap", reason = "Use ? or unwrap_or" },
]

// .dependency-cruiser.js 片段：前端不能直接 import 后端模块
module.exports = {
  forbidden: [{
    name: 'no-cross-boundary',
    from: { path: '^src/components/' },
    to: { path: '^src-tauri/' },
    comment: 'Frontend components must not import Rust backend directly'
  }]
};

// .claude/settings.json 中的 Hook 配置
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "cargo clippy --manifest-path src-tauri/Cargo.toml -- -D warnings 2>&1 | tail -5"
      }
    ],
    "PreCommit": [
      {
        "command": "cargo test --manifest-path src-tauri/Cargo.toml 2>&1 | tail -10"
      }
    ]
  }
}

// .claude/settings.json
{
  "mcpServers": {
    "sqlite-readonly": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-sqlite", "--readonly", "./data/todos.db"]
    }
  }
}

// .devcontainer/devcontainer.json
{
  "image": "rust:latest",
  "features": {
    "ghcr.io/devcontainers/features/node:1": {},
    "ghcr.io/devcontainers/features/rust:1": {}
  },
  "mounts": [
    "source=${localWorkspaceFolder},target=/workspace,type=bind"
  ]
}

#!/bin/bash
# scripts/doc-sync-check.sh
# 检查 README 中列出的 Tauri 命令是否与代码一致

readme_cmds=$(grep -oP '`\K[a-z_]+(?=`)' README.md | sort)
code_cmds=$(grep -oP '#\[tauri::command\]\s*pub fn \K[a-z_]+' src-tauri/src/commands/*.rs | sort)

diff <(echo "$readme_cmds") <(echo "$code_cmds") && echo "✅ Docs in sync" || echo "❌ Docs out of sync"

# CLAUDE.md - Tauri Todo App

## Project Overview
A cross-platform desktop Todo List app built with Tauri v2 + React + TypeScript.
Backend logic in Rust, frontend in React.

## Tech Stack
- Tauri v2 (latest stable)
- Rust (backend commands, state management, SQLite persistence)
- React 18 + TypeScript (frontend UI)
- SQLite via rusqlite (local data storage)
- TailwindCSS (styling)

## Architecture Rules
- All Tauri commands MUST be defined in `src-tauri/src/commands/` directory
- Each command module handles one domain (e.g., `todo.rs` for todo operations)
- State management uses Tauri's managed state (`tauri::State`)
- Frontend calls backend ONLY through `@tauri-apps/api/core.invoke()`
- NO direct filesystem access from frontend
- All data persistence goes through Rust/SQLite, never localStorage

## Code Style
- Rust: follow `cargo clippy` suggestions, use `Result<T, E>` for all fallible operations
- TypeScript: strict mode, no `any` types
- All Tauri commands must return `Result<T, String>` for proper error handling
- Use serde for all Rust ↔ Frontend data serialization

## File Structure
src-tauri/
  src/
    main.rs          # Tauri app entry, register commands
    commands/
      mod.rs         # Re-export all command modules
      todo.rs        # Todo CRUD commands
    models/
      mod.rs
      todo.rs        # Todo struct with Serialize/Deserialize
    db.rs            # SQLite connection and migrations
src/
  App.tsx            # Main React component
  components/
    TodoList.tsx     # Todo list display
    TodoItem.tsx     # Single todo item
    AddTodo.tsx      # Add new todo form
  hooks/
    useTodos.ts      # Custom hook wrapping Tauri invoke calls
  types/
    todo.ts          # TypeScript types matching Rust structs

## Testing
- Rust: `cargo test` for backend logic
- Frontend: vitest for component tests
- Run `cargo clippy` before every commit

## Common Mistakes to Avoid
- Don't forget `#[tauri::command]` attribute on command functions
- Don't forget to register commands in `main.rs` via `.invoke_handler()`
- Always derive `Serialize, Deserialize` on structs passed to frontend
- Use `tauri::async_runtime` for async operations, not raw tokio

# 安装 pre-commit
pip install pre-commit

# 项目根目录创建 .pre-commit-config.yaml
cat > .pre-commit-config.yaml << 'EOF'
repos:
  - repo: local
    hooks:
      - id: cargo-clippy
        name: Rust Clippy
        entry: cargo clippy --manifest-path src-tauri/Cargo.toml -- -D warnings
        language: system
        pass_filenames: false
        types: [rust]
      - id: cargo-test
        name: Rust Tests
        entry: cargo test --manifest-path src-tauri/Cargo.toml
        language: system
        pass_filenames: false
        types: [rust]
      - id: typescript-check
        name: TypeScript Check
        entry: npx tsc --noEmit
        language: system
        pass_filenames: false
        types: [ts, tsx]
EOF

pre-commit install

# 初始化 Tauri 项目
npm create tauri-app@latest todo-app -- --template react-ts

# 进入项目目录
cd todo-app

# 把 CLAUDE.md 放进去，然后启动 Claude Code
claude

# 给 Agent 第一个任务
> 请按照 CLAUDE.md 的架构规范，实现 Todo 的 CRUD 功能。
> 先实现 Rust 后端：数据模型、SQLite 存储、Tauri 命令。
> 然后实现 React 前端：列表展示、添加、完成切换、删除。
> 每完成一个模块先跑 cargo test 和 cargo clippy 确认通过。

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Todo {
    pub id: i64,
    pub title: String,
    pub completed: bool,
    pub created_at: String,
}

#[derive(Debug, Deserialize)]
pub struct CreateTodo {
    pub title: String,
}

use tauri::State;
use crate::db::Database;
use crate::models::todo::{Todo, CreateTodo};

#[tauri::command]
pub fn list_todos(db: State<'_, Database>) -> Result<Vec<Todo>, String> {
    db.list_todos().map_err(|e| e.to_string())
}

#[tauri::command]
pub fn add_todo(db: State<'_, Database>, input: CreateTodo) -> Result<Todo, String> {
    db.add_todo(&input.title).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn toggle_todo(db: State<'_, Database>, id: i64) -> Result<Todo, String> {
    db.toggle_todo(id).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn delete_todo(db: State<'_, Database>, id: i64) -> Result<(), String> {
    db.delete_todo(id).map_err(|e| e.to_string())
}

import { useState, useEffect, useCallback } from "react";
import { invoke } from "@tauri-apps/api/core";
import type { Todo } from "../types/todo";

export function useTodos() {
  const [todos, setTodos] = useState<Todo[]>([]);

  const refresh = useCallback(async () => {
    const data = await invoke<Todo[]>("list_todos");
    setTodos(data);
  }, []);

  useEffect(() => { refresh(); }, [refresh]);

  const addTodo = async (title: string) => {
    await invoke("add_todo", { input: { title } });
    await refresh();
  };

  const toggleTodo = async (id: number) => {
    await invoke("toggle_todo", { id });
    await refresh();
  };

  const deleteTodo = async (id: number) => {
    await invoke("delete_todo", { id });
    await refresh();
  };

  return { todos, addTodo, toggleTodo, deleteTodo };
}

## Maintenance Rules
- Run `cargo clippy` and `cargo test` before every PR
- When adding a new command, ALWAYS update `main.rs` invoke_handler registration
- When adding a new Rust struct for frontend, ALWAYS add matching TypeScript type
- Keep README.md in sync with actual feature list

@startmindmap
* Harness Engineering
** 演进路径
*** Prompt Engineering\n(怎么问)
*** Context Engineering\n(给什么信息)
*** Skill Engineering\n(怎么干活)
*** Harness Engineering\n(在什么环境里干活)
** 三大支柱
*** Context Engineering
**** CLAUDE.md / AGENTS.md
**** 架构文档
**** 可观测性数据
*** Architectural Constraints
**** 依赖分层规则
**** 确定性 Linter
**** Pre-commit Hook
**** 结构化测试
*** Entropy Management
**** 文档一致性检查
**** 架构违规扫描
**** 命名规范巡检
** 实战：Tauri Todo App
*** CLAUDE.md 定义架构
*** Pre-commit 约束质量
*** Agent 生成代码
*** Clippy + Test 守门
@endmindmap