打通任督二脉:让你的 GitHub Copilot 瞬间学会 Claude Code 的所有绝招

Claude Code、Cursor、GitHub Copilot、Codex 怎么选?别再按“哪个最强”来判断了 摘要:文章建议在AI编程中优先从单元测试入手,而非直接修改业务代码。通过测试矩阵明确边界条件和业务规则,再让AI生成符合框架的测试代码,并反向审查测试质量。关键是将AI测试流程固化到团队开发中,通过试点验证效果。AI的真正价值在于降低测试覆盖成本,但开发者仍需保持对业务风险和技术细节的判断力。建议从低风险模块开始实践AI辅助测试,逐步推广。 阅读详情

打通任督二脉:让你的 GitHub Copilot 瞬间学会 Claude Code 的所有绝招

目标读者:希望在 VSCode/Zed 编辑器中直接复用 Claude Code 强大本地能力的开发者、DevOps 工程师、AI 工具流搭建者。
核心价值:通过自动化映射机制,打破 Claude Code CLI 与编辑器 Copilot 之间的"生殖隔离",实现一套 Skills/Agents 双端复用。
阅读时间:8 分钟

在这里插入图片描述

引言

你是否遇到过这种割裂的体验:在终端里,Claude Code 配置了强大的 tech-blog 技能,能一键生成高质量博客;配置了 code-review Agent,能深度审查代码。但在 VSCode 编辑器里,面对 GitHub Copilot,你却只能用最基础的自然语言对话,Copilot 对你精心调教的那些本地技能一无所知。

这就像是你拥有一本绝世武功秘籍(Claude Code Skills),但你的随身保镖(Copilot)却是个只会打直拳的门外汉。

如果我们能建立一种机制,自动将 Claude Code 的所有能力"注册"给 Copilot,会发生什么?

本文将深度解析如何通过一个 Node.js 扫描脚本,自动生成"能力映射表",让 Copilot 瞬间"读取"并掌握你所有的本地 Skills、Agents 和 Commands。

为什么需要"能力映射"?

Claude Code 的核心优势在于其高度可定制的 Local Skills(本地技能)和 Agents(智能体)。这些定义通常以 Markdown 文件的形式存储在 ~/.claude/skills 或 ~/.claude/agents 目录中。

然而,GitHub Copilot 运行在编辑器的上下文中,它无法直接通过系统路径去"扫描"和"理解"这些散落在文件系统中的技能定义。

我们需要一个"中间层"——Mapping Files(映射文件)。

这就像是给 Copilot 准备的一份"技能菜单"。菜单上不仅列出了有什么菜(Skill Name),还写明了这道菜是什么味道(Description),以及大厨在哪里(File Path)。Copilot 拿到这份菜单,就能根据你的需求点菜了。

在这里插入图片描述

核心实现:自动化扫描脚本

为了实现这一目标,我 Vibe 了一个名为 scan-and-generate.mjs 的自动化脚本。它的核心职责是:遍历目录 -> 提取元数据 -> 生成 Markdown。

1. 灵活的配置策略

脚本的设计必须足够通用,以支持 Skills、Agents、Commands 以及插件(Plugins)中的各种资源。我们在代码中定义了一个强大的 CONFIG 对象:

const CONFIG = {
  mappings: [
    {
      id: "skills",
      name: "Local Skills",
      outputFile: "skills-mapping.md",
      sourceDir: ROOT_DIR + "/skills/",
      sourcePattern: "*/SKILL.md", // 锁定 SKILL.md 文件
      frontmatterFields: ["description", "name"], // 提取关键元数据
      groupBy: (file) => {
        // 智能分组逻辑,按功能类别归档
        const relative = file.replace(ROOT_DIR + "/skills/", "");
        const skillName = relative.split("/")[0];
        return getSkillCategory(skillName);
      },
    },
    // ... 其他映射配置(Agents, Commands等)
  ],
};

这段配置定义了"去哪找"(sourceDir)、“找什么”(sourcePattern)以及"怎么展示"(groupBy)。特别是 frontmatterFields,它直接从 Markdown 的头部元数据(Frontmatter)中提取技能描述,这是 Copilot 理解技能用途的关键。

2. 智能提取与分组

脚本不仅是简单的列表生成,还包含了智能的分类逻辑。例如,getSkillCategory 函数维护了一个映射表,将杂乱的技能归类为 “Content & Writing”、“Development”、“Project Management” 等类别。

// 示例:将技能映射到类别
const categories = {
  "tech-blog": "Content & Writing",
  "code-review": "Code Analysis",
  zustand: "Development",
  // ...
};

这种结构化的输出对于 LLM(大语言模型)非常友好。当 Copilot 阅读这份文档时,它能建立起结构化的认知:“哦,如果用户要写文章,我应该去 Content & Writing 分类下找找。”

3. 生成 Copilot 可读的指令

仅仅列出文件是不够的,我们还需要告诉 Copilot 如何使用 这些技能。脚本会读取 templates 目录下的指令模版,并将其嵌入到生成的 Markdown 头部。

以 skills-mapping.md 为例,生成的头部包含这样的指令:

“当用户激活本地技能时… 1. 识别技能引用… 3. 使用 Read 工具读取 SKILL.md 文件… 4. 将技能规则应用到当前会话…”

这相当于给 Copilot 植入了一段"元指令"(Meta-Prompt),教它如何加载和执行外部技能。

在这里插入图片描述

4. 完整实现

1. scan-and-generate.mjs
#!/usr/bin/env node
/**
 * Scan and Generate Mapping Documents
 * 扫描 ~/.claude/ 目录并生成映射文档
 */

import {
  readFileSync,
  writeFileSync,
  mkdirSync,
  existsSync,
  lstatSync,
  readdirSync,
} from "fs";
import { globSync } from "glob";
import { dirname, basename, join } from "path";
import { fileURLToPath } from "url";

const __dirname = dirname(fileURLToPath(import.meta.url));
const ROOT_DIR = process.env.HOME + "/.claude";
const OUTPUT_DIR = join(__dirname, "output");
const TEMPLATES_DIR = join(__dirname, "templates");

// 确保输出目录存在
if (!existsSync(OUTPUT_DIR)) {
  mkdirSync(OUTPUT_DIR, { recursive: true });
}

// 扫描配置
const CONFIG = {
  mappings: [
    {
      id: "commands",
      name: "Local Commands",
      outputFile: "commands-mapping.md",
      sourceDir: ROOT_DIR + "/commands/",
      sourcePattern: "**/*.md",
      exclude: ["CLAUDE.md"],
      frontmatterFields: ["description", "argument-hint", "allowed-tools"],
      groupBy: (file) => {
        const relative = file.replace(ROOT_DIR + "/commands/", "");
        const parts = relative.split("/");
        return parts.length > 1 ? capitalize(parts[0]) : "General";
      },
      getShortcut: (file, frontmatter) => {
        const relative = file
          .replace(ROOT_DIR + "/commands/", "")
          .replace(".md", "")
          .replace(/\//g, ":");
        return relative ? "/" + relative : "/";
      },
      getName: (frontmatter, title, file) => {
        return frontmatter.name || title || basename(file, ".md");
      },
    },
    {
      id: "plugins-commands",
      name: "Plugin Commands",
      outputFile: "plugins-commands-mapping.md",
      sourceDir: ROOT_DIR + "/plugins/cache/",
      sourcePattern: ["**/commands/*.md", "**/.claude/commands/*.md"],
      exclude: ["CLAUDE.md"],
      frontmatterFields: ["description", "name"],
      groupBy: (file) => {
        const match = file.match(/plugins\/cache\/([^\/]+)\/([^\/]+)/);
        if (match) {
          return formatPluginName(match[1], match[2]);
        }
        return "Unknown";
      },
      getShortcut: (file, frontmatter) => {
        const cmdMatch = file.match(/[\/\.](claude\/)commands\/([^\/]+)\.md$/);
        const cmdName = cmdMatch ? cmdMatch[2] : basename(file, ".md");
        const orgMatch = file.match(/plugins\/cache\/([^\/]+)\//);
        const org = orgMatch ? orgMatch[1] : "";
        return "/" + (org ? org.replace("-plugins", "") + ":" : "") + cmdName;
      },
      getName: (frontmatter, title, file) => {
        const match = file.match(/[\/\.](claude\/)commands\/([^\/]+)\.md$/);
        return frontmatter.name || match?.[2] || basename(file, ".md");
      },
    },
    {
      id: "plugins-agents",
      name: "Plugin Agents",
      outputFile: "plugins-agents-mapping.md",
      sourceDir: ROOT_DIR + "/plugins/cache/",
      sourcePattern: ["**/agents/**/*.md", "**/.claude/agents/**/*.md"],
      exclude: ["CLAUDE.md"],
      frontmatterFields: ["description", "name"],
      groupBy: (file) => {
        const match = file.match(/plugins\/cache\/([^\/]+)\/([^\/]+)/);
        if (match) {
          return formatPluginName(match[1], match[2]);
        }
        return "Unknown";
      },
      subgroupBy: (file) => {
        const relative = file.split(/agents\//)[1];
        if (!relative) return "Agents";
        const parts = relative.split("/");
        return parts.length > 1 ? capitalize(parts[0]) : "Agents";
      },
      getShortcut: null,
      getName: (frontmatter, title, file) => {
        return frontmatter.name || title || basename(file, ".md");
      },
    },
    {
      id: "plugins-skills",
      name: "Plugin Skills",
      outputFile: "plugins-skills-mapping.md",
      sourceDir: ROOT_DIR + "/plugins/cache/",
      sourcePattern: "**/.claude/skills/*.md",
      exclude: ["CLAUDE.md", "SKILL.md"],
      frontmatterFields: ["description", "name"],
      groupBy: (file) => {
        const match = file.match(/plugins\/cache\/([^\/]+)\/([^\/]+)/);
        if (match) {
          return formatPluginName(match[1], match[2]);
        }
        return "Unknown";
      },
      getShortcut: null,
      getName: (frontmatter, title, file) => {
        return frontmatter.name || title || basename(file, ".md");
      },
    },
    {
      id: "skills",
      name: "Local Skills",
      outputFile: "skills-mapping.md",
      sourceDir: ROOT_DIR + "/skills/",
      sourcePattern: "*/SKILL.md",
      exclude: [],
      frontmatterFields: ["description", "name"],
      groupBy: (file) => {
        const relative = file.replace(ROOT_DIR + "/skills/", "");
        const skillName = relative.split("/")[0];
        return getSkillCategory(skillName);
      },
      getShortcut: null,
      getName: (frontmatter, title, file) => {
        return frontmatter.name || title || basename(file, ".md");
      },
    },
    {
      id: "agents",
      name: "Local Agents",
      outputFile: "agents-mapping.md",
      sourceDir: ROOT_DIR + "/agents/",
      sourcePattern: "**/*.md",
      exclude: ["CLAUDE.md"],
      frontmatterFields: ["description", "name"],
      groupBy: (file) => {
        const relative = file.replace(ROOT_DIR + "/agents/", "");
        const parts = relative.split("/");
        return parts.length > 1 ? capitalize(parts[0]) : "General";
      },
      getShortcut: null,
      getName: (frontmatter, title, file) => {
        return frontmatter.name || title || basename(file, ".md");
      },
    },
  ],
};

// 工具函数
function formatPluginName(org, plugin) {
  const displayNames = {
    thedotmack: "Claude Mem",
    "nyldn-plugins": "Claude Octopus",
    "claude-plugins-official": "Official Plugins",
    "planning-with-files": "Planning With Files",
  };
  const orgDisplay = displayNames[org] || org;
  const pluginDisplay = plugin === org ? "" : ` (${org})`;
  return orgDisplay + pluginDisplay;
}

function capitalize(str) {
  if (!str) return "";
  return str.charAt(0).toUpperCase() + str.slice(1);
}

function getSkillCategory(skillName) {
  const categories = {
    "eslint-auto-fix": "Development",
    "ast-grep": "Development",
    "frontend-design": "Development",
    "code-refactor-flow": "Development",
    zustand: "Development",
    "migrating-js-to-ts": "Development",
    "logging-best-practices": "Development",
    "code-analyze": "Code Analysis",
    "code-review": "Code Analysis",
    "git-diff-report": "Code Analysis",
    "prompt-optimizer": "AI & Prompt",
    codeagent: "AI & Prompt",
    "codex-subagent": "AI & Prompt",
    claudeception: "Skill Management",
    "skill-creator": "Skill Management",
    "skill-validator": "Skill Management",
    "skill-review": "Skill Management",
    "tech-blog": "Content & Writing",
    "stop-slop": "Content & Writing",
    "task-manager": "Project Management",
    figma2code: "Project Management",
  };
  return categories[skillName] || "Other";
}

function parseFrontmatter(content) {
  const result = {};
  const match = content.match(/^---\n([\s\S]*?)\n---/);
  if (!match) return result;

  const yamlContent = match[1];
  const lines = yamlContent.split("\n");
  let currentKey = null;
  let multilineValue = [];
  let isMultiline = false;

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    const colonIndex = line.indexOf(":");

    // 检查是否是新的键值对
    if (colonIndex > 0 && !line.startsWith(" ") && !line.startsWith("\t")) {
      // 保存之前的多行值
      if (isMultiline && currentKey) {
        result[currentKey] = multilineValue.join(" ").trim();
        multilineValue = [];
        isMultiline = false;
      }

      const key = line.slice(0, colonIndex).trim();
      const value = line.slice(colonIndex + 1).trim();

      // 检查是否是多行格式 (> 或 |)
      if (value === ">" || value === "|") {
        currentKey = key;
        isMultiline = true;
        multilineValue = [];
      } else {
        // 单行值
        currentKey = key;
        result[key] = value.replace(/^\[|\]$/g, "").replace(/,\s*/g, ", ");
      }
    } else if (isMultiline && line.trim()) {
      // 多行值的内容行(忽略空行)
      multilineValue.push(line.trim());
    }
  }

  // 保存最后一个多行值
  if (isMultiline && currentKey) {
    result[currentKey] = multilineValue.join(" ").trim();
  }

  return result;
}

function getTitle(content) {
  const lines = content.split("\n");
  for (const line of lines) {
    if (line.startsWith("# ")) {
      return line.replace("# ", "").trim();
    }
  }
  return null;
}

function scanFiles(pattern, exclude = []) {
  const patterns = Array.isArray(pattern) ? pattern : [pattern];
  let files = [];
  for (const p of patterns) {
    files = files.concat(globSync(p, { ignore: exclude }));
  }
  return [...new Set(files.filter((f) => !lstatSync(f).isDirectory()))];
}

// 获取插件目录下的最新版本号
function getLatestVersion(versions) {
  if (versions.length === 0) return null;

  // 分离语义版本和非语义版本
  const semverVersions = [];
  const nonSemverVersions = [];

  for (const v of versions) {
    // 语义版本格式: x.y.z (可能带有 pre-release 标签)
    if (/^\d+\.\d+(\.\d+)?(-[a-zA-Z0-9.-]+)?$/.test(v)) {
      semverVersions.push(v);
    } else {
      nonSemverVersions.push(v);
    }
  }

  // 如果有语义版本,使用 semver 比较
  if (semverVersions.length > 0) {
    // 简单的 semver 比较函数
    const compareSemver = (a, b) => {
      const parse = (v) => {
        const parts = v.split("-")[0].split(".").map(Number);
        const preRelease = v.split("-")[1] || "";
        return {
          major: parts[0] || 0,
          minor: parts[1] || 0,
          patch: parts[2] || 0,
          preRelease,
        };
      };
      const pa = parse(a);
      const pb = parse(b);

      if (pa.major !== pb.major) return pb.major - pa.major;
      if (pa.minor !== pb.minor) return pb.minor - pa.minor;
      if (pa.patch !== pb.patch) return pb.patch - pa.patch;

      // 处理 pre-release: 正式版 > pre-release
      if (!pa.preRelease && pb.preRelease) return -1;
      if (pa.preRelease && !pb.preRelease) return 1;
      return 0;
    };

    return semverVersions.sort(compareSemver)[0];
  }

  // 否则使用字母序最后一个
  return nonSemverVersions.sort().pop();
}

// 获取插件目录下所有版本目录
function getPluginVersions(pluginPath) {
  if (!existsSync(pluginPath)) return [];

  const entries = readdirSync(pluginPath, { withFileTypes: true });
  return entries
    .filter((entry) => entry.isDirectory())
    .map((entry) => entry.name);
}

// 过滤文件,只保留每个插件最新版本的内容
function filterLatestVersionFiles(files, patterns, exclude = []) {
  if (files.length === 0) return files;

  // 解析文件路径,提取插件标识和版本
  // 格式: plugins/cache/{org}/{plugin}/{version}/...
  const pluginVersions = new Map(); // key: "org/plugin", value: version

  for (const file of files) {
    const match = file.match(/plugins\/cache\/([^\/]+)\/([^\/]+)\/([^\/]+)/);
    if (match) {
      const org = match[1];
      const plugin = match[2];
      const version = match[3];
      const key = `${org}/${plugin}`;

      if (!pluginVersions.has(key)) {
        pluginVersions.set(key, version);
      } else {
        const currentLatest = pluginVersions.get(key);
        const candidateVersions = [currentLatest, version];
        const latest = getLatestVersion(candidateVersions);
        pluginVersions.set(key, latest);
      }
    }
  }

  // 重新扫描获取最新版本的实际文件
  const latestFiles = new Set();
  const sourceDir = ROOT_DIR + "/plugins/cache/";

  for (const [key, version] of pluginVersions) {
    const [org, plugin] = key.split("/");
    const versionPath = join(sourceDir, org, plugin, version);

    if (existsSync(versionPath)) {
      for (const pattern of patterns) {
        const fullPattern = join(versionPath, pattern);
        const matched = globSync(fullPattern, {
          ignore: exclude,
        });
        matched.forEach((f) => latestFiles.add(f));
      }
    }
  }

  return [...latestFiles];
}

function groupFiles(files, groupBy, subgroupBy = null) {
  const groups = {};
  for (const file of files) {
    const category = groupBy(file);
    if (!groups[category]) {
      groups[category] = subgroupBy ? {} : [];
    }

    if (subgroupBy) {
      const subcategory = subgroupBy(file);
      if (!groups[category][subcategory]) {
        groups[category][subcategory] = [];
      }
      groups[category][subcategory].push(file);
    } else {
      groups[category].push(file);
    }
  }
  return groups;
}

function getAgentUsageInstructions(mappingId) {
  // 模板文件映射
  const templateFiles = {
    commands: "commands-usage.md",
    "plugins-commands": "plugins-commands-usage.md",
    "plugins-agents": "plugins-agents-usage.md",
    "plugins-skills": "plugins-skills-usage.md",
    skills: "skills-usage.md",
    agents: "agents-usage.md",
  };

  const templateFile = templateFiles[mappingId];
  if (!templateFile) {
    return "";
  }

  const templatePath = join(TEMPLATES_DIR, templateFile);
  if (!existsSync(templatePath)) {
    console.warn(`Warning: Template file not found: ${templatePath}`);
    return "";
  }

  try {
    return readFileSync(templatePath, "utf-8");
  } catch (error) {
    console.warn(
      `Warning: Failed to read template file: ${templatePath}`,
      error,
    );
    return "";
  }
}

function generateMarkdown(mapping, groups) {
  let md = `---\nversion: 1.0\nlastUpdated: ${new Date().toISOString().split("T")[0]}\n---\n\n`;
  md += `# ${mapping.name} 映射表\n\n`;
  md += `本文件从 \`${mapping.sourceDir}\` 目录自动扫描生成。\n\n`;

  // 添加 Agent 使用流程说明
  const usageInstructions = getAgentUsageInstructions(mapping.id);
  if (usageInstructions) {
    md += usageInstructions;
  }

  md += `---\n\n`;

  const categories = Object.keys(groups).sort();
  let totalCount = 0;

  for (const category of categories) {
    const group = groups[category];
    md += `## ${category}\n\n`;

    if (mapping.subgroupBy && typeof group === "object") {
      const subcategories = Object.keys(group).sort();
      for (const subcategory of subcategories) {
        const files = group[subcategory];
        md += `### ${subcategory}\n\n`;
        md += generateTable(mapping, files, totalCount);
        totalCount += files.length;
      }
    } else {
      const files = Array.isArray(group) ? group : group[category] || [];
      md += generateTable(mapping, files, totalCount);
      totalCount += files.length;
    }
  }

  md += `---\n\n`;
  md += `*最后更新:${new Date().toLocaleDateString("zh-CN")}*\n`;

  return md;
}

function generateTable(mapping, files, startIndex) {
  if (files.length === 0) return "";

  let md = "";
  const hasShortcut = mapping.getShortcut !== null;

  if (hasShortcut) {
    md += `| 快捷方式 | 名称 | 描述 | 完整路径 |\n`;
    md += `|----------|------|------|----------|\n`;
  } else {
    md += `| 名称 | 描述 | 完整路径 |\n`;
    md += `|------|------|----------|\n`;
  }

  for (const file of files.sort()) {
    md += generateRow(mapping, file) + "\n";
  }
  md += "\n";

  return md;
}

function generateRow(mapping, filePath) {
  const content = readFileSync(filePath, "utf-8");
  const frontmatter = parseFrontmatter(content);
  const title = getTitle(content);

  const shortPath = filePath.replace(process.env.HOME, "~");
  const name = mapping.getName(frontmatter, title, filePath);
  const shortcut = mapping.getShortcut
    ? mapping.getShortcut(filePath, frontmatter)
    : "";
  let description = frontmatter.description || "-";
  // Clean up description - remove surrounding quotes if present
  if (description.startsWith('"') && description.endsWith('"')) {
    description = description.slice(1, -1);
  }

  if (shortcut) {
    return `| ${shortcut} | ${name} | ${description} | \`${shortPath}\` |`;
  }
  return `| ${name} | ${description} | \`${shortPath}\` |`;
}

function run() {
  console.log("Scanning and generating mapping documents...\n");

  for (const mapping of CONFIG.mappings) {
    console.log(`  Processing: ${mapping.name}...`);

    const patterns = Array.isArray(mapping.sourcePattern)
      ? mapping.sourcePattern
      : [mapping.sourcePattern];

    let files = [];
    for (const pattern of patterns) {
      // Prepend sourceDir to all patterns
      const fullPattern = join(mapping.sourceDir, pattern);
      files = files.concat(globSync(fullPattern, { ignore: mapping.exclude }));
    }
    files = [...new Set(files.filter((f) => !lstatSync(f).isDirectory()))];

    // 插件 mapping 需要过滤只保留最新版本
    if (mapping.id.startsWith("plugins-")) {
      files = filterLatestVersionFiles(files, patterns, mapping.exclude);
    }

    if (files.length === 0) {
      console.log(`    Warning: No files found for ${mapping.name}`);
      continue;
    }

    const groups = groupFiles(files, mapping.groupBy, mapping.subgroupBy);

    const markdown = generateMarkdown(mapping, groups);
    const outputPath = join(OUTPUT_DIR, mapping.outputFile);
    writeFileSync(outputPath, markdown, "utf-8");

    const totalItems = Object.values(groups).reduce((sum, group) => {
      if (mapping.subgroupBy && typeof group === "object") {
        return sum + Object.values(group).reduce((s, f) => s + f.length, 0);
      }
      return sum + (Array.isArray(group) ? group.length : 0);
    }, 0);

    console.log(`    Generated: ${mapping.outputFile} (${totalItems} items)`);
  }

  console.log("\nAll mapping documents generated successfully!");
}

run();

2. Agent Template 格式
## Agent 使用流程

当用户输入命令时,按以下步骤执行:

1. **解析命令快捷方式**
   - 顶层命令:直接查找表格(格式:`/command`)
   - 嵌套命令:解析 category:command 格式(格式:`/category:command`)

2. **查找映射表**
   - 在对应分类表格中查找快捷方式列
   - 获取完整路径字段

3. **读取命令文件**
   - 使用 Read 工具读取完整路径对应的 .md 文件
   - 解析 frontmatter 获取 allowed-tools 和其他元数据

4. **执行命令**
   - 按照命令文件中的指令执行
   - 严格使用 frontmatter 中指定的 allowed-tools
   - 如果未指定 allowed-tools,使用默认工具集

---

实战演练:在 Copilot 中调用 tech-blog

万事俱备,现在的核心问题是:体验如何?

假设你已经运行了脚本,生成了 skills-mapping.md。

  1. 加载上下文:在 VSCode Copilot Chat 中,通过 @workspace 或直接打开 skills-mapping.md 文件,让 Copilot 读取这个文件。
  2. 下达指令:输入 “我想写一篇关于 Zustand 状态管理的博客,使用 tech-blog 技能的深度风格。”
  3. Copilot 的思考链:
    • 扫描 skills-mapping.md。
    • 发现 tech-blog 条目,描述匹配 “技术博客文章创作工具”。
    • 获取路径 ~/.claude/skills/tech-blog/SKILL.md。
    • (关键一步) Copilot 会读取该路径下的文件内容(前提是你允许它读取,或者你将内容复制到了 Context 中)。
    • Copilot 学习到 tech-blog 的 Prompt 规则(如 3W 框架、金句要求)。
    • 执行输出:Copilot 按照 tech-blog 的深度版风格,生成了一篇结构完美的文章。

这通过一次简单的映射,打破了工具间的壁垒。 你在 Claude Code 里沉淀的每一次 Prompt 优化、每一个 Agent 调教,现在都能无缝同步给编辑器里的 Copilot。

在这里插入图片描述

总结

“工欲善其事,必先利其器”。但在 AI 时代,我们面临的问题往往不是器不够利,而是"器"太多且互不相通。

通过 scan-and-generate.mjs 这样一个小巧的胶水脚本,我们不仅仅是生成了一份文档,更是建立了一座桥梁。它连接了 CLI 的灵活性与 IDE 的便捷性,连接了系统级的能力与编辑器级的交互。

现在,去运行你的扫描脚本,把你的 Claude Code 变成 Copilot 的最强外脑吧。

参考资料

AI编程助手入门指南:GitHub Copilot、Cursor与Claude的安装与基础使用 阅读详情

相关推荐

Claude Code的完美平替:OpenCode + GitHub Copilot

OpenCode + GitHub Copilot 的组合比起其他平替方案而言,从工具、模型、价格等多个维度都是最优选择。所以,强烈推荐尝试一下这个编码组合。最后,做个小调研,目前你正在用什么工具和模型套件呢?留言区聊一聊吧。更多关于Vibe Coding的内容分享也可以关注我的博客: 程序猿DD。

程序猿DD 6275

低成本运行 Claude Code:通过 LiteLLM 接入 GitHub Copilot Chat API 的完整指南

通过 LiteLLM 将 Claude Code 接入 GitHub Copilot Chat API,复用现有订阅额度,降低 API 成本并提升网络连接稳定性。

Xi Xu 的博客 2446

用Arduino和MAX30102做个心率血氧仪,从硬件连线到算法调试全流程避坑

本文详细介绍了如何使用Arduino和MAX30102传感器构建高精度心率血氧仪,涵盖硬件连线、软件配置、信号处理及算法优化全流程。通过实战案例和避坑指南,帮助开发者快速实现临床级精度的健康监测设备,适用于可穿戴设备和医疗健康领域。

weixin_26897585的博客 388

Claude Code如何使用Github Copilot订阅

copilot-api start --proxy-env #这个是一个start参数,表示从环境变量里面初始化代理,比如读取HTTP_PROXY,HTTPS_PROXY ,ALL_PROXY。写配置文件:~/.claude/settings.json。开始使用claude。

欢迎关注我 https://x.com/Awesome_AI_News 2549

Android开发必备:TBS腾讯浏览服务静态集成完整指南(附Demo下载)

本文详细解析了Android开发中TBS腾讯浏览服务的静态集成方案,通过对比动态集成,深入剖析了其核心原理与适用场景。文章提供了从环境准备、资源获取、项目配置到代码初始化的完整指南,并重点介绍了WebView与文件预览等高级特性的实战应用。针对集成过程中的常见问题,提供了详尽的排查清单与性能调优建议,旨在帮助开发者构建极致稳定、不依赖网络的WebView与文件预览功能。文末附有经过验证的Demo项目可供下载参考。

earth的博客 371

Windows10完美驱动Apple Studio Display:从雷电接口到亮度调节全攻略

本文详细介绍了如何在Windows10系统上完美驱动Apple Studio Display,涵盖雷电接口兼容性、亮度调节及色彩管理等关键问题。通过实测对比不同转接方案和显卡兼容性,推荐使用贝尔金VR线和NVIDIA GTX-1660显卡,并提供了BootCamp驱动安装和亮度调节的终极解决方案,帮助用户实现最佳显示效果。

elastic6hunter的博客 1124

Claude部署(copilot反向代理)

1、进行教育邮箱认证可免费使用claude pro 2年,有机会的话可以进行认证,无法教育认证的话只能花钱充claude的会员了,如何进行教育认证可观看该Up的视频2、教育认证通过后在GitHub个人主页下的Copilot/Features中开启Copilot Pro。

m0_59034641的博客 1906

安装Tailscale

如果返回 /usr/bin/tailscale 或类似路径,说明已安装但 sudo 可能找不到它。如果 which tailscale 没有输出,说明安装失败,重新执行安装步骤。Tailscale 的后台服务 tailscaled 必须运行。检查 tailscaled 服务是否运行。检查 tailscale 命令是否存在。

FairLikeSnow的博客 1490

2025年AI代码生成工具横评:GitHub Copilot vs. Claude Code vs. 字节Trae

2025年的AI代码战场,GitHub Copilot、Claude Code和字节Trae正上演一场“三国杀”。这场技术对决背后,既有微软的生态霸权、Anthropic的算法碾压,也有字节跳动的本土突围——开发者们早已不再满足于“代码补全”,而是追求更精准、更懂场景的智能协作。

2501_92849183的博客 3076

知识图谱中的 Ontology(本体论)

本文的部分图片和内容来自中国科学院自动化研究所刘康老师的课件 Ontology(本体论) Ontology 是(特定领域)信息组织的一种形式,是领域知识规范的抽象和描述,是表达、共享、重用知识的方法。 Ontology 是知识体系构建的关键技术,知识图谱是一种人工智能技术,它的关键在于让计算机能够处理人类的知识。然而,人类脑海中的知识通常是直觉性的,我们无法将这种直觉性的知识直接输入给计算机,On...

P01son的博客 2万+

性能测试软件(LR12) 具体汉化(中文)方法

LoadRunner 12 的下载及安装详细过程请参考:https://blog.youkuaiyun.com/xiao66guo/article/details/105465854 1、在LoadRunner文件中找到 Setup.exe 可执行文件,并以管理员的身份运行: C盘 —> Temp—>HP LoadRunner 12.02 Community Edition—> D...

多谢大人光临寒舍,请随便看看,喝口茶吧 ☕️☕️☕️ 1993

Copilot vs Claude Code终极对决哪个会更好用呢?

最好的工具不是替代思考,而是增强思考。Copilot和Claude Code代表了AI编程辅助的两个方向——一个专注即时效率,一个专注深度能力。

weixin_43319207的博客 3022

PADS VX2.4 缝合孔(阵列过孔)的添加方法

缝合孔的主要目的是:①:增加底层和顶层的地铜皮的连接性,②:起到屏蔽外界信号干扰的作用。铺完铜后,右击空区域选择“选择形状”命令,选取整板中的一块大铜皮,右击选择“覆铜区域内过孔阵列模式”→“沿周边”指令后,再右击选择“覆铜区域内过孔阵列”,便能看到已选区域内添加的缝合孔(过孔阵列),也可以通过铜皮显示或隐藏的无模命令:PO进行查看。完成上面的“防止错误”和“过孔样式”的设置后,开始对整板进行铺铜处理,点击“工具栏”→覆铜平面指示器,在弹出的对话框点击“开始”,便能观察铺铜后的板子。

tianpu2320959696的博客 3076

打通 Claude Code 生态:如何让本地 Agent 共享 Commands、Subagents 与 Skills

本文介绍了一种轻量级架构方案"映射加载器"(Mapping Loader),旨在打通Claude Code与其他本地AI Agent(如Gemini CLI)之间的能力共享。通过"扫描→映射→加载"三步策略,将Claude Code中的Commands、Subagents、Skills等原子能力解耦为标准化的Markdown表格,实现一次编写多处复用。核心创新在于采用人类可读的Markdown作为注册表,并设计通用查询模式,使不同Agent无需了解彼此目录结构即可动态

💻 Code:TypeScript / Engineering 🤖 AI:Prompt Optimization / Context Memory / Coding Agents 1240

Unreal5 从入门到精通之 学习Niagara特效系统

UE5 Niagara粒子系统解析 Niagara是UE5中的高性能粒子特效系统,相比传统粒子系统具有完全可编程性和可视化节点编辑两大特点。核心单元发射器(Emitter)分为模板发射器(预设效果如喷泉、火焰)和空白发射器(高度自定义)。系统提供13种预设模板,包括吹飞粒子、五彩纸屑爆发、动态光束等常见特效。 Niagara采用三级模块化设计: 系统级:全局参数设置与更新 发射器级:控制粒子生成规则与行为 粒子级:处理单个粒子的生命周期和渲染 关键模块包括初始化粒子属性、物理模拟、颜色渐变等,支持GPU加速

TxNet 1134

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

AI编程工具对比:Cursor、GitHub Copilot与Claude Code

Claude Code处理复杂算法时像有架构师思维,能规避83%的接口冲突问题” —— 某电商平台技术主管“Cursor的Tab补全有时像魔法,四分之一的情况能完美猜中我的意图” —— 全栈开发者“Copilot免费版足够日常使用,但企业级功能收费偏高” —— 初创公司CTO。

m0_52307083的博客 6933

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Skills 使用指南 从零入门

创建 Skill 的正确流程:初始化项目→ 使用/init创建获取 skill-creator→ 从 GitHub 下载到查看现有 skills→ 使用/skills命令创建新 skill→ 在下创建目录和 SKILL.md开发和测试→ 编写文档和脚本,在 Chat 中测试分享→ 通过 Git 或直接分享目录使用/init初始化项目使用/skills查看和管理 skillsSkills 直接放在目录。

weixin_44001799的博客 2921

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

Claude Code 的完美平替:OpenCode + GitHub Copilot(顶级模型+最优价格)

在当前席卷全球的“Vibe Coding”浪潮中,Anthropic 推出的 Claude 系列模型 + 终端工具 Claude Code,凭借极强的逻辑推理能力,成为了开发者眼中的“白月光”。但现实是残酷的:对于中国开发者而言,账号随时被封、海外信用卡支付遭拒、API 额度受限以及复杂的网络环境,构成了一道难以逾越的门槛。这套方案最具杀伤力的地方在于其经济逻辑。虽然最近国产编程模型不断发力,Claude Code + GLM-4.7 的表现非常出色,但面对复杂问题,Claude系列模型依然完胜。

程序猿DD 2319

OpenClaw 现实核查:Claude Code、Cursor 与 GitHub Copilot 技术对比(2026)

《主流AI编程工具深度解析:ClaudeCode、Cursor与GitHub Copilot技术对比》 摘要: 近期关于"OpenClaw"的误解实为技术社区的概念混淆,经权威验证该工具并不存在。本文基于2026年最新技术数据,对三大主流开发工具进行专业对比:1)ClaudeCode采用MCP协议和GANHarness架构,具备多代理协作特性;2)Cursor集成FlowState技术,支持双模式编辑;3)GitHub Copilot 3.0强化了Predictive Debugging

嵌入式老陈的博客 969

claude-code对比GitHub-Copilot

功能/工具定位项目级开发助手文件级代码辅助工具上下文支持超长上下文(200k)上下文较小主要功能增量开发、一键修复、测试用例支持智能代码预测、逻辑补全适用场景复杂项目、全局优化局部代码生成、快速补全成本高,限量限额低,支持无限使用区域支持不支持中国大陆支持中国大陆根据需求选择合适的工具,更适合复杂项目的全局开发,而则在日常编码和局部优化中表现出色。建议两者搭配使用。

阿祥_优快云 1449

VSCode + Copilot 保姆级 AI 编程实战教程,免费用 Claude,夯爆了!

VSCode+GitHub Copilot AI编程实战指南:从安装到塔罗牌网站开发。文章详细介绍了VSCode安装GitHub Copilot插件的步骤,对比了其4大优势:多模型支持、多种运行模式、可视化管理、清晰交互体验。通过基础功能演示和"AI占卜师网站"开发实战,展示了Plan模式方案设计和Agent模式自动执行的完整流程,帮助开发者高效实现AI编程。

努力做最接地气的编程干货分享,感谢关注 3815

万字长文:2026 年 AI 编程工具横向测评,Cursor/Copilot/Claude Code 优劣势与适用场景全对比

从代码生成质量、上下文理解能力、多语言支持、开发效率提升、团队协作适配、成本性价比6个核心维度,对三款工具进行横向对比,帮助开发者精准选择最适合自己的AI编程伙伴。

学海无涯,笃行致远 2180

Claude Code for VS Code 使用教程

Claude Code 是 Anthropic 推出的一款工具,也被称为世界最强编程 Agent 之一。Claude Code 的 VS Code 扩展提供了原生的图形化界面,支持内联 Diff 视图、-mentions 引用、计划审查等功能,是在 VS Code 中使用 Claude Code 的推荐方式。本文档主要介绍如何通过 AceData Cloud 的代理服务,在 VS Code 中配置和使用 Claude Code 扩展。

weixin_59061577的博客 3379

2026年AI编程工具深度横评:Claude Code、Cursor、GitHub Copilot全方位对比

Claude Code、Cursor、Copilot谁更强?从六个维度深度实测。Copilot性价比最高,Cursor体验最流畅,Claude Code能力最强但API成本高昂。本文最后分享一个Token中转站方案,仅改两行代码,成本直降70%以上。帮你找到最适合的AI编程组合。

Papersheep1215的博客 9805

inMusic 开设 GitHub 仓库,公开 MPC 开源组件

inMusic 在 GitHub 开设官方仓库,按许可证要求公开 Akai MPC 各代设备及 MPC Sample 使用的开源组件,但并未开源 MPC 操作系统本身。

老孙正经胡说 213

GitHub 开源趋势日报 | 2026-11-08

每日精选 GitHub Trending 热门项目,聚焦 AI 与大模型、Agent 智能体领域,带你用一篇文章看懂开源风向。

weixin_45631123的博客 476
上一篇: 为什么你的 Claude 正在把代码写成“屎山”?——揭秘 AI 编程的“近视眼”缺陷
下一篇: Cursor Memory 实战:如何终结 AI 助手的“金鱼记忆”
王师傅炼丹中
博客等级 码龄8年 205粉丝 192原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王师傅炼丹中

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值