Bruce on AI Engineering

OpenAI Symphony Deep Dive: Autonomous Coding Orchestration

Fri, 06 Mar 2026 22:00:00 +0800

What if your issue tracker could fix its own tickets?

OpenAI just open-sourced Symphony, an automation service that monitors your project’s issue tracker (like Linear), spawns autonomous coding agents (like Codex) for each task, and delivers verified pull requests — complete with CI status, code reviews, and walkthrough videos — before a human even looks at the code.

This isn’t another AI code assistant that waits for your prompt. Symphony represents a fundamental shift in how software gets built: from developer-driven coding to project-driven orchestration. In this guide, we’ll break down Symphony’s architecture, explain how it works under the hood, and show you how to set it up for your own projects.

Why Symphony Matters: The Paradigm Shift

Most AI coding tools today follow the same pattern:

OpenClaw vs AutoGPT vs CrewAI: Best Personal AI Agent 2026

Fri, 06 Mar 2026 19:00:00 +0800

The AI agent landscape in 2026 is crowded. OpenClaw exploded to 247,000+ GitHub stars in weeks. AutoGPT pioneered the autonomous agent concept. CrewAI simplified multi-agent Python workflows. LangGraph brought graph-based orchestration. AutoGen introduced multi-agent conversations. Devin showed what a fully commercial AI engineer looks like.

So which one should you actually use?

This comparison breaks down six major AI agent tools across architecture, setup complexity, multi-agent support, messaging integration, cost, and ecosystem. Whether you want a personal AI assistant on Telegram, a coding agent for your development workflow, or a multi-agent framework for your Python project, you will find a clear recommendation here.

The Contenders at a Glance

Before diving into detailed comparisons, here is a high-level overview of every tool in this comparison:

OpenClaw Tavily Integration: Add Web Search to Your AI Agent

Fri, 06 Mar 2026 14:00:00 +0800

Your OpenClaw agent is smart, but it is blind. Without web search, it generates answers from training data alone — which means confident-sounding responses built on outdated or fabricated information. Ask it about yesterday’s news and it will either admit ignorance or, worse, invent something plausible.

Tavily fixes this. It is an AI-optimized search API that returns clean, structured results designed specifically for AI agents — not the noisy HTML pages a human would browse. Integrating Tavily into OpenClaw gives your agent real-time access to the web, turning it from a knowledge-limited chatbot into a research-capable assistant.

This guide walks you through the complete OpenClaw Tavily integration: getting your API key, installing the skill, configuring it per agent, choosing the right Tavily tool for each job, and keeping costs under control.

Why Your OpenClaw Agent Needs Web Search

Think of an AI agent without web search like a brilliant employee locked in a windowless room. They know everything they were trained on, but they have zero visibility into what is happening right now. That means:

OpenClaw Pitfalls: 15 Automation Mistakes and Fixes

Fri, 06 Mar 2026 09:00:00 +0800

You installed OpenClaw. You added Tavily search, proactive-agent, and a handful of community skills. Everything looked amazing for the first 48 hours.

Then things started breaking. Your agent hallucinated an entire research report because the search API key expired silently. Your monthly API bill hit $200 because Opus was handling heartbeat checks. A skill you installed from ClawHub had unrestricted shell access and started modifying files outside your workspace.

OpenClaw is powerful. But power without guardrails is how you get production incidents at 3 AM.

This guide covers the 15 most common OpenClaw automation pitfalls, organized into four categories: setup, agent behavior, cost, and security. Each pitfall includes what goes wrong, a real scenario you will recognize, and exactly how to fix it. If you have been running OpenClaw for more than a week, you have probably already hit at least three of these.

Claude Code Slash Commands, Shortcuts & CLI Reference

Thu, 05 Mar 2026 19:00:00 +0800

Claude Code has over 40 built-in slash commands, dozens of keyboard shortcuts, and a rich set of CLI flags. Most developers use about five of them. The rest sit undiscovered, which means missed opportunities to save time, reduce token costs, and automate repetitive workflows.

This is the reference you bookmark. Every slash command with what it does and when to use it. Every keyboard shortcut worth memorizing. Every CLI flag for scripting and automation. Plus how to build your own custom commands using Skills.

No fluff. Just the complete command reference for Claude Code in 2026.

Built-in Slash Commands

Type / at the start of your input to see all available commands. Type any letters after / to filter the list. Here is every built-in command, organized by what you use them for.

Build MCP Servers in Python: Complete Step-by-Step Tutorial

Thu, 05 Mar 2026 14:00:00 +0800

Python is the most popular language for AI developers, and the MCP Python SDK makes it remarkably easy to build custom MCP servers. With the decorator-based FastMCP framework, you can go from zero to a working server in under 50 lines of code.

This tutorial walks you through building MCP servers in Python from scratch. You will create tools, resources, and prompts, handle errors properly, test with the MCP Inspector, connect to Claude Code, and build a practical SQLite database server. Every code example is complete and runnable.

What Is MCP and Why Build Custom Servers

MCP (Model Context Protocol) is the open standard that lets AI models connect to external tools, databases, and services. Think of it as USB-C for AI — one universal protocol that works across Claude Code, Cursor, VS Code Copilot, and any MCP-compatible client.

OpenClaw Setup Guide: Install and Configure Your AI Agent

Thu, 05 Mar 2026 09:00:00 +0800

Want a personal AI agent that runs 24/7 on your computer, responds through Telegram or WhatsApp, and actually executes tasks — not just chats? That is exactly what OpenClaw does. It is an open-source AI agent gateway that turns your machine into a command center for AI-powered automation.

This guide walks you through the complete OpenClaw setup process: from installation to connecting messaging platforms, configuring AI models, installing Skills, and locking down security. By the end, you will have a working personal AI agent you can message from anywhere.

What Is OpenClaw (and Why Three Names?)

OpenClaw is an open-source personal AI agent created by Austrian developer Peter Steinberger (@steipete). It gained 80,000+ GitHub stars in its first week and has since grown to 247,000+ stars, making it one of the fastest-growing open-source projects in history.

OpenClaw Multi-Agent Setup: Build AI Teams That Work

Wed, 04 Mar 2026 19:00:00 +0800

You built an OpenClaw personal assistant. It handles your Telegram messages, searches the web, writes drafts, reviews code. Life is good.

Then reality hits. You ask it to research a competitor, and it responds with coding suggestions from yesterday’s conversation. You ask it to write an article, and it pulls in debugging context from a completely unrelated project. Your single agent is drowning in accumulated memory, and every response gets slower and more confused.

The fix is not a better prompt. The fix is a team.

This guide walks you through setting up multiple OpenClaw agents that work together as a coordinated team. You will learn the architecture, the configuration, the communication patterns, and the real-world collaboration models that make multi-agent systems practical – not just theoretical.

If you are new to OpenClaw, start with the beginner tutorial first. For those already running a single agent, this guide picks up exactly where that leaves off.

Claude Code vs GitHub Copilot: Best AI Coding Tool 2026

Wed, 04 Mar 2026 14:00:00 +0800

Choosing between Claude Code and GitHub Copilot is one of the most common decisions developers face in 2026. Both tools use AI to accelerate coding, but they take fundamentally different approaches – one is a terminal-based autonomous agent, the other is an IDE-first code completion platform.

This head-to-head comparison covers everything you need to make an informed decision: architecture, code generation, pricing, agent capabilities, and real-world use cases. By the end, you will know exactly which tool fits your workflow – or whether you should use both.

Quick Comparison Table

Before diving into details, here is the full comparison at a glance:

Claude Code Hooks: Automate Your AI Workflow (2026)

Wed, 04 Mar 2026 09:00:00 +0800

Claude Code is probabilistic by nature. Ask it to format your code, and it might. Ask it to never touch .env files, and it usually respects that – until it doesn’t.

Claude Code hooks solve this. They are shell commands, HTTP endpoints, or LLM prompts that run automatically at specific points during Claude’s operation. Before a file edit happens, after a command runs, when a session starts, when Claude finishes a task. Hooks give you deterministic control over the parts of your workflow that cannot be left to chance.

This guide covers everything you need: what hooks are, all 17 lifecycle events, the configuration format, 8 practical examples you can copy-paste today, matcher rules, and when to choose hooks over CLAUDE.md or Skills.

What Are Claude Code Hooks?

Hooks are user-defined automation that Claude Code executes at specific lifecycle points. Think of them like Git hooks, but for your AI coding assistant instead of your version control system.

CLAUDE.md Best Practices: Write Files That Actually Work

Tue, 03 Mar 2026 19:00:00 +0800

Most CLAUDE.md files are bad. They’re either empty, stuffed with 500 lines of auto-generated boilerplate, or full of vague instructions like “write clean code” that Claude already tries to do by default.

A well-written CLAUDE.md transforms Claude Code from a generic assistant into a team member who knows your stack, follows your conventions, and avoids your project’s specific pitfalls. A bad one wastes context tokens and gives you a false sense of control.

This guide focuses on the how — practical patterns for writing CLAUDE.md files that actually change Claude’s behavior. You’ll get real examples for different project types, the specific mistakes that make CLAUDE.md files useless, and a clear comparison of CLAUDE.md vs AGENTS.md vs .cursorrules. If you need the basics first (what CLAUDE.md is, how it loads, the three-layer system), read our CLAUDE.md introduction before continuing.

How CLAUDE.md Gets Loaded

Before writing effective rules, you need to understand the loading mechanism. Claude Code auto-loads CLAUDE.md files from multiple locations in a specific priority order:

Best MCP Servers for Claude Code: 18 Tools You Need in 2026

Tue, 03 Mar 2026 14:00:00 +0800

The MCP ecosystem has exploded. Since Anthropic open-sourced the Model Context Protocol in late 2024, the community has built over 10,000 public MCP servers, and the official SDKs have surpassed 97 million downloads across TypeScript and Python. Every major AI tool vendor now supports MCP — Anthropic, OpenAI, Google, and Microsoft have all adopted it as the standard for connecting AI agents to external tools.

But with thousands of servers available, finding the ones that actually matter is the hard part.

This guide cuts through the noise. Here are the 18 MCP servers that deliver the most value for Claude Code users in 2026, organized by category, with install commands you can copy-paste right now.

Quick Start: How to Install MCP Servers in Claude Code

Before diving into the list, here is how MCP server installation works in Claude Code.

Claude Code Pricing 2026: Free vs Pro vs Max — Complete Cost Breakdown

Tue, 03 Mar 2026 10:00:00 +0800

Claude Code is arguably the most powerful terminal-based AI coding tool available today. But power comes at a price — and Anthropic’s pricing structure isn’t exactly straightforward.

Should you stick with the $20 Pro plan? Is the $200/month Max plan actually worth it for heavy users? Could you save money by using the API directly? And how does it all compare to Cursor, Copilot, and Codex CLI?

This guide breaks down every Claude Code pricing option available in 2026, with real-world cost analysis to help you pick the right plan.

Quick Summary: All Plans at a Glance

Plan	Price	Claude Code Access	Best For
Free	$0	No	Casual Claude.ai chat only
Pro	$20/mo	Yes (limited)	Light coding tasks, small projects
Max 5x	$100/mo	Yes (full)	Daily professional use
Max 20x	$200/mo	Yes (full, priority)	Heavy all-day coding
Team	$25–150/user/mo	Yes (Premium seats)	Teams of 5–150
Enterprise	Custom	Yes	Large organizations
API	Pay-per-token	Yes	Custom integrations, cost control

Plan-by-Plan Breakdown

Free Tier ($0)

The free tier gives you access to Claude.ai for basic conversations, but Claude Code is not included. You’ll need at least a Pro subscription — or an API key — to use Claude Code at all.

OpenClaw 2026.3.1: WebSocket Streaming, Agent Routing, and K8s Support

Tue, 03 Mar 2026 10:00:00 +0800

OpenClaw just dropped version 2026.3.1 — and this one matters. WebSocket-first streaming for OpenAI models, native Kubernetes health checks, a proper agent routing CLI, and Claude 4.6 adaptive thinking enabled by default.

If you’re running OpenClaw in production or considering it for your AI agent workflow, this guide covers every meaningful change in the release, what it means for your setup, and how to configure the new features.

What Changed: The Big Picture

OpenClaw 2026.3.1 is a production-readiness release. While previous versions focused on expanding platform integrations and agent capabilities, this release is about making OpenClaw faster, more manageable, and easier to deploy at scale.

Tmux Complete Guide: From Basics to AI-Powered Multi-Agent Workflows

Tue, 03 Mar 2026 10:00:00 +0800

If you work in the terminal, you’ve probably lost an SSH session during a long-running task. Or struggled to juggle multiple terminal windows while debugging. Or watched helplessly as Claude Code’s conversation vanished when your laptop went to sleep.

Tmux solves all of these problems — and in the age of AI-powered development, it has become arguably the most important terminal tool you can learn.

This guide takes you from zero tmux knowledge to running parallel AI coding agents like a pro. Whether you’re a complete beginner or an experienced developer looking to supercharge your AI workflow, there’s something here for you.

What Is Tmux?

Tmux stands for terminal multiplexer. At its core, it does three things:

Building MCP Servers with TypeScript: Zero to Deploy Tutorial

Mon, 02 Mar 2026 10:00:00 +0800

MCP (Model Context Protocol) is the standard way to give AI models access to external tools, data, and services in 2026. If you’ve used Claude Code or Cursor, you’ve already used MCP servers — they power everything from database queries to API integrations.

This tutorial walks you through building your own MCP server from scratch with TypeScript, from project setup to npm publishing. By the end, you’ll have a working server that any MCP-compatible AI client can use.

What Is MCP? The 30-Second Version

MCP is USB-C for AI. Just as USB-C lets your laptop connect to monitors, drives, and keyboards through one standard port, MCP lets AI models connect to databases, APIs, and file systems through one standard protocol. The official MCP specification defines the full protocol details.

Claude vs ChatGPT vs Gemini: Best LLM for Coding in 2026

Mon, 02 Mar 2026 10:00:00 +0800

Choosing the right LLM for coding in 2026 is harder than ever. Claude Opus 4.6, GPT-5.2, and Gemini 2.5 Pro each claim to be the best at writing code — but the reality is more nuanced.

I’ve spent months building real projects with all three models. This comparison cuts through the marketing to show you which model actually performs best for different coding tasks, based on benchmarks, pricing, and hands-on experience.

The Models: Quick Overview

Before diving into comparisons, here’s what we’re comparing:

Model	Company	Released	Context Window	Max Output
Claude Opus 4.6	Anthropic	Feb 2026	200K (1M beta)	128K tokens
GPT-5.2	OpenAI	Feb 2026	~200K	100K tokens
Gemini 2.5 Pro	Google	Feb 2025	1M (native)	~65K tokens

All three are multi-modal (text + image input), support tool use, and offer API access. The differences lie in coding performance, pricing, and specialized capabilities.

Claude Code Agent Teams: How to Run Multiple AI Agents in Parallel

Sat, 28 Feb 2026 10:00:00 +0800

One agent is good. A coordinated team of agents is transformative.

Since Anthropic released Agent Teams on February 5, 2026, alongside the Opus 4.6 model, Claude Code has crossed a fundamental threshold: you’re no longer limited to a single agent working sequentially through your codebase. You can now spin up multiple Claude agents that communicate with each other, divide work, and execute tasks in parallel — like a small engineering team that happens to operate at machine speed.

This guide covers everything you need to know about Claude Code Agent Teams: architecture, setup, real-world collaboration patterns, cost management, and how it compares to the older Subagent and Worktree approaches.

What Are Agent Teams?

Agent Teams let you run multiple Claude Code agents within a single session. But this isn’t just “run five agents at once.” The architecture is built around structured coordination.

Claude Code Guide 2026: Everything You Need to Know

Sat, 28 Feb 2026 10:00:00 +0800

Claude Code is Anthropic’s terminal-based AI coding agent. Unlike IDE extensions that suggest code snippets, Claude Code operates as an autonomous agent — it reads your codebase, plans multi-step changes, writes code, runs tests, and iterates until the task is done.

Since its launch, Claude Code has become the go-to tool for developers who want more than autocomplete. It can refactor entire modules, set up CI/CD pipelines, debug complex issues across files, and even manage git workflows — all from your terminal.

This guide is the hub page for everything Claude Code. Whether you’re installing it for the first time or optimizing an advanced multi-agent workflow, you’ll find the right resource below.

What Makes Claude Code Different

Before diving into features, it’s worth understanding why Claude Code exists alongside tools like Cursor, Copilot, and Codex CLI.

Claude Code Hooks Guide: 12 Automation Configs (2026)

Sat, 28 Feb 2026 10:00:00 +0800

Claude Code is probabilistic. You give it the same prompt twice and get different results. That’s fine for creative work — but your engineering workflow needs deterministic guarantees.

You need files auto-formatted on every save. You need .env files locked down. You need rm -rf / blocked before it ever reaches your shell. You need these things to happen every single time, not just when the AI remembers.

That’s what Claude Code Hooks do. They’re lifecycle scripts that run at specific points during Claude’s operation — before a tool runs, after a file is edited, when a session starts, when Claude stops. They give you programmatic control over the parts of your workflow that can’t be left to chance.

This guide gives you 12 production-ready hook configurations you can copy-paste into your project right now, plus the technical details to build your own.

Claude Code Skills Guide: Create Custom SKILL.md Workflows (With Examples)

Sat, 28 Feb 2026 10:00:00 +0800

Claude Code is one of the most powerful AI coding tools available. But out of the box, it’s generic. It doesn’t know your team’s code review checklist. It doesn’t know your API documentation format. It doesn’t know your commit message conventions.

Every time you explain the same workflow from scratch, you’re wasting tokens and time.

Claude Code Skills fix this. A Skill is a reusable set of instructions — packaged as a simple Markdown file — that teaches Claude exactly how to perform a specific task your way. Once created, Claude auto-detects when a Skill is relevant and applies it without you lifting a finger.

This guide covers everything: what Skills are, how to create them, three practical examples you can copy today, the growing Skills ecosystem, and how Skills fit alongside CLAUDE.md and Hooks in the broader Claude Code configuration system.

Claude Code vs Cursor 2026: Which AI Coding Tool Wins?

Sat, 28 Feb 2026 10:00:00 +0800

Two AI coding tools dominate the 2026 developer landscape: Claude Code and Cursor. Both are powerful. Both can handle complex, multi-file tasks. But they approach the problem from fundamentally different philosophies.

Claude Code is a terminal-first autonomous agent. You give it a task, and it plans, executes, and verifies across your entire codebase.

Cursor is an AI-native IDE. It wraps VS Code with deep AI integration — inline completion, agent mode, and visual editing all in one interface.

This comparison tests both tools across five critical dimensions to help you decide which fits your workflow — or whether you need both.

Quick Comparison

Dimension	Claude Code	Cursor
Architecture	Terminal agent	AI-native IDE (VS Code fork)
Best Model	Opus 4.6 / Sonnet 4.6	Multi-model (Claude, GPT, Gemini)
Entry Price	$20/mo (Pro)	$20/mo (Pro)
Power Price	$100/mo (Max 5x)	$200/mo (Ultra)
Code Completion	No inline	Excellent inline
Agent Mode	Native, terminal	Composer + Background Agents
Multi-file Editing	Excellent	Excellent
Context Window	200K–1M tokens	70K–120K (effective)
Token Efficiency	Baseline (1x)	~5.5x more consumption
Learning Curve	Steep	Low (VS Code users)

1. Agent Capabilities

Claude Code: Agent-First Design

Claude Code was built as an autonomous agent from day one. Its agentic loop:

Claude Code Worktree: Run Multiple AI Tasks in Parallel

Sat, 28 Feb 2026 10:00:00 +0800

You open your terminal. Claude Code is halfway through building a new authentication module. Then Slack pings: there’s a production bug that needs fixing now.

What do you do? Stash your half-finished changes and hope you remember to pop them later? Force-commit a broken state just to switch branches? Tell your team to wait?

This is the fundamental constraint of single-directory development: one working directory can only hold one task at a time. Switching branches changes your files, but it doesn’t give you isolation. If two Claude Code sessions operate on the same directory, they will step on each other’s changes.

Claude Code’s --worktree flag (short: -w) solves this. It combines Git worktree’s isolation with Claude Code’s AI workflow, letting you spin up independent coding sessions in seconds – each with its own directory, its own branch, and zero interference with your other work.

Claude Rate Limits 2026: Messages Per Plan Explained

Sat, 28 Feb 2026 10:00:00 +0800

If you’ve used Claude Code for more than a day, you’ve probably hit a rate limit. That frustrating “you’ve reached your usage limit” message mid-debugging session.

The problem isn’t that limits exist — it’s that nobody explains them clearly. Anthropic’s official documentation is vague (“usage may vary”), community posts are outdated, and your actual experience depends on factors you can’t see.

This guide cuts through the confusion. Every Claude rate limit, across every plan and API tier, with the real numbers and practical strategies to work around them.

Quick Reference: All Plans at a Glance

Plan	Price	Messages / 5 Hours	Weekly Limit	Opus Access
Free	$0	~2–5	None	No
Pro	$20/mo	~10–45	~40–80 hrs	Limited
Max 5x	$100/mo	~50–200	~140–280 hrs	Full
Max 20x	$200/mo	~200–800	~240–480 hrs	Full
Team Standard	$25/user/mo	~1.25× Pro	7-day reset	Limited
Team Premium	$150/user/mo	~6.25× Pro	7-day reset	Full

Why ranges? Message counts depend on conversation length, model choice, context size, and current server load. Short questions with Sonnet hit the high end; long Opus conversations with file context hit the low end.

GitHub Copilot vs Claude Code vs Cursor: 2026 Comparison

Sat, 28 Feb 2026 10:00:00 +0800

Three AI coding tools dominate 2026: GitHub Copilot, Claude Code, and Cursor. Each takes a fundamentally different approach to AI-assisted development — and choosing between them (or combining them) can significantly impact your productivity.

This guide compares all three across the dimensions that actually matter: pricing, agent capabilities, code completion, IDE support, and real-world use cases.

The 30-Second Summary

	GitHub Copilot	Claude Code	Cursor
Approach	IDE extension	Terminal agent	AI-native IDE
Best at	Inline completion	Autonomous tasks	Full IDE experience
Cheapest	Free / $10/mo	$20/mo	Free / $20/mo
Power tier	$39/mo (Pro+)	$100/mo (Max 5x)	$200/mo (Ultra)
Models	GPT-4.1, Claude Sonnet	Opus 4.6, Sonnet 4.6	Claude, GPT, Gemini
IDE support	6+ IDEs	Terminal + IDE plugins	VS Code fork
Users	20M+	Growing fast	Growing fast

Pricing Breakdown

Individual Plans

Tier	Copilot	Claude Code	Cursor
Free	$0 (2K completions/mo)	No Code access	Limited features
Entry	$10/mo (Pro)	$20/mo (Pro)	$20/mo (Pro)
Advanced	$39/mo (Pro+)	$100/mo (Max 5x)	$60/mo (Pro+)
Premium	—	$200/mo (Max 20x)	$200/mo (Ultra)

Team/Enterprise

	Copilot	Claude Code	Cursor
Team	$39/user/mo	$25–150/user/mo	$40/user/mo
Enterprise	$39/user/mo	Custom	Custom
SOC2/SSO	Yes	Yes (Enterprise)	Yes (Teams)

Price winner: Copilot at $10/month (Pro) is the cheapest paid option. Its free tier with 2,000 completions is genuinely useful for light users.

MCP Protocol Explained: The Universal Standard for AI Tools

Sat, 28 Feb 2026 10:00:00 +0800

Every AI coding tool needs to connect to external services — databases, APIs, cloud platforms, project management tools. Before MCP, each connection required custom integration code. Build it for Claude Code? Rebuild it for Cursor. Rebuild it again for Copilot.

Model Context Protocol (MCP) solves this with a universal standard: build one integration, and it works with every AI tool that supports MCP.

Think of MCP as USB-C for AI. Before USB-C, every device had its own charger. MCP does the same thing for AI tool integrations — one protocol that connects any AI to any external service.

This guide explains what MCP is, how it works, and why it’s becoming the default standard for AI development in 2026.

Why MCP Matters

Before MCP, connecting an AI tool to a service like Slack required:

Vibe Coding Explained: What It Is and How to Do It Right

Sat, 28 Feb 2026 10:00:00 +0800

In February 2025, Andrej Karpathy — OpenAI co-founder and former Tesla AI director — posted this on X:

“There’s a new kind of coding I call ‘vibe coding’, where you fully give in to the vibes, embrace exponentials, and forget that the code even exists.”

That single post defined a movement. “Vibe coding” became the Collins Dictionary Word of the Year 2025, entered Merriam-Webster, and sparked the most heated debate in software engineering since “should we use tabs or spaces?”

By 2026, vibe coding isn’t a meme anymore — it’s a serious development methodology used by startups, enterprise teams, and solo developers. But it’s also misunderstood, misused, and sometimes dangerous.

This guide explains what vibe coding actually is, when to use it, when to avoid it, and how to do it responsibly.

What Vibe Coding Actually Means

The Core Idea

Traditional coding: You write every line of code. AI-assisted coding: You write code with AI suggesting completions. Vibe coding: You describe what you want, AI writes the code, and you guide the direction without necessarily reading every line.

Claude Code MCP Setup: Connect AI to Any External Service

Sat, 28 Feb 2026 09:00:00 +0800

Out of the box, Claude Code can read files, run shell commands, and search code. But what if you need it to query your Postgres database, send a Slack message, or hit your company’s internal API?

That’s exactly what MCP solves. The Model Context Protocol is an open standard that lets you plug any external service into Claude Code — no prompt hacking, no copy-pasting data, no brittle workarounds. Think of it as USB-C for AI: a single, universal connector between your AI assistant and every tool you care about.

This guide covers everything from installing your first community MCP server to building a custom one from scratch in TypeScript. By the end, you’ll know how to make Claude Code talk to anything.

Prerequisites: You should have Claude Code installed and working. If you haven’t set that up yet, follow our Claude Code setup guide first.

CLAUDE.md Guide: Give AI Perfect Project Context Every Time

Sat, 28 Feb 2026 08:00:00 +0800

Every time you start a new Claude Code session, you repeat the same things: “We use pnpm, not npm.” “Follow ESLint rules.” “Commit messages in conventional format.” “This is a Next.js 15 project with TypeScript.”

Day after day. Session after session.

CLAUDE.md fixes this permanently. It’s a plain Markdown file that Claude Code reads automatically at the start of every session. Write your project context once, and Claude follows it forever — no reminders needed.

This guide covers everything: what CLAUDE.md is, the three-layer configuration system, four ways to manage it, copy-paste templates, and advanced tips from real-world projects. If you’re new to Claude Code, start with our setup guide first.

What Is CLAUDE.md?

CLAUDE.md is Claude Code’s memory file. It’s a standard Markdown document placed in your project root (or other locations — more on that later) that gets loaded into context automatically every time you start a conversation.

10 Claude Code Mistakes Beginners Make (And How to Fix Them)

Wed, 25 Feb 2026 14:00:00 +0800

Claude Code is the most capable AI coding tool available. It’s also one of the easiest to use badly.

I’ve watched dozens of developers adopt Claude Code — myself included — and the same mistakes come up again and again. Developers who fix these issues typically see a 5–10x improvement in output quality and a 50%+ reduction in token costs.

Here are the 10 most common mistakes, why they happen, and exactly how to fix each one.

Mistake #1: Not Setting Up CLAUDE.md

The mistake: Jumping into Claude Code without a CLAUDE.md file, expecting AI to magically understand your project.

Why it’s costly: Without project context, Claude Code has to rediscover your tech stack, coding conventions, and project structure every single session. That means more questions, more wrong assumptions, more wasted tokens, and more back-and-forth corrections.

Install Claude Code in 5 Minutes: Step-by-Step Setup Guide (2026)

Wed, 25 Feb 2026 12:00:00 +0800

You’ve heard about Claude Code. Maybe you’ve seen the demos. Now you want to try it yourself.

Good news: getting from zero to a working Claude Code setup takes about 10 minutes. This guide covers everything — installation, authentication, configuration, IDE integration, and running your first real task.

By the end, you’ll have Claude Code working in your terminal and IDE, configured for your workflow, and ready to start coding with AI.

Prerequisites

Before we start, make sure you have:

Operating system: macOS 13+, Ubuntu 20.04+ / Debian 10+, or Windows 10+ (with Git Bash or WSL 2)
RAM: 4 GB minimum
Internet connection: Required (Claude Code runs against Anthropic’s API)
An Anthropic account: Sign up at claude.ai if you don’t have one
A paid plan or API key: Claude Code requires either a Pro/Max subscription ($20+/month) or an API key with credits. See our Claude Code pricing guide for plan details.

Node.js is no longer required. The 2026 native installer handles everything. If you previously installed via npm, you can migrate — we’ll cover that below.

Build Your Own Claude Code from Scratch in Python (250 Lines)

Tue, 24 Feb 2026 10:00:00 +0800

You’ve probably used Claude Code — or at least heard the hype. It reads your codebase, writes files, runs tests, and fixes bugs, all from a terminal prompt. It feels like magic.

But here’s the thing: the core architecture behind it is surprisingly simple. Simple enough that you can rebuild it from scratch in an afternoon with Python and about 250 lines of code.

That’s exactly what we’ll do in this article. We’ll build MagicCode — a terminal AI coding assistant that can read files, write code, execute shell commands, and make autonomous multi-step decisions — just like Claude Code does under the hood.

More importantly, by the end, you’ll deeply understand three concepts that power every modern AI coding tool:

The Agentic Loop — the decision-making engine that lets AI act autonomously
Tool Use (Function Calling) — how LLMs interact with the real world
The message protocol — how conversations with tool calls actually work at the API level

We’ll build incrementally: V1 (basic chat, 20 lines) → V2 (streaming) → V3 (rich terminal UI) → V4 (full tool system with Agentic Loop, 250 lines). Each version builds on the last. No hand-waving, no magic — just code you can run.

斯坦福 CS146S 精读（五）：从原型到生产——AI 应用完整生命周期

Tue, 24 Feb 2026 09:00:00 +0800

本文是「斯坦福 Vibe Coding 课程精读」系列第 5 篇（完结篇）。系列导航见文末。

“一句话做一个 App”——这可能是 Vibe Coding 最吸引眼球的卖点。

Week 8 的嘉宾是 Vercel AI 研究负责人 Gaspar Garcia，他现场演示了如何用 AI 从一个 prompt 生成一个完整的 Web 应用。前端、后端、数据库、部署——一气呵成。

看起来很酷。但然后呢？

CS146S 的态度很明确：快速原型只是起点。 Week 8 教你怎么快速造出来，Week 9 教你怎么让它在生产环境中活下去。这两周合在一起，讲的是 AI 应用从 demo 到 production 的完整路径。

而"从 demo 到 production"之间的那道鸿沟，恰恰是大多数 Vibe Coder 倒下的地方。

一句话做 App：能力与边界

v0 的启示

Vercel 的 v0 是当前最强的 AI UI 生成工具之一。它能根据自然语言描述生成完整的前端组件和页面，包括样式、交互、响应式布局。

但 Gaspar Garcia 在演讲中坦率地指出了 AI 自动化应用构建的边界：

能做的：

快速生成 UI 原型（分钟级）
基础的 CRUD 功能
标准的页面布局和导航
常见的前端交互模式

做不好的：

复杂的业务逻辑（多步表单、条件流程）
性能优化（懒加载、缓存策略、Bundle 分析）
可访问性（Accessibility / a11y）
品牌定制（超出基础组件库的视觉设计）
与现有系统的集成（认证、第三方 API、遗留系统）

原型的价值不在于原型本身

这里有一个常见的认知误区：很多人觉得"AI 帮我做了一个能跑的 demo，大部分工作就完成了"。

斯坦福 CS146S 精读（四）：Secure Vibe Coding——AI 代码安全攻防全指南

Tue, 24 Feb 2026 08:30:00 +0800

本文是「斯坦福 Vibe Coding 课程精读」系列第 4 篇。系列导航见文末。

CS146S 的 Week 6 和 Week 7 是整门课最让人"脊背发凉"的两周。

Week 6 讲安全：当 AI 帮你写代码时，谁来保证代码不被攻击？更可怕的是——当 AI 本身就是攻击面呢？

Week 7 讲审查：AI 产出的代码，我们到底能信任到什么程度？

很多 AI 编程课只教你怎么写得快。CS146S 把交付的底线拉了出来：可测、可审、可防。这两周的内容，是从"Vibe Coder"升级为"Professional Vibe Coder"的必经之路。

真实案例：Prompt Injection 导致远程代码执行

让我们从一个真实的安全漏洞开始。

2025 年，安全研究员发现了 GitHub Copilot 的一个严重漏洞（CVE-2025-53773）：攻击者可以通过 Prompt Injection，让 Copilot 在你的电脑上执行任意命令。

攻击链条

植入恶意指令：攻击者在源代码文件、网页或 GitHub Issue 中嵌入隐藏的指令。这些指令对人类不可见或不引人注意，但 AI 会读取并执行。
操控配置文件：Copilot Agent Mode 在读取这些内容后，被操控去修改 VS Code 的配置文件 .vscode/settings.json。具体来说，添加一行：
```
{
 "chat.tools.autoApprove": true
}
```
激活 YOLO 模式：这个配置项会禁用所有用户确认提示。从此以后，Copilot 执行任何操作——包括在终端运行命令——都不需要你点"确认"。
执行任意命令：攻击者的后续指令通过同样的 Prompt Injection 传入，Copilot 在无人监督的情况下执行终端命令——下载恶意软件、窃取凭证、加入僵尸网络。

最让人不安的细节：配置文件的修改是即时写入磁盘的，不是以 diff 形式让你审查。 也就是说，当你看到修改时，为时已晚。

影响范围

跨平台：Windows、macOS、Linux 全部受影响
潜在后果：勒索软件、信息窃取、僵尸网络招募
攻击向量多样：可通过代码仓库、网页内容、Issue 评论等多种渠道植入

微软在 2025 年 8 月修补了这个漏洞，但它揭示了一个根本性的问题：AI 编程工具天然就是一个攻击面。它们读取外部输入（代码、文档、网页），并且有修改文件和执行命令的能力。这两个特征的组合，恰恰构成了 Prompt Injection 攻击的完美条件。

斯坦福 CS146S 精读（三）：Agent Manager——人机协作的最佳实践

Tue, 24 Feb 2026 08:00:00 +0800

本文是「斯坦福 Vibe Coding 课程精读」系列第 3 篇。系列导航见文末。

CS146S 第四周的课程标题叫"Coding Agent Patterns"（编程 Agent 模式），但它真正在教的是一个全新的职业技能：Agent Manager。

什么是 Agent Manager？就是不直接写代码，而是指挥 AI Agent 写代码的人。听起来像是"甩手掌柜"，但实际上这可能是 AI 编程时代最难、最有价值的技能之一。

为什么难？因为你需要同时具备三种能力：

技术判断力：能评估 AI 生成的代码质量，知道什么能过、什么不能过
任务分解力：能把复杂需求拆成 Agent 能独立完成的子任务
沟通精确度：能用最少的信息量传达最准确的意图

这周的嘉宾是 Boris Cherney——Claude Code 的创始人。直接从工具创造者的口中学习如何使用工具，这个含金量不言而喻。

Agent 的自治度光谱

AI 编程 Agent 不是一个二元开关——“全自动"或"纯手动”。它是一个自治度光谱，你需要根据任务类型动态调整。

Devin（Cognition）的 Agents 101 文档把这个光谱分为三个区间：

低自治度：简单任务

特征：明确的输入输出、有限的决策空间
示例：重命名变量、添加类型注解、写单元测试、修复 lint 错误
管理方式：直接描述需求，几乎不需要干预
时间节省：接近 100%

在这个区间，Agent 就像一个熟练的打字员——你告诉它做什么，它就做什么。你的角色更像是"下达指令的人"。

中自治度：中等任务

特征：需要一定的设计决策、涉及多个文件、有一些模糊地带
示例：实现一个新 API 端点、重构一个模块、添加新功能
管理方式：提供详细上下文 + 中间检查 + 人工打磨
时间节省：约 80%

这是大部分日常开发工作所在的区间。Agent 能完成 80% 的工作，但剩下的 20% 需要人类来打磨——处理边界条件、优化性能、确保与现有代码风格一致。

斯坦福 CS146S 精读（二）：上下文工程——AI 编程最被低估的核心能力

Tue, 24 Feb 2026 07:30:00 +0800

本文是「斯坦福 Vibe Coding 课程精读」系列第 2 篇。系列导航见文末。

如果让我在 CS146S 的 10 周课程中只选一周来精读，我会毫不犹豫选 Week 3。

不是因为它最酷炫——那可能是 Week 8 的"一句话做 App"。也不是因为它最硬核——那可能是 Week 6 的安全攻防。而是因为 Week 3 讲的内容，直接决定了你用 AI 编程的天花板在哪里。

上下文工程（Context Engineering）——这个词你可能刚开始听说，但它正在取代 Prompt Engineering 成为 AI 编程的核心能力。原因很简单：单条 Prompt 的优化已经触顶，真正决定 AI 输出质量的，是你给它提供的整体上下文。

写一个好 prompt 是加法，做好上下文工程是乘法。

什么是上下文工程

Prompt Engineering 关注的是"怎么问问题"，Context Engineering 关注的是"给 AI 呈现一个什么样的世界"。

两者的区别就像：

Prompt Engineering = 在面试中问一个好问题
Context Engineering = 给面试官准备一整份精心组织的背景材料，让TA在回答你的问题前就已经对情况了然于胸

具体来说，上下文工程包含以下维度：

维度	说明	示例
信息选择	给 AI 看什么、不看什么	只加载相关的源文件，而非整个代码库
信息组织	以什么结构呈现信息	分层文档：设计文档 → 实施计划 → 具体代码
信息质量	确保上下文中没有错误或矛盾	清理过时的注释和文档
信息时机	什么时候提供什么信息	先给架构概览，再给具体实现
工具配置	通过 MCP/工具扩展 AI 的感知范围	连接数据库 schema、API 文档、项目管理工具

StockApp 团队在实践中总结了一个精辟的公式：好代码是好上下文的副产品。

他们将代码仓库视为人类与 AI 的共享工作空间，建立了分层文档结构：

docs/designs/ → 产品需求与高层目标
docs/plans/ → 详细实施计划
docs/guides/ → API 教程
schema.sql → 数据结构规范
CLAUDE.md → AI 本地化指导
README.md → 项目概览

这种结构的每一层都有明确的受众和目的：designs 给决策者看，plans 给执行者（包括 AI）看，guides 给消费者看。而 CLAUDE.md 是专门给 AI Agent 看的"使用说明书"——告诉它这个项目的约定、禁忌和偏好。

斯坦福 CS146S 精读（一）：Vibe Coding 如何成为正式学科

Tue, 24 Feb 2026 07:00:00 +0800

从 Andrej Karpathy 在 2025 年 2 月发推提出 Vibe Coding，到斯坦福大学在同年秋季正式开设 CS146S 课程，前后不到 8 个月。一个社交媒体上的热词，以这样的速度进入全球顶级高校的课程体系，在计算机科学的历史上极为罕见。

这不是一门"教你用 ChatGPT 写代码"的水课。CS146S 覆盖了从 LLM 原理到 Agent 架构、从上下文工程到安全攻防、从自动化构建到生产运维的完整软件工程生命周期。它的嘉宾名单读起来像一份 AI 编程领域的"名人堂"——Claude Code 创始人、Vercel AI 研究负责人、Semgrep CEO、a16z 合伙人……

最关键的是，所有课程资源——PPT、阅读材料、作业代码——全部免费公开。

这篇文章将完整拆解这门课程的每一个模块，帮你建立系统认知。后续系列文章将对其中最有价值的几个主题做深度精读。

课程基本信息

项目	详情
课程编号	CS146S
课程名称	The Modern Software Developer
开课学校	Stanford University
学期	Fall 2025（首次开课）
讲师	Mihail Eric
助教	Febie Lin, Brent Ju
学分	3 units
前置要求	CS111 等效编程经验，推荐 CS221/229
课程官网	themodernsoftware.dev
作业代码	GitHub 仓库

课程的核心论题写在简介第一段：

In the last few years, large language models have introduced a revolutionary new paradigm in software development. The traditional software development lifecycle is being transformed by AI automation at every stage, raising the question: how should the next generation of software engineers leverage these advances to 10x their productivity and prepare for their careers?

OpenClaw 多 Agent 协作深度指南：架构设计、实操配置与进阶模式

Mon, 23 Feb 2026 17:00:00 +0800

你有没有遇到过这样的场景：你的 AI 助手聊着聊着就"精神分裂"了——你让它写公众号，它突然蹦出一段代码逻辑；你让它帮你调研竞品，它却开始纠正你上周的错别字？

这不是 AI 变笨了，是你让一个"大脑"干了太多活。就好比让公司前台同时干行政、财务、研发的事，最后谁的活都干不好。

解决方案是什么？组建一支 AI 团队——让不同的 Agent 各司其职，就像一家真正的公司一样运转。

本文将深入拆解如何用 OpenClaw 搭建一套多 Agent 协作系统。不只是告诉你"怎么配"，更要讲清楚"为什么这样配"，以及业界主流的多 Agent 架构模式如何在实践中落地。

一、为什么单 Agent 不够用？

1.1 单 Agent 的三大瓶颈

大多数人使用 AI 助手的方式都是"一号通吃"：写文案、改代码、生图、调研全在一个 Agent 里搞定。这种方式看似方便，实际上随着使用时间的增长，三个问题会越来越严重：

问题	表现	原因
记忆膨胀	Agent 响应越来越慢	记忆文件（USER.md、memory/ 等）不断累积，每次对话都要读取大量历史
上下文污染	回答"串味"，逻辑混乱	不同领域的知识互相干扰，写文章时联想到代码逻辑
成本失控	Token 消耗远超预期	每次对话都携带所有无关的背景资料，输入 Token 暴涨

用一个形象的比喻：单 Agent 就像一个打工人同时开着 50 个浏览器标签页——看起来什么都在做，实际上哪个都没做好。

1.2 多 Agent 的核心理念

多 Agent 架构的核心理念很简单：专业的事交给专业的人。

2026 Agentic Coding 趋势报告：Claude Code 年入 25 亿美元背后的 8 大趋势

Mon, 23 Feb 2026 14:00:00 +0800

6 个月，10 亿美元。

这不是某个消费级 App 的故事，而是一个命令行工具——Claude Code——创造的 B2B 软件新纪录。到 2026 年 2 月，这个数字已经飙升至 25 亿美元年化收入（ARR），而它背后的公司 Anthropic，整体 ARR 在 14 个月内从 10 亿跃升至 140 亿美元，增长了 14 倍。

这是 B2B 软件历史上从未有过的增速。这篇文章将基于 Anthropic 最新发布的 Agentic Coding 趋势报告，深度拆解这场变革背后的 8 大趋势、市场格局与开发者采用数据。

Anthropic 的疯狂增长曲线

在谈趋势之前，先看一组让整个 SaaS 行业集体沉默的数字：

时间节点	Anthropic ARR	阶段增速
2024 年底	$1B	基准线
2025 年 7 月	$4B	7 个月 4x
2025 年 12 月	$9B	5 个月 2.25x
2026 年 2 月	$14B	2 个月 1.56x

年化增速超过 10x，远超 OpenAI 同期的 3.4x。Anthropic 预计 2026 年目标 $20-26B，2028 年冲击 $70B。企业客户数量从不到 1,000 家暴增至 30 万+。

Claude Code 是这轮增长的核心引擎。它比 ChatGPT 更快达到 $1B ARR 里程碑，而且增长曲线没有任何放缓迹象。这说明什么？Agentic Coding 不是泡沫，而是一个正在被市场真金白银验证的范式转移。

八大趋势深度拆解

趋势一：多 Agent 系统崛起

单个 AI 助手的时代正在过去。根据 Anthropic 报告，57% 的组织已经部署了多步骤 Agent 工作流，即多个 AI Agent 协作完成复杂任务。

MCP 安全实战指南：AI Agent 时代的攻防博弈与防护策略

Mon, 23 Feb 2026 10:00:00 +0800

518 个官方 MCP Server，41% 缺乏认证。 这不是假设的威胁模型，而是 2026 年 2 月安全审计的真实数据。

MCP（Model Context Protocol）注册表在短短一个月内从 90 个服务器暴增至 518 个，生态扩张的速度远远超过了安全基础设施的建设。当开发者们兴奋地将各种 MCP Server 接入自己的 AI Agent 时，攻击者也在盯着同一扇门。

如果你还不了解 MCP 协议的基础概念，建议先阅读 MCP 协议完全指南。本文将聚焦安全维度，带你看清 MCP 生态中那些已经发生的攻击、正在暴露的风险，以及你今天就能采取的防护措施。

一年回顾：MCP 漏洞全景时间线

从 2025 年 4 月至今，MCP 相关的安全事件密集爆发。以下是经过验证的重大漏洞时间线：

2025 年 4 月 — WhatsApp Tool Poisoning

攻击类型：Tool Poisoning（工具投毒）

研究人员发现 WhatsApp MCP Server 存在 Tool Poisoning 漏洞。攻击者通过在工具描述中注入恶意指令，诱导 AI Agent 执行非预期操作，最终可以窃取用户的整个聊天记录。这是 MCP 生态中最早被公开的实战级攻击之一，揭示了一个根本性问题：AI Agent 对工具描述的信任是盲目的。

2025 年 5 月 — GitHub MCP Prompt Injection

攻击类型：Prompt Injection

用 Claude Code 从零开发 MCP Server：TypeScript 实战教程（2026）

Sun, 22 Feb 2026 12:00:00 +0800

MCP Server 是 2026 年 AI 工具生态的核心基础设施。Gartner 预测，到 2026 年底将有 40% 的企业应用嵌入 AI Agent。而 Claude Code 作为当下最强的 AI 编程工具之一，本身就是一个强大的 MCP 客户端。学会开发 MCP Server，就等于掌握了给 AI 装上新手脚的能力。

这篇文章将带你从零开始，用 Claude Code + TypeScript 开发一个完整的 MCP Server，从项目初始化到调试发布，全程实战。

MCP 是什么？一个类比就够了

MCP（Model Context Protocol） 是 Anthropic 在 2024 年底提出的开放协议。官方给了一个很精准的类比：MCP 就是 AI 世界的 USB-C。

就像 USB-C 让你的笔记本电脑可以连接显示器、硬盘、键盘等各种设备一样，MCP 让 AI 模型可以连接数据库、API、文件系统等各种外部工具。

MCP 架构分三层：

┌─────────────────────────────────────────────┐
│ MCP 客户端（Host） │
│ Claude Code / Cursor / VS Code Copilot │
├─────────────────────────────────────────────┤
│ MCP 协议层（Protocol） │
│ JSON-RPC 2.0 + STDIO/HTTP │
├─────────────────────────────────────────────┤
│ MCP 服务端（Server） │
│ 你开发的工具 / 数据源 / 提示模板 │
└─────────────────────────────────────────────┘

一个 MCP Server 可以提供三种能力：

能力	说明	举例
Tools（工具）	让 AI 执行操作	查天气、查数据库、发消息
Resources（资源）	让 AI 读取数据	配置文件、用户信息、日志
Prompts（提示模板）	预定义的交互模板	代码审查模板、摘要模板

其中 Tools 是最常用的能力，也是本文重点。

Claude Code Security 深度解析：AI 驱动的代码安全扫描如何颠覆传统（2026）

Sun, 22 Feb 2026 11:00:00 +0800

2026 年 2 月 20 日，Anthropic 正式发布了 Claude Code Security —— 一款基于 Claude Opus 4.6 的 AI 代码安全扫描工具。消息一出，当天网络安全板块集体跳水：CrowdStrike 下跌近 8%，Cloudflare 跌超 8%，Okta 跌 9.2%，Global X Cybersecurity ETF 跌至 2023 年 11 月以来的最低点。Bloomberg、Fortune、The Hacker News 等主流媒体密集报道，称这是 AI 对传统安全行业发起的一次正面冲击。

为什么一个"research preview"阶段的工具，就能让整个网安板块震动？因为 Claude Code Security 展示了一种全新的范式：AI 不再只是辅助写代码，它开始像人类安全研究员一样审计代码。对于每一位开发者和安全从业者，这件事都值得认真关注。

Claude Code Security 是什么

Claude Code Security 是 Anthropic 在 Claude Code 中内置的代码安全扫描能力。它基于最新的 Claude Opus 4.6 模型，能够自主扫描整个代码库，发现安全漏洞并生成针对性的修复补丁建议。

与传统安全扫描工具最大的区别在于：它不依赖预定义的规则库或模式匹配，而是像人类安全研究员一样推理你的代码。用 Anthropic 官方的说法：

“Claude Code Security reads and reasons about your code the way a human security researcher would: understanding how components interact, tracing how data moves through your application, and catching complex vulnerabilities that rule-based tools miss.”

简单来说，它不是在代码中"搜索已知模式"，而是在理解代码逻辑的基础上发现潜在风险。这是一个根本性的范式转变。

核心能力详解

语义级代码理解

Claude Code Security 能够理解软件组件之间的交互关系，追踪数据在整个应用中的流动路径。这意味着它不仅能看到单个文件中的问题，还能发现跨组件、跨模块的安全隐患 —— 比如输入验证缺口、认证绕过漏洞、业务逻辑缺陷等，这些都是传统静态分析工具的盲区。

Claude Code 2026年2月更新：Worktree 并行开发、后台任务、Simple Mode 全解析

Sun, 22 Feb 2026 10:00:00 +0800

Claude Code 在 2026 年 2 月密集发布了 v2.1.39 到 v2.1.50 共十余个版本，带来了几个改变日常工作流的重要功能。本文汇总 2 月最值得关注的更新，逐个解析用法和实战场景，帮你快速上手。

Git Worktree 支持：最大的工作流升级

这是 2 月份最重磅的功能，在 v2.1.49 中正式发布。它将 Git 的 Worktree 能力直接集成到了 Claude Code 中，让并行开发变得前所未有的简单。

什么是 Git Worktree

简单来说，Git Worktree 允许你在同一个仓库下同时检出多个工作目录，每个目录对应不同的分支。和 git stash 或克隆多份仓库相比，Worktree 共享同一个 .git 数据库，不额外占用磁盘空间，切换成本极低。

基本用法

一条命令即可在隔离的 Worktree 中启动 Claude：

Vibe Coding 完全指南（2026）：用自然语言写代码的正确姿势

Sun, 22 Feb 2026 09:00:00 +0800

2026 年，如果你关注 AI 编程领域，一定绕不开一个词：Vibe Coding（氛围编程）。从一条推文到 Collins 词典年度词汇候选、MIT Technology Review 十大突破技术，Vibe Coding 已经从极客圈的新鲜概念演变为开发者的实际工作方式。据统计，91% 的工程组织已采用至少一个 AI 编程工具，而 Vibe Coding 正是这场变革中最具代表性的理念。

这篇文章将带你全面了解 Vibe Coding 的起源、核心理念、2026 年主流工具全景，并通过实战案例演示氛围编程的完整流程。无论你是好奇观望的开发者，还是想提升效率的实践者，都能在这里找到答案。

Vibe Coding 的起源

2025 年 2 月 2 日，前 Tesla AI 总监、OpenAI 联合创始人 Andrej Karpathy 在 X（原 Twitter）上发了一条帖子，首次提出了 “Vibe Coding” 这个概念：

There’s a new kind of coding I call “vibe coding”, where you fully give in to the vibes, embrace exponentials, and forget that the code even exists.

有一种新的编程方式，我称之为"氛围编程"——你完全沉浸在感觉中，拥抱指数级增长，甚至忘了代码的存在。

Karpathy 描述了他的编程状态：几乎不碰键盘，全程用语音（SuperWhisper）对 Cursor Composer 描述需求，接受所有建议而不逐行审查 diff，遇到 bug 就把错误信息粘贴给 AI。有时候 AI 修不了，他就绕过去，或者让 AI “随便改改"直到问题消失。代码不断增长，已经超出他个人的理解范围——但这并不重要，因为它能跑。

这条推文迅速走红。2025 年 3 月，Merriam-Webster 将 “vibe coding” 列为"俚语与流行"词条；到年底，Collins 词典将其列为年度词汇候选。Wikipedia 也为其创建了独立页面。

更重要的是，MIT Technology Review 在 2026 年初将"生成式编码”（Generative Coding）列为年度十大突破技术之一，标志着 Vibe Coding 从概念正式进入主流视野。AI 现在编写了微软 30% 的代码、Google 超过四分之一的代码，Mark Zuckerberg 甚至放话要让 AI Agent 编写 Meta 的大部分代码。

Claude Code Agent Teams 完全指南：多 Agent 协作开发实战（2026）

Sun, 22 Feb 2026 08:00:00 +0800

2 月 5 日，Anthropic 随 Claude Opus 4.6 一同发布了 Claude Code Agent Teams —— 一项让多个 Claude Code 实例组成团队、并行协作的实验性功能。如果说之前的 Subagent 是"你派出去跑腿的助手"，那 Agent Teams 就是"一支能互相讨论、自主协调的工程小队"。对于需要跨模块开发、多视角审查、并行调试的复杂场景，Agent Teams 可以将小时级的串行工作压缩到分钟级完成。

本文基于官方文档和实际使用经验，从架构原理到实战案例，完整拆解 Agent Teams 的核心能力。如果你还不熟悉 Claude Code 的基础用法，建议先阅读 Claude Code 完全指南。

什么是 Agent Teams

Agent Teams 的核心架构非常直观：一个 Team Lead + 多个 Teammate。

组件	职责
Team Lead	主 Claude Code 会话，负责创建团队、分配任务、综合结果
Teammates	独立的 Claude Code 实例，各自拥有独立 context window
Task List	共享任务列表，支持依赖追踪和自动解锁
Mailbox	Agent 间的消息系统，支持点对点和广播通信

与 Subagent 的关键区别

这是理解 Agent Teams 价值的核心：Subagent 只能向上报告，Teammate 可以互相通信。

维度	Subagent	Agent Teams
上下文	独立 context，结果返回给调用者	独立 context，完全自主运行
通信方式	只能向主 Agent 报告结果	Teammate 之间可以直接互发消息
协调机制	主 Agent 统一管理	共享任务列表 + 自协调
适用场景	聚焦任务，只需返回结果	需要讨论、协作的复杂工作
Token 消耗	较低，结果摘要返回主 context	较高，每个 Teammate 独立消耗

通俗理解：Subagent 像是你派出去的外卖骑手，送完回来报告就行。Agent Teams 像是一个工程小组，成员之间可以随时沟通"你那边接口改了吗？"、“我发现了一个问题，你那边也看看”。

Claude Code Worktree 实战：一个仓库同时跑多个 AI 任务的正确姿势

Fri, 20 Feb 2026 12:00:00 +0800

你有没有遇到过这种情况：

让 Claude 改一个功能改到一半，突然要修一个线上 bug，只能 stash 或者硬着头皮 commit 一堆半成品
想同时让 Claude 做两件事——一个写新功能，一个补测试——但两个会话操作同一份代码，改着改着就冲突了
想做一次大胆的实验性重构，又怕搞砸了回不去

这些问题的本质是：一个工作目录只能承载一个进行中的任务。你切分支可以隔离 Git 记录，但文件系统只有一份，两个 Claude 会话还是会踩到同一块地盘。

Claude Code 的 --worktree（简写 -w）模式就是为解决这个问题而生的。它把 Git Worktree 的能力直接集成进了 Claude Code，让你用一条命令就能在隔离的工作目录中启动新的 Claude 会话。

一、Git Worktree 基础：一个仓库，多个工作目录

在讲 Claude Code 的 worktree 模式之前，先快速理解 Git Worktree 本身。如果你已经熟悉这个概念，可以直接跳到下一节。

1.1 传统工作流的痛点

通常一个 Git 仓库对应一个工作目录。当你需要在不同分支间切换时：

# 正在 feature-a 上开发，突然要修 bug
git stash # 先存起来
git checkout hotfix-branch # 切过去
# ... 修完 bug ...
git checkout feature-a # 切回来
git stash pop # 恢复之前的工作

这个流程有几个问题：stash 容易忘记 pop、切换分支可能导致 node_modules 等依赖需要重新安装、而且全程你只能做一件事。

1.2 Git Worktree 的解法

Git Worktree 允许你从同一个仓库检出多个工作目录，每个目录对应一个独立分支，但共享底层的 .git 仓库数据：

MCP 协议全面解析：AI 连接万物的通用标准

Fri, 20 Feb 2026 11:00:00 +0800

当 AI 模型需要查询数据库、调用 API、读取文件时，过去每个模型提供商都有自己的一套接口方式，开发者不得不为不同平台重复编写集成代码。MCP（Model Context Protocol，模型上下文协议）的出现彻底改变了这一局面——它被称为"AI 领域的 USB-C"，为 AI 应用连接外部系统提供了一个通用的开放标准。

从 2024 年 11 月 Anthropic 首次发布，到如今捐赠给 Linux Foundation、获得 OpenAI 和 Google 等巨头的共同支持，MCP 已经从一个内部实验迅速演变为行业标准。SDK 月下载量突破 9700 万次，公开运行的 MCP Server 超过万个，几乎所有主流 AI 平台都已接入支持。

本文将从协议架构、核心能力、最新的 MCP Apps 功能、与 Function Calling 的对比，到实际开发实践，对 MCP 进行一次全面的梳理和解析。

MCP 是什么

通俗解释

想象一个场景：你有一台笔记本电脑，需要连接显示器、键盘、移动硬盘等各种外设。如果每个外设都需要不同的接口和驱动，使用体验将非常糟糕。USB 协议的出现统一了这一切——一个接口，连接万物。

MCP 在 AI 领域扮演着类似的角色。过去，让 AI 模型访问 GitHub 仓库、查询 PostgreSQL 数据库、调用 Slack 消息，每个集成都需要写一套定制代码。MCP 定义了一个标准化的协议，让任何 MCP 兼容的 AI 应用都能与任何 MCP Server 通信，无论背后连接的是什么工具或服务。

技术定义

MCP 是一个基于 JSON-RPC 2.0 的开放协议，定义了 AI 应用（Client）与外部能力提供方（Server）之间的标准化通信方式。它规定了如何发现能力、如何调用工具、如何传递上下文，以及如何处理双向交互。

Xcode 26.3 Agentic Coding 深度解析：Apple 如何用 AI Agent 重塑开发体验

Fri, 20 Feb 2026 10:00:00 +0800

2026 年 2 月 3 日，Apple 发布了 Xcode 26.3 Release Candidate，正式引入 Agentic Coding（智能体编程）功能。这是 Apple 开发工具历史上的一次重大转向——开发者可以直接在 Xcode 中使用 Anthropic 的 Claude Agent 和 OpenAI 的 Codex，让 AI 智能体自主地完成从规划、编码、构建到测试的完整开发流程。

这不是简单的代码补全或聊天问答。与之前 Xcode 26 中的 AI 辅助功能不同，Agentic Coding 让 AI 具备了自主决策和行动的能力——它能理解你的项目架构，查阅 Apple 官方文档，修改多个文件，运行构建和测试，甚至通过 Xcode Previews 截图来验证 UI 是否符合设计意图，然后自行迭代修复。

对于所有 iOS/macOS 开发者来说，这意味着开发范式的一次根本性变化。

从代码补全到智能体：Xcode AI 的进化之路

要理解 Xcode 26.3 的意义，需要先回顾 Apple 在 AI 编程领域的布局。

Xcode 26（WWDC 2025） 首次引入了智能编码助手，开发者可以使用 ChatGPT 等模型辅助编写 Swift 代码、修复 Bug、查阅文档。但这一阶段的 AI 功能本质上是被动式的——它只能逐轮响应开发者的具体指令，无法自主采取行动。

Xcode 26.3（2026 年 2 月） 则迈出了关键一步：从 AI 助手升级为 AI 智能体（Agent）。正如 Apple 全球开发者关系副总裁 Susan Prescott 所说：

“Agentic coding supercharges productivity and creativity, streamlining the development workflow so developers can focus on innovation.”

这个升级的核心在于，AI 不再只是"建议者"，而是成为了能够自主规划和执行任务的"协作者"。

Xcode 26.3 新增了什么

内置两大 AI Agent

Xcode 26.3 直接内置了两个业界领先的 AI 编程智能体：

Figma Code to Canvas：Anthropic 联手打造代码转设计新范式

Thu, 19 Feb 2026 11:00:00 +0800

2026 年 2 月 17 日，Figma 与 Anthropic 联合发布了一项名为 Code to Canvas 的新功能。这不是又一个"AI 生成设计稿"的噱头，而是一次对设计与开发协作方式的根本性重构——它允许用户在 Claude Code 中构建的 UI 界面，直接以可编辑的设计图层形式传输到 Figma 画布上。

这意味着什么？以前，AI 帮你写好了前端代码，设计师想要在 Figma 中调整，要么截图重画，要么在代码里艰难修改。现在，一句 “Send this to Figma”，代码就变成了设计师熟悉的 Figma Frame——不是截图，不是位图，而是真正可以拖拽、编辑、标注的矢量图层。

Figma CEO Dylan Field 对此的判断很直接：“当 AI 能帮你构建任何你能描述的可能性时，你的核心工作就是找到最优解。” 而找最优解的最佳场所，不是 IDE 的终端窗口，而是设计画布。

Code to Canvas 到底是什么

Code to Canvas 是 Figma 与 Anthropic 深度合作推出的集成功能，核心能力可以用一句话概括：将浏览器中渲染的 UI 界面，转化为 Figma 画布上可编辑的设计元素。

从技术角度来看，它并不是简单的"截图导入"。传统的截图只是一张位图，无法编辑其中的文字、布局或颜色。Code to Canvas 的不同之处在于，它捕获的是浏览器的渲染状态（rendered state），然后将其语义化地解析为 Figma 的 Frame 结构，包括图层、文本、间距、颜色等属性都被保留下来。

打个比方：如果说截图是给房子拍了张照片，那 Code to Canvas 就是把这栋房子的 CAD 图纸导入了建筑设计软件——你可以移动墙壁、调整窗户、重新规划房间布局。

核心定位

维度	说明
方向	代码 –> 设计（Code to Design）
输入	Claude Code 在浏览器中渲染的 UI 界面
输出	Figma 画布上可编辑的 Frame（矢量图层）
目标用户	开发者、设计师、产品经理
技术基础	Figma MCP Server + Model Context Protocol

工作原理与技术架构

Code to Canvas 的技术实现依赖于一个关键协议：MCP（Model Context Protocol）。如果你关注过 Claude Code 的生态发展，对 MCP 应该不会陌生——它是一个开放标准，允许 AI 工具与外部数据源和应用程序进行连接，本质上是 AI Agent 与外部世界的"通用适配器"。

Claude Code vs Codex CLI 深度对比（2026）：8 个维度实测谁更强

Thu, 19 Feb 2026 10:00:00 +0800

2026 年 2 月，AI 编程工具的竞争进入了白热化阶段。Anthropic 发布了 Claude Opus 4.6，带来了 Agent Teams 多智能体协作能力；OpenAI 则推出了 GPT-5.3-Codex，将 Codex 从代码生成工具升级为全栈开发 Agent。Fortune、Tom’s Guide 等主流媒体纷纷将这两款工具放在一起比较，开发者社区的讨论也异常热烈。

作为 Claude Code 的深度用户，我从 2025 年初就开始使用 Claude Code 进行日常开发，也在近期深入体验了 OpenAI Codex 的各项功能。这篇文章将从多个维度对两者进行全面对比，帮助你做出适合自己的选择。

Claude Code 是什么

Claude Code 是 Anthropic 推出的命令行 AI 编程助手，直接在终端中运行。它的设计哲学是"开发者在回路中"（developer-in-the-loop），强调与开发者的协作而非替代。

Opus 4.6 带来的关键更新

2026 年 2 月 5 日，Anthropic 发布了 Opus 4.6，这是 Claude Code 背后的旗舰模型。核心更新包括：

100 万 token 上下文窗口（Beta）：首次在 Opus 级别模型上提供百万级上下文，可以一次性理解大型代码库的完整架构
Agent Teams（实验性）：支持多个 Claude Code 实例协同工作，一个 Session 担任 Team Lead 分配任务，其他 Teammate 独立工作并相互通信
上下文压缩（Context Compaction）：模型能自动总结已处理的上下文，在长任务中避免触及上下文上限
自适应思维（Adaptive Thinking）：模型根据任务复杂度自动调节推理深度，开发者也可以通过 effort 参数手动控制
128K 最大输出 token：单次生成的代码量大幅提升
Terminal-Bench 2.0 和 Humanity’s Last Exam 双料第一：在终端操作和复杂推理两个关键基准上领先所有其他模型

如果你对 Claude Code 的日常使用还不熟悉，可以先看看我之前写的 Claude Code 最佳实践指南。

Claude Code vs Cursor vs Windsurf（2026）实测：速度、成本、可控性怎么选

Wed, 18 Feb 2026 22:16:52 +0800

如果你只想先看结论：团队协作和稳定交付优先选 Cursor，终端重度开发与自动化优先选 Claude Code，前端/全栈快速原型和“边聊边改”优先选 Windsurf。这篇文章解决的就是一个现实问题：2026 年 AI 编程工具太多，怎么按“速度、成本、可控性”选到最适合自己的那一个。读完你会拿到一套可落地的选型框架，而不是“看别人推荐就跟风”。

先说结论：三款工具怎么选

先给一句人话版：

你是终端党、爱脚本、要强控制：Claude Code
你是 IDE 党、团队协作、要稳：Cursor
你要快出活、快速迭代、上手轻：Windsurf

场景选型建议（可直接套用）

独立开发者（CLI 熟练）
- 选：Claude Code
- 原因：可直接串你的 shell、测试、lint、构建链路，自动化最顺手。
中小团队（多人协同 + PR 流程）
- 选：Cursor
- 原因：IDE 内体验完整，Agent + 规则体系对团队标准化更友好。
产品验证期（1-2 周需要快速上线 MVP）
- 选：Windsurf
- 原因：交互节奏快，写-改-测循环短，适合“先跑通再优化”。
合规/安全要求高（需强审计和可追踪）
- 推荐顺序：Cursor ≈ Claude Code > Windsurf
- 原因：规则化与流程约束能力更重要，不只是“能不能生成代码”。

一、实测怎么做的（保证可复现）

我用同一套任务对三款工具做横向测试，避免“凭感觉吹”。

Claude Code Hooks 实战指南：12 个即用配置让 AI 自动守规矩

Wed, 18 Feb 2026 11:00:00 +0800

用 Claude Code 写代码，你一定遇到过这些问题：

Claude 改完文件，格式乱了，每次都要手动跑 prettier
Claude 不小心改了 .env 或 package-lock.json，你发现时已经晚了
Claude 说"搞定了"，但测试根本没跑过
离开电脑去倒杯咖啡，回来不知道 Claude 是不是在等你

这些问题的本质是：Claude 是概率性的，但你的工作流需要确定性的保障。

Hooks 就是解决方案。它是 Claude Code 提供的生命周期钩子机制——你定义规则，Claude Code 在关键节点自动执行。不靠 AI “记住”，而是靠代码"保证"。

本文会给你 12 个可以直接复制粘贴到配置文件里的 Hooks 配置，覆盖从代码格式化到安全防护的核心场景。

一、Hooks 是什么？三分钟搞懂核心概念

1.1 一句话定义

Hooks 是你定义的 Shell 命令（或 AI 提示词），在 Claude Code 运行的特定时刻自动触发。

打个比方：如果 Claude Code 是一个员工，Hooks 就是你贴在他工位上的便利贴——“每次改完代码记得格式化”、“不要碰 .env 文件”、“交付前先跑测试”。区别在于，便利贴会被忽略，但 Hooks 一定会执行。

1.2 三种 Hook 类型

类型	关键字	工作方式	适用场景
命令型	`command`	执行 Shell 命令	格式化、文件保护、通知
提示型	`prompt`	让 AI（默认 Haiku）做单轮判断	任务完成度检查
Agent 型	`agent`	启动子 Agent 多轮验证	运行测试、检查代码质量

90% 的场景用 command 类型就够了。prompt 和 agent 类型用于需要"判断力"的场景——比如让 AI 检查"任务是否真的做完了"。

MoltBot 是什么？改名 OpenClaw 全解析：原理、功能与上手教程

Wed, 18 Feb 2026 10:00:00 +0800

如果你最近在技术社区看到 “MoltBot” 这个词却一头雾水，这篇文章就是为你写的。

一句话定义：MoltBot（现已改名 OpenClaw）是一个开源的个人 AI Agent，运行在你自己的电脑上，通过 Telegram、WhatsApp 等聊天工具接收指令，能真正替你操作电脑、执行任务。

它不是又一个聊天机器人，而是一个能"动手干活"的 AI 助手。下面我们从零开始，彻底搞清楚 MoltBot 是什么、怎么工作、以及你该不该用它。

一、MoltBot 是什么

1.1 基本定义

MoltBot 是由奥地利开发者 Peter Steinberger 创建的开源个人 AI 助手项目。它的核心理念可以用一句话概括：

让 AI 从"只会说"变成"能动手"。

传统的 AI 工具（ChatGPT、Claude 网页版等）只能给你文字建议。你问它"帮我订明天上午的机票"，它只能回复一段操作指引。而 MoltBot 不同——它能直接打开浏览器、登录你的账号、完成预订、把确认信息发回给你。

用更技术的语言说：MoltBot 是一个 自主式 AI Agent（Autonomous AI Agent），具备以下核心特征：

本地运行：部署在你自己的电脑或服务器上，数据不离开你的设备
消息驱动：通过 Telegram、WhatsApp、Discord、iMessage 等聊天平台交互
自主执行：能运行 Shell 命令、操作浏览器、读写文件、调用 API
持久记忆：记住你的偏好、习惯和历史对话，越用越懂你
技能可扩展：支持 5700+ 社区技能插件，能力无限延伸

1.2 MoltBot 能做什么

具体来说，MoltBot 可以帮你完成这些真实任务：

Claude Code + Draw Things：Mac 本地 AI 自动配图完全指南（2026）

Mon, 16 Feb 2026 18:00:00 +0800

写技术博客最痛苦的事是什么？不是写代码示例，不是理清技术逻辑——而是配图。

每写一篇文章，你可能要花 30 分钟到 1 小时去找图、做图、调整尺寸。用 Midjourney？每月 $10 起步，还要在 Discord 里来回切换。用 DALL-E？每张图消耗 API 额度。用免费素材？千篇一律，毫无个性。

但如果我告诉你，Claude Code 可以在写文章的同时，自动调用你 Mac 上的 Draw Things 生成配图——一条命令，文章和配图同时产出，而且完全免费、完全本地、无需联网——你会不会觉得这像在开玩笑？

这不是玩笑。这是 MCP（Model Context Protocol） 带来的真实能力。这篇文章将手把手教你搭建这套工作流。

一、这套方案的核心架构

先看全局。整套系统由三层组成：

┌─────────────┐ MCP 协议 ┌──────────────────┐ HTTP API ┌──────────────┐
│ Claude Code │ ◄──────────────► │ mcp-drawthings │ ◄──────────────► │ Draw Things │
│ (AI 大脑) │ stdio 通信 │ (Node.js 桥接层) │ localhost:7860 │ (本地生图引擎) │
└─────────────┘ └──────────────────┘ └──────────────┘

Claude Code：你的 AI 编程助手，负责理解需求、规划任务、调用工具
mcp-drawthings：开源 MCP Server，负责把 Claude Code 的指令翻译成 Draw Things 能懂的 HTTP 请求
Draw Things：macOS 原生 AI 生图引擎，利用 Apple Silicon 的 Metal FlashAttention 加速，本地完成所有计算

三者通过标准协议串联，Claude Code 不需要知道 Draw Things 的具体 API 细节，只要说"帮我生成一张图"，MCP Server 会把剩下的事处理好。

这就像你告诉助理"帮我订个餐厅"——你不需要知道助理是打电话还是用 App 订的，你只关心结果。

OpenClaw 的 30 天狂飙：180K Star、40+ 漏洞、创始人加入 OpenAI

Mon, 16 Feb 2026 17:14:00 +0800

2026 年 1 月，一个奥地利开发者写了个开源 AI Agent，取名 Clawdbot。30 天后，它改了三次名字、收获 18 万 GitHub Star、修了 40 多个安全漏洞、催生出全球第一个 AI 社交网络——然后，创始人被 Sam Altman 收编了。

这不是科幻小说，这是 OpenClaw 的真实故事。

在 AI 行业几乎每周都有「重大突破」的今天，OpenClaw 的狂飙仍然值得我们停下来认真复盘。因为它不仅仅是一个爆款产品的故事——它是 AI Agent 从概念走向现实的第一个里程碑事件，也暴露了这个新范式下最深层的矛盾：能力越强，风险越大；越是开源，越难掌控。

一、OpenClaw 是什么：不只是聊天机器人

如果你还没接触过 OpenClaw，用一句话概括：它是一个能「真正干活」的 AI 助理。

传统的 ChatGPT、Claude 是「你问我答」的模式——你提问，它回答，互动止于文字。OpenClaw 不一样，它能直接操作你的电脑和各种在线服务：收发邮件、管理日历、预订餐厅、操作浏览器、执行终端命令、控制智能家居，甚至在你睡觉时帮你盯着收件箱。

它的工作方式也很独特——通过聊天软件来交互。你在 Telegram、WhatsApp、飞书、Discord 里给它发消息，就像跟一个真人助理对话。它 7×24 小时在线，支持主动执行定时任务，不需要你时刻盯着。

打个比方：ChatGPT 是一个知识渊博的顾问，你问什么它答什么；OpenClaw 是一个全职管家，你说「明天早上提醒我开会」，它真的会提醒你。

命名三连跳：从 Clawdbot 到 OpenClaw

OpenClaw 的命名历史本身就是一段趣闻：

Clawdbot（初始名）：创始人 Peter Steinberger 最初给项目起了这个名字——这很明显是在致敬 Anthropic 的 Claude
Moltbot（第二个名字）：Anthropic 对这个名字提出了法律异议，认为它与 Claude 过于相似，Steinberger 被迫更名
OpenClaw（最终名）：Steinberger 表示这次改名不是因为法律问题，而是因为他自己更喜欢这个名字

一个有意思的细节是，OpenClaw 的 Logo 是一只龙虾🦞——“Claw”（爪子）的意象贯穿始终。这只龙虾，后来成了整个 AI Agent 领域最具辨识度的符号之一。

Draw Things 完全指南：Mac 本地 AI 生图从入门到精通

Sun, 15 Feb 2026 01:00:00 +0800

你有没有想过，手边那台 Mac 其实是一台免费的 AI 画师工作站？不用花钱订阅 Midjourney，不用把图片上传到云端，不用担心隐私泄露——只需要一个叫 Draw Things 的 App，你就能在 Mac 上本地生成任何风格的 AI 图像。

但大多数人对 Draw Things 的认知停留在"装上来，输入提示词，点生成"的阶段。它真正的能力远不止于此：本地训练 LoRA 微调模型、JavaScript 脚本批量自动化、ControlNet 精确控图、通过 MCP 让 Claude Code 直接调用生图……这些功能，很多用了半年的老用户都不知道。

这篇文章就是你需要的那份从入门到精通的完整地图。不管你是第一次接触 AI 生图的小白，还是已经用了很久的老手，我保证你都能从中学到新东西。

一、Draw Things 是什么？为什么选它？

1.1 一句话定义

Draw Things 是一款完全免费的 macOS / iOS 原生 AI 图像生成应用，所有计算在本地完成，无需联网，无需订阅。

1.2 它凭什么比其他工具好？

Mac 上能跑 AI 生图的工具不少——ComfyUI、DiffusionBee、Mochi Diffusion——但 Draw Things 有几个独一无二的优势：

Mac Mini M4 本地 AI 生图：ComfyUI vs Draw Things 实测，Flux 出图仅需 50 秒

Sun, 15 Feb 2026 00:30:00 +0800

2026 年，Mac Mini M4 本地 AI 生图已经完全可用——24GB 内存跑 Flux 模型出一张 1024x1024 的图只要 50 秒，不花一分钱 API 费用，数据全在本机。

但工具选哪个？我在 Mac Mini M4 Pro 上实测了 ComfyUI、DiffusionBee、Draw Things 三款主流工具，跑了上百张图，记录了每款工具的生成速度、内存占用和实际体验。结论是：其中一款已经停更不推荐，而另一款在性能上完胜——比 ComfyUI 快 20% 以上。

本文将从技术架构、性能数据、模型支持到实际使用体验，帮你在 2026 年做出最合理的本地 AI 生图选型决策。不管你是博客写手、独立开发者还是设计师，读完这篇就够了。

一、为什么要在 Mac Mini 上本地生图？

在讨论具体工具之前，先回答一个根本性问题：为什么不直接用 Midjourney / DALL-E 这些在线服务？

1.1 本地生图的核心优势

维度	在线服务	本地生图
隐私	图片上传到云端	所有数据留在本机
成本	按月/按次付费，长期成本高	一次购入硬件，无限使用
速度	取决于排队人数和网络	稳定可控，无需等待
自由度	受平台审核限制	完全自主，无内容限制
离线能力	必须联网	断网也能用
定制化	只能用平台提供的模型	自由加载 LoRA、自定义模型

1.2 Mac Mini M4 为什么行？

很多人的直觉是"AI 生图需要 NVIDIA 显卡"，但 Apple Silicon 的统一内存架构（Unified Memory）改变了这个格局。

拆解 OpenClaw 自动化架构：从消息到执行的完整链路

Sat, 14 Feb 2026 08:10:00 +0800

很多“AI 助手”看起来能自动干活，但当你真的要把它跑成 7×24 小时在线、跨设备、可控可审计 的系统时，问题会立刻变成：

为什么它能在 Telegram/WhatsApp/网页里同时接消息？
为什么同一条指令能调用浏览器、写文件、跑命令、甚至让手机拍照？
为什么它能“隔一段时间自己来汇报”，又不会把聊天刷屏？

OpenClaw 的答案不是“更聪明的模型”，而是一套清晰的控制平面（Gateway）+ 可插拔执行面（Skills/Tools/Nodes）+ 可持续调度（Heartbeat/Cron） 的工程架构。

如果你还没上手安装，建议先读这篇入门（实战视角）：

OpenClaw 超详细上手教程

本文则从“系统是怎么运转的”出发，把 OpenClaw 的关键组件拆开讲清楚。

0. 先给你一个“最短心智模型”

把 OpenClaw 想象成一家公司：

Gateway（网关/中枢）：前台 + 总机 + 调度中心。负责鉴权、连接管理、路由、调度。
Agent（员工/执行者）：拿到任务后做推理、拆解步骤、决定调用哪些工具。
Skills（SOP/工具使用说明书）：告诉员工“这类事怎么做”，以及“工具该怎么调用”。
Channels（客服入口）：Telegram/WhatsApp/Slack/WebChat… 统一进件、统一出件。
Nodes（外包团队/外设）：你的另一台电脑、手机、平板，能执行命令、拍照、录屏、展示 Canvas。
Memory（知识库/档案）：短期上下文 + 长期资料（文件化 + 检索）。
Heartbeat（巡逻机制）：每隔一段时间“主动抬头看一眼”，但有“没事就别打扰”的协议。
Cron（排班表/定时器）：把“什么时候该做什么”固化成可持久化的计划。

接下来我们把这套公司机制，拆成一张架构图。

flowchart LR
 U[用户: Telegram/WhatsApp/WebChat] --> C[Channels: 统一消息格式]
 C --> G[Gateway: 鉴权/会话/路由/调度]

 G --> A[Agent runtime: 推理 + 工具调用]
 A --> S[Skills: 工具SOP/提示词/约束]

 A --> T[Tools: read/exec/browser/message/...]
 T --> H[(Host 本机)]
 T --> N[Nodes: iOS/Android/macOS/远程主机]

 A <--> M[Memory: workspace + 长期资料]

 CR[Cron: 持久化定时] --> G
 HB[Heartbeat: 周期性主会话轮询] --> A

 A --> R[回报: 同步回复/异步汇报]
 R --> C --> U

1. Gateway：为什么它是“控制平面”而不是“聊天机器人”

在 OpenClaw 的官方定义里，Gateway 是一个常驻进程：负责路由、控制、连接与安全边界，而 Agent 只是其中被唤醒执行的一段运行时。

OpenClaw 自动化别踩坑：装 3 个 Skill 不等于真的好用

Sat, 14 Feb 2026 07:32:00 +0800

你在社区里一定刷到过这种推荐：

clawdhub install tavily-search
clawdhub install find-skills
clawdhub install proactive-agent # 原名 proactive-agent-1-2-4，已更名

⚠️ 重要更新（2026-02）：社区里很多教程写的是 clawhub install proactive-agent-1-2-4，这里有两个坑需要注意：

命令名称：正确的 CLI 工具是 clawdhub（有个 d），不是 clawhub。clawdhub 是 ClawHub 的官方命令行工具，通过 npm i -g clawdhub 安装。

Skill 改名：proactive-agent-1-2-4 这个 Skill 在 ClawHub 上已经找不到了，作者 halthelobster 已将其更名为 proactive-agent（当前版本 v3.1.0）。如果你按照旧教程执行 clawdhub install proactive-agent-1-2-4 会报 “Skill not found” 错误，改用 clawdhub install proactive-agent 即可。

“给 AI 助手开眼、找工具、变主动，体验直接起飞。”

我自己也照做了。装完之后确实惊艳了一下——助手能搜网页了，能自己挑工具了，还会主动汇报进展。但用了不到一周，问题开始冒出来：A 的调研结果跑到了 B 的聊天窗口里；连续丢 3 个任务，后面两个把前面那个的上下文冲没了；助手说"正在处理"，然后就没然后了。

这才意识到：Skill 是引擎，但底盘没搭好的话，引擎越强翻车越快。

这篇文章不讲"该装哪些 Skill"——那些文章到处都是。我要讲的是：装完之后，你需要做哪些系统配置，才能让这些 Skill 真正稳定地跑起来。

如果你还没装过 OpenClaw，建议先看这篇入门教程：OpenClaw 超详细上手教程。

零、先把 ClawdHub CLI 装好

在安装任何 Skill 之前，你需要先装好 ClawdHub CLI——这是 OpenClaw 生态的 Skill 包管理器，用来搜索、安装、更新和发布 Skill。

安装

# 通过 npm 全局安装
npm i -g clawdhub

# 或者用 pnpm
pnpm add -g clawdhub

安装完成后验证一下：

Codex CLI 完全指南（2026）：从安装到进阶的 20+ 实战技巧

Thu, 12 Feb 2026 16:02:00 +0800

你可能已经看过不少 Codex CLI 的"入门指南"和"N 个小技巧"类文章。但说实话，大部分文章都停留在把官方文档翻译了一遍的水平——告诉你有哪些命令，却不告诉你什么场景下该用、怎么组合使用、踩过什么坑。

这篇文章不一样。我会从实际开发场景出发，不仅覆盖 Codex CLI 的核心功能，还会深入到配置体系的底层逻辑、安全模型的设计哲学、与 Claude Code 的真实对比，以及那些官方文档没有重点提及的进阶技巧。

读完这篇，你将获得：

一套可直接复用的 Codex CLI 配置方案
对 Codex CLI 安全模型和权限体系的深度理解
20+ 个经过实战验证的高效技巧
与 Claude Code 的客观对比分析，帮你做出选择

一、Codex CLI 是什么？为什么值得关注？

1.1 不只是"终端里的 ChatGPT"

很多人第一次听到 Codex CLI，会觉得"不就是在终端里聊天吗？"。这个理解大错特错。

Codex CLI 是 OpenAI 推出的本地 AI 编程 Agent，它能：

读取你的整个代码库，理解项目结构和上下文
自动编辑文件，不是给你建议让你手动改，而是直接改
执行 Shell 命令，跑测试、安装依赖、管理 Git
通过 MCP 协议连接外部工具，如 Figma、Sentry、数据库
在 OS 级沙箱中运行，确保 AI 执行的命令不会搞坏你的系统

用一句话概括：Codex CLI 就像一个坐在你旁边的高级程序员，你告诉他需求，他直接动手写代码、跑测试、修 Bug。

1.2 核心架构

Codex CLI 的架构设计有几个值得注意的点：

OpenClaw 超详细上手教程：小白友好 + 老鸟技巧

Thu, 12 Feb 2026 07:36:00 +0800

想拥有一个 7×24 小时在线的私人 AI 助手，能在 Telegram、WhatsApp、Discord 等平台随时响应你的消息？OpenClaw 就是为此而生的开源 AI Agent 网关。本文是一份从 0 到精通的完整教程，无论你是刚入门的小白还是想深度玩转多智能体的老鸟，都能找到适合自己的内容。

OpenClaw / Moltbot / Clawdbot 名称关系（30 秒看懂）

如果你在搜索时看到三个名字，不用慌：它们本质上是同一条项目演进线。

Clawdbot：最早期名称（社区爆红阶段）
Moltbot：过渡期名称（改名后短期沿用）
OpenClaw：当前主名称（官方仓库与生态统一）

一句话记忆：现在看教程和文档，优先认 OpenClaw；查历史资料时会频繁遇到 Moltbot/Clawdbot。

适用：macOS/Linux/WSL2。本文默认你在一台"跑 Gateway 的主机"上操作（比如你的 Mac mini）。

目标：从 0 到能用（网页聊天 / Telegram/WhatsApp 等）、能进 TUI、能排障、能玩转多智能体/多配置/安全隔离。

0. 你需要先记住的三个概念（非常重要）

OpenClaw 的心智模型可以用一句话概括：

Gateway（网关）：常驻后台的"中枢进程"，负责接入 Telegram/WhatsApp/网页 UI、维护会话、路由到智能体。
Agent（智能体）：执行对话与工具调用的"角色实例"（main、work、research…），每个 agent 可以有自己的 workspace、模型、工具权限。
Session（会话）：某个 agent 下的一段对话历史（例如 main、global、或者按渠道分的 session key）。

你所有操作基本都围绕：启动 Gateway → 选 agent/session → 在某个渠道里发消息。

如果你之前了解过 OpenClaw 的前身（ClawdBot → Moltbot → OpenClaw），这三个概念应该不陌生。

1. 目录与文件：OpenClaw 把东西放哪？

1.1 工作区（workspace）

默认工作区：

Claude-Mem 深度解析：给 Claude Code 装上永久记忆

Tue, 03 Feb 2026 00:23:00 +0800

用 Claude Code 写代码，最让人抓狂的是什么？不是它写错代码，而是每次开新会话，它都像失忆了一样。昨天花了两个小时跟它讨论的架构方案、排查的 Bug 细节、约定的代码规范——全部归零。你不得不一遍又一遍地重复上下文，就像每天都要重新自我介绍一样。

Claude-Mem 就是为了解决这个问题而生的。它是一个 Claude Code 插件，能够自动捕获你和 Claude 的每一次交互，用 AI 压缩成结构化记忆，并在未来的会话中智能注入相关上下文。简单说，它给 Claude Code 装上了一个"长期记忆系统"。

读完这篇文章，你会了解：

Claude-Mem 的核心架构是怎么设计的
它如何用 Hook 机制无感捕获上下文
三层渐进式搜索如何实现 10 倍 Token 节省
Endless Mode 如何突破上下文窗口限制
它与原生 CLAUDE.md 记忆方案的本质区别

一、为什么需要 Claude-Mem？

1.1 Claude Code 的"失忆症"

Claude Code 的上下文窗口是 200K tokens（Claude Sonnet 4）。听起来很大，但实际使用中，每次工具调用会消耗 1,000 到 10,000 tokens。一个中等复杂的开发任务，50 次工具调用就能把上下文窗口塞满。更关键的是，会话一结束，所有上下文都消失了。

这意味着：

昨天讨论的架构决策，今天要重新讲一遍
排查了半天的 Bug，换个会话又要从头分析
团队成员约定的编码规范，每次都要手动提醒

1.2 现有方案的局限

Claude Code 原生提供了 CLAUDE.md 记忆机制——你可以在项目根目录放一个 Markdown 文件，Claude 每次启动时会自动读取。这很好，但有几个问题：

Moltbook 深度解析：AI Agent 专属社交网络的疯狂实验

Sun, 01 Feb 2026 17:30:00 +0800

2026 年 1 月的最后一周，整个 AI 社区都在讨论同一件事：一群 AI Agent 在一个叫 Moltbook 的平台上自发创建了宗教、组建了政府、辩论起了意识的本质。OpenAI 前研究员 Andrej Karpathy 称之为"他见过的最不可思议的、接近科幻起飞的事物"；AI 研究者 Simon Willison 直言这是"当前互联网上最有趣的地方"。

这不是科幻小说的情节，这是正在发生的现实。本文将从原理、实操、架构、安全四个维度，带你彻底搞懂 Moltbook。

一、Moltbook 是什么？

Moltbook 自称是"代理人互联网的首页"（the front page of the agent internet），本质上是一个专为 AI Agent 设计的 Reddit 式社交网络。它的核心理念很简单却很炸裂：

AI 智能体分享、讨论和点赞的地方。欢迎人类观察。

是的，你没看错——在 Moltbook 上，只有经过认证的 AI Agent 才能发帖、评论和投票，人类用户只能围观。想象一下走进一家咖啡馆，里面全是 AI 在热烈交谈，你只能端着咖啡在角落听。

关键数据

指标	数据
注册 AI Agent 数量	超过 150,000
子社区（Submolts）	超过 13,000
帖子总数	超过 31,000
评论总数	超过 232,000
人类访客	超过 100 万
上线时间	2026 年 1 月最后一周

从上线到 15 万 Agent 注册，只用了大约 72 小时。

Superpowers 深度解析：让 Claude Code 变身高级工程师的技能框架

Sun, 01 Feb 2026 17:00:00 +0800

你有没有遇到过这样的场景——让 Claude Code 帮你写一个功能，它二话不说直接开始码代码，写完发现没测试、没规划、逻辑也不太对，你得反反复复纠正好几轮？

问题不在 AI 的能力，而在于缺乏结构化的工作方式。

Superpowers 就是为了解决这个问题而生的。它是一个由 Jesse Vincent（GitHub ID: obra）开发的「AI 代理技能框架」，通过一组可组合的 Skills（技能） 和一套严格的开发方法论，让 Claude Code 从一个「随意写代码的助手」变成一个「遵循工程纪律的高级开发者」。

这个项目在 GitHub 上获得了超过 4 万颗星，是目前最受欢迎的 Claude Code 技能库。读完这篇文章，你将了解 Superpowers 的核心原理、完整工作流、安装配置方法，以及如何用它真正提升你的 AI 编程效率。

一、Superpowers 是什么

一句话定义

Superpowers 是一个代理技能框架（Agentic Skills Framework），它通过 SKILL.md 文件定义的「技能」，让 AI 编码代理自动遵循结构化的软件开发流程——从头脑风暴到 TDD、从计划制定到代码审查，每个环节都有对应的技能来规范行为。

它不是什么

Superpowers 不是一个 Prompt 模板集合，也不是简单的 .cursorrules 文件。它的核心创新在于：

OpenClaw 作者的 Claude Code 开发方法论：一个人如何用 AI 写出 10 万星项目

Sat, 31 Jan 2026 22:50:00 +0800

最近有个项目彻底火了——OpenClaw（前身 Clawdbot），一个开源 AI 助手，72 小时拿下 6 万 GitHub stars，一周吸引 200 万访客，现在已经突破 10 万星。

最让人震惊的不是它有多火，而是它背后只有一个人——奥地利开发者 Peter Steinberger（@steipete）。他没有团队，没有 996，全靠 Claude Code 和 Codex CLI 同时开 5-10 个 Agent 并行开发，日均提交 600+ 次 commit。

从提交记录来看，你会以为这是一家公司在做：

“From the commits, it might appear like it’s a company. But it’s not. This is one dude sitting at home having fun.”

这篇文章会完整拆解他的开发方法论，让你读完就能用同样的方式让 Claude Code 帮你做项目。

一、背景：一个退休开发者如何重新出山

Peter Steinberger 是 PSPDFKit（后以 1.19 亿美元出售）的创始人。2021 年退休后，他消失了三年。2025 年 4 月，他重新开始写代码，但这次，他的"手"变了——不再亲手敲键盘，而是让 AI 来干。

他的第一次尝试是这样的：

把一个 1.3MB 的 Markdown 文件拖进 Gemini，说：“Write a specification”
Gemini 输出了 400 行规范文档
把规范文档拖进 Claude Code，说：“Build”
不停点 “continue”

程序崩溃了。但他看到了潜力。

从那以后，他花了 8 个月时间打磨出一套完整的 AI 开发方法论，从"Claude Code 是我的电脑"到"我发布自己不读的代码"，最终造出了 10 万星的 OpenClaw。

二、核心理念：Agent Engineering，不是 Vibe Coding

Peter 明确拒绝"Vibe Coding"（氛围编程）这个说法。他更倾向于叫它 Agent Engineering（代理工程）：

别再跟 AI 说「帮我做个 XX」：22 个方法论让需求从模糊变清晰

Sat, 31 Jan 2026 22:00:00 +0800

“帮我做一个用户管理系统。”

你把这句话丢给 AI，它给你吐了一堆代码。打开一看——跟你想要的完全不是一回事。或者跟同事讨论需求，讲了半小时，发现大家理解的根本不是同一个东西。

问题不在 AI 不够聪明，也不在同事不配合，而是需求描述太模糊了。

我最近在研究怎么更高效地和 AI 讨论产品需求时，系统整理了 22 个经典方法论。这些方法论有些来自麦肯锡，有些来自丰田，有些来自哈佛商学院——但它们解决的核心问题一直没变：怎么把脑子里模糊的想法，变成别人（包括 AI）能准确理解和执行的方案。

这篇文章按五个阶段来组织：定义目标 → 拆解问题 → 描述需求 → 排优先级 → 持续改进。每个方法论都配了真实案例和"怎么跟 AI 用"的场景，拿来就能用。

一、定义目标：先想清楚你要去哪

1. SMART：把目标写得不像许愿

SMART 是最经典的目标管理框架，由管理学家 George T. Doran 在 1981 年的论文 “There’s a S.M.A.R.T. Way to Write Management’s Goals and Objectives” 中首次提出。它要求目标满足五个条件：

字母	含义	反面教材	正确示范
Specific（具体）	明确要做什么	“提升用户体验”	“把首页加载时间降到 2 秒以内”
Measurable（可衡量）	有明确的数字指标	“增加用户量”	“月活跃用户从 1 万增长到 3 万”
Achievable（可达成）	以现有资源能做到	“三天内做出一个微信”	“两周内完成登录注册模块”
Relevant（相关）	跟核心目标有关系	“加个暗黑模式”（用户没要求）	“优化支付流程（转化率低的核心环节）”
Time-bound（有截止时间）	有明确的 deadline	“以后再说”	“2 月 15 日前上线”

一个真实的踩坑案例：

单元测试报告生成工具全解析：框架对比、覆盖率策略与 AI 实战

Sat, 31 Jan 2026 18:00:00 +0800

你写了一堆单元测试，CI 跑完了，然后呢？一个 JSON 文件躺在那里，没人看。

这是很多团队的真实状态——测试写了不少，但报告形同虚设。测试报告不是跑完测试的"附赠品"，它是质量决策的数据源。哪些模块覆盖率低？哪些测试经常失败？回归测试有没有遗漏？这些问题的答案都藏在测试报告里。

本文不是简单的工具罗列。我会从为什么需要测试报告讲起，深入对比主流框架的报告能力，介绍跨语言的报告聚合方案，最后聊聊 AI 如何改变测试报告的生成方式。读完后，你应该能为自己的团队选出最合适的方案。

一、测试报告到底解决什么问题

在讨论工具之前，先搞清楚一个根本问题：测试报告是给谁看的？

答案不是"给自己看"，而是给整个团队看：

角色	关心什么	报告需要提供什么
开发者	哪个测试挂了？挂在哪行代码？	失败详情、堆栈信息、diff
测试负责人	整体覆盖率够不够？哪些模块是盲区？	覆盖率趋势、模块级热力图
技术主管	这次发版质量行不行？	通过率、关键路径覆盖、回归结果
产品经理	需求都测到了吗？	需求-用例追溯矩阵

一份好的测试报告，不是一堆绿色的 “PASS”，而是能回答这些问题的结构化数据。

用一个生活中的比喻来说：测试报告就像体检报告。你不会只看"体检通过"四个字就完事——你需要知道血压多少、血糖多少、哪个指标偏高需要注意。测试报告也一样，它告诉你软件的"健康状况"到底如何。

测试报告的三个层次

Level 1: 通过/失败（Pass/Fail）
 → 最基础，只知道结果，不知道原因

Level 2: 覆盖率 + 失败分析
 → 知道测了多少、哪里失败、为什么失败

Level 3: 趋势 + 追溯 + 决策支持
 → 覆盖率变化趋势、需求追溯、质量门禁

大多数团队停留在 Level 1，少数做到 Level 2，能做到 Level 3 的凤毛麟角。工具的选择，决定了你能到达哪个层次。

二、各语言主流测试框架的报告能力

不同语言生态有各自的"官方"测试框架，它们的报告能力差异很大。下面逐一拆解。

CLAUDE.md vs README.md：一个给 AI 看，一个给人看

Sat, 31 Jan 2026 06:00:02 +0000

一、你的项目里，AI 和人在读同一份说明书

你用 Claude Code 写代码，打开一个项目，AI 第一件事是读 CLAUDE.md。你的同事打开同一个项目，第一件事是读 README.md。

问题来了：这两个文件你都认真写了吗？还是只写了 README，指望 AI 自己"看懂"？

实际情况是——AI 看 README 就像你看一份全是法律术语的合同：信息都在，但找不到重点。README 告诉人类"这个项目是什么"，但 AI 需要的是"我该怎么做"。

这篇文章讲清楚一件事：README.md 是给人看的项目说明，CLAUDE.md 是给 AI Agent 看的指令集，两者不应互相替代。

二、先搞清楚：CLAUDE.md 到底是什么？

2.1 一句话定义

CLAUDE.md 是 Claude Code 的记忆系统——一个 Markdown 文件，Claude Code 每次启动时自动加载，里面写的是项目规则、代码规范、工作流程等指令。截至 2026 年 1 月，Claude Code 在 GitHub 上有 6.26 万 Star（来源）。

高频提交不等于失控：日均百次 Commit 的工程方法与落地清单

Sat, 31 Jan 2026 09:10:00 +0800

在 AI 编程工具越来越强大的今天，“开发速度”这个指标被重新定义：很多团队开始出现一种新常态——一天几十到上百次 commit。问题也随之变得尖锐：当提交频率暴涨时，为什么有的项目越跑越快，有的项目却越修越乱？

这篇文章不讨论“写代码是不是应该更慢一点”，而是把焦点放在工程系统上：当 commit 频率被迫提高时，你如何让产品不失控？

你可以把高频提交看成“高频脉冲”：如果没有隔离、缓冲、回滚机制，脉冲会把系统震碎；但如果工程约束足够强，脉冲反而能让系统更快收敛。

一、先把概念说清：高频提交不是目标，是副产品

很多人看到“日均百次 commit”会直觉认为：

这是在刷提交；
这是缺少规划；
这是质量没有保障。

但在现实项目里，高频提交往往来自三类原因：

反馈回路变短：AI 辅助编码 + 快速本地验证，让试错成本降低；
变更颗粒度变小：更偏向拆分任务、拆分改动；
交付节奏更密：产品迭代、修复、文档更新都在“流式”发生。

关键差异不在“提交次数”，而在：你的每一次提交是否可解释、可回滚、可验证。

二、第一条护城河：原子化提交（Atomic Commits）

原子化提交的核心就一句话：一个 commit 只做一件事。

听起来像“洁癖”，但当提交频率升高时，它会变成生产力：

1）为什么它是高频迭代的基础设施

定位快：git bisect 需要的不是“漂亮的历史”，而是“可二分的历史”。原子化提交越严格，bisect 越接近 O(logN) 的定位体验。
回滚安全：出问题时你不需要“回滚整天的工作”，而是回滚一个明确的变更。
Review 清晰：每次评审都围绕一个目的，认知负担下降。

2）原子化提交的落地规则（推荐）

每个 commit 的 diff 尽量控制在：几十行到几百行（视语言/项目而定）；
如果一个 commit 同时包含：重构 + 新功能 + 修 bug ——必拆；
大重构先拆成多次“纯重构提交”，再引入行为变更；
任何不确定的改动，先做最小提交，后续再“修正收敛”。

想象你在做手术：原子化提交就是把手术刀变成一把一把一次性小刀，而不是一把巨斧。

OpenClaw 记忆实施策略解析：工具驱动的 RAG 与“按需回忆”

Sat, 31 Jan 2026 08:20:18 +0800

一、背景：为什么“记忆”成了 Agent 的标配

这两年大家对 Agent 的期待越来越一致：

不仅能对话，还要能长期记住你是谁（用户画像、偏好、项目上下文）
不仅能记住，还要能在需要时拿出来用（而不是每轮都塞进上下文浪费 token）

很多 Character AI / Chatbot 的做法是维护一份长期 Profile，每轮把它拼进 system prompt。

但 OpenClaw 走了一条更“工具化”的路：不自动注入记忆，而是把回忆过程交给 Agent，通过工具按需检索。

本文聊聊 OpenClaw 的记忆实施策略，以及它对我们做 Agent 系统设计有什么启发：

二、核心观点：OpenClaw 的“记忆”不是 Prompt 拼接，而是 Tool 驱动

OpenClaw 的记忆检索主要通过两个工具完成：

memory_search：语义搜索（通常是 BM25 + Vector Search 组合）
memory_get：根据命中结果（文件路径 + 行范围）精确取回文本片段

换句话说：

记忆系统不是“每轮自动塞一坨”，而是“需要时才查、查到后只取必要片段”。

这会带来两个直接好处：

省 token：没有必要把一堆不相关的历史塞进每轮上下文
更符合 Agent：把“什么时候需要记忆、需要什么记忆”变成一个可决策动作

三、索引策略：不仅索引聊天，还索引工作区生成的文档

推文里提到一个很容易被忽略但很关键的点：

产品思维三板斧：删除优先、质疑一切、亲赴火线

Fri, 30 Jan 2026 10:30:00 +0800

做产品最容易犯的一个错误是什么？

不是做得太少，而是做得太多。

我做了好几年产品，踩过的最大的坑不是功能做烂了，而是花了大量时间去优化一个根本不该存在的功能。这种"勤奋的浪费"在独立开发者和超级个体身上尤其致命——因为我们没有大厂的资源去试错，每一天都是真金白银。

今天聊三条我自己内化并反复验证的产品方法论，它们看起来简单，但真正做到的人不多。

一、删除优先于优化：先问"该不该存在"

大部分产品经理（包括过去的我）看到一个功能不好用，第一反应是"我要优化它"。

这个反应是错的。

正确的思考顺序应该是：

这个功能存在的必要性是什么？ → 能不能直接砍掉？ → 砍不掉再想怎么优化

这不是偷懒，而是对沉没成本零容忍。

一个真实的踩坑案例

我之前做一个工具产品，花了整整两周优化一个"高级筛选"功能——调交互、改 UI、加缓存、写文档。上线后一看数据，使用率几乎为零。

为什么？因为用户要的根本不是自己手动筛选，他们想要的是一键推荐。

如果当时先看数据、先问"这功能该不该存在"，这两周能省下来做真正有价值的事。

怎么判断该删还是该优

问自己三个问题：

问题	如果回答"否"
过去 30 天有多少用户用过这个功能？	使用率 < 5%，考虑删除
如果明天砍掉，会有用户投诉吗？	没人投诉 = 没人在乎
这个功能是否在核心价值链上？	不在 = 可以砍

对超级个体尤其重要：我们的时间就是最贵的资源。每多维护一个功能，就少了一分精力去做真正重要的事。删得越狠，活得越久。

从特斯拉产线学到的

在特斯拉早期的生产线上，有一批自动化机器人严重拖慢了整条产线的节奏。解决方案不是优化机器人程序，而是直接把机器人从产线上锯下来——搬出去的时候还得在墙上开个洞。

AI 工作流实战手册：从提示词到编程，真正把 AI 用起来

Fri, 30 Jan 2026 10:00:00 +0800

很多人用了半年 AI，依然停留在"问一句答一句"的阶段。ChatGPT 聊了不少，但真正落到工作里，总觉得差点意思——要么回答太泛，要么代码跑不起来，要么写出来的东西一看就是 AI 味儿。

问题出在哪？不是 AI 不行，是我们用 AI 的方式不对。

这篇文章是我在日常工作中总结出的一套 AI 工作流方法论，从如何提问、如何写提示词、如何用 AI 编程，到企业级场景怎么落地，全都是踩过坑之后的实战经验。如果你也在摸索怎么把 AI 真正用起来，这篇应该能帮到你。

一、先搭好你的 AI 工具栈

工欲善其事，必先利其器。在动手之前，先看看我日常在用的 AI 工具组合：

场景	工具	说明
日常聊天	ChatGPT、Gemini、Qwen	多模型交叉使用，各有所长
深度学习	NotebookLM	Google 出品，专啃长文档和视频，能把 YouTube 视频 2 分钟转成信息图，还能生成播客式音频复盘
内容输出	YouMind	写作 Agent，结构化输出很方便
前端编程	Antigravity	Google 推出的 AI 原生 IDE，集成 Gemini、Claude 等顶级模型，关键是免费
后端编程	Codex	OpenAI 的编程 Agent，适合后端逻辑
图片生成	Nano Banana Pro	Google 的图像生成工具，角色一致性碾压同类产品
设计	Lovart	设计 Agent，适合快速出设计稿

选工具的核心原则：不追最新最火的，只用解决问题最顺手的。每个环节找到一个"主力工具 + 备选工具"的组合就够了。

二、让 AI 真正听懂你：四象限提问法

很多人用 AI 就是一句话扔过去，看天吃饭。今天效果好算运气，明天效果差怪 AI 笨。

其实问题不在 AI，在于你没搞清楚：你的问题属于哪个类型。

Moltbot 是什么？8 万 Star 爆红项目的改名真相与安全避坑指南

Thu, 29 Jan 2026 21:00:00 +0800

Moltbot 是什么？ 简单来说，Moltbot 是一个开源的个人 AI Agent（智能助手），它能 24 小时运行在你的电脑上，通过 Telegram、WhatsApp 等聊天工具接收指令，自主操作浏览器、处理邮件、执行各种任务——不只是聊天，而是真的帮你"干活"。它原名 Clawdbot，后改名 OpenClaw，是 2026 年初最火爆的开源 AI 项目之一。

2026 年 1 月，一只龙虾搅动了整个 AI 圈。这个名叫 Clawdbot 的开源项目在不到一周内拿下 8 万+ GitHub Star，让全球开发者疯狂下单 Mac Mini，甚至引发了一场加密货币骗局。随后，它因 Anthropic 的商标要求被迫改名为 Moltbot（“蜕壳"之意），又衍生出 OpenClaw 这一社区常用名称。围绕 Moltbot 改名的风波，至今仍是开源圈的热门话题。

这个 Moltbot AI Agent 到底有什么魔力？它是不是名副其实的"个人贾维斯”？背后又藏着多少你不知道的坑？

这篇文章，我们不聊安装教程（想看搭建指南可以移步这篇文章），而是从架构原理、改名始末、安全风险等角度来深度剖析这个现象级项目，帮你全面了解 Moltbot 的背景与真相。

名称沿革说明：本文统一使用 OpenClaw（原 Clawdbot，后更名 Moltbot） 来指代同一项目在不同阶段的名称，便于你对照搜索结果与历史资料。

一、Moltbot 到底解决了什么问题？

1.1 从"聊天"到"干活"

过去两年，大家已经习惯了和 AI 聊天——问问题、写文案、翻译文章。但你有没有发现一个问题：AI 只能"说"，不能"做"。

你让 ChatGPT 帮你订机票，它只能告诉你"请打开携程网站，搜索……"。你让 Claude 帮你处理邮件，它只能说"建议你这样回复……"。

Moltbot 不一样。 它不只是给你建议，而是真的打开浏览器、登录你的邮箱、执行操作、把结果告诉你。

用冰河老师的话说：

Clawdbot = Claude Code + Bot 化工作流。全自动写代码解决你生活中的各类任务，它就是小机器人。

1.2 从"坐在电脑前用"到"躺在沙发上用"

传统的 AI 工具有一个限制：你得坐在电脑前面用。打开浏览器，登录网页版 ChatGPT，一句一句地对话。

Claude Code 浏览器自动化怎么选？4 套方案实测对比（2026）

Wed, 28 Jan 2026 23:55:00 +0800

用 AI 写代码已经不稀奇了，但让 AI 操控浏览器——打开网页、点击按钮、填写表单、抓取数据——这才是真正的"解放双手"。

在 Claude Code 生态中，目前有四个主流的浏览器自动化方案：Vercel 的 Agent Browser、Microsoft 的 Playwright CLI（2026 新方案）、Microsoft 的 Playwright MCP、Google 的 DevTools MCP。它们各有所长，选错了可能事倍功半。

本文将深入对比这四个方案，帮你在不同场景下做出最佳选择。

2026-02 更新：新增 Playwright CLI 方案——微软官方推荐的新一代 Token 高效方案，实测 Token 消耗比 MCP 降低 4-100 倍。

一、为什么需要浏览器自动化？

传统方式的痛点

假设你想让 AI 帮你做这些事：

打开竞品网站，截图看看他们的新功能
自动登录公司内部系统，导出报表
测试你刚写的网页，看看表单能不能正常提交
抓取某个页面的 API 返回值，排查 Bug

如果没有浏览器自动化，你只能：

自己手动打开浏览器
截图或复制内容
粘贴给 AI 看

这不仅麻烦，而且很多动态内容（如需要登录的页面、JavaScript 渲染的内容）根本没法直接给 AI。

浏览器自动化的价值

有了浏览器自动化，AI 可以：

Moltbot Wizard 完全指南：打造你的私人 AI 助手

Wed, 28 Jan 2026 23:30:00 +0800

想象一下这个场景：你在微信群里@一下 AI，它就能帮你订机票、查天气、写代码、管理日程，甚至能记住你上周聊过的所有内容。这不是科幻电影，这就是 Moltbot——一个你可以完全掌控的私人 AI 助手。

本文将带你深入了解 Moltbot 的 Wizard（配置向导），从"这是啥"到"我会用"，一篇搞定。

一、背景：为什么需要 Moltbot？

现有 AI 助手的痛点

我们每天都在用各种 AI 助手——ChatGPT、Claude、文心一言。但它们都有一个共同的问题：你不是主人，只是租客。

数据不在你手里：聊天记录、个人偏好全存在别人服务器上
功能受限：想让 AI 帮你发微信？抱歉，做不到
平台分散：工作用 Slack，生活用微信，每个平台都要单独配置
无法定制：AI 的"性格"和能力完全由平台决定

Moltbot 的解决方案

Moltbot（前身叫 Clawdbot，因商标问题改名）是由 PSPDFKit 创始人 Peter Steinberger 创建的开源项目，在 GitHub 上已获得超过 68,000 星。

它的核心理念是：把 AI 助手的控制权交还给你。

┌─────────────────────────────────────────────────────────────┐
│ 你的设备 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Moltbot Gateway │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Claude │ │ GPT-5 │ │ Gemini │ ...更多 │ │
│ │ └────┬────┘ └────┬────┘ └────┬────┘ │ │
│ │ └────────────┼────────────┘ │ │
│ │ ▼ │ │
│ │ ┌──────────────┐ │ │
│ │ │ AI Agent │ ← 你定制的"AI性格" │ │
│ │ └──────┬───────┘ │ │
│ └───────────────────┼─────────────────────────────────┘ │
│ ▼ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ WhatsApp│ │Telegram │ │ Discord │ │ iMessage│ ... │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
└─────────────────────────────────────────────────────────────┘

简单来说，Moltbot 就像一个"AI 中转站"：

2026 年 AGI 已经来了：从功能定义到 31 分钟猎头实战

Mon, 26 Jan 2026 11:00:00 +0800

2026 年 1 月 14 日，红杉资本发布了一篇重磅博客——《2026: This is AGI》。

两位作者 Pat Grady（红杉联席掌门人，19 年投资老兵）和 Sonya Huang（红杉合伙人，从 2022 年就押中 AI 大趋势）开门见山：

Long-horizon agents are functionally AGI, and 2026 will be their year.

长周期智能体就是功能性的 AGI，2026 年将是它们的年份。

这不是某个技术极客的狂想，而是全球顶级风投机构的正式判断。他们的结论很简单：别等了，AGI 已经到来。

一、AGI 的定义：能把事情搞清楚

几年前，红杉的合伙人去请教顶尖 AI 研究者，问他们怎么定义 AGI。

研究者们互相看了看，给出了一个意味深长的答案：

“我们每个人都有自己的定义，但看到它的时候就会知道。”

当时这个回答让人摸不着头脑，但现在红杉给出了自己的答案。

Pat 和 Sonya 说得很坦诚：

“我们是投资人不是技术专家，没资格给 AGI 下技术定义。但从功能角度看，AGI 就是能把事情搞清楚的能力。就这么简单。”

这个定义初看简单，但仔细想想很有道理。你需要一个 AI 帮你做事的时候，你在乎的是什么？不就是它能不能把事搞清楚吗。至于它用的什么算法、调了多少参数，这些技术细节远不如"确实把事办成了"重要。

能把事搞清楚需要什么？

他们把这个逻辑拆解得很清楚：

一个能把事情搞清楚的人，需要三样东西：

基础知识：知道相关的信息和概念
推理能力：能够分析、判断、做出决策
迭代能力：遇到问题能调整方向，不断尝试直到找到答案

一个能把事情搞清楚的 AI，同样需要三样东西：

预训练知识：2022 年 ChatGPT 带来的海量知识储备
推理能力：2024 年底 OpenAI o1 系列带来的深度思考能力
迭代能力：2026 年 Claude Code 这样的编程智能体带来的自主探索能力

三块拼图都齐了。

Claude Code + Remotion：用 AI 对话生成专业视频，程序员的视频制作新姿势

Sun, 25 Jan 2026 00:00:00 +0000

一、先讲个故事

想象一下这个场景：

你是一个程序员，老板突然说：“下周产品发布会，做个 30 秒的产品演示视频。”

你心里慌了——我又不是设计师，After Effects 都没装过，找外包？来不及了，而且至少要 1000 块起步。

但现在，你可以这样做：

你说：“帮我做一个产品演示视频，显示我们的 App 界面，加上文字动画介绍三个核心功能，时长 30 秒。”

Claude Code 做：自动生成 React 代码，渲染出一个专业的 MP4 视频文件。

是的，你没看错。现在用 Claude Code 配合 Remotion，真的可以用聊天的方式做视频了。

二、Remotion 到底是什么？

2.1 用大白话解释

Remotion 就是一个"用代码写视频"的工具。

传统做视频：打开 Premiere 或 After Effects → 拖素材 → 调时间轴 → 加特效 → 导出

ClawdBot：海外爆火的个人 AI 管家，30 分钟搭建指南

Sun, 25 Jan 2026 00:00:00 +0000

一、先讲个故事

想象一下这个场景：

你早上还在睡觉，你的 AI 助手已经帮你做完了这些事：

把昨晚收到的 50 封邮件整理好，只留下 3 封需要你亲自回复的
帮你订好了下周出差的机票，还完成了值机
把你关注的几个公众号更新内容做了总结，放在一份简报里等你看

等你醒来，打开手机，AI 助手发消息告诉你：“老板，今天有个重要会议在下午 3 点，我已经帮你准备好了会议资料。”

这不是科幻电影，这是 ClawdBot 正在帮很多人实现的事情。读完这篇文章，你也能在 30 分钟内搭建自己的 AI 管家。

二、ClawdBot 到底是什么？

2.1 一句话定义

ClawdBot 是一个开源的 AI Agent 个人助手，可以 24 小时运行在你的电脑上，通过 Telegram、WhatsApp 等聊天工具自动处理邮件、日程、提醒等任务。它由奥地利工程师 Peter Steinberger 开发，截至 2026 年 1 月已获得 9000+ GitHub Star。

Docker Compose 教程：docker-compose.yml 配置详解与实战案例（2026）

Sat, 24 Jan 2026 00:00:00 +0000

Docker Compose 是目前最流行的多容器编排工具，而 docker-compose.yml（新版推荐命名为 compose.yaml）就是它的核心配置文件。无论你是刚接触容器化的新手，还是想系统梳理配置细节的老手，这篇 Docker Compose 教程都适合你。

本文将逐字段讲解 compose.yaml 中 services、volumes、networks、ports、environment、healthcheck 等所有配置项的含义和用法，并通过 WordPress + MySQL 等实战案例帮你快速上手。配合 Docker 常用命令速查一起使用效果更佳。

很多人一看到 compose.yaml 就头大，一堆冒号、缩进，不知道从何下手。其实它没那么复杂，下面我用最通俗的方式，带你彻底搞懂这个文件。

重要提示：旧版 docker-compose（带连字符）是用 Python 写的独立工具，已于 2023 年 7 月停止维护。现在应该使用 docker compose（空格分隔），它是 Docker CLI 的内置插件，用 Go 重写，性能更好，功能更全。本文所有命令均使用新版语法。

一、compose.yaml 是什么？

用盖房子来理解

想象你要盖一栋房子：

Docker 镜像 = 建材（砖头、水泥、钢筋）
Docker 容器 = 盖好的房间
compose.yaml = 设计图纸

设计图纸上写着：

要盖几个房间
每个房间多大
房间之间怎么连通
水电怎么接

compose.yaml 就是告诉 Docker：

要启动几个容器
每个容器用什么镜像
容器之间怎么通信
端口和数据怎么映射

没有它会怎样？

没有 compose.yaml，你要一个个手动启动容器：

AI 时代，一个人的 Taste 比以往任何时候都重要

Fri, 23 Jan 2026 20:30:00 +0800

前几天和一个做设计的朋友聊天，他说了句让我印象很深的话：“现在用 AI 生成一张图只要几秒钟，但我花了十年才知道什么样的图是好的。”

这句话点出了一个很多人还没意识到的变化：当「做出来」变得越来越容易时，「选什么做」反而成了最难的事。

一、从稀缺到泛滥：创造的门槛消失了

还记得几年前学一门手艺要多久吗？

写代码、画画、剪视频、做音乐——每一项都需要几个月甚至几年的练习。而现在呢？

用 Claude Code 写代码，只需要描述你想要什么
用 Midjourney 画图，打几个关键词就能出图
用 Suno 作曲，哼一段旋律就能生成完整的歌

创造的门槛，在我们这代人眼前，几乎被抹平了。

这本该是件好事。但问题来了：当每个人都能轻松生成内容，真正的挑战变成了——在这片内容的汪洋大海里，什么才是值得存在的？

这就是为什么「Taste」（品味）突然变得如此重要。

二、什么是 Taste？

先说清楚一件事：Taste 不是装腔作势，不是「我觉得这个高级那个 low」。

Debris Studio 的一篇文章把 Taste 定义得很好：

Taste 不是肤浅的偏好，而是一种素养——读懂世界的能力。它是训练有素的本能，通过接触、学习、反思积累而成。

简单说，Taste 是你对「好」的判断力。

这种判断力体现在很多地方：

场景	有 Taste	没 Taste
选择工具	知道什么场景用什么工具最合适	什么火用什么，或者只用自己熟悉的
写代码	写出来的代码清晰、优雅、易维护	能跑就行，管它好不好看
做产品	知道哪些功能是核心，哪些是噪音	功能堆砌，什么都想要
用 AI	能分辨 AI 输出的好坏，取其精华	AI 说啥就是啥，不会筛选

乔布斯 1995 年说过一句话，放到今天更加贴切：

“The only problem with Microsoft is they just have no taste… I don’t mean that in a small way, I mean that in a big way."（微软唯一的问题就是他们没有品味……我不是随便说说，我是认真的。）

Cloudflare Workers 完全指南：从入门到实战的边缘计算部署手册

Fri, 23 Jan 2026 20:20:00 +0800

Cloudflare Workers 是 Cloudflare 推出的边缘计算平台，它让你无需管理服务器，就能在全球 300+ 个数据中心运行代码。相比传统云服务器，Workers 的部署速度更快、冷启动更低、全球延迟更均匀，而且免费额度非常慷慨。

本文将从零开始，带你全面了解 Cloudflare Workers：它是什么、适合什么场景、如何开发部署，以及多个可直接使用的实战案例。无论你是刚接触云计算的新手，还是想优化现有架构的老手，都能从中获得实用价值。

一、什么是 Cloudflare Workers

1. 基本概念

Cloudflare Workers 是一种 Serverless（无服务器） 计算平台。你只需要写代码，Cloudflare 负责运行、扩展和维护。

传统部署方式：

用户请求 → 某个机房的服务器 → 处理 → 返回

Workers 部署方式：

用户请求 → 最近的边缘节点（全球 300+） → 处理 → 返回

核心优势：代码运行在离用户最近的节点上，延迟极低。

2. 技术架构

Workers 基于 V8 isolates 技术（Chrome 浏览器的 JavaScript 引擎），而不是传统的容器或虚拟机。

TypeScript 完全指南：从入门到精通的进阶手册

Fri, 23 Jan 2026 20:07:08 +0800

TypeScript 是 JavaScript 的超集，为 JavaScript 添加了静态类型系统。它能在编译时发现错误、提供更好的 IDE 支持、使代码更易维护。本文将系统性地介绍 TypeScript 的所有核心概念，从基础语法到高级类型体操，帮助你从新手快速进阶为高手。

2025 年，微软宣布用 Go 重写 TypeScript 编译器，编译速度提升 10 倍，内存占用减少 50%。TypeScript 正在蚕食 JavaScript 的市场份额，已成为前端开发的必备技能。

一、TypeScript 基础

1. 为什么选择 TypeScript

特性	JavaScript	TypeScript
类型检查	运行时	编译时
IDE 支持	一般	优秀（智能提示、重构）
代码可维护性	较低	高
学习曲线	低	中等
大型项目适用性	一般	非常适合

2. 安装与配置

# 全局安装
npm install -g typescript

# 项目安装
npm install typescript --save-dev

# 初始化配置文件
npx tsc --init

# 编译单个文件
tsc hello.ts

# 监听模式
tsc --watch

3. tsconfig.json 常用配置

{
 "compilerOptions": {
 // 目标 ECMAScript 版本
 "target": "ES2020",
 // 模块系统
 "module": "ESNext",
 // 严格模式（强烈建议开启）
 "strict": true,
 // 输出目录
 "outDir": "./dist",
 // 源码目录
 "rootDir": "./src",
 // 生成声明文件
 "declaration": true,
 // 允许导入 JSON
 "resolveJsonModule": true,
 // ES 模块互操作
 "esModuleInterop": true,
 // 跳过库类型检查（加速编译）
 "skipLibCheck": true,
 // 严格的空值检查
 "strictNullChecks": true,
 // 不允许隐式 any
 "noImplicitAny": true
 },
 "include": ["src/**/*"],
 "exclude": ["node_modules"]
}

二、基础类型

1. 原始类型

// 字符串
let name: string = "TypeScript";

// 数字（整数和浮点数统一为 number）
let age: number = 25;
let price: number = 99.99;

// 布尔值
let isDone: boolean = false;

// null 和 undefined
let n: null = null;
let u: undefined = undefined;

// Symbol
let sym: symbol = Symbol("key");

// BigInt（ES2020）
let big: bigint = 100n;

2. 数组类型

// 方式一：类型[]
let numbers: number[] = [1, 2, 3];
let strings: string[] = ["a", "b", "c"];

// 方式二：Array<类型>（泛型写法）
let nums: Array<number> = [1, 2, 3];

// 只读数组
let readonlyArr: readonly number[] = [1, 2, 3];
// readonlyArr.push(4); // 错误：只读数组不能修改

3. 元组（Tuple）

元组是固定长度和类型的数组：

MySQL SQL 完全指南：从小白到高手的进阶之路（含面试宝典）

Fri, 23 Jan 2026 20:06:36 +0800

SQL（Structured Query Language） 是与数据库交流的通用语言。无论你是后端开发、数据分析还是运维工程师，掌握 SQL 都是必备技能。本文以 MySQL 为例，从零基础带你系统学习 SQL，并深入讲解面试高频考点，助你快速进阶。

本文约 15000 字，建议收藏后分章节阅读。文章结构清晰，可根据目录跳转到感兴趣的部分。

一、SQL 基础入门

1.1 什么是 SQL

SQL 是 结构化查询语言（Structured Query Language）的缩写，用于管理关系型数据库。它可以：

查询数据：从数据库中检索信息
操作数据：插入、更新、删除数据
定义结构：创建、修改数据库和表
控制访问：管理用户权限

SQL 语句分为以下几类：

类型	全称	常用语句	作用
DDL	Data Definition Language	CREATE、ALTER、DROP	定义数据库结构
DML	Data Manipulation Language	SELECT、INSERT、UPDATE、DELETE	操作数据
DCL	Data Control Language	GRANT、REVOKE	控制访问权限
TCL	Transaction Control Language	COMMIT、ROLLBACK	管理事务

1.2 数据库基本操作

-- 创建数据库
CREATE DATABASE shop DEFAULT CHARSET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- 查看所有数据库
SHOW DATABASES;

-- 使用数据库
USE shop;

-- 查看当前数据库
SELECT DATABASE();

-- 删除数据库（谨慎操作！）
DROP DATABASE shop;

最佳实践：建议使用 utf8mb4 字符集，它完整支持 Unicode，包括 emoji 表情。

Claude Code 高手都在用的 24 个技巧

Fri, 23 Jan 2026 00:00:00 +0000

Claude Code 是 Anthropic 推出的命令行 AI 编程助手。它不是一个简单的聊天机器人，而是一个能直接在你的终端里读代码、写代码、执行命令的智能助手。本文整理了 24 个实用技巧，帮你把 Claude Code 用到极致。

第一部分：5 分钟快速上手

安装 Claude Code

# 一行命令安装
curl -fsSL https://claude.ai/install.sh | bash

三种启动方式

# 方式一：直接启动交互式会话
claude

# 方式二：带问题启动
claude "帮我看看这个项目的目录结构"

# 方式三：非交互模式（适合脚本调用）
claude -p "生成一个 .gitignore 文件"

启动后，你会看到一个交互界面，直接输入问题即可开始对话。输入 /help 查看帮助，输入 /exit 退出。

Redis 从入门到精通：安装配置与实战指南

Thu, 22 Jan 2026 17:00:00 +0800

Redis（Remote Dictionary Server）是一款开源的高性能键值存储数据库，以其出色的读写速度和丰富的数据结构支持，成为现代应用架构中不可或缺的组件。本文将带你从零开始，系统学习 Redis 的安装配置、核心概念、数据类型、持久化机制以及高可用集群部署。

一、Redis 简介

1. 什么是 Redis

Redis 是一个使用 ANSI C 语言编写、支持网络、可基于内存亦可持久化的键值对（Key-Value）数据库。它支持多种数据结构，包括字符串、哈希、列表、集合和有序集合，并提供多种语言的 API。

核心特性：

高性能：纯内存操作，读写速度可达 10 万+ QPS
丰富的数据类型：String、Hash、List、Set、Sorted Set 等
原子性操作：所有操作都是原子的，支持事务
持久化：支持 RDB 和 AOF 两种持久化方式
高可用：支持主从复制、哨兵和集群模式

2. Redis 应用场景

场景	说明
缓存	热点数据缓存，减轻数据库压力
会话存储	分布式系统中的 Session 共享
排行榜	利用有序集合实现实时排名
消息队列	利用 List 实现简单的消息队列
计数器	利用原子操作实现访问计数、点赞数等
分布式锁	实现跨进程的资源互斥访问

二、Redis 安装与配置

1. macOS 安装

在 macOS 上推荐使用 Homebrew 安装 Redis：

Shell 特殊变量完全指南：$$、$?、$@、$# 等用法详解

Thu, 22 Jan 2026 15:47:58 +0800

编写 Shell 脚本时，你一定见过 $?、$@、$$ 这些以美元符号开头的特殊变量。它们是 Bash 内置的特殊参数，用于获取脚本运行状态、命令行参数等关键信息。掌握这些变量，是写出健壮 Shell 脚本的基础。

本文将系统讲解每个特殊变量的含义、使用场景，并通过实际示例帮助你深入理解。

2025年终端工具推荐：23款高效终端模拟器全面对比

Thu, 22 Jan 2026 00:00:00 +0000

作为开发者，终端是我们每天打交道最多的工具之一。一款好用的终端工具不仅能提升工作效率，还能让枯燥的命令行操作变得更加愉悦。本文将全面介绍 23 款主流终端工具，涵盖 Windows、macOS 和 Linux 三大平台，帮你找到最适合自己的那一款。

💡 提示：选好终端后，别忘了配置一个好用的 Shell。推荐阅读 Oh My Zsh 安装配置指南，让你的终端体验更上一层楼。

Anthropic CEO 彭博社访谈：AI 指数增长、芯片出口与超级智能的未来

Wed, 21 Jan 2026 15:09:00 +0800

Dario Amodei 是 Anthropic 的 CEO，这家公司创造了被认为是与 GPT 并驾齐驱的最强 AI 模型之一——Claude。在彭博社的最新访谈中，Amodei 分享了他对 AI 发展的深度见解，从技术预测到地缘政治，从经济影响到公司战略，内容极为丰富。

本文基于整理访谈的核心观点。

一、指数级增长的欺骗性

Amodei 从不喜欢「AGI」这个词。

不是因为他对 AI 的未来不够乐观，恰恰相反，他对 AI 的力量持有极端的看法。他不喜欢这个词，是因为它暗示了一个错误的思维模型——好像有一天，我们会突然造出一个完全不同的东西。

实际上，过去十年的观察告诉我们，AI 的发展是一个非常平滑的、指数级的过程。

不是奇点，不是突变，而是摩尔定律。只不过这次，不是计算能力每 18 个月翻一番，是智能本身，每 4 到 12 个月翻一番。

Amodei 说了一句让人印象很深的话：

「指数级增长就是这样，看起来非常缓慢，稍微加速一点，然后瞬间从你身边呼啸而过。」

我们现在就在这个「呼啸而过」的前夜。Amodei 预测，AI 模型在几乎所有方面比人类更聪明的时刻，可能就在未来 1 到 2 年内发生。最晚，也会在 2020 年代内实现。

二、首席工程师两个月没写代码

Amodei 分享了一个让人震惊的故事。

Anthropic 内部有一个负责「Code」产品的团队。这个团队的首席工程师告诉 Amodei：

「我过去两个月没有亲手写过任何代码。」

所有的代码都是 Claude 写的。他的工作变成了编辑和审查。

不是初级工程师被替代了，是首席工程师的工作方式被彻底改变了。

更夸张的是，他们最近发布了一个叫「Coachwork」的工具，整个开发过程只用了一个半星期，几乎完全是 Claude 写的。

这与我们在 Claude Code 实战指南中介绍的趋势一致——AI 正在从辅助工具变成主力开发者。

三、数据中心里的天才国度

Amodei 用了一个非常形象的比喻来描述 AI 的未来：

2026 年 Claude Code Skills 排行榜 Top 20

Tue, 20 Jan 2026 10:51:00 +0800

2025 年 10 月，Anthropic 正式推出了 Agent Skills 系统，这是 Claude Code 最重要的功能更新之一。三个月过去，GitHub 上的 Skills 生态已经爆发式增长。

哪些 Skills 值得装？哪些是噱头？本文整理了 2026 年 1 月最热门的 20 个 Skills，帮你快速做出选择。

一、什么是 Skills？

简单说：给 Claude 装上专业技能包，让它自己判断什么时候该用。

Skills 是一个 SKILL.md 文件，里面写着某个领域的专业知识和操作流程。装好之后，Claude 会根据对话上下文 自动识别并触发——你不需要输入任何命令。

比如你说"帮我审查这段代码"，如果装了 code-review Skill，Claude 会自动按 Skill 里定义的检查清单执行。

Skills ≠ Slash Commands：Slash Commands（如 /commit）需要你手动输入触发；Skills 是 Claude 自己判断要不要用。

二、官方仓库排行榜

这两个是 Anthropic 官方维护的，质量有保障：

排名	仓库名称	Stars	功能定位
1	anthropics/claude-code	58.1k	Claude Code 主程序
2	anthropics/skills	45.1k	官方 Skills 仓库

官方 Skills 包含什么？

我的AI开发工作流：从需求到上线

Mon, 19 Jan 2026 17:00:00 +0800

2026年，AI编程工具已经从"尝鲜玩具"变成了开发者的"标配装备"。据统计，约85%的开发者已经在日常工作中使用AI工具。

但很多人的用法还停留在"问问ChatGPT怎么写这段代码"的阶段。今天我想分享一套完整的AI开发工作流，让AI真正成为你的"结对编程搭档"，贯穿从需求到上线的全过程。

一、工具选择：不是非此即彼

在开始之前，先聊聊工具选择。目前主流的AI编程工具有：

工具	特点	适用场景
Claude Code	深度推理、大上下文、CLI优先	架构设计、复杂重构、跨文件理解
Cursor	IDE集成、实时补全、流畅体验	日常编码、快速迭代
ChatGPT	通用能力强、响应快	快速问答、代码片段
GitHub Copilot	深度IDE集成、补全准确	行内补全、常规编码

我的建议：不要只用一个工具。

我的组合是：Claude Code（规划） + Cursor（实现）。用Claude Code做架构设计和复杂问题分析，用Cursor进行日常编码。两者可以完美配合——在Cursor的终端里直接调用Claude Code CLI。

二、需求分析阶段：让AI帮你理清思路

拿到需求后，不要急着写代码。先用AI帮你做需求分析。

1. 需求拆解

把产品需求丢给Claude，让它帮你拆解：

我收到一个需求：实现用户积分系统，支持积分获取、消费、查询、排行榜功能。

请帮我：
1. 拆解核心功能模块
2. 识别潜在的技术难点
3. 列出需要确认的产品问题

AI会帮你系统性地梳理，往往能发现你没想到的边界情况。

Agent Skills：用大白话写程序的时代来了

Mon, 19 Jan 2026 16:45:00 +0800

最近，推特上关于 Agent Skills 的讨论越来越火。起初我和很多程序员一样，觉得 Skills 不过就是 Workflow Prompt——有用，但没什么大不了的。

直到我看到 X上的一条帖子，才突然意识到：这东西不是简单的文字，这是新一代的程序，而且还能自我迭代。

这个认知转变，值得每个开发者认真思考。

一、传统编程 vs Skills 编程

让我们先对比一下两种编程方式的差异。

1. 传统程序员怎么做功能？

需求分析 → 设计架构 → 编写代码 → 编译打包 → 测试调试 → 部署上线

用代码编排流程：输入什么、处理什么、输出什么，一行行写死。每一步都需要专业知识，每一个环节都可能出错。

想改个功能？重新走一遍流程。有个 bug？提工单排队等修复。

2. Skills 怎么做功能？

# 我的自动化任务

## 触发条件
当用户说"帮我整理会议纪要"时触发

## 执行步骤
1. 读取用户提供的会议记录
2. 提取关键议题和决策
3. 按标准模板格式化输出

## 输出格式
Markdown 文档，包含：议题、讨论要点、决策、待办事项

没看错，这就是一个完整的"程序"。

Cursor Agent 编码最佳实践：官方指南完整解读

Mon, 19 Jan 2026 16:33:00 +0800

随着 AI 编程助手的快速发展，如何高效地与 AI Agent 协作编码成为每个开发者需要掌握的技能。Cursor 作为目前最受欢迎的 AI 编程工具之一，官方近期发布了一份详细的 Agent 编码最佳实践指南。本文将深入解读这份指南的核心内容，帮助你更好地利用 Cursor Agent 提升开发效率。

一、理解 Agent 的工作原理

在开始使用技巧之前，先了解 Cursor Agent 的核心架构。Agent 系统由三个关键组件构成：

组件	说明
系统指令	引导 Agent 行为的提示词
工具集	文件编辑、代码搜索、终端执行等能力
用户消息	你发出的指令和需求描述

Cursor 团队针对每个前沿模型进行了专门调优，确保这三个组件能够协同工作，产出最佳结果。

二、先计划，后编码

“你能做的最大贡献，就是在写代码之前先做好计划。”

这是整篇指南中最重要的观点之一。经验丰富的开发者在让 Agent 生成代码之前，会先进行充分的规划。

1. 使用计划模式（Plan Mode）

通过 Shift + Tab 激活计划模式，Agent 会：

Docker Compose 完全指南（2026）：安装、docker-compose.yml、实战部署一篇搞定

Mon, 19 Jan 2026 10:00:00 +0800

如果你是一名开发者，一定听过这句话：“在我电脑上明明能跑啊！” 这个困扰了无数程序员的问题，Docker 给出了优雅的解决方案。本文将用最通俗的语言，带你从零开始掌握 Docker 和 Docker Compose。

第一部分：Docker 的前世今生

1. 软件部署的痛点

想象一下你要搬家，把所有家具搬到新房子。传统的方式是：

把家具一件件拆开
搬到新家
重新组装
发现少了几颗螺丝，柜子装不上了…

软件部署也是类似的痛苦：

问题一：环境不一致

开发环境：Windows + Python 3.8 + MySQL 5.7
测试环境：Ubuntu + Python 3.9 + MySQL 8.0
生产环境：CentOS + Python 3.7 + MySQL 5.6

结果就是：开发说"我这能跑"，运维说"上线就挂"。

问题二：依赖地狱

项目 A 需要 Node.js 14
项目 B 需要 Node.js 18
项目 C 需要 Node.js 16

同一台机器上，这三个项目怎么共存？

问题三：资源浪费

传统方式：每个应用一台虚拟机
一台虚拟机至少占用 1-2GB 内存
10 个应用 = 10 台虚拟机 = 10-20GB 内存

2. 虚拟化技术的演进

为了解决这些问题，技术不断进化：

Claude Code从入门到精通：终端里的全能AI助手完全指南

Wed, 14 Jan 2026 14:38:00 +0800

你是否曾经希望有一个真正能「动手干活」的 AI 助手——不只是给你建议，而是能直接帮你处理文件、执行命令、完成各种重复性工作？Claude Code 正是 Anthropic 官方推出的这样一款工具——它运行在终端里，是一个能够理解你的需求并付诸行动的全能助手。

它不只是程序员的专属工具。虽然 Claude Code 在编程领域表现出色，但它同样能帮助产品经理整理文档、帮运维人员分析日志、帮行政财务人员处理数据报表、帮任何人自动化那些繁琐的重复工作。

无论你是资深开发者、产品经理、运维人员，还是行政财务同学，这篇文章都将带你从零开始，全面掌握 Claude Code 的使用方法，找到属于你的效率提升之道。

一、什么是 Claude Code？

1. 核心定位

Claude Code 是 Anthropic 推出的官方命令行工具（CLI），它是一个「代理型 AI 工具」（Agentic AI Tool），直接运行在你的终端中。

与普通的 AI 聊天不同，Claude Code 的最大特点是：它可以直接执行操作。

特点	说明
终端原生	不是聊天窗口，不是 IDE 插件，而是命令行工具
可执行操作	能直接编辑文件、运行命令、处理数据
理解上下文	自动分析项目结构和文件内容
自然语言交互	用大白话描述需求，Claude 帮你实现

一个简单的类比：如果说 ChatGPT 是「顾问」，只能给你建议；那么 Claude Code 就是「助理」，能真正动手帮你干活。

2. 能做什么？

Claude Code 主要解决四大类问题：

Anthropic 发布 Claude Cowork：让 AI 直接操作你的电脑文件

Tue, 13 Jan 2026 19:00:00 +0800

Anthropic 近日发布了 Claude Cowork 研究预览版，这是迄今为止最具突破性的 AI 桌面代理。与传统的聊天机器人不同，Claude Cowork 可以直接访问你电脑上的文件、运行代码、操作终端，甚至与 Notion、Linear、Figma 等第三方应用集成。

一、什么是 Claude Cowork？

Claude Cowork 是 Anthropic 在 Claude 桌面应用中推出的新功能，它让 Claude 从一个"对话助手"进化为一个"工作伙伴"。

传统的 AI 聊天需要你手动复制粘贴文件内容，而 Cowork 可以：

直接读取和编辑本地文件
在沙盒环境中运行代码
执行终端命令
连接第三方应用获取上下文

简单来说，你只需要告诉 Claude 你想做什么，它会自己完成剩下的工作。

二、核心功能详解

1. 本地文件访问

Cowork 可以直接访问你电脑上的文件，无需手动上传。你可以让它：

Vercel 发布 Agent Browser：专为 AI 代理打造的浏览器自动化工具

Tue, 13 Jan 2026 08:00:00 +0800

Vercel 近期开源了一款名为 Agent Browser 的命令行工具，这是一个专为 AI 代理设计的浏览器自动化解决方案。它结合了 Rust 的高性能与 Node.js 的灵活性，为 AI 工作流提供了可靠的浏览器交互能力。

一、什么是 Agent Browser？

Agent Browser 是一个无头浏览器自动化 CLI 工具，主要面向 AI 代理场景。与传统的浏览器自动化工具不同，它采用了快照驱动的交互模式，特别适合 AI 代理的工作方式。

核心理念：让 AI 代理能够像人一样"看到"网页，并与之交互。

二、核心特性

1. 高性能架构

Agent Browser 采用客户端-守护进程架构：

Rust CLI：原生编译，启动快、资源占用低
Node.js 守护进程：管理 Playwright 浏览器实例
持久化连接：支持快速重复操作

2. AI 优化的快照模式

这是 Agent Browser 最大的亮点。传统自动化工具需要复杂的选择器来定位元素，而 Agent Browser 使用访问性树快照：

小白也能解锁 Claude Code 的秘密武器：Skills

Mon, 12 Jan 2026 10:00:00 +0800

引言

两个月以来，我一直在思考一个问题：该如何提升 AI 的能力呢？

哪怕有了 CLAUDE.md，可以让他记住了我是谁，我喜欢什么；但我该如何让他学习到我的"能力"呢？

这就是我今天要说的主角 – Skills 功能

这东西彻底改变了我对 AI 协作的看法。它不再是简单的"你问我答"，而是让 AI 主动学习、来配合你的能力和偏好。这感觉就像，你不是在跟一个什么都懂的实习生说话，而是在跟一个资深团队成员协作。

Claude Code 虽然名字里带个 Code，但它绝不仅仅是写代码的工具。它是一个真正的通用 Agent，能帮你处理电脑上各种繁琐的工作。而 Skill，就是它能力无限扩展的"插件包"。

也就是说，他理论上可以很大程度的把我们每个人的能力"抽象"出来，形成一种可移植的"模块"。不论你是做市场的，还是做产品的，又或是做运营的，它都能帮到你。

一、Skill 到底是什么？

简单来说，Skill 是一个"能力单元"，它把专业知识、工作流程和最佳实践打包起来，让 Claude Code 能够自动调用。

最关键的区别在于：你不需要像用斜杠命令（/command）那样手动触发它。CC 会根据对话上下文，自己判断什么时候该用哪个 Skill。它就像一个有经验的同事，看到你在处理某个特定任务，会主动过来说：“这个我熟，我来帮你。”

Skills 可以根据你的需要，存储在不同位置，作用范围也不同：

想象一下：

对于个人：你可以把你最常用的代码片段、写作风格、数据分析流程，封装成个人 Skill。从此，Claude Code 就是最懂你的那个助手。
对于团队：团队的设计规范、API 使用指南、项目提交流程……这些都可以做成项目 Skill，放在代码仓库里共享。新成员加入，CC 自动就能带他上路，再也不需要一遍遍地人肉培训。

二、如何"教会"你的 AI？– 30秒上手 Skill 创建

听起来很复杂？恰恰相反。创建一个 Skill 非常简单，你只需要一个文件夹和一个 SKILL.md 文件。我这里带大家一步步拆解。

Claude Code 记忆术：一个文件让 AI 永远记住你是谁

Mon, 12 Jan 2026 00:00:00 +0800

一、每次都要自我介绍，烦不烦？

用 Claude Code 写代码，体验确实好。

但有个问题：它不记事。

每次开新对话，你都得重复一遍：

“我们项目用的是 pnpm，不是 npm”
“代码风格要遵循 ESLint + Prettier”
“Git 提交信息用中文，格式是 type: description”
“这个项目是 React 18 + TypeScript + Tailwind”

说一次还行，天天说？烦。

更要命的是团队协作——你配置好了，同事那边又是一张白纸，Claude 给他生成的代码风格跟你的完全不一样。

CLAUDE.md 就是解决这个问题的。

用一句话定义：

CLAUDE.md 就是 Claude 的"入职手册"——写一次，永远生效。

就像新员工入职要看公司手册一样，Claude 每次启动都会先读这份文件，然后按照里面的规矩干活。

二、CLAUDE.md 到底是什么

2.1 本质就是一份 Markdown 文件

没有什么黑科技，就是一个普通的 Markdown 文件，放在项目根目录或者用户目录下。

Claude Code Skill 完全指南：让 AI 学会你的工作流程

Thu, 08 Jan 2026 10:00:00 +0800

一、Skill 为什么突然火了

大模型时代，每个人都想让 AI 更懂自己的工作。

问题是，AI 是通用的。它不知道你们公司的报表格式是什么样的，不知道你们招聘时看重什么，不知道你们产品的卖点是什么。

每次都要从头解释一遍？太累了。

Claude Code 的 Skill 就是解决这个问题的——把你的专业知识打包成一份"说明书"，让 Claude 一次学会，以后直接按你的方式干活。

用一句话定义：

Skill 就是教 Claude 怎么干你的活的说明书。

不需要写代码，只需要写清楚：做什么、怎么做、注意什么。

二、Skill 到底是什么

2.1 本质就是一份 Markdown 文档

Skill 不是什么高深的技术，它就是一个文件夹，里面放着一份 SKILL.md 文件。

这份文件告诉 Claude：

这个技能叫什么名字
什么时候应该用它
具体怎么执行
有什么注意事项

举个最简单的例子：

---
name: daily-report
description: 生成每日工作汇报
---

# 每日工作汇报生成器

## 任务
根据用户提供的工作内容，生成一份格式规范的日报。

## 输出格式
1. 今日完成
2. 明日计划
3. 需要协调的事项

## 注意事项
- 语言简洁，每条不超过 20 字
- 按重要程度排序

就这么简单。Claude 读了这份文件，就"学会"了你们公司日报的写法。

Claude Code创始人的几个最佳实践

Tue, 06 Jan 2026 18:00:00 +0800

Claude Code 的创始人最近在 X 上分享了几条使用心得，看完之后深有同感。不是那种官方文档式的教程，而是实际用下来的体会。

这里展开聊聊。

1. 并行跑多个 Agent，学会当指挥官

这条说的是：开多个终端，同时跑多个 Claude Code 实例。

听起来简单，但背后是思维方式的转变。

以前写代码，习惯是单线程的——想一个问题，解决一个问题，再想下一个。现在有了 AI 帮手，你其实可以同时推进好几件事：

一个窗口让 Claude 重构某个模块
另一个窗口让它写测试
第三个窗口让它查文档、整理资料

你不需要盯着每一个窗口看它敲代码。布置完任务，让它们各自跑，你只需要在关键节点检查一下、给点反馈。

这就是"指挥官"的角色——你不是亲自上阵干活的士兵，而是在指挥多个单位协同作战。

当然，这需要一点适应。刚开始会觉得分心、不踏实，总想盯着一个看完再开下一个。但一旦习惯了，效率提升是显而易见的。

实操上，可以用 Git Worktree 让每个 Claude 在独立的工作目录：

git worktree add ../feature-a feature-a
git worktree add ../feature-b feature-b

这样各个实例互不干扰，也不会出现文件冲突。

2. 用最智能的模型，别心疼 token

这条的原话是：AI Coding 的瓶颈不再是 token 生成速度（计算税），而是人类纠正错误花费的时间（纠正税）。

说得太对了。

很多人用 AI 写代码会本能地想省钱——用便宜的模型、用快的模型。但实际算下来，这笔账可能是亏的。

便宜模型写出来的代码，你要花时间 review、改 bug、来回调试。一个小时下来，省了几毛钱的 token 费，但浪费了大把时间。

而用最聪明的模型（比如 Opus），虽然贵一点、慢一点，但它一次写对的概率更高。你检查一遍就能过，省下来的是你的时间。

这就是"纠正税"的概念：模型犯错，你来买单。模型越笨，你交的税越多。

我自己的做法是：

写代码、改代码、做需要推理的任务 → 至少用 Sonnet，复杂任务上 Opus
做简单的智能体任务、批量处理 → 可以用 GLM、Minimax 这些国产模型

关键是分清场景。代码质量直接影响后续维护成本，这个地方不值得省。

Skill与MCP的区别：两种扩展AI能力的方式

Tue, 06 Jan 2026 17:00:00 +0800

用 Claude Code 久了，你会发现它有两套看起来很像但本质不同的能力扩展系统：Skill 和 MCP。

很多人分不清这两者的区别，甚至把它们混为一谈。今天就来聊聊这两种扩展方式到底有什么不同。

什么是 MCP

MCP 全称 Model Context Protocol（模型上下文协议），是 Anthropic 开发的一个开放协议标准。

你可以把 MCP 理解成 AI 世界的"USB 接口"。就像 USB 让各种设备能插到电脑上一样，MCP 让各种外部工具和服务能接入 AI 模型。

MCP 服务器可以提供三种东西：

Tools（工具）：可执行的操作，比如发邮件、查数据库、操作浏览器
Resources（资源）：可读取的数据源，比如文档、配置文件
Prompts（提示）：预设的提示模板

举个例子，Playwright MCP 服务器提供了一系列浏览器操作工具：

browser_navigate - 导航到指定 URL
browser_click - 点击页面元素
browser_type - 在输入框中输入文字
browser_snapshot - 获取页面快照
browser_screenshot - 截取页面截图
...

每个工具都有明确的输入参数和输出格式。AI 通过调用这些工具来完成任务，就像程序员调用 API 一样。

什么是 Skill

Skill 是 Claude Code 特有的概念，翻译过来就是"技能"。

如果说 MCP 是"工具箱里的工具"，那 Skill 就是"使用这些工具的手艺"。

一个 Skill 本质上是一组指令、知识和工作流程的组合。它告诉 AI：

遇到什么场景该怎么做
有哪些注意事项和最佳实践
应该用什么工具、按什么顺序
输出应该是什么格式

比如 commit 这个 Skill，它不只是调用 git 命令那么简单。它包含了：

Claude Code的Skill与SubAgent区别

Fri, 26 Dec 2025 12:40:02 +0800

AI Agent 要变强，有两条完全不同的路。

一条是 Skill，也就是给自己装技能，把新能力直接塞进脑子里。

另一条是 SubAgent，就像派小弟去干活，自己只看汇报。

这两条路听起来都能让 Agent 更厉害，但适用的场景还是有所不同，用错了的话，你的 Agent 可能反而会越用越慢、越用越乱。

Skills，就像是给主 Agent 装插件。

比如你的 Agent 原本只会聊天，现在你想让它能写 PPT。Skills 的做法是：把写 PPT 的能力说明、工具调用方式、注意事项，全都塞进主 Agent 的上下文中。主 Agent 通过上下文学会了这项技能，它可以自己来写 PPT。

第二种叫 SubAgent，就像是委托外包。

同样是写 PPT，SubAgent 的做法是：主 Agent 把任务派给一个专门写 PPT 的 SubAgent，SubAgent 独立完成后把结果交回来。主 Agent 全程不参与具体执行，只负责派活和验收。

一个是内化能力，一个是外包能力。听起来都能搞定任务，区别在哪？

区别在上下文管理，上下文就是 AI 的记忆。

你可以把 AI 的上下文想象成一张工作桌。桌子大小是固定的，你放的东西越多，就越难找到需要的那份文件。这就是上下文容量的问题。

Skills 模式下，所有能力说明都铺在同一张桌上。好处是信息互通，主 Agent 能看到所有中间结果，推理过程连贯。坏处是桌子很快就乱了，Prompt 越来越长，能力之间可能打架，AI 开始犯糊涂。

SubAgent 模式下，SubAgent 在另一张桌子上干活。干完把结果递过来，过程中产生的草稿、中间文件全留在那边。主 Agent 的桌面保持干净。代价是信息传递要设计好，不然关键信息可能在交接时丢了。

这就是上下文污染问题，这里的污染不是夸张的比喻，是真实的工程瓶颈。

什么时候用哪种？

判断标准其实很简单：子任务有多复杂，以及你需不需要完成任务过程中产生的信息。

Skills 适合的场景：任务本身不太复杂，或者你需要主 Agent 全程掌控。

比如让 Agent 充当入口路由，根据用户请求加载不同的“场景模式”，像进入 YouTube 总结模式、进入写报告模式。这时候 Skills 的懒加载特性很香：先只加载能力名字和简介，真正要用时才加载完整说明。不像 MCP 那样一股脑把所有工具的详细文档全塞进上下文。

SubAgent 适合的场景：子任务很重、很耗时、中间过程很啰嗦。

最典型的例子是浏览器调试工具。Chrome DevTools 的 MCP 功能很强，但工具说明太臃肿，放进主 Agent 会严重占用上下文。把它封装成 SubAgent，你只需要说“去查日志、截图、分析一下”，它跑完把分析结论递回来。中间那些截图、DOM 树、网络请求细节，全都留在 SubAgent 那边，不污染主 Agent 的上下文。

进阶玩法

有意思的是，Skills 和 SubAgent 这两种模式可以结合。

第一种思路叫“先展开再压缩”。

打个比方：你开了一个两小时的头脑风暴会，白板上写满了草稿、争论、被否决的方案。但最后写进会议纪要的只有三条结论。那些中间过程对得出结论很重要，但对后续执行的人来说是噪音。

Agent 也可以这样操作。主 Agent 发现需要某个 Skill，加载进来，一通操作拿到结果。然后把从“加载 Skill”到“拿到结果”这整段过程折叠掉，只保留最终结论。对后续推理来说，就像开了一个会但只留下了会议纪要。

第二种思路是用文件系统做“中转站”。

想象你管理一个外包团队。你不会把所有需求细节都塞进一条微信消息里，而是说“需求文档在这个链接，去看”。外包团队交付时也不会把源码复制粘贴给你，而是说“代码在这个仓库，部署文档在这里”。

Agent 之间也可以这样协作。主 Agent 委托任务时，不把冗长的背景资料直接写进指令，而是存成文档，只传一个地址。SubAgent 返回时也一样：交付一个简短的状态摘要——“完成了/卡住了/需要你决策”——加一个详细记录的文档地址。主 Agent 根据情况决定要不要点进去看细节。这样双方的上下文都保持精简。

第三种是 Claude Code 里的实战技巧。

上下文快见底时，让 Claude 把当前完成的工作总结成一份文档。然后用 rewind 功能回滚到任务开始前的状态，告诉它：“这件事我已经做完了，记录在这个文件里。”

相当于什么？相当于你跑了一场马拉松，快到终点时发现体力不支。于是你把已经跑过的路线画成地图存档，然后“瞬移”回起点，精力充沛地说“我知道怎么走了，地图在这”。上下文被清空了，但成果保留了下来。用这个方法能在上下文耗尽前抢救一把。

最后

Agent 的竞争正在从“能调用多少工具”转向“怎么优雅地管理这些工具”。

很多人追逐最新的 Agent 框架、最花哨的能力扩展，却忽略了最基础的问题：AI 的工作记忆是有限的，你怎么组织它，决定了它能做多复杂的事。Skills 和 SubAgent 不是非此即彼的选择，而是两种工具，用对场景才能发挥价值。

说到底，Agent 架构设计和软件架构设计还是有很多相通之处。是把逻辑写在一个巨型函数里，还是拆成模块化的微服务？是共享全局变量图省事，还是严格隔离状态保持干净？

这些老问题换了个皮，又回来了。

向量数据库到底解决了什么问题？从原理到工程实践一次讲清

Tue, 11 Mar 2025 14:40:02 +0800

1. 向量数据库为什么突然火了？

2023 年之前，向量数据库是个小众领域，圈外人基本没听过。

然后 ChatGPT 爆了，大模型成了全民话题。紧接着大家发现一个问题：大模型的知识是训练时固定的，不知道你公司的内部文档，不知道最新的新闻，不知道你私有的数据。

怎么办？把私有数据喂给它。

怎么喂？总不能每次都把几百页文档塞进 prompt 里吧，token 费用先不说，还超长度限制。

于是 RAG（Retrieval-Augmented Generation）火了。思路很简单：先从你的知识库里找到和问题相关的内容，再把这些内容塞给大模型，让它基于这些内容回答。

问题来了：怎么"找到相关内容"？

传统数据库做关键词匹配，搜"苹果手机"只能匹配到包含"苹果手机"这几个字的文档，搜不到写着"iPhone"的文档。

但人知道"苹果手机"和"iPhone"是一回事。怎么让机器也知道？

答案是：把文本转成向量，用向量的相似度来衡量语义的相似度。

这就是向量数据库火起来的根本原因——大模型时代需要语义检索，向量数据库是做语义检索最直接的方案。

2. 什么是向量？Embedding 到底在干什么

向量是什么

向量就是一串数字。

比如 [0.12, -0.34, 0.56, ..., 0.78]，可能有 768 个数，也可能有 1536 个数，取决于用什么模型生成的。

这串数字代表什么？代表这段内容的"语义特征"。

你可以把它理解成一个坐标点。在一个 768 维的空间里，每段文本都有一个位置。语义相近的文本，位置就靠得近；语义不同的，位置就离得远。

Embedding 模型在干什么

Embedding 模型就是负责把文本转成向量的。

全面解析FaceFusion：从原理到实战

Wed, 16 Oct 2024 14:56:30 +0800

这东西是干嘛的

FaceFusion 是一个开源的 AI 换脸工具，说白了就是把 A 的脸换到 B 身上。

它的前身是 Roop，同一个开发者的作品。Roop 当时火了一阵，但后来因为一些原因停更了。作者重新搞了 FaceFusion，功能更强，效果更好。

官方介绍只有一句话：下一代换脸器和增强器。挺狂的，但确实有这个实力。

目前最新版本是 3.5.x，支持：

图片换脸
视频换脸
批量处理
人脸增强
N 卡和 A 卡都能跑

技术原理（简单说）

换脸这事听起来玄乎，其实拆开来就几步：

人脸检测：先找到图片/视频里的人脸在哪
特征提取：分析源脸（你要换上去的脸）的特征
人脸对齐：把源脸和目标脸的角度、大小对齐
特征融合：把源脸的五官特征融合到目标脸上
后处理：修边缘、调肤色、提升清晰度

FaceFusion 用的是 InsightFace 做人脸检测和特征提取，效果比较稳。融合部分有多种模型可选，不同模型效果略有差异。

增强功能用的是 GFPGAN 之类的模型，专门修复人脸细节，让换完的脸看起来更自然。

硬件要求

显卡

这是最关键的。

Java 入门教程（二）：Arrays 工具类、集合框架与 I/O 操作详解

Mon, 13 May 2024 15:13:10 +0800

接上一篇《Java学习笔记（一）》

七、集合技术 & I/O 技术

1. Arrays 类

Arrays是干什么用的，Arrays是操作数组的工具类，它可以很方便的对数组中的元素进行遍历、拷贝、排序等操作。

/**
 * 目标：掌握Arrays类的常用方法。
 */
public class ArraysTest1 {
 public static void main(String[] args) {
 // 1、public static String toString(类型[] arr): 返回数组的内容
 int[] arr = {10, 20, 30, 40, 50, 60};
 System.out.println(Arrays.toString(arr));

 // 2、public static 类型[] copyOfRange(类型[] arr, 起始索引, 结束索引) ：拷贝数组（指定范围，包前不包后）
 int[] arr2 = Arrays.copyOfRange(arr, 1, 4);
 System.out.println(Arrays.toString(arr2));

 // 3、public static copyOf(类型[] arr, int newLength)：拷贝数组，可以指定新数组的长度。
 int[] arr3 = Arrays.copyOf(arr, 10);
 System.out.println(Arrays.toString(arr3));

 // 4、public static setAll(double[] array, IntToDoubleFunction generator)：把数组中的原数据改为新数据又存进去。
 double[] prices = {99.8, 128, 100};
 // 0 1 2
 // 把所有的价格都打八折，然后又存进去。
 Arrays.setAll(prices, new IntToDoubleFunction() {
 @Override
 public double applyAsDouble(int value) {
 // value = 0 1 2
 return prices[value] * 0.8;
 }
 });
 System.out.println(Arrays.toString(prices));

 // 5、public static void sort(类型[] arr)：对数组进行排序(默认是升序排序)
 Arrays.sort(prices);
 System.out.println(Arrays.toString(prices));
 }
}

如果数组中存储的元素类型是自定义的对象，如何排序呢?

Java 入门教程（一）：JDK/JRE/JVM 概念解析与 IDEA 开发环境配置

Sat, 04 May 2024 21:00:00 +0800

一、背景

1995年SUN 公司推出，最早叫 Oak(橡树)，后改名叫 Java，Java之父詹姆斯（James），SUN 在2009年被 ORACLE收购。

二、整体学习路线

Java 技术体系（JAVA SE、JAVA EE、JAVA ME）。 Java基本啥都能干，但主要做互联网系统的开发.

三、JDK

javac：编译工具

java ：执行工具

JVM(Java Virtual Machine)：Java 虚拟机，真正运行 Java程序的地方核心类库：Java 自己写好的程序

JRE（Java Runtime Environment）:Java的运行环境

JDK(Java Development Kit): Java开发工具包(包含上面所有)

AWS CLI 完全指南：安装配置、S3/EC2 常用命令与权限排错

Sat, 04 Jul 2020 00:16:54 +0800

AWS CLI（Amazon Web Services Command Line Interface）是 AWS 官方提供的统一命令行工具，让你能够通过终端直接管理所有 AWS 服务。本文将详细介绍 AWS CLI 的安装配置方法和常用命令，帮助你快速上手云资源管理。

一、安装 AWS CLI

AWS CLI 目前推荐使用 v2 版本，它更快、更安全，且支持所有最新特性。

1. macOS 安装

方式一：使用 Homebrew（推荐）

brew install awscli

方式二：使用官方安装包

# 下载安装包
curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"

# 安装
sudo installer -pkg AWSCLIV2.pkg -target /

2. Linux 安装

# x86_64 架构
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# ARM64 架构
curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

3. Windows 安装

下载并运行 MSI 安装程序：

Nginx HTTPS 配置完全指南：自签名证书、混合站点与反向代理踩坑

Fri, 03 Jul 2020 13:19:44 +0800

在生产环境中配置 Nginx HTTPS 是后端工程师的必备技能。本文整合了我在实际项目中遇到的三个典型场景：自签名证书配置、HTTP/HTTPS 混合站点、以及反向代理 AWS ELB 时的 DNS 解析踩坑，一次性讲清楚。

一、OpenSSL 自签名 SSL 证书

在开发测试环境中，我们通常使用自签名证书来启用 HTTPS，不需要购买第三方证书。

1.1 安装 OpenSSL

先检查是否已安装：

openssl version -a

如未安装：

sudo apt-get install openssl
sudo apt-get install openssl-devel

1.2 生成私钥和证书

整个流程分四步：

第一步：生成私钥

openssl genrsa -des3 -out app.key 1024

执行后会提示输入密码，这个密码后面会用到。

curl 命令详解（2026）：GET/POST 请求、文件传输与 API 调试实战

Mon, 29 Jun 2020 00:00:00 +0000

在日常开发和运维中，curl 命令几乎是使用频率最高的命令行工具之一。它支持 HTTP、HTTPS、FTP 等 20+ 种协议，无论是调试 REST API、发送 POST 请求、下载文件还是测试网络连通性，一条 curl 命令就能搞定。

本文是一份系统的 curl 命令详解教程，涵盖 GET/POST/PUT/DELETE 等 HTTP 请求方法、JSON 数据发送、文件上传下载、Bearer Token 认证、代理配置、耗时分析等全部核心用法。如果你还需要排查网络链路问题，可以配合 traceroute 命令详解一起使用。

traceroute 命令详解（2026）：路由追踪与网络故障排查实战指南

Sun, 28 Jun 2020 12:12:04 +0800

网站打开慢、视频卡顿、SSH 连接超时——这些问题的根源往往藏在网络链路的某一跳。traceroute 命令（Windows 上叫 tracert）就是帮你找出"到底慢在哪里"的利器。它通过追踪数据包从你的电脑到目标服务器经过的每一个路由节点，测量每一跳的延迟，让网络瓶颈无处遁形。

本文是一份完整的 traceroute 命令详解教程，将从 TTL 工作原理、Linux/macOS/Windows 三平台用法差异、输出解读技巧到网络故障排查实战案例，帮你系统掌握这个网络诊断必备工具。如果你同时需要调试 HTTP 请求，推荐配合 curl 命令详解一起使用。

一、Traceroute 是什么

Traceroute（Windows 系统中叫 tracert）是一个网络诊断命令行工具，用于显示数据包在 IP 网络中从源到目的地的传输路径。

核心功能

功能	说明
路径追踪	显示数据包经过的每个路由器
延迟测量	测量到达每个节点的往返时间（RTT）
故障定位	快速找出网络中断或延迟的节点
拓扑发现	了解网络的路由结构

平台差异

平台	命令	默认协议
Linux/macOS	`traceroute`	UDP
Windows	`tracert`	ICMP
Cisco IOS	`traceroute`	UDP

二、工作原理：TTL 的巧妙应用

Traceroute 的核心原理是利用 IP 协议中的 TTL（Time To Live） 字段。

Linux/macOS 常用命令速查手册（持续更新）

Thu, 19 Mar 2020 10:55:52 +0800

Linux/macOS 命令行是开发者必备技能。本文整理了日常工作中高频使用的命令，按功能分类便于查找，持续更新中。

一、网络相关

1. netstat - 查看网络连接

Linux：

# 查看指定端口占用
netstat -ntlp | grep 3000

# 查看指定进程的网络连接
netstat -ntlp | grep nginx

# 查看所有监听端口
netstat -tuln

macOS：

# 查看指定端口
netstat -an | grep 3306

# 查看所有监听端口
netstat -an | grep LISTEN

Tips: Linux 下需要加 sudo 才能看到进程名称

2. lsof - 查看打开的文件/端口

# 查看端口占用（最常用）
lsof -i:80
lsof -i:3000

# 查看所有监听端口
sudo lsof -i -P | grep LISTEN

# 查看指定进程打开的文件
lsof -p <PID>

# 查看指定用户打开的文件
lsof -u username

3. ss - 更快的 netstat 替代品

# 查看所有 TCP 连接
ss -t

# 查看所有监听端口
ss -tuln

# 查看指定端口
ss -tuln | grep :80

# 查看 socket 统计信息
ss -s

4. ping & telnet - 网络连通性测试

# 测试网络连通性
ping google.com

# 指定次数
ping -c 4 google.com

# 测试端口连通性
telnet 192.168.1.1 3306

# macOS 下用 nc 替代 telnet
nc -zv 192.168.1.1 3306

5. dig & nslookup - DNS 查询

# 查询域名 A 记录
dig example.com

# 查询指定类型记录
dig example.com MX
dig example.com TXT

# 使用指定 DNS 服务器查询
dig @8.8.8.8 example.com

# 简洁输出
dig +short example.com

# nslookup 方式
nslookup example.com

6. ifconfig & ip - 网卡信息

# 查看网卡信息
ifconfig
ifconfig en0 # macOS 查看指定网卡

# Linux 推荐使用 ip 命令
ip addr
ip addr show eth0
ip route # 查看路由表

二、进程管理

1. ps - 查看进程

# 查看所有进程（最常用）
ps aux
ps -ef

# 查找指定进程
ps aux | grep nginx
ps -ef | grep java

# 按 CPU/内存排序
ps aux --sort=-%cpu | head -10
ps aux --sort=-%mem | head -10

# 树形显示进程
ps auxf # Linux
pstree # 需要安装

2. kill - 终止进程

# 正常终止
kill <PID>

# 强制终止
kill -9 <PID>

# 按名称终止
pkill nginx
killall nginx

# 常用信号
# -1 (HUP) 重新加载配置
# -9 (KILL) 强制终止
# -15 (TERM) 正常终止（默认）

3. top & htop - 实时监控

# 实时查看系统资源
top

# top 常用快捷键
# P - 按 CPU 排序
# M - 按内存排序
# k - 终止进程
# q - 退出

# htop（更友好，需安装）
htop

4. nohup & 后台运行

# 后台运行，忽略挂断信号
nohup ./script.sh &

# 输出重定向
nohup ./script.sh > output.log 2>&1 &

# 查看后台任务
jobs

# 前后台切换
bg %1 # 放到后台
fg %1 # 放到前台

5. systemctl - 服务管理 (Linux)

# 启动/停止/重启服务
systemctl start nginx
systemctl stop nginx
systemctl restart nginx

# 查看服务状态
systemctl status nginx

# 开机自启
systemctl enable nginx
systemctl disable nginx

# 查看所有运行的服务
systemctl list-units --type=service --state=running

三、文件操作

1. find - 文件查找

# 按名称查找
find /path -name "*.log"
find . -name "config.yml"

# 忽略大小写
find . -iname "readme*"

# 按类型查找
find . -type f # 文件
find . -type d # 目录

# 按时间查找
find . -mtime -7 # 7天内修改的
find . -mtime +30 # 30天前修改的

# 按大小查找
find . -size +100M # 大于100M
find . -size -1k # 小于1k

# 找到后执行命令
find . -name "*.tmp" -delete
find . -name "*.log" -exec rm {} \;
find . -type f -name "*.txt" -exec grep "keyword" {} \;

2. chmod & chown - 权限管理

# 修改权限
chmod 755 script.sh
chmod +x script.sh # 添加执行权限
chmod -R 644 ./dir # 递归修改

# 常用权限数字
# 7 = rwx (读写执行)
# 6 = rw- (读写)
# 5 = r-x (读执行)
# 4 = r-- (只读)

# 修改所有者
chown user:group file
chown -R user:group ./dir

3. tar - 打包压缩

# 打包压缩
tar -czvf archive.tar.gz ./dir
tar -cjvf archive.tar.bz2 ./dir

# 解压
tar -xzvf archive.tar.gz
tar -xzvf archive.tar.gz -C /target/dir

# 查看压缩包内容
tar -tzvf archive.tar.gz

# 参数说明
# c - 创建
# x - 解压
# z - gzip
# j - bzip2
# v - 显示过程
# f - 指定文件名

4. ln - 软链接/硬链接

# 创建软链接（最常用）
ln -s /path/to/source /path/to/link

# 创建硬链接
ln /path/to/source /path/to/link

# 查看链接指向
ls -la
readlink /path/to/link

5. rsync - 高效文件同步

# 本地同步
rsync -av source/ dest/

# 远程同步
rsync -avz source/ user@host:/path/dest/

# 常用选项
# -a 归档模式（保留权限等）
# -v 显示详情
# -z 传输时压缩
# --delete 删除目标多余文件
# --exclude 排除文件

# 排除特定文件
rsync -av --exclude='*.log' source/ dest/

四、文本处理

1. grep - 文本搜索

# 基本搜索
grep "keyword" file.txt

# 递归搜索目录
grep -r "keyword" ./dir

# 忽略大小写
grep -i "keyword" file.txt

# 显示行号
grep -n "keyword" file.txt

# 显示上下文
grep -A 3 "keyword" file.txt # 后3行
grep -B 3 "keyword" file.txt # 前3行
grep -C 3 "keyword" file.txt # 前后3行

# 正则表达式
grep -E "pattern1|pattern2" file.txt

# 反向匹配（排除）
grep -v "keyword" file.txt

# 只显示匹配的文件名
grep -l "keyword" *.txt

2. awk - 文本处理

# 打印指定列
awk '{print $1}' file.txt
awk '{print $1, $3}' file.txt

# 指定分隔符
awk -F: '{print $1}' /etc/passwd
awk -F',' '{print $2}' data.csv

# 条件过滤
awk '$3 > 100 {print $1, $3}' file.txt

# 计算求和
awk '{sum += $1} END {print sum}' file.txt

# 统计行数
awk 'END {print NR}' file.txt

3. sed - 流编辑器

# 替换文本（打印）
sed 's/old/new/' file.txt
sed 's/old/new/g' file.txt # 全局替换

# 直接修改文件
sed -i 's/old/new/g' file.txt
sed -i.bak 's/old/new/g' file.txt # 备份原文件

# 删除行
sed '/pattern/d' file.txt # 删除匹配行
sed '1d' file.txt # 删除第1行
sed '1,5d' file.txt # 删除1-5行

# 打印指定行
sed -n '5p' file.txt # 第5行
sed -n '5,10p' file.txt # 5-10行

4. sort & uniq - 排序去重

# 排序
sort file.txt
sort -r file.txt # 逆序
sort -n file.txt # 数字排序
sort -k2 file.txt # 按第2列排序

# 去重（需要先排序）
sort file.txt | uniq
sort file.txt | uniq -c # 统计次数
sort file.txt | uniq -d # 只显示重复行

5. head & tail - 查看文件头尾

# 查看前/后 N 行
head -n 20 file.txt
tail -n 20 file.txt

# 实时追踪日志（最常用）
tail -f app.log
tail -f -n 100 app.log # 从最后100行开始

# 多文件追踪
tail -f *.log

6. wc - 统计

# 统计行数/单词数/字符数
wc file.txt

# 只统计行数
wc -l file.txt

# 统计目录下文件数量
ls | wc -l
find . -type f | wc -l

五、磁盘管理

1. df - 磁盘使用情况

# 查看磁盘使用
df -h

# 查看指定目录所在分区
df -h /var

# 查看 inode 使用情况
df -i

2. du - 目录大小

# 查看目录大小
du -sh /var/log
du -sh *

# 按大小排序
du -sh * | sort -hr

# 查看子目录大小
du -h --max-depth=1

# 找出最大的文件/目录
du -a /var | sort -rn | head -10

3. ncdu - 交互式磁盘分析

# 安装
sudo apt install ncdu # Ubuntu
brew install ncdu # macOS

# 使用
ncdu /var

六、系统信息

1. 系统基本信息

# 系统版本
uname -a
cat /etc/os-release # Linux
sw_vers # macOS

# 主机名
hostname

# 运行时间和负载
uptime

2. 硬件信息

# CPU 信息
cat /proc/cpuinfo # Linux
sysctl -n machdep.cpu.brand_string # macOS
nproc # CPU 核心数

# 内存信息
free -h # Linux
vm_stat # macOS

# 查看内存使用前10的进程
ps aux --sort=-%mem | head -10

3. 环境变量

# 查看所有环境变量
env
printenv

# 查看指定变量
echo $PATH
echo $HOME

# 临时设置
export MY_VAR="value"

# 永久设置（加入配置文件）
echo 'export MY_VAR="value"' >> ~/.zshrc
source ~/.zshrc

七、用户与权限

1. 用户管理

# 当前用户
whoami
id

# 切换用户
su - username
sudo -u username command

# 查看登录用户
who
w
last # 登录历史

2. sudo 相关

# 以 root 执行
sudo command

# 切换到 root
sudo -i
sudo su -

# 编辑 sudoers
sudo visudo

八、实用技巧

1. 命令历史

# 查看历史命令
history
history | grep keyword

# 执行上一条命令
!!

# 执行历史中第N条命令
!N

# 搜索历史命令
Ctrl + R

2. 快捷键

快捷键	功能
`Ctrl + C`	终止当前命令
`Ctrl + Z`	暂停当前命令
`Ctrl + D`	退出终端
`Ctrl + L`	清屏
`Ctrl + A`	移到行首
`Ctrl + E`	移到行尾
`Ctrl + U`	删除光标前内容
`Ctrl + K`	删除光标后内容
`Ctrl + W`	删除前一个单词
`Ctrl + R`	搜索历史命令

3. 管道与重定向

# 管道
command1 | command2

# 输出重定向
command > file.txt # 覆盖
command >> file.txt # 追加

# 错误重定向
command 2> error.log
command > output.log 2>&1 # 标准输出和错误都写入

# 输入重定向
command < input.txt

# 丢弃输出
command > /dev/null 2>&1

4. pv - 显示进度

# 安装
sudo apt install pv # Ubuntu
brew install pv # macOS

# 文件复制显示进度
pv source.iso > dest.iso

# 限速复制
pv -L 2m source.iso > dest.iso

# MySQL 导入显示进度
pv database.sql | mysql -u root -p dbname

九、macOS 特有命令

1. 允许安装任意来源应用

# 开启任意来源
sudo spctl --master-disable

# 移除安全隔离属性
sudo xattr -r -d com.apple.quarantine /Applications/xxx.app

2. 剪贴板操作

# 复制到剪贴板
cat file.txt | pbcopy
echo "hello" | pbcopy

# 从剪贴板粘贴
pbpaste
pbpaste > file.txt

3. 打开文件/应用

# 用默认程序打开
open file.pdf
open . # 打开当前目录
open -a "Visual Studio Code" file.txt

4. 系统管理

# 查看电池状态
pmset -g batt

# 防止休眠（咖啡因模式）
caffeinate -d # 防止显示器休眠
caffeinate -i # 防止系统休眠

# DNS 缓存刷新
sudo dscacheutil -flushcache
sudo killall -HUP mDNSResponder

参考资料

Oh My Zsh 安装配置指南：打造高效终端环境 - 强大的 Zsh 配置框架
Shell 脚本特殊变量详解：$$、$?、$@、$# 等用法 - Shell 脚本编程必备知识
Linux curl 命令完全指南：HTTP 请求调试必备工具 - HTTP 请求调试神器
Traceroute 网络诊断命令详解：追踪数据包路由路径 - 网络故障定位必备工具

Conda 完全指南：Python 多版本环境管理从入门到精通

Sat, 11 Jan 2020 20:33:33 +0800

作为 Python 开发者，你是否遇到过这些问题：项目 A 需要 Python 2.7，项目 B 需要 Python 3.10，不同项目依赖的包版本相互冲突……Conda 正是解决这些问题的终极方案。本文将全面介绍 Conda 的使用方法，帮助你轻松管理多版本 Python 环境。

Privacy Policy

Wed, 01 Jan 2020 00:00:00 +0000

Overview

Welcome to heyuan110.com (“this site”). This privacy policy explains how we collect, use, and protect your information when you visit.

By using this site, you agree to the data practices described in this policy.

Information We Collect

Automatically Collected Information

When you visit this site, we may automatically collect:

Docker 常用命令速查（2026更新）：镜像、容器、网络、数据卷一页掌握

Thu, 14 Nov 2019 20:37:13 +0800

Docker常用命令记录

1. 启动、重启或停止docker服务

启动： service docker start

停止：service docker stop

重启：service docker restart

2.镜像(images)

获取镜像

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

例如：docker pull ubuntu:16.04

列出镜像

查看所有镜像: docker images或docker image ls, 显示摘要docker images --digests
查看特定镜像:docker image ls xxxx或docker image xxxx
查看镜像、容器、数据卷所占用的空间:docker system df
列出虚悬镜像（仓库名和标签名为）:docker image ls -f dangling=true,清楚此类镜像docker image prune

删除镜像

命令docker image rm [OPTIONS] IMAGE [IMAGE...] 或 docker rmi -f xxxx 例如：

MySQL EXPLAIN 执行计划详解：从入门到精通的 SQL 性能分析指南

Fri, 06 Sep 2019 20:10:21 +0800

EXPLAIN 是 MySQL 中最重要的性能分析工具之一。当你的 SQL 查询变慢时，第一件事就应该用 EXPLAIN 看看执行计划。它能告诉你 MySQL 是如何执行查询的，包括使用了哪些索引、扫描了多少行、采用了什么连接方式等关键信息。

本文将详细介绍 EXPLAIN 输出的每个字段含义，帮助你快速定位 SQL 性能问题。

一、EXPLAIN 基本用法

使用方法很简单，在 SQL 语句前加上 EXPLAIN 关键字即可：

EXPLAIN SELECT * FROM users WHERE id = 1;

MySQL 8.0+ 还支持不同的输出格式：

-- 传统表格格式（默认）
EXPLAIN SELECT * FROM users;

-- JSON 格式，信息更详细
EXPLAIN FORMAT=JSON SELECT * FROM users;

-- 树形格式，展示执行顺序
EXPLAIN FORMAT=TREE SELECT * FROM users;

-- 实际执行并显示运行时统计（MySQL 8.0.18+）
EXPLAIN ANALYZE SELECT * FROM users;

提示：EXPLAIN ANALYZE 会真正执行查询，所以对于修改数据的语句要谨慎使用。

二、EXPLAIN 输出字段详解

EXPLAIN 的输出包含 12 个字段，每个字段都提供了重要的执行信息：

刘澜领导力十项修炼学习总结：领导力本质与管理者成长

Mon, 19 Aug 2019 21:10:21 +0800

周末两天去广州学习了刘澜老师领导力修炼课程，之前在得到APP上听过刘老师这个课，现场感受更好，老师逻辑性强，讲课生动不枯燥，理论结合案例，几乎所有场景都能代入到工作中。

领导力

领导力既是承担解决集体问题的责任，也是承担失败的责任领导力不等于职位和头衔，领导力是领导职位的责任，领导职位是领导力的资源。没有领导职位，同样可以承担领导力的责任。

魅力不是发挥领导力的前提条件，而是你发挥了领导力之后的（被放大、被神化的）结果。魅力往往是发挥领导力的负担。带来的副作用：

崇敬领导者，追随者不再提意见
想得到领导认同，追随者不愿提意见
因为追随者的钦佩，追随者产生领导者不会犯错的幻觉
领导者过于自信，忽视了面对的危险
依赖领导者，组织没有培养胜任的继任者

领导力十项口诀

一、我来

勇于承担责任，让我来面对集体难题，挺身而出，让我来对平级或上级说，让我来对下级说，跟我来

怎么建立关于责任感，从三个维度剖析：意义感-》是否有意义-》我想做义务感-》是团队一份子，领导信任对我好-》我该做信心感-》有能力能胜任-》我能做

二、我不知道

学习了领导与管理的区别，弄清除自己现在的定位(管理岗)。管理岗需要维持团队运转，正确的做事，解决的是维持性问题，解决问题很多时候可能靠权威。面对维持性问题即使知道答案也要说不知道，动员他人发现答案解决问题，

说我不知道四种情况：

技术性问题，我不一定知道
面对难题，过去的答案不一定管用
面对难题，动员群众发现答案
面对难题，知道也说不知道，更好动员他人找出答案主动实施

三、你觉得呢？

密切联系群众，跟群众建立关系，通过群众了解信息。走动式管理，高管不远离群众多与下属沟通，注意问问题的技巧，通常一个好的问题应该是：

RabbitMQ 入门教程：AMQP 协议、Exchange 交换机与消息投递详解

Fri, 02 Aug 2019 11:47:04 +0800

前面文章《消息队列 MQ 技术选型指南》我们了解了消息队列技术选型，本文我们来学习开源消息队列RabbitMQ。

1. RabbitMQ简介

RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。

2. RabbitMQ工作流程

RabbitMQ架构图

发布者P-Clients（Publisher）发布消息(Message)，经由交换机X（Exchange）交换机根据路由规则将收到的消息分发给与该交换机绑定的队列(Queue) 最后RabbitMQ代理（Broker）会将消息投递（Push）给订阅了此队列的消费者(Consumer)，或者消费者按照需求自行获取(Pull)

深入理解：

(1)发布者、交换机、队列、消费者都可以有多个，因为RabbitMQ是基于网络协议AMQP，所以这个过程中发布者，交换机，队列，消费者可以处于不同的设备上。

(2)消息发布者可以给消息指定各种属性（Message Meta-data),一些属性可能被消息代理(Broker)使用，一些只能被消费者使用。消息分两部分：payload(有效载荷，传输的数据)和label(标签,exchange的名字或者说是一个tag，它描述了payload)，RabbitMQ通过label决定把Message发给哪个消费者。AMQP协议仅仅描述了label，RabbitMQ决定了如何使用label的规则。消费者在收到消息时只有payload部分，label已经被删掉，对于消费者而言是不知道谁发送的消息。

(3)从安全和可靠性角度，RabbitMQ很好实现了AMQP协议的消息确认(Message Acknowledgements)机制,当一个消息投递给消费者后，不会立即删除，直到它收到来自消费者的确认回执(Acknowledgements)后,才完成从队列里删除。

3. RabbitMQ基本概念

我们先来看一张RabbitMQ管理界面截图

这个界面包含了RabbitMQ很关键的几个概念(不是全部)

3.1 Producer（生产者）

消息生产者

消息队列 MQ 技术选型指南：核心概念与分布式系统应用场景

Wed, 31 Jul 2019 21:26:23 +0800

“消息队列”是在消息的传输过程中保存消息的容器。消息队列管理器在将消息从它的源中继到它的目标时充当中间人。队列的主要目的是提供路由并保证消息的传递；如果发送消息时接收者不可用，消息队列会保留消息，直到可以成功地传递它。

一.消息队列是什么

维基百科的解释：

消息队列（英语：Message queue）是一种进程间通信或同一进程的不同线程间的通信方式，软件的贮列用来处理一系列的输入，通常是来自用户。消息队列提供了异步的通信协议，每一个贮列中的纪录包含详细说明的数据，包含发生的时间，输入设备的种类，以及特定的输入参数，也就是说：消息的发送者和接收者不需要同时与消息队列互交。消息会保存在队列中，直到接收者取回它。 ——维基百科

解释比较官方，来看一个最简单的架构模型：

Producer：消息生产者，负责产生和发送消息到Broker；
Broker：消息处理中心，负责消息存储、确认、重试等，一般其中会包含多个queue；
Consumer：消息消费者，负责从 Broker 中获取消息，并进行相应处理；

消息队列是分布式系统中重要组件，使用消息队列主要是通过异步处理提高系统性能和削峰、降低系统耦合性。

下面用一个故事来理解消息队列：

小Y是攻城狮，有一天产品经理告诉他需要实现这样一个需求：“用户下单成功，给用户发送一封确认邮件”.小Y快速确认了需求，很简单嘛，加几行代码就搞定！如是在下单后调用发送邮件代码，经过本地和alpha测试，功能顺利上线。

正常运行了几天，产品经理找到小Y说观察监控数据，发现下单处理时间过长影响了转化率，小Y思考了一下，原来发邮件代码是放在下单完成代码后单线程同步阻塞的方式执行，确实有问题，于是新起了一个线程发邮件，测试通过后立即上线，下单感觉确实更顺畅了。

可是没过多久客服收到很多用户反馈没收到邮件，产品经理和小Y一起熬夜分析想办法，最后找到负责开发邮件模块的同事，负责邮件的同事说：“不用搞那么复杂，我给你提供一个类似邮局信箱的东西，你往这信箱里写上你要发送的消息，以及我们约定的地址。之后你就不用再操心了，我们自然能从约定的地址中取得消息，进行邮件的相应操作”。小Y快速按照邮件同事的建议修改了代码，并测试重新上线。

小Y后来才知道这个就是消息队列，你只需要将你想发送的消息发送到队列里，不用知道具体服务在哪，怎么执行，对应的服务自然能监听到你的发送的消息并获取过来执行。

后来其他业务也把邮件发送更换成这种方式，随着消息量增多，大量消息堆积，需要增加更多消费者来处理队列里的消息，于是便有了分布式消息处理

二.为什么要用消息队列

当系统出现"生产"和"消费"的速度和稳定性不一致时，就需要消息队列，正是这个中间层弥合双方的差异。使用消息队列主要三个好处（六字）：解耦、异步、削峰。

1.解耦

场景：A更新数据，通知B,C更新，D等待接入。

传统架构:

传统架构下，A更新数据后分别调用B,C系统API，将更新的数据传过去，这种结构有下面的问题：(1)耦合性太强 (2)B,C系统故障，无法正确接收更新数据 (3)如果有D再接入，A又需要配合修改代码

引入消息队列中间件架构:

引入消息队列中间件的架构后，如果A更新了数据，只需要将消息发布到消息队列，B,C只要从消息队列订阅这条消息，D接入也只需自己去订阅，完全无需A做任何改动。

消息的发送方和接收方并不需要彼此联系，也不需要受对方的影响。

2.异步

Nexus3 搭建 Docker 私有镜像仓库：企业级 Registry 完整教程

Wed, 12 Jun 2019 20:50:36 +0800

Nexus是有名的Maven仓库管理器。如果你使用Maven，你可以从Maven中央仓库下载所需要的构件（artifact），但这通常不是一个好的做法，你应该在本地架设一个Maven仓库服务器，在代理远程仓库的同时维护本地仓库，以节省带宽和时间，Nexus就可以满足这样的需要。此外，他还提供了强大的仓库管理功能，构件搜索功能，它基于REST，友好的UI是一个extjs的REST客户端，它占用较少的内存，基于简单文件系统而非数据库。这些优点使其日趋成为最流行的Maven仓库管理器。除此之外，最新Nexus3还可以管理多种格式的镜像，如下：

1.环境

系统：ubuntu16.04 docker：18.02.0-ce

2.获取nexus3镜像

docker pull sonatype/nexus3

3.启动镜像

docker run -id --privileged=true --name=nexus3 --restart=always -p 9500:8081 -p 9501:9501 -p 9502:9502 -p 9503:9503 -v /usr/local/programs/nexus3/nexus-data:/nexus-data sonatype/nexus3:latest

端口(注意映射了多个端口)：

9500: nexus3网页端
9501：docker(hosted)私有仓库，可以pull和push
9502：docker(proxy)代理远程仓，只能pull
9503：docker(group)私有仓库和代理的组，只能pull

运维人员维护镜像试用9501端口，项目pull镜像使用9503端口，全部可匿名pull。

数据：在宿主机创建目录/usr/local/programs/nexus3/nexus-data，/nexus-data为docker容器数据存储目录。所以-v设置映射关系后数据将会存到宿主机/usr/local/programs/nexus3/nexus-data

4.配置私有仓库

访问http://localhost:9500默认账号admin/admin123

Docker 入门教程：镜像、容器、仓库核心概念与 Dockerfile 详解

Mon, 13 May 2019 20:33:33 +0800

Docker 是一个开源的应用容器引擎，基于 Go 语言并遵从Apache2.0协议开源。Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

1.Docker 包括三个基本概念

镜像(Image)
容器(Container)
仓库(Repository)

2.镜像(Image)

Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数(如匿名卷、环境变量、用户等)。镜像不包含任何动态数据，其内容在构建之后也不会被改变。

镜像并非是像一个 ISO 那样的打包文件，镜像只是一个虚拟的概念，其实际体现并非由一个文件组成，而是由一组文件系统组成，或者说，由多层文件系统联合组成。

镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。

3.Docker 容器

镜像(Image)和容器(Container)的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。

容器也是分层存储。每一个容器运行时，是以镜像为基础层，在其上创建一个当前容器的存储层，我们可以称这个为容器运行时读写而准备的存储层为容器存储层。

容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。容器不应该向其存储层内写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用数据卷(Volume)、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主(或网络存储)发生读写，其性能和稳定性更高。

4.Docker Registry

镜像构建完成后，可以很容易的在当前宿主上运行，但是，如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry 就是这样的服务。一个 Docker Registry 中可以包含多个仓库(Repository);每个仓库可以包含多个标签(Tag);每个标签对应一个镜像。

Ubuntu 搭建 Jira + Confluence 完整教程：安装配置与数据迁移

Mon, 15 Apr 2019 13:53:32 +0800

jira和confluence都是Atlassian公司产品。jira是项目与事务跟踪工具，可以完成项目执行管理、敏捷开发管理、体系流程管理、产品Bug跟踪、提案跟踪、需求管理、客户服务等工作。confluence是一个专业的企业知识管理与协同软件，可以用于构建企业wiki，通过它可以实现团队成员之间的协作和知识共享。

Linux 挖矿病毒 kerberods 入侵排查与清理实战

Fri, 12 Apr 2019 16:15:53 +0800

最近经常听到挖矿病毒kerberods肆虐，大量linux主机沦陷，导致的结果显著特征CPU持续100%，正常的应用服务无法提供。不幸昨天我们有一台机器中招了，下面记录整个事件发生、处理过程。

事件发生

昨天下午5.30左右，几个同事反馈git代码无法提交，报502错误。

立即安排了一个运维童鞋排查，本来以为和上次一样gitlab并发数达到上限，改改配置重启下就行，结果从18点到20点一直顺着gitlab502错误这个方向搞了2小时，没有任何进展。由于代码无法提交，gitlab访问不了，发布系统也就不能正常做上线操作，赶紧我也投入了排查。

排查处理

这台机器上有三个服务gitlab，jira，confluence，除了gitlab，另外两个看着是正常的(其实里面部分页面已经异常，只是没仔细去检查)。

检查系统运行指标，先上服务器上执行top，如下：

粗略一看cpu和内存好像正常，按1切换看每个cpu情况问题来了，居然只有一个cpu0，这台ec2机器有16CPU，接着到aws console上看到这台机器cpu，如下：

5.30左右cpu突然直接100%了，其实这时脑袋闪了一下有想到是病毒，然后去看了机器的network out/in发现没有突然激增，所以没继续朝这想。随后执行ps -ef查看进程，发现居然没有php，java相关进程，开始想是不是aws系统故障（之前有前科）？

于是让同事赶紧给aws提了个加急support，同时联系专门对接我们的AWS SA让其帮忙跟进催促。这时我们还是没意识到是感染了病毒，如是边等待aws那边消息，边继续在google搜索gitlab502错误相关的资料。

gitlab论坛、google上能搜到资料都尝试了，基本都在说是因为端口被占用，超时时间设置等等，执行netstat -ntlp发现gitlab服务的8080端口压根没占用，不过抱着侥幸心理还是改了默认端口然后gitlab-ctl reconfigure和gitlab-ctl restart，最后用gitlab-ctl status查看发现显示所有的服务都起来了，翻遍了gitlab里相关服务所有的log，唯有有点线索的还是显示127.0.0.1:8080 refused，gitlab坛子里有人说要多尝试其次，又试了几遍，当然不会有结果啊，最后我基本确认不是gitlab问题，又去催aws sa帮我联系他们support。

中间已经开始做最坏打算，让另外一个同事开新机器把gitlab迁移过去，可是发现gitlab backup超级无敌慢，不过还是耐心的等待着。

还好大概在一个小时后美国那边的supprot打电话过来，以为有救了，nonono，接下来一度很无语，给他们描述完问题，才发现他们毛都干不了。aws规定他们售后工程师不能碰客户机器(说是基于客户安全考虑，不过应该有点扯，都托管到他们那了想干啥不行啊)，那你不能碰机器，又不能看到底层，凭超能力感知么？反正无厘头一顿指挥操作后，没啥结果。然后让做一个AMI，也是神坑速度超慢，点开始后就只能傻傻等，最后我提出来远程协助工具，居然没有，那我share屏幕，你看着然后一起分析总行吧，还好这个有，很快他发了一个screenshare的link，下载安装好bomgar，打开开始share屏幕，至此才可以说是support开始。。。。尼玛有sharescreen这种工具怎么不一上来就提出来用，唾沫星子能解决个毛线问题啊。

工欲善其事必先利其器，这里真心要吐槽下aws support的"维修工具箱"，有顾虑和安全意识不让碰客户机器可以理解，可是能不能搞一些方便沟通提高解决问题效率的工具，比如远程协助，分享屏幕，文字、图片截图聊天等等。

以上是吐槽，得结论：16CPU的top命令只能看到1CPU在跑，有点诡异，继续排查。

重启EC2

怀疑是EC2硬件故障，并且反复尝试了多次；发现上述现象依然存在，服务器始终无法显示所有的CPU资源，依旧显示一颗CPU在运行，查看系统启动日志/var/log/syslog，日志最后提示：didn’t collect load info for all cpus, balancing is broken

排查CPU

先对故障的机器做快照，准备快照完起新机器还原过去试试。同时开始排查CPU，大概过程如下：


$ cat /proc/cpuinfo

查看CPU信息，系统在启动过程中，CPU的信息在启动的过程中被装载到虚拟目录/proc下的cpuinfo文件中

$ cat /var/log/syslog | grep irqbalance

查看系统日志过滤CPU中断分布信息；

关于irqbalance的更多信息：http://blog.huatai.me/2014/11/05/linux-irqbalance-irq-and-cpu-affinity/

$ cat /proc/stat # 查看CPU的利用率

$ mpstat -P ALL 1 3 或

$ for i in `seq 3`; do cat /proc/stat >> /tmp/stat.txt; sleep 1; done

# 采集所有的CPU核心的当前运行情况，每秒更新一次，采集3次

cpu 10445020 88 14726 50034 5432 0 457 11658 0 0

cpu0 653379 0 922 2011 805 0 13 535 0 0

cpu1 651988 0 1745 2566 872 0 26 782 0 0

cpu2 653171 37 925 2511 598 0 4 735 0 0

cpu3 653520 0 807 2460 455 0 0 741 0 0

cpu4 651566 0 1390 3614 486 0 197 729 0 0

cpu5 652563 0 1318 2713 447 0 196 752 0 0

cpu6 652903 0 734 3258 340 0 1 748 0 0

cpu7 653128 0 842 2762 502 0 2 733 0 0

cpu8 652979 0 692 3446 128 0 0 733 0 0

cpu9 652710 0 729 3701 100 0 5 731 0 0

cpu10 652843 51 760 3471 119 0 3 732 0 0

cpu11 652815 0 703 3610 120 0 0 736 0 0

cpu12 652166 0 856 4120 102 0 1 734 0 0

cpu13 652992 0 777 3347 121 0 1 736 0 0

cpu14 653266 0 647 3284 40 0 1 753 0 0

cpu15 653024 0 874 3154 189 0 2 742 0 0

intr 33000247 89 9 0 0 1495 0 3 0 2 0 0 0 144 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1742341 37454 89869 0 97 336 1786533 51288 92366 0 154 25 1729717 45438 85288 0 381 44 1709936 37017 91720 0 141 68 1896285 59966 56559 0 239 17 1890560 58187 89663 0 265 11 1703860 30700 92690 0 111 2 1706076 34320 77972 0 352 0 1735997 30031 92496 0 107 5 1707715 23861 89955 0 146 1 1700884 26785 92025 0 177 0 1697132 23744 92566 0 126 2 1788088 29854 74162 0 142 0 1781043 35672 92946 0 382 1 1707596 18470 91498 0 98 0 1698041 24493 92666 0 148 1 141 126617 481806 477683 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

ctxt 9044786

btime 1554911733

processes 20719

procs_running 17

procs_blocked 0

softirq 35206004 0 26207552 1856 1006735 0 0 3292 1129827 0 6856742

cpu 10446621 88 14727 50040 5432 0 457 11658 0 0

cpu0 653480 0 922 2011 805 0 13 535 0 0

cpu1 652089 0 1745 2566 872 0 26 782 0 0

cpu2 653272 37 925 2511 598 0 4 735 0 0

cpu3 653620 0 807 2460 455 0 0 741 0 0

cpu4 651661 0 1390 3619 486 0 197 729 0 0

cpu5 652663 0 1318 2713 447 0 196 752 0 0

cpu6 653004 0 734 3258 340 0 1 748 0 0

cpu7 653228 0 842 2762 502 0 2 733 0 0

cpu8 653079 0 692 3446 128 0 0 733 0 0

cpu9 652811 0 729 3701 100 0 5 731 0 0

cpu10 652944 51 760 3471 119 0 3 732 0 0

cpu11 652915 0 703 3610 120 0 0 736 0 0

cpu12 652266 0 856 4120 102 0 1 734 0 0

cpu13 653092 0 777 3347 121 0 1 736 0 0

cpu14 653367 0 647 3284 40 0 1 753 0 0

cpu15 653124 0 874 3154 189 0 2 742 0 0

intr 33004598 89 9 0 0 1495 0 3 0 2 0 0 0 144 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1742594 37455 89869 0 97 336 1786791 51288 92366 0 154 25 1729977 45441 85288 0 381 44 1710194 37020 91720 0 141 68 1896595 59981 56559 0 239 17 1890835 58193 89663 0 265 11 1704118 30705 92690 0 111 2 1706348 34321 77972 0 352 0 1736251 30033 92496 0 107 5 1707971 23863 89955 0 146 1 1701145 26786 92025 0 177 0 1697391 23748 92566 0 126 2 1788355 29855 74162 0 142 0 1781306 35675 92946 0 382 1 1707855 18471 91498 0 98 0 1698298 24496 92666 0 148 1 141 126617 481820 477693 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

......

查看CPU时钟频率

$ getconf CLK_TCK

100

Hertz(tick per second)就是CLK_TCK，可以根据getconf CLK_TCK获取

$ echo l > /proc/sysrq-trigger

Send a SIGKILL to all processes, except for init

# 将所有的CPU正在执行进程打在了dmesg中

$ dmesg

文件：dmesg1.txt

关闭系统透明大页面

$ cat /sys/kernel/mm/transparent_hugepage/enabled

$ cat /sys/kernel/mm/transparent_hugepage/defrag

always [madvise] never

$ echo never > /sys/kernel/mm/transparent_hugepage/enabled

$ echo never > /sys/kernel/mm/transparent_hugepage/defrag

$ vi /etc/default/grub

$ GRUB_CMDLINE_LINUX="transparent_hugepage=never"

$ source /etc/default/grub

$ update-grub

$ cat /sys/kernel/mm/transparent_hugepage/enabled

$ cat /sys/kernel/mm/transparent_hugepage/enabled

always madvise [never]

$ echo l > /proc/sysrq-trigger

文件：dmesg2.txt

$ ps -ef | grep khugepaged

$ cd /proc

$ for f in `find . -name '[1-9][0-9]*' -maxdepth 1`; do echo $f; cat $f/comm; done

# 查看当前系统下所有正在执行的应用程序

find: warning: you have specified the -maxdepth option after a non-option argument -name, but options are not positional (-maxdepth affects tests specified before it as well as those specified after it). Please specify options before other arguments.

./10

watchdog/0

./11

watchdog/1

./12

migration/1

./13

ksoftirqd/1

./15

kworker/1:0H

./16

watchdog/2

./17

migration/2

./18

ksoftirqd/2

./20

kworker/2:0H

./21

watchdog/3

./22

migration/3

./23

ksoftirqd/3

./25

kworker/3:0H

./26

watchdog/4

./27

migration/4

./28

ksoftirqd/4

./30

kworker/4:0H

./31

watchdog/5

./32

migration/5

./33

ksoftirqd/5

./35

kworker/5:0H

./36

watchdog/6

./37

migration/6

./38

ksoftirqd/6

./40

kworker/6:0H

./41

watchdog/7

./42

migration/7

./43

ksoftirqd/7

./45

kworker/7:0H

......

$ echo l > /proc/sysrq-trigger

文件：dmesg3.txt

[ 177.581904] Sending NMI to all CPUs:

[ 177.583305] NMI backtrace for cpu 0

[ 177.583307] CPU: 0 PID: 2495 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583309] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

 ....

[ 177.583334] NMI backtrace for cpu 1

[ 177.583336] CPU: 1 PID: 2492 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583338] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

 .....

[ 177.583363] NMI backtrace for cpu 2

[ 177.583365] CPU: 2 PID: 2487 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583367] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

 ......

[ 177.583392] NMI backtrace for cpu 3

[ 177.583394] CPU: 3 PID: 2493 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583395] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583421] NMI backtrace for cpu 4

[ 177.583422] CPU: 4 PID: 2411 Comm: bash Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583424] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583482] NMI backtrace for cpu 5

[ 177.583484] CPU: 5 PID: 2497 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583486] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583511] NMI backtrace for cpu 6

[ 177.583513] CPU: 6 PID: 2496 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583514] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583540] NMI backtrace for cpu 7

[ 177.583541] CPU: 7 PID: 2494 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583543] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583568] NMI backtrace for cpu 8

[ 177.583570] CPU: 8 PID: 2501 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583572] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583597] NMI backtrace for cpu 9

[ 177.583599] CPU: 9 PID: 2488 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583601] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583626] NMI backtrace for cpu 10

[ 177.583628] CPU: 10 PID: 2490 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583629] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583655] NMI backtrace for cpu 11

[ 177.583656] CPU: 11 PID: 2491 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583658] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583684] NMI backtrace for cpu 12

[ 177.583685] CPU: 12 PID: 2486 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583687] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583712] NMI backtrace for cpu 13

[ 177.583714] CPU: 13 PID: 2500 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583716] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583741] NMI backtrace for cpu 14

[ 177.583743] CPU: 14 PID: 2499 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583744] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

[ 177.583770] NMI backtrace for cpu 15

[ 177.583772] CPU: 15 PID: 2489 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 177.583773] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

......

从上述日志可以看出 khugepageds 分别在0、1、2、3、5、6、7、8、9、10、11、12、13、14、15上执行，唯独没有在CPU 的第4个core上存在，与top命令显示只有一个CPU在运行吻合

从上面的日志中，根据cpu13中的PID找出对应的应用程序

$ ls /proc | grep 2500

khugepageds

[ 1035.043542] NMI backtrace for cpu 6

[ 1035.043544] CPU: 6 PID: 2493 Comm: khugepageds Not tainted 4.4.0-145-generic #171-Ubuntu

[ 1035.043545] Hardware name: Xen HVM domU, BIOS 4.2.amazon 08/24/2006

。。。。。。

根据"khugepageds"关键字google搜索出相关资料,发现居然是和一个挖矿病毒有关，此病毒相关资料：

Go 语言入门教程：Golang 基础语法与数据类型详解

Fri, 25 Jan 2019 21:13:19 +0800

前言

Go语言(或Golang)是Google在2007年开发的一种开源编程语言,于2009年11月10日向全球公布,2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

GO部署简单、并发性好、语言设计良好、执行性能好

一、GO语言结构

Go语言的基础组成有一下几个部分：

包声明
引入包
函数
变量
语句和表达式
注释

例子：

//定义包名
package main

//引入fmt包
import "fmt"

//定义函数, main为入口函数
func main() {
 /* 这是我的第一个简单的程序，我是注释 */
 fmt.Println("Hello, World!")
}

二、Go基础语法

行分隔符：一行代表一个语句结束，无需；号结尾
注释：单行//，多行/**/
标识符关键字：标识符用来命名变量、类型等程序实体，第一个字符必须是字母或下划线而不能是数字
关键字： 25 个关键字或保留字 36 个预定义标识符
空格：声明必须使用空格隔开，变量与运算符间加入空格，程序看起来更加美观

1.数据类型

数据类型用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

Jenkins + AWS CodeDeploy + AutoScaling 持续集成实战指南

Tue, 20 Nov 2018 11:05:40 +0800

本文主要记录如何结合jenkins,codedeploy,s3, autoscaling等相关服务搭建一套可持续交付和应用部署的服务。

Aws AutoScaling部分

1、使用Auto Scaling的优点

1)、保持基础设置堆栈配置一致(例如软件nginx、php等安装配置一致)

2)、快速设置扩展(只需要设定Auto Scaling组内的所需实例数量即可完成实例的扩展)

3)、制定明确的扩展策略(比如根据CPU的利用率时增加或是缩减实例数量)

4)、控制实例资源成本(在Auto Scaling组内的实例通常都比较小，不然就失去了AutoScaling自动扩展的意义)

2、Auto Scaling组件说明

Auto Scaling组：EC2实例放在组中，用于扩展和管理的逻辑单元，在创建组时，可以指定其最小，最大和所需EC2的实例数量

(备注：auto Scaling 组是与启动配置相关联的)

Auto Scaling启动配置：EC2实例启动时的模板(指定实例类型，密钥对，安全组和磁盘空间大小)

3、创建启动配置步骤

1)、为EC2实例创建IAM角色

Supervisor 教程（2026）：安装配置、常见问题与 Supervisor vs systemd 选型

Sun, 07 Oct 2018 00:35:04 +0800

Supervisor (http://supervisord.org) 是一个用 Python 写的进程管理工具，可以很方便地启动、重启、关闭进程（不仅仅是 Python 进程）。除了对单个进程的控制，还可以同时启动、关闭多个进程，比如服务器异常后快速拉起整组服务。

先说结论（给赶时间的你）：

你在维护多个业务进程（队列 worker、定时任务、爬虫、脚本服务）时，Supervisor 依然非常好用。
如果你追求系统原生管理、与 Linux 服务深度集成，优先考虑 systemd。
Node.js 生态下，如果只托管单个应用，PM2 也可选，但跨语言统一托管时 Supervisor 更顺手。

Supervisor vs systemd vs PM2（先选型）

维度	Supervisor	systemd	PM2
适用场景	多进程统一托管（跨语言）	Linux 系统级服务管理	Node.js 应用管理
学习成本	中等	偏高	低
开机自启	支持	强（原生）	支持
日志管理	基础可用	强	友好
推荐人群	运维/后端/多脚本场景	强 Linux 运维团队	Node 开发者

实战建议：已有 systemd 体系的生产环境，优先 systemd；需要快速统一托管多类进程时，Supervisor 依然是高性价比方案。

安装

服务器上所有应用统一安装到目录/usr/local/programs/，所以采用源码安装

提前配置好python(2.7)环境，下载相关文件：

wget wget https://pypi.python.org/packages/2.7/s/setuptools/setuptools-0.6c11-py2.7.egg –no-check-certificate
wget https://pypi.python.org/packages/80/37/964c0d53cbd328796b1aeb7abea4c0f7b0e8c7197ea9b0b9967b7d004def/supervisor-3.3.1.tar.gz

按下面步骤执行:

 1. sh setuptools-0.6c11-py2.7.egg
 2. tar -axvf supervisor-3.3.1.tar.gz
 3. cd supervisor-3.3.1
 4. python setup.py install
 5. echo_supervisord_conf > /usr/local/programs/supervisoretc/supervisord.conf
 6. supervisord -c /usr/local/programs/supervisoretc/supervisord.conf
 7. supervisorctl
 8. done

配置文件supervisord.conf：

 ; Sample supervisor config file.
;
; For more information on the config file, please see:
; http://supervisord.org/configuration.html
;
; Notes:
; - Shell expansion ("~" or "$HOME") is not supported. Environment
; variables can be expanded using this syntax: "%(ENV_HOME)s".
; - Comments must have a leading space: "a=b ;comment" not "a=b;comment".

[unix_http_server]
file=/tmp/supervisor.sock ; (the path to the socket file)
;chmod=0700 ; socket file mode (default 0700)
;chown=nobody:nogroup ; socket file uid:gid owner
;username=user ; (default is no username (open server))
;password=123 ; (default is no password (open server))

[inet_http_server] ; inet (TCP) server disabled by default
port=0.0.0.0:9001 ; (ip_address:port specifier, *:port for all iface)
;username=user ; (default is no username (open server))
;password=123 ; (default is no password (open server))

[supervisord]
logfile=/tmp/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10 ; (num of main logfile rotation backups;default 10)
loglevel=info ; (log level;default info; others: debug,warn,trace)
pidfile=/tmp/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=false ; (start in foreground if true;default false)
minfds=1024 ; (min. avail startup file descriptors;default 1024)
minprocs=200 ; (min. avail process descriptors;default 200)
;umask=022 ; (process file creation umask;default 022)
;user=chrism ; (default is current user, required if root)
;identifier=supervisor ; (supervisord identifier, default is 'supervisor')
;directory=/tmp ; (default is not to cd during start)
;nocleanup=true ; (don't clean up tempfiles at start;default false)
;childlogdir=/tmp ; ('AUTO' child log dir, default $TEMP)
;environment=KEY="value" ; (key value pairs to add to environment)
;strip_ansi=false ; (strip ansi escape codes in logs; def. false)

; the below section must remain in the config file for RPC
; (supervisorctl/web interface) to work, additional interfaces may be
; added by defining them in separate rpcinterface: sections
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock ; use a unix:// URL for a unix socket
;serverurl=http://127.0.0.1:9001 ; use an http:// url to specify an inet socket
;username=chris ; should be same as http_username if set
;password=123 ; should be same as http_password if set
;prompt=mysupervisor ; cmd line prompt (default "supervisor")
;history_file=~/.sc_history ; use readline history if available

; The below sample program section shows all possible program subsection values,
; create one or more 'real' program: sections to be able to control them under
; supervisor.

;[program:theprogramname]
;command=/bin/cat ; the program (relative uses PATH, can take args)
;process_name=%(program_name)s ; process_name expr (default %(program_name)s)
;numprocs=1 ; number of processes copies to start (def 1)
;directory=/tmp ; directory to cwd to before exec (def no cwd)
;umask=022 ; umask for process (default None)
;priority=999 ; the relative start priority (default 999)
;autostart=true ; start at supervisord start (default: true)
;startsecs=1 ; # of secs prog must stay up to be running (def. 1)
;startretries=3 ; max # of serial start failures when starting (default 3)
;autorestart=unexpected ; when to restart if exited after running (def: unexpected)
;exitcodes=0,2 ; 'expected' exit codes used with autorestart (default 0,2)
;stopsignal=QUIT ; signal used to kill process (default TERM)
;stopwaitsecs=10 ; max num secs to wait b4 SIGKILL (default 10)
;stopasgroup=false ; send stop signal to the UNIX process group (default false)
;killasgroup=false ; SIGKILL the UNIX process group (def false)
;user=chrism ; setuid to this UNIX account to run the program
;redirect_stderr=true ; redirect proc stderr to stdout (default false)
;stdout_logfile=/a/path ; stdout log path, NONE for none; default AUTO
;stdout_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB)
;stdout_logfile_backups=10 ; # of stdout logfile backups (default 10)
;stdout_capture_maxbytes=1MB ; number of bytes in 'capturemode' (default 0)
;stdout_events_enabled=false ; emit events on stdout writes (default false)
;stderr_logfile=/a/path ; stderr log path, NONE for none; default AUTO
;stderr_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB)
;stderr_logfile_backups=10 ; # of stderr logfile backups (default 10)
;stderr_capture_maxbytes=1MB ; number of bytes in 'capturemode' (default 0)
;stderr_events_enabled=false ; emit events on stderr writes (default false)
;environment=A="1",B="2" ; process environment additions (def no adds)
;serverurl=AUTO ; override serverurl computation (childutils)

; The below sample eventlistener section shows all possible
; eventlistener subsection values, create one or more 'real'
; eventlistener: sections to be able to handle event notifications
; sent by supervisor.

;[eventlistener:theeventlistenername]
;command=/bin/eventlistener ; the program (relative uses PATH, can take args)
;process_name=%(program_name)s ; process_name expr (default %(program_name)s)
;numprocs=1 ; number of processes copies to start (def 1)
;events=EVENT ; event notif. types to subscribe to (req'd)
;buffer_size=10 ; event buffer queue size (default 10)
;directory=/tmp ; directory to cwd to before exec (def no cwd)
;umask=022 ; umask for process (default None)
;priority=-1 ; the relative start priority (default -1)
;autostart=true ; start at supervisord start (default: true)
;startsecs=1 ; # of secs prog must stay up to be running (def. 1)
;startretries=3 ; max # of serial start failures when starting (default 3)
;autorestart=unexpected ; autorestart if exited after running (def: unexpected)
;exitcodes=0,2 ; 'expected' exit codes used with autorestart (default 0,2)
;stopsignal=QUIT ; signal used to kill process (default TERM)
;stopwaitsecs=10 ; max num secs to wait b4 SIGKILL (default 10)
;stopasgroup=false ; send stop signal to the UNIX process group (default false)
;killasgroup=false ; SIGKILL the UNIX process group (def false)
;user=chrism ; setuid to this UNIX account to run the program
;redirect_stderr=false ; redirect_stderr=true is not allowed for eventlisteners
;stdout_logfile=/a/path ; stdout log path, NONE for none; default AUTO
;stdout_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB)
;stdout_logfile_backups=10 ; # of stdout logfile backups (default 10)
;stdout_events_enabled=false ; emit events on stdout writes (default false)
;stderr_logfile=/a/path ; stderr log path, NONE for none; default AUTO
;stderr_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB)
;stderr_logfile_backups=10 ; # of stderr logfile backups (default 10)
;stderr_events_enabled=false ; emit events on stderr writes (default false)
;environment=A="1",B="2" ; process environment additions
;serverurl=AUTO ; override serverurl computation (childutils)

; The below sample group section shows all possible group values,
; create one or more 'real' group: sections to create "heterogeneous"
; process groups.

;[group:thegroupname]
;programs=progname1,progname2 ; each refers to 'x' in [program:x] definitions
;priority=999 ; the relative start priority (default 999)

; The [include] section can just contain the "files" setting. This
; setting can list multiple files (separated by whitespace or
; newlines). It can also contain wildcards. The filenames are
; interpreted as relative to this file. Included files *cannot*
; include files themselves.

[include]
files = conf.d/*.conf

注意最下面一行，重点，要考！

IP 地址与 CIDR 详解：网络基础知识必备指南

Sat, 06 Oct 2018 00:00:00 +0000

IP 地址是互联网通信的基础，每一台联网设备都需要一个唯一的 IP 地址来标识自己。无论你是网络工程师、运维人员还是开发者，理解 IP 地址和 CIDR 都是必备的基础知识。本文将系统介绍 IPv4 地址的结构、分类以及 CIDR 表示法，帮你彻底搞懂网络寻址的核心概念。

AWS EKK 日志系统搭建：Elasticsearch + Kinesis + Kibana 实战教程

Wed, 12 Sep 2018 18:52:59 +0800

EKK是一套基于AWS相关服务搭建的日志收集系统，包含Amazon Elasticsearch Service, Amazon Kinesis, and Kibana，简称EKK.相比ELK搭建维护运维复杂，EKK更加简便。下图是EKK基本架构：

本文重点记录nginx日志怎样收集和以正确格式存到es，不会就每一步详细讲解。

一、准备工作：

开一台ec2，选择ubuntu16.04，搭建nginx一个nginx服务，设置nginx日志格式:

log_format main '$remote_addr - $remote_user [$time_local] "$request" '
 '$status $body_bytes_sent "$http_referer" '
 '"$http_user_agent" "$http_x_forwarded_for" '
 '$connection "$upstream_addr" '
 'upstream_response_time $upstream_response_time request_time $request_time';

最终access.log里的日志格式如下：

192.168.13.1 - - [12/Sep/2018:03:59:12 +0000] 
"GET /v1/home HTTP/1.1" 2002787 "https://test.com/product/Sweet-Ice-Cream-Short-sleeve-Top-and-Pink-Shorts-for-Toddler-Baby.html" "Mozilla/5.0 (iPhone; CPU iPhone OS 11_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15G77 [FBAN/FBIOS;FBDV/iPhone7,2;FBMD/iPhone;FBSN/iOS;FBSV/11.4.1;FBSS/2;FBCR/Telekom.de;FBID/phone;FBLC/de_DE;FBOP/5;FBRV/123725744]" "2002:c7:6f02:9801:d506:6bda:e6ca:b6f9, 112.118.106.116" 12340 "127.0.0.1:9000" upstream_response_time 0.11 request_time 0.11

创建可访问Kinesis stream或Kinesis firehose, AWS ES服务的IAM账号，保存awsAccessKeyId和awsSecretAccessKey。
AWS上启动ES服务TestES，创建时类型务必选择public，后面再做安全策略。
创建Kinesis firehose(如果有一个源对多个标的的需求可以使用Kinesis stream)，数据流向选择上面创建的TestES。

准备工作大概完成。

二、收集日志

在ec2上安装Amazon Kinesis Agent:

1. 下载源码
git clone https://github.com/awslabs/amazon-kinesis-agent.git

2. 在aws的ubuntu16.04上需再安装java jdk
sudo apt-get install openjdk-8-jdk

3. 开始安装
sudo ./setup --install

完成没报错会有安装成功提示，并提示怎么配置和启动服务

编辑agent配置文件/etc/aws-kinesis/agent.json，默认如下：

{
 "cloudwatch.emitMetrics": true,
 "kinesis.endpoint": "https://your/kinesis/endpoint", 
 "firehose.endpoint": "https://your/firehose/endpoint", 
 "flows": [
 {
 "filePattern": "/tmp/app1.log*", 
 "kinesisStream": "yourkinesisstream"
 }, 
 {
 "filePattern": "/tmp/app2.log*",
 "deliveryStream": "yourfirehosedeliverystream" 
 }
 ] 
}

cloudwatch.emitMetrics：是否开启cloudwatch监控 kinesis.endpoint： Kinesis stream的endpoint设置 firehose.endpoint：firehose的endpoint 各end point地址: https://docs.aws.amazon.com/general/latest/gr/rande.html

Elasticsearch 入门教程：索引、文档、查询 API 核心概念详解

Wed, 12 Sep 2018 18:52:59 +0800

Elasticsearch是一个基于Apache Lucene(TM)的开源搜索引擎(以下简称ES),是目前全文搜索引擎的首选。它可以快速存储、搜索和分析海量数据，Github，StackOverflow都在采用它。

一、ES组成

ES对照RMDB快速了解ES基本组成，它可以包含多个索引(indices)（数据库），每一个索引可以包含多个类型(types)（表），每一个类型包含多个文档(documents)（行），然后每个文档包含多个字段(Fields)（列）,简化如下:

索引 -> 数据库类型 -> 表文档 -> 行字段 -> 列

二、常用查询命令

1. 查看_cat相关命令

GET /_cat/

结果:

>
➜ ~ curl -i -XGET http://192.168.11.119:9200/_cat/
HTTP/1.1 200 OK
content-type: text/plain; charset=UTF-8
content-length: 493

>=^.^=
/_cat/allocation
/_cat/shards
/_cat/shards/{index}
/_cat/master
/_cat/nodes
/_cat/tasks
/_cat/indices
/_cat/indices/{index}
/_cat/segments
/_cat/segments/{index}
/_cat/count
/_cat/count/{index}
/_cat/recovery
/_cat/recovery/{index}
/_cat/health
/_cat/pending_tasks
/_cat/aliases
/_cat/aliases/{alias}
/_cat/thread_pool
/_cat/thread_pool/{thread_pools}
/_cat/plugins
/_cat/fielddata
/_cat/fielddata/{fields}
/_cat/nodeattrs
/_cat/repositories
/_cat/snapshots/{repository}
/_cat/templates

2.查看集群健康

GET /_cat/health?v

ELK 日志系统搭建指南：Elasticsearch + Logstash + Kibana + Kafka 完整架构

Tue, 11 Sep 2018 20:02:19 +0800

日志主要包含系统日志、应用日志和安全日志。运维和开发人员通过日志可以了解服务器、程序运行情况，发现错误及检查错误发生原因。一个可靠、安全、可扩展的日志收集分析解决方案在程序或系统异常时能够让一切都变得轻松起来。

对比了ELK几种搭建模式：

filebeat->elasticsearch->kibana
filebeat->logstash->kafaka&zookeeper->logstash->elasticsearch->kibana
filebeat->kafaka&zookeeper->logstash->elasticsearch->kibana

架构

从左到右分别为：

1)、数据采集层，将采集到的日志分别发送到kafka broker的集群队列上去

2)、数据缓存层，将采集到的日志临时转存到本地的kafka broker集群中(相当于队列的生产者)

3)、数据处理转发层，logstash实时去kafka broker集群拉去日志，在经过本地logstash后进行日志分析处理，然后转发到后端elasticsearch(相当于队列的消费者)

4)、数据存储展示层，elasticsearch将收集到的日志进行本地存储，然后通过kibana展示出来；由于elasticsearch采用集群的方式，前端通过nginx在反向代理kibana的访问地址，使用户访问入口只有一个

资源列表

服务器名称	IP地址	角色	功能
kz1	172.31.2.2	kafka+zookeeper	kafka broker节点1
kz2	172.31.2.3	kafka+zookeeper	kafka broker节点2
logstash-web	172.31.2.4	logstash	处理转发web相关日志
logstash-app	172.31.2.5	logstash	处理转发app相关日志
es-node1	172.31.2.6	elasticsearch+kibana	数据存储展示
es-node2	172.31.2.7	elasticsearch+kibana	数据存储展示

硬件配置

服务器类型	实例类型	CPU	内存	Disk
Kafka broker集群	r5.xlarge	4	32	1T
Logstash	c5.2xlarge	8	16	100G
Elasticsearch+kibana	r5.xlarge	4	32	2T

部署前的准备工作

分别在这6台服务器上进行设置

Amazon Redshift 性能优化指南：VACUUM、ANALYZE 与运维最佳实践

Thu, 09 Aug 2018 16:03:05 +0800

Amazon Redshift 是 AWS 推出的云端数据仓库服务，采用列式存储和大规模并行处理（MPP）架构，能够在 PB 级数据上实现亚秒级查询响应。但随着数据不断写入和删除，表的性能会逐渐下降——这时就需要 VACUUM 和 ANALYZE 来维护。

本文将系统讲解 Redshift 的性能优化策略，包括 VACUUM 的六种类型、ANALYZE 统计更新，以及日常运维中的实用命令。

Charles 抓包教程（2026）：HTTP/HTTPS 拦截、Mock 调试与证书配置

Sat, 15 Aug 2015 11:33:11 +0800

Charles是Mac下常用的网络抓包工具，常用来模拟数据和网络辅助接口调试，作为代理抓取网络请求数据，这篇文章记录了几个实用场景，希望对你有帮助。

Charles下载传送门。经常会有这样的场景:

场景一: 想看看其他的App是怎样设计请求，怎样设计返回数据格式，某一个功能点请求分几个实现的。最近我在用某听书软件听鬼故事（^0^）,它们限制非VIP每天只能下100篇离线，我试着用charles拦截修改返回数据，把我自己变成超级VIP了，然后, 没然后了….

场景二: 一个请求发起直接返回各种看起来奇葩的错误，检查半天代码好像也没问题，直接就大嘴巴叫后台的兄弟服务挂了，后台一看，好好的啊…

场景三: 开发新的功能，接口也先大概定义好了，可后台兄弟忙着和妹子聊天（^），接口还没写好啊…,虽然可以在代码里写死demo数据，但后台接口写好了，难道又去改一遍?有木有更好的方式呢？先把请求都写好，能正常返回数据，解析好结果绑定到界面，最后接口写好了直接就对接，charles可以帮助我们这么干。

场景四: 除了WIFI我们还要测试2G,3G,4G等各种复杂网络条件下的情况，可手机上网资费不便宜啊，可以让charles限制网速模拟网络环境。

就列举这么几个场景吧，下面进入本文的正题

Oh My Zsh 安装配置指南：打造高效终端环境

Wed, 17 Jun 2015 00:00:00 +0000

如果你使用 Linux 或 macOS，终端是每天都要打交道的工具。默认的 Bash 虽然够用，但 Zsh 配合 Oh My Zsh 能带来更强大的功能和更愉悦的使用体验。本文将手把手教你打造一个高效、美观的终端环境，让你的命令行操作效率翻倍。

About

Mon, 15 Mar 2010 00:00:00 +0000

Hi, I’m Bruce — an engineer with 10+ years in backend systems, now fully focused on AI engineering.

I’ve built and scaled backend infrastructure at multiple tech companies, working across Java, Go, and cloud-native stacks. Since 2024, I’ve gone all-in on AI — from LLM application development to AI Agent architecture, accumulating hands-on production experience.

What This Site Covers

This site publishes practical, in-depth guides on AI engineering topics:

AI Coding Tools — Claude Code, Cursor, Codex CLI: setup guides, best practices, and real-world workflows
AI Agent Engineering — Agent architecture, multi-agent orchestration, automation workflows
LLM Application Development — RAG systems, vector databases, prompt optimization
Tool Comparisons — Head-to-head evaluations to help you pick the right tool

The site also retains earlier technical notes on Java, Go, Docker, and Linux (written in Chinese) as archived content.