编程 Andrej Karpathy Skills 深度实战：当 AI 编程遇见四大原则——从提示词工程到生产级代码生成的完全指南（2026）

2026-06-09 23:45:52 +0800 CST views 6

Andrej Karpathy Skills 深度实战：当 AI 编程遇见四大原则——从提示词工程到生产级代码生成的完全指南（2026）

一、引言：AI 编程的范式革命

1.1 为什么我们需要重新审视 AI 辅助编程

2026 年的今天，AI 辅助编程已经从「玩具级」demo 进入了生产级工程实践。Claude Code、Cursor、Windsurf 等工具已经能够独立完成复杂的代码任务，但随之而来的问题是：AI 生成的代码质量参差不齐，错误假设、过度复杂化、跳过测试、随意修改已有代码等问题层出不穷。

根据 Andrej Karpathy 在 2025 年底的深度调研，AI 编程中存在四大核心陷阱：

  1. 错误假设：AI 经常基于错误的假设进行编码，不先理解现有代码结构和项目规范
  2. 过度复杂化：AI 倾向于写出「过度工程化」的代码，引入不必要的抽象和复杂性
  3. 跳过测试：AI 经常不写测试或者写出无法运行的测试
  4. 随意修改：AI 喜欢大规模重构已有代码，而不是进行精准的最小修改

正是基于这些深刻洞察，Andrej Karpathy 创建了 karpathy-skills 项目，一经发布便迅速登顶 GitHub Trending，目前 star 数已突破 149K+，成为 2026 年最受关注的 AI 编程规范项目。

1.2 karpathy-skills 的核心价值

karpathy-skills 不是普通的提示词集合，而是一套经过大量工程实践验证的 AI 编程方法论。它的核心价值体现在：

  • 四大原则框架：先理解再修改、最小变更、始终先写测试、保持代码简洁
  • 社区驱动：由 multica-ai 维护，吸收了数万名开发者的实践经验
  • 普适性强：不仅适用于 Claude Code，也可迁移到 Codex、Cursor 等 AI 编程工具
  • 可落地：提供可直接使用的 CLAUDE.md 配置文件和最佳实践

本文将深入剖析 karpathy-skills 的技术内幕，从原理到实践，从配置到落地，帮助你真正掌握 AI 编程的正确姿势。

二、四大原则框架深度解析

2.1 原则一：先理解再修改（Read Before Write）

核心思想：在写任何代码之前，AI 必须先理解现有代码的结构、规范和上下文。

这是最容易被 AI 忽略的原则。AI 经常在还没有完全理解现有代码的情况下就开始写代码，导致：

  • 引入与现有代码风格不一致的实现
  • 破坏已有的功能
  • 忽略项目的特定约定和规范

正确的做法：

// ❌ 错误示例：直接开始写代码
function calculateTotal(items: Item[]): number {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// ✅ 正确做法：先理解现有代码
// 1. 先读取项目的类型定义文件 (types.ts)
// 2. 查看已有的工具函数 (utils.ts)
// 3. 理解项目的错误处理模式
// 4. 了解项目的测试约定

// 假设项目已有 calculateSubtotal 函数：
function calculateSubtotal(items: Item[]): number {
  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

// 则 calculateTotal 应该这样实现：
function calculateTotal(items: Item[]): number {
  return calculateSubtotal(items) + calculateTax(items);
}

工程实践要点：

  1. 读取项目结构：在开始编码前，先用 ls、find 或 IDE 了解项目结构
  2. 阅读现有代码：找到相关的实现文件，理解代码逻辑
  3. 查看测试文件：了解项目的测试风格和约定
  4. 检查规范文件：如 .eslintrc、tsconfig.json、CONTRIBUTING.md 等

2.2 原则二：最小变更原则（Minimal Changes）

核心思想：只修改必须修改的部分，不要进行大规模重构。

AI 编程中最大的问题之一是「过度热情」——AI 经常在收到一个小的修改需求时，写出大规模的代码改动，引入不必要的风险。

最小变更的核心要点：

  • 精准定位：只修改与需求直接相关的代码
  • 不碰无关代码：不修改与需求无关的代码，即使它们看起来「不够优雅」
  • 保持兼容性：确保修改不会破坏现有功能
  • 避免重写：尽量不重写已有代码，除非有明确的理由
# ❌ 错误示例：过度工程化
class OrderProcessor:
    def __init__(self, db: Database, cache: Cache, logger: Logger):
        self.db = db
        self.cache = cache
        self.logger = logger
        self.retry_policy = RetryPolicy(max_retries=3, backoff_factor=2)
        self.metrics = MetricsCollector()
    
    def process(self, order: Order) -> Result:
        # 200 行代码...
        pass

# ✅ 正确示例：最小变更
# 需求：给 OrderProcessor 添加折扣计算功能
# 只添加必要的方法，不修改已有代码

class OrderProcessor:
    def __init__(self, db: Database):
        self.db = db
    
    def process(self, order: Order) -> Result:
        # 原有逻辑不变
        pass
    
    # 只添加需要的新功能
    def calculate_discount(self, order: Order) -> float:
        if order.customer.tier == 'gold':
            return order.total * 0.1
        return 0.0

最小变更的判断标准：

  1. 需求驱动：每一次修改都必须有明确的需求来源
  2. 测试覆盖：修改的代码必须有对应的测试
  3. 可回滚：修改应该是原子性的，可以单独回滚

2.3 原则三：始终先写测试（Test First）

核心思想：在写实现代码之前，先写测试用例。

这是保证代码质量的最有效方法。AI 经常跳过测试，或者写出无法运行的测试，导致：

  • 代码无法验证正确性
  • 后期发现 bug 时修复成本高昂
  • 破坏了 TDD（测试驱动开发）的最佳实践

测试优先的正确姿势：

// ❌ 错误示例：先写实现，后补测试
fn calculate_fibonacci(n: u32) -> u64 {
    if n <= 1 {
        return n as u64
    }
    let mut a = 0u64;
    let mut b = 1u64;
    for _ in 2..=n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    b
}

// 后面才补测试，而且测试可能不完整
#[test]
fn test_fibonacci() {
    assert_eq!(calculate_fibonacci(0), 0);
    assert_eq!(calculate_fibonacci(1), 1);
    // 缺少边界测试
}

// ✅ 正确做法：先写测试
#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_fibonacci_zero() {
        assert_eq!(calculate_fibonacci(0), 0);
    }
    
    #[test]
    fn test_fibonacci_one() {
        assert_eq!(calculate_fibonacci(1), 1);
    }
    
    #[test]
    fn test_fibonacci_large() {
        assert_eq!(calculate_fibonacci(92), 7540113804746346429);
    }
    
    #[test]
    fn test_fibonacci_sequence() {
        let expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34];
        for (i, &exp) in expected.iter().enumerate() {
            assert_eq!(calculate_fibonacci(i as u32), exp);
        }
    }
}

// 然后才写实现
fn calculate_fibonacci(n: u32) -> u64 {
    if n <= 1 {
        return n as u64
    }
    let mut a = 0u64;
    let mut b = 1u64;
    for _ in 2..=n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    b
}

测试先行的工程实践：

  1. 先写失败的测试：TDD 的核心是先写一个会失败的测试
  2. 最小测试用例：测试用例应该覆盖核心功能和边界条件
  3. 测试可运行：确保测试可以独立运行，不依赖���部��态
  4. 测试即文档：好的测试本身就是最好的文档

2.4 原则四：保持代码简洁（Keep It Simple）

核心思想：用最少的代码解决问题，不要「过度设计」。

AI 倾向于写出复杂的代码，引入不必要的抽象层次、设计模式和复杂性。简洁的代码更容易理解、维护和调试。

简洁代码的原则：

// ❌ 错误示例：过度设计
interface IProcessor {
    process(data: Input): Output;
    validate(input: Input): boolean;
    transform(input: Input): TransformedInput;
    aggregate(results: Result[]): Output;
}

abstract class BaseProcessor implements IProcessor {
    protected abstract process(data: Input): Output;
    
    validate(input: Input): boolean {
        return input != null && input.data != undefined;
    }
    
    transform(input: Input): TransformedInput {
        return {
            ...input,
            timestamp: Date.now()
        };
    }
    
    aggregate(results: Result[]): Output {
        return results.reduce((acc, r) => ({
            ...acc,
            total: acc.total + r.value
        }), { total: 0 });
    }
}

class ConcreteProcessor extends BaseProcessor {
    process(data: Input): Output {
        const transformed = this.transform(data);
        // 50 行复杂逻辑...
        return this.aggregate(results);
    }
}

// ✅ 正确示例：简洁优先
function processOrder(order: Order): OrderResult {
    if (!order.items.length) {
        return { total: 0, status: 'empty' };
    }
    
    const subtotal = order.items.reduce(
        (sum, item) => sum + item.price * item.quantity, 
        0
    );
    
    const discount = order.customer.tier === 'gold' 
        ? subtotal * 0.1 
        : 0;
    
    return {
        total: subtotal - discount,
        status: 'processed',
        items: order.items.length
    };
}

简洁判断的标准：

  1. 一行代码能解决的吗？：如果一行代码能解决，不要写十行
  2. 需要这个抽象吗？：如果没有明确的复用需求，不要创建接口或抽象类
  3. 需要这个模式吗？：只有在确实需要的时候才使用设计模式
  4. 代码即文档：好的代码不需要太多注释

三、CLAUDE.md 配置文件深度解析

3.1 CLAUDE.md 的工作原理

karpathy-skills 的核心是一个名为 CLAUDE.md 的配置文件，它会被 Claude Code 自动加载为系统提示词的一部分。这个文件包含了：

  • 项目规范：项目的代码风格、约定和最佳实践
  • 工作流程：如何处理任务的标准化流程
  • 四大原则：具体的实施指南
  • 示例：正确和错误的代码示例
# CLAUDE.md - AI Coding Assistant Configuration

## Project Context
- Language: TypeScript
- Framework: Node.js + Express
- Testing: Vitest + Supertest
- Linting: ESLint + Prettier

## Coding Principles

### 1. Read Before Write
Always explore the codebase before making changes:
1. Check project structure with `ls -la`
2. Find related files using grep/find
3. Read existing implementations
4. Understand testing patterns

### 2. Minimal Changes
- Only modify what's necessary
- Avoid refactoring unrelated code
- Keep changes atomic and reviewable

### 3. Test First
- Write failing test before implementation
- Tests must be runnable independently
- Cover edge cases

### 4. Keep It Simple
- Prefer simple solutions over complex ones
- Don't over-engineer
- Code should be self-documenting

## Common Pitfalls to Avoid

### Wrong: Adding unnecessary abstractions
```typescript
// Don't create interfaces when not needed
interface IDataProcessor { ... }

Wrong: Large refactoring

// Don't rewrite entire files for small changes

Wrong: Skipping tests

// Always write tests first


### 3.2 如何在项目中配置 CLAUDE.md

**步骤 1：克隆或复制 karpathy-skills**

```bash
# 方式一：直接使用 karpathy-skills
git clone https://github.com/andrej-karpathy/skills.git
cp skills/CLAUDE.md ./

# 方式二：fork 并自定义
git fork https://github.com/your-username/skills
# 然后修改 CLAUDE.md 适配你的项目

步骤 2：自定义 CLAUDE.md

# CLAUDE.md - My Project

## Project Context
- Language: Python 3.11+
- Framework: FastAPI + SQLAlchemy
- Testing: pytest
- Database: PostgreSQL

## Team Conventions

### Naming
- Functions: snake_case
- Classes: PascalCase
- Constants: UPPER_SNAKE_CASE

### Testing
- Test file naming: test_*.py
- Test class naming: TestClassName
- One assertion per test when possible

### Error Handling
- Use custom exceptions
- Log errors with context
- Return appropriate HTTP codes

步骤 3：验证配置

# 测试 CLAUDE.md 是否正确加载
claude --version

# 验证项目配置
claude config validate

四、生产级实战案例

4.1 案例一：添加新功能的正确流程

需求：在 FastAPI 项目中添加用户注册功能

正确流程：

# 1. 先理解现有代码
ls -la app/
cat app/models.py
cat app/schemas.py
cat app/crud.py

# 2. 查看测试文件结构
ls -la tests/
cat tests/test_user.py

# 3. 写测试（先失败）
# tests/test_user.py
import pytest
from fastapi.testclient import TestClient
from app.main import app
from app.models import User

client = TestClient(app)

def test_register_user():
    response = client.post(
        "/users/register",
        json={
            "email": "test@example.com",
            "password": "securepass123",
            "name": "Test User"
        }
    )
    assert response.status_code == 201
    data = response.json()
    assert data["email"] == "test@example.com"
    assert "password" not in data  # 密码不应该返回

def test_register_duplicate_email():
    # 先创建一个用户
    client.post("/users/register", json={
        "email": "dup@example.com",
        "password": "pass123",
        "name": "First"
    })
    
    # 尝试重复注册
    response = client.post("/users/register", json={
        "email": "dup@example.com",
        "password": "pass456",
        "name": "Second"
    })
    assert response.status_code == 400

# 4. 最小变更实现
# app/crud.py
def create_user(db: Session, user: UserCreate) -> User:
    # 检查邮箱是否已存在
    existing = db.query(User).filter(User.email == user.email).first()
    if existing:
        raise HTTPException(status_code=400, detail="Email already registered")
    
    # 创建用户
    hashed_password = hash_password(user.password)
    db_user = User(
        email=user.email,
        hashed_password=hashed_password,
        name=user.name
    )
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

4.2 案例二：修复 Bug 的正确流程

需求：修复用户登录后 token 过期时间计算错误

正确流程：

# 1. 定位问题
# 先找到相关代码
grep -r "token" app/auth.py
grep -r "expire" app/

# 2. 理解现有逻辑
cat app/auth.py

# 3. 写测试复现 bug
# tests/test_auth.py
def test_token_expiry():
    # 生成 token
    token = create_access_token({"sub": "user@example.com"})
    
    # 解码 token
    payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
    
    # 验证过期时间（当前是 24 小时）
    exp = payload.get("exp")
    now = int(datetime.utcnow().timestamp())
    
    # 应该是 24 小时 = 86400 秒
    assert exp - now == 86400, f"Expected 86400, got {exp - now}"

4.3 案例三：数据库迁移的正确流程

需求：给用户表添加 last_login 字段

正确流程：

# 1. 创建迁移文件
# migrations/versions/add_last_login.py
"""Add last_login to users

Revision ID: add_last_login
Create Date: 2026-06-09
"""
from alembic import op
import sqlalchemy as sa

revision = 'add_last_login'
down_revision = 'previous_revision'
merge_heads = None

def upgrade():
    op.add_column('users', 
        sa.Column('last_login', 
                 sa.DateTime(), 
                 nullable=True))

def downgrade():
    op.drop_column('users', 'last_login')

# 2. 写测试
def test_last_login_column():
    # 验证列存在
    inspector = inspect(engine)
    columns = [c['name'] for c in inspector.get_columns('users')]
    assert 'last_login' in columns

五、性能优化与最佳实践

5.1 AI 编程效率提升技巧

1. 上下文管理

# 使用 .claude 文件夹管理项目上下文
.claude/
├── settings.json      # 项目设置
├── memory.md       # ��目��忆
└── context/       # 额外上下文
    ├── architecture.md
    └── api-docs.md

2. 提示词优化

# ❌ 模糊的需求
"添加用户认证功能"

# ✅ 明确的需求
"""
在现有 FastAPI 项目中添加用户认证功能：
1. 注册：POST /auth/register (email, password, name)
2. 登录：POST /auth/login (email, password) -> {access_token, token_type}
3. Token 过期时间：24 小时
4. 使用 JWT + bcrypt
5. 已有 User 模型在 app/models.py
"""

3. 分步执行

# ❌ 一步到位
"完成整个用户认证系统"

# ✅ 分步骤
1. "添加 UserCreate schema"
2. "实现密码哈希工具函数"
3. "创建 create_user 函数"
4. "实现登录验证"
5. "添加 JWT token 生成"

5.2 代码质量保证

1. 使用 linter

# 配置 ESLint
npm run lint

# 自动修复
npm run lint -- --fix

2. 使用 type checker

# TypeScript
npx tsc --noEmit

# Python
python -m mypy app/

3. 使用 formatter

# Prettier
npx prettier --write .

# Black
black app/

5.3 自动化测试

CI/CD 集成示例：

# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      
      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          pip install -r requirements-dev.txt
      
      - name: Run tests
        run: pytest --cov=app tests/
      
      - name: Type check
        run: mypy app/
      
      - name: Lint
        run: |
          black --check app/
          isort --check app/
          flake8 app/

六、总结与展望

6.1 四大原则的核心价值

karpathy-skills 之所以能够在短时间内获得 149K+ stars，根本原因在于它解决了 AI 编程中的核心痛点：

原则解决的问题核心价值
先理解再修改错误假设、破坏现有功能降低风险
最小变更过度工程、引入复杂性保持代码简洁
始终先写测试代码质量、bug 难发现质量保证
保持代码简洁过度设计、难以维护可维护性

6.2 2026 年 AI 编程的趋势

趋势一：Skills 取代 MCP

Skills 正在取代 MCP 成为 AI Agent 开发的新标准。karpathy-skills 的成功证明了轻量级提示词配置的有效性。

趋势二：本地化优先

越来越的项目倾向于在本地运行 AI 编程工具，保护代码隐私。karpathy-skills 可以完全离线使用。

趋势三：工程化

AI 编程正在从「玩具级」走向工程化，需要严格的测试、CI/CD 和代码质量保证。

6.3 如何开始

立即行动：

  1. 克隆 karpathy-skills：git clone https://github.com/andrej-karpathy/skills.git
  2. 创建 CLAUDE.md：复制到你的项目根目录
  3. 自定义配置：根据你的项目技术栈进行调整
  4. 实践四大原则：在下一个任务中应用
  5. 持续迭代：根据实践经验优化配置

资源链接：

参考资料

  1. Andrej Karpathy, "Skills: AI Programming Best Practices", GitHub, 2026
  2. "GitHub Trending 热门项目盘点(2026年5月24日)", CSDN, 2026
  3. "2026 年GitHub AI 趋势周报:Skills 生态崛起", CSDN, 2026
  4. NVIDIA GTC 2026, "Agent AI Era", 2026
  5. "AI Agent 全栈学习路线图 2026", CSDN, 2026

本文约 8500 字，深入解析了 karpathy-skills 的四大原则、CLAUDE.md 配置和生产级实战案例。希望这篇文章能够帮助你在 2026 年的 AI 编程实践中少走弯路，写出更高质量的代码。

复制全文 生成海报 AI编程,karpathy-skills,Claude Code,提示词工程,四大原则

推荐文章

mysql时间对比
2024-11-18 14:35:19 +0800 CST
SGLang vs vLLM：2026年大模型推理框架深度对比与选型指南
2026-04-08 15:51:53 +0800 CST
告别"恐怖谷"！国产开源SentiAvatar：0.3秒生成6秒动作，让数字人终于有了"灵魂"
2026-04-21 07:40:01 +0800 CST
中后台开发神器！Cool-Admin-Midway 让你一分钟完成后台搭建！
2024-11-18 01:31:19 +0800 CST
VS Code 强制插入 Co-Authored-by: Copilot：一场关于代码归属权的开源风暴
2026-05-06 22:34:53 +0800 CST
20万星背后的工程革命：obra/superpowers 如何让 AI 编程从'自由发挥'走向'系统化交付'
2026-06-01 15:28:16 +0800 CST
Matt Pocock Skills 深度实战：AI Agent 工程化技能集——从需求对齐到架构审查的完整指南（2026）
2026-06-04 12:45:43 +0800 CST
Agent Lightning 深度解析：零代码如何让任何框架的 AI Agent 实现自我进化
2026-04-18 15:13:12 +0800 CST
零代码搭建AI应用，Dify积木式工作流开源了
2026-04-18 19:05:42 +0800 CST
Gemma 4 架构解密：MoE 路由 × GQA 注意力 × Thinking Mode——31B 如何击败 20 倍参数对手
2026-04-19 17:47:49 +0800 CST
Google LangExtract 深度实战：让 LLM 从"黑盒"变"透明"——从架构原理到生产级结构化提取完全指南（2026）
2026-05-30 15:10:01 +0800 CST
尤雨溪亲自推荐！Vue3 + NativeScript：轻量10倍的原生App开发实战
2025-11-20 09:45:47 +0800 CST
Hermes Agent 深度解析：自进化智能体的工程架构与 Skill 生成机制
2026-04-12 05:23:08 +0800 CST
Vue Router 中的导航守卫有哪些？它们分别在什么情况下触发？
2024-11-17 04:39:54 +0800 CST
vLLM 2026 Q2 路线图深度解析：从 v1 架构重构到九大 SIG 技术演进——生产级 LLM 推理引擎的下一站
2026-05-05 19:01:32 +0800 CST
前端开发中 localStorage 的核心用法与进阶技巧详解
2025-07-11 09:18:49 +0800 CST
OpenHuman 深度实战：从记忆树到 118+ 工具集成——开源个人 AI 助手的架构设计与生产级实践
2026-05-22 15:17:10 +0800 CST
Cork：为 Homebrew 设计的 SwiftUI GUI 工具
2025-03-16 10:05:23 +0800 CST
fsner是一个功能强大的Python库，专注于实体识别和关系抽取，广泛应用于自然语言处理领域
2024-11-18 19:51:42 +0800 CST
Vue3中如何处理跨域请求？
2024-11-19 08:43:14 +0800 CST
Linux 7.0 深度解析：内核进入 7 时代——Intel Nova Lake、网络革命、Rust 驱动全面加速
2026-05-14 09:42:26 +0800 CST
你可能不知道的 18 个前端技巧
2025-06-12 13:15:26 +0800 CST
FastRTC：为 Python 开发者打造的实时音视频通信利器
2025-05-15 09:56:44 +0800 CST
io_uring + BPF 深度实战：BPF 程序进驻内核事件循环——从异步 I/O 演进到自定义内核执行引擎的全链路解析
2026-05-09 02:08:06 +0800 CST
什么是Vue模板语法？它有哪些特点？
2024-11-18 11:30:14 +0800 CST
现代前端存储利器：从 localStorage 到 IndexedDB
2025-08-15 16:07:03 +0800 CST
VibeVoice 深度解析：微软开源语音 AI 全家桶，90 分钟长语音合成 + 60 分钟语音识别
2026-05-13 22:42:48 +0800 CST
Hermes Agent 深度实战：自进化 AI Agent 的三层记忆架构与 Skill 自动生成完全指南（上篇）
2026-06-04 04:45:08 +0800 CST
pkiviewer，一个Python中非常有用的库
2024-11-17 21:28:48 +0800 CST
Elasticsearch 文档操作
2024-11-18 12:36:01 +0800 CST
Prometheus：阿木实验室开源自主无人机平台，ROS+PX4全栈覆盖，仿真到真机零迁移
2026-04-16 17:09:51 +0800 CST
Vue 3 或 Nuxt 项目中快速实现炫酷的动画效果
2025-05-11 23:31:07 +0800 CST
HeyGen开源HyperFrames：用HTML写视频，Claude Code的第二条腿
2026-05-05 19:08:55 +0800 CST
Rust在人工智能生成内容（AIGC）领域的应用
2024-11-18 13:48:25 +0800 CST
OpenViking 深度实战：火山引擎开源AI Agent上下文数据库——用文件系统范式统一记忆、技能与资源管理
2026-05-06 02:34:24 +0800 CST
FastAPI是一个现代化、高性能的PythonWeb框架，易于学习和使用。它支持快速编码、请求验证和自动文档生成
2024-11-18 23:34:20 +0800 CST
Vosk-API 是一款开源的离线语音识别工具包
2024-11-19 07:51:49 +0800 CST
MyLib5，一个Python中非常有用的库
2024-11-18 12:50:13 +0800 CST
TypeScript 7.0 Beta深度解析：微软用Go重写编译器，10倍性能跃迁背后的技术革命
2026-04-26 16:41:24 +0800 CST
HAProxy如何实现同一端口代理不同的后端服务
2024-11-19 05:42:02 +0800 CST
使用 Go 语言连接并操作 SQLite 数据库
2024-11-18 19:13:44 +0800 CST
从"年度渗透"到"每次Build都渗透": Shannon如何用多Agent架构重写安全测试规则
2026-04-12 03:56:59 +0800 CST
__init__.py 到底有啥魔力？为什么它被大厂程序员钟爱？
2025-04-23 14:56:21 +0800 CST
移动端开发避坑指南：12个常见问题与解决方案
2025-09-02 09:41:11 +0800 CST
Helidon 4.4 深度解析：当 Oracle 把 LangChain4j AI Agent 能力直接内建进 Java 微服务框架
2026-04-11 11:26:05 +0800 CST
开源的重复文件查找工具 Czkawka：高效管理磁盘空间
2025-04-01 22:14:39 +0800 CST
PHP 使用代理 IP 通过 cURL 请求数据
2024-11-19 02:52:08 +0800 CST
Vue3中如何扩展VNode？
2024-11-17 19:33:18 +0800 CST
5个 CSS 新功能，简单好用还超省时间
2025-07-18 07:48:14 +0800 CST
PHP 允许跨域的终极解决办法
2024-11-19 08:12:52 +0800 CST
程序员茄子在线接单