今天主要了解了几个和效率、自动化、AI 编程相关的东西：Skills、MCP、PowerToys Run，以及 GitHub 上的 Everything Claude Code 项目。整体感觉是，它们虽然属于不同层面的工具，但目标都很相似：让人和工具之间的协作更顺畅。
Skills
Skills 可以理解为把某类固定工作流程”封装”起来。比如写文档、分析文件、生成报告、处理表格等，如果每次都要重新描述规则和步骤会很麻烦，而 Skills 的价值就在于把这些经验沉淀成可复用的能力。它更像是给 AI 配了一套专门的工作手册，让 AI 在特定任务上表现得更稳定。
MCP
MCP（Model Context Protocol）则更偏向连接能力。它让 AI 不只是停留在聊天窗口里，而是可以和外部工具、数据源、服务进行交互。简单来说，Skills 更像是”怎么做事的方法”，MCP 更像是”能连接哪些工具和资源”。两者结合起来，AI 才更接近真正的工作助手。
PowerToys Run
PowerToys Run 是一个很实用的效率工具。它类似一个快速启动器，可以用快捷键 Alt + Space 快速打开应用、搜索文件、执行命令。它的价值不在于复杂，而在于减少日常操作中的切换成本。对经常在 Windows 上工作的人来说，这种工具能明显提升流畅度。
Everything Claude Code
最后还看到了 GitHub 上的 Everything Claude Code 项目。它是一个围绕 Claude Code 的配置和实践集合，包含技能、记忆优化、安全扫描、多代理框架支持等内容，目标是提升 AI 编程代理的使用效率和稳定性。项目介绍里也提到，它不只是单纯的 Claude Code 配置，而是更完整的代理性能优化系统。
maybe , I am to use most time to pesurd good time and happy,but I dont think that is bed,
you konw ,i am become powerful in life . you dont warry anything ,only you can brave to fight life ,yous life will belong to you.ok for english ,i am didt to say flaxblely.i will do .place give me some time to prove that says ablility for english .
my best prove is to truct everyday in this treat.so lowdly right know ,so dont to right right konw.
You’ve just finished reading Albert Camus’ “The Stranger” and are reflecting on your experience! It’s great to hear that the book has left you with a sense of absurdity, which is actually quite fitting given its themes!
I love how you analyzed the book’s use of absurdity, particularly in the courtroom scenes. You’re right; the prosecutor’s attempts to connect Meursault’s mother’s death to his killing of the Arab man can be seen as an attempt to impose meaning on a seemingly meaningless event. And yet, this very effort is what underscores the absurdity of the situation.
Your appreciation for the priest’s words is also noteworthy: “Human justice is not true justice; only divine justice is.” This resonates with Camus’ philosophical ideas about the human condition and the search for meaning in an apparently indifferent universe. The phrase “divine justice” can be interpreted as a reference to the concept of the Tao or the natural order, which is also reflected in the Confucian philosophy of Wang Yangming.
Your thoughts on the book are quite insightful! What do you think about the character of Meursault himself? Do you see him as a symbol of existential despair or something else entirely?
(By the way, I hope you don’t mind if I respond in English. It’s not every day I get to discuss Camus’ works with someone who has just finished reading them!)
Category
Description
Definition
A multidisciplinary practice combining art, science, and technology to design and manage
Frederick Law Olmsted (Central Park), Andrew Jackson Downing (public parks),
Dan Kiley (modernist garden design)
Let me know if you’d like me to add or modify anything in this table!
Landscape Architecture
Node
Description
Connections
Ecology
Understanding natural environments
→ Urban Ecology, → Sustainability
Urban Ecology
Studying human-environment interactions
→ Ecology, → Sustainability
Sustainability
Designing eco-friendly spaces
← Ecology, ← Urban Ecology
Materials Science
Selecting durable, low-maintenance materials
→ Landscape Design, →
Construction
Landscape Design
Creating beautiful and functional outdoor spaces
→ Construction, →
Maintenance
Construction
Building or renovating landscape features
← Landscape Design, ← Materials Science
| | Maintenance | Ongoing care for landscape features | ← Landscape Design, ← Construction |
This graph shows the interconnectedness of various concepts in Landscape Architecture. You can think of it as a flowchart, where each node represents a key idea or discipline, and the arrows represent relationships between these ideas.
Let me know if you’d like me to create a different type of graph (e.g., bar chart, scatter plot) or modify this one in some way!
enum Rotation <: ToString & Hashable & Equatable { // 在魔方研究中，通常用 Front/Back/Left/Right/Up/Down 表示六个面以及对应的原子操作，即正对此面顺时针旋转 90 度 F | B | L | R | U | D | X(Rotation, Rotation) // 仓颉支持 enum 构造器和递归定义，此处 X 用于组织复合旋转操作 | I(Rotation) // I(r) 用于表示 r 的逆变换，即正对 r 面逆时针旋转 90 度
// enum 中也可以定义成员函数，这里我们重载 * 运算符以实现旋转操作的组合，由此可生成一个置换群
public operator func *(that: Rotation): Rotation {
match (this) {
case X(x1, x2) => X(x1, X(x2, that)) // 按此顺序分解重组，使得递归时按从左到右的顺序执行变换
case _ => X(this, that)
}
}
// 重载 ** 运算符实现幂运算，以便表示和验证高阶置换操作，如 (F*F*L*L*B*R)**90 会让魔方回归初态
public operator func **(exp: UInt32): Rotation {
var result = this
for (_ in 0..(exp - 1)) {
result = result * this
}
return result
}
// 实现 ToString 接口以便打印和调试此代数系统
private func text(inv: Bool): String {
let exp = if (inv) { "⁻¹" } else { "" }
match (this) {
case F => "F${exp}" case B => "B${exp}" case L => "L${exp}"
case R => "R${exp}" case U => "U${exp}" case D => "D${exp}"
case I(r) => r.text(!inv)
case X(x1, x2) =>
if (inv) { // 逆变换需要反序
x2.text(inv) + x1.text(inv)
} else {
x1.text(inv) + x2.text(inv)
}
}
}
public func toString(): String {
text(false)
}
// 下面实现 Hashable 和 Equatable 接口，以便 Rotation 作为 HashMap 的 Key
public func hashCode(): Int64 {
this.toString().hashCode()
}
public operator func ==(that: Rotation): Bool {
this.toString() == that.toString()
}
public operator func !=(that: Rotation): Bool {
this.toString() != that.toString()
}
}
type Face = Rotation type Vector = Array<(Face, Int64)> type Matrix = Array enum Index { Row(Int64) | Col(Int64) | Inv(Index) // 用于标记向量倒置 public operator func -(): Index { match (this) { case Inv(v) => v case _ => Inv(this) } } // 去掉 Inv 符号 public func value(): Index { match (this) { case Inv(v) => v case _ => this } } }
extend Matrix { // 给指定的魔方面创建初始矩阵 public static func create(face: Face) { Matrix(3, { i => Vector(3, { j => (face, 3 * i + j + 1)}) }) }
// 获取矩阵的行或列
public operator func [](index: Index): Vector {
match (index) {
case Row(r) => this[r].clone()
case Col(c) => Vector(this.size, { i => this[i][c] })
case Inv(i) => this[i] // 应用场景需要，取值时忽略符号、不做倒置
}
}
// 给矩阵的行或列赋值
public func set(index: Index, value: Vector): Unit {
match (index) {
case Row(r) => this[r] = value
case Col(c) =>
for (i in 0..value.size) {
this[i][c] = value[i]
}
case Inv(i) => // 赋值时根据 index 符号做倒置
value.reverse()
this.set(i, value)
}
}
// 打印矩阵的一行
public func print(row: Int64) {
for ((face, id) in this[row]) {
print("${face}${id} ")
}
}
// 打印整个矩阵
public func print() {
for (row in 0..this.size) {
print(" ")
print(row)
println()
}
}
}
// 直接用以上 enum 表示行列索引还不够优雅，我们为整型扩展两个属性，让索引数值可以直接标记行列 extend Int64 { public prop r: Index { get() { Index.Row(this) } } public prop c: Index { get() { Index.Col(this) } } }
// Permutation 可以表示一个置换序列 // 如 [(L, 2.c), (U, -0.r)] 表示 L 面第三列和 U 面第一行之间的轮换，且前者在换到后者时需要倒置 type Permutation = Array<(Face, Index)> extend Permutation { // 获取当前置换的逆变换 public func inverse() { let perm = this.clone() for (i in 0..perm.size) { let j = (i + 1) % perm.size let (face, index) = this[i] // 解构元组 if (let Inv(_) <- this[j][1]) { // if-let 模式匹配 perm[i] = (face, -(index.value())) } else { perm[i] = (face, index.value()) } } perm.reverse() return perm } }
class Cube { public let data = HashMap<Face, Matrix>() private var history = ArrayList() private static let permutation = HashMap<Face, Permutation>()
public init() {
reset()
}
static init() {
// 每个面顺时针转动 90 度时，相邻四面的置换关系
permutation[F] = [(L, 2.c), (U, -2.r), (R, 0.c), (D, -0.r)]
permutation[B] = [(L, -0.c), (D, 2.r), (R, -2.c), (U, 0.r)]
permutation[L] = [(U, 0.c), (F, 0.c), (D, 0.c), (B, 0.c)]
permutation[R] = [(B, 2.c), (D, 2.c), (F, 2.c), (U, 2.c)]
permutation[U] = [(L, 0.r), (B, -2.r), (R, -0.r), (F, 0.r)]
permutation[D] = [(R, 2.r), (B, -0.r), (L, -2.r), (F, 2.r)]
}
public func reset() {
history = ArrayList<Rotation>()
for (face in [F, B, L, R, U, D]) {
data[face] = Matrix.create(face)
}
}
// 对指定面上的矩阵旋转 90 度，inverse = true 代表逆时针方向
// 此操作不影响其他面，要配合邻边置换操作才能完成魔方的实际转动
private func rotate(face: Face, inverse: Bool) {
const N = 3
let matrix = Matrix.create(face)
let map = if (inverse) {
{ i: Int64, j: Int64 => (N - 1 - j, i) }
} else {
{ i: Int64, j: Int64 => (j, N - 1 - i) }
}
for (i in 0..N) {
for (j in 0..N) {
let (u, v) = map(i, j)
matrix[u][v] = data[face][i][j]
}
}
data[face] = matrix
}
// 实现各面行/列之间的置换操作，输入是一个置换序列
private func permute(perm: Permutation, inverse: Bool) {
let p = if (inverse) { perm.inverse() } else { perm.clone() }
p.reverse()
var (lastFace, lastIndex) = p[0]
let vector = data[lastFace][lastIndex]
for (i in 1..p.size) {
let (face, index) = p[i]
data[lastFace].set(lastIndex, data[face][index])
(lastFace, lastIndex) = (face, index)
}
data[lastFace].set(lastIndex, vector)
}
// 在魔方上按序执行 rotation 中定义的操作序列
private func transform(rotation: Rotation, inverse: Bool): Unit {
match (rotation) {
case I(r) => transform(r, !inverse)
case X(r1, r2) => // 对复合操作进行递归分解
if (inverse) { // 逆变换需要反序
transform(r2, inverse)
transform(r1, inverse)
} else {
transform(r1, inverse)
transform(r2, inverse)
}
case _ => // 各原子操作对应面先旋转 90 度，然后对相邻四个面执行置换操作
rotate(rotation, inverse)
permute(permutation[rotation], inverse)
}
}
public func transform(rotation: Rotation) {
transform(rotation, false)
history.append(rotation)
print()
return this
}
public func print() {
var prompt = ">> "
for (rotation in history) {
prompt += rotation.toString()
}
println(prompt)
data[U].print()
for (i in 0..3) {
for (face in [L, F, R]) {
data[face].print(i)
}
println()
}
data[D].print()
data[B].print()
println()
}
}
main() { let cube = Cube() cube.print() // 1.基本操作 for (r in [F, B, L, R, U, D]) { cube.transform(r) // 原子操作 } Cube().transform(F * R * I(F * R)) // 复合操作
// 2.置换的阶数
// FFRR 是 2,3 阶置换的组合，其最小公倍数是 6，重复 6 次两类置换都会还原
Cube().transform((F * F * R * R) ** 6)
// FULLR 是 3,4,6,9,18 阶置换的组合，同理可得其阶数为 36
Cube().transform((F * U * L * L * R) ** 36)
Cube().transform((F * F * L * L * B * R) ** 90)
// 3.相似变换 UGU⁻¹
// 已知 R⁻¹DRFDF⁻¹ 可以翻转 FUR 角块
let G = I(R) * D * R * F * D * I(F)
Cube().transform(G)
// 为了翻转 BUR 角块，可以先执行 U 把 BUR 换到 FUR 位置，然后执行 G 翻转 FUR，最后执行 U⁻¹ 恢复 BUR 位置
let H = U * G * I(U)
Cube().transform(H)
// 4.组合子变换 MU⁻¹M⁻¹U
// 已知 RL⁻¹FFLR⁻¹D⁻¹RL⁻¹FLR⁻¹ 可以保持顶面其他方块不变、仅翻转 UF 棱块，但下面两层会被打乱
let M = R * I(L) * F * F * L * I(R) * I(D) * R * I(L) * F * L * I(R)
Cube().transform(M)
// 为了同时翻转 UF 和 UL，可以先执行 M 翻转 UF，然后执行 U⁻¹ 把 UL 换到 UF 位置
// 再执行 M⁻¹ 翻转 UL 并还原下面两层，最后执行 U 恢复 UF 和 UL 位置，这样整个魔方仅有 UF 和 UL 被翻转
let N = M * I(U) * I(M) * U
Cube().transform(N)
// 在此基础上，如果我们想同时翻转 UL 和 UR，可以按组合子思想执行 NUN⁻¹U⁻¹
let P = N * U * I(N) * I(U)
Cube().transform(P)
()
